You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@celix.apache.org by rl...@apache.org on 2019/07/17 17:33:40 UTC

[celix] branch develop updated (53428d9 -> 163735a)

This is an automated email from the ASF dual-hosted git repository.

rlenferink pushed a change to branch develop
in repository https://gitbox.apache.org/repos/asf/celix.git.


    from 53428d9  Fixed scope in pubsub examples
     new eb19982  Updated utils to use celix_properties_t* instead of properties_pt
     new 9c1b9a2  Updated celix-examples to use celix_properties_t* over properties_pt
     new 163735a  Using celix_properties_t* in pubsub and updated formatting

The 3 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 .../pubsub/examples/pubsub/common/include/poi.h    |   28 +-
 .../examples/pubsub/publisher/CMakeLists.txt       |   16 +-
 .../private/include/pubsub_publisher_private.h     |   14 +-
 .../publisher/private/src/pubsub_publisher.c       |  171 +-
 .../examples/pubsub/publisher2/CMakeLists.txt      |   16 +-
 .../examples/pubsub/subscriber/CMakeLists.txt      |   16 +-
 .../private/include/pubsub_subscriber_private.h    |    6 +-
 .../subscriber/private/src/pubsub_subscriber.c     |   38 +-
 bundles/pubsub/keygen/CMakeLists.txt               |   26 +-
 bundles/pubsub/keygen/ed_file.c                    |  450 ++--
 bundles/pubsub/keygen/makecert.c                   |   41 +-
 bundles/pubsub/mock/tst/pubsubmock_test.cc         |    8 +-
 bundles/pubsub/pubsub_admin_nanomsg/CMakeLists.txt |   56 +-
 .../src/pubsub_nanomsg_admin.cc                    |    2 +-
 .../src/pubsub_nanomsg_admin.h                     |    2 +-
 .../src/pubsub_nanomsg_common.cc                   |    2 +-
 .../src/pubsub_nanomsg_topic_receiver.cc           |    4 +-
 .../src/pubsub_nanomsg_topic_sender.cc             |    6 +-
 .../src/pubsub_psa_nanomsg_constants.h             |   12 +-
 bundles/pubsub/pubsub_admin_udp_mc/CMakeLists.txt  |   20 +-
 bundles/pubsub/pubsub_admin_zmq/CMakeLists.txt     |   86 +-
 .../pubsub/pubsub_admin_zmq/src/psa_activator.c    |  160 +-
 .../src/pubsub_psa_zmq_constants.h                 |   16 +-
 .../pubsub/pubsub_admin_zmq/src/pubsub_zmq_admin.c |    2 +-
 .../pubsub_admin_zmq/src/pubsub_zmq_common.c       |    2 +-
 .../src/pubsub_zmq_topic_receiver.c                |   12 +-
 .../pubsub_admin_zmq/src/pubsub_zmq_topic_sender.c |   30 +-
 bundles/pubsub/pubsub_admin_zmq/src/zmq_crypto.c   |  361 ++--
 bundles/pubsub/pubsub_admin_zmq/src/zmq_crypto.h   |    4 +-
 .../pubsub/pubsub_api/include/pubsub/publisher.h   |    8 +-
 .../pubsub/pubsub_api/include/pubsub/subscriber.h  |    4 +-
 bundles/pubsub/pubsub_discovery/CMakeLists.txt     |   12 +-
 .../pubsub/pubsub_discovery/src/psd_activator.c    |  110 +-
 .../pubsub_discovery/src/pubsub_discovery_impl.c   |    2 +-
 .../pubsub_discovery/src/pubsub_discovery_impl.h   |   60 +-
 .../pubsub/pubsub_serializer_json/CMakeLists.txt   |    8 +-
 .../src/ps_json_serializer_activator.c             |   38 +-
 .../src/pubsub_serializer_impl.c                   |  439 ++--
 .../src/pubsub_serializer_impl.h                   |    2 +-
 bundles/pubsub/pubsub_spi/CMakeLists.txt           |   12 +-
 bundles/pubsub/pubsub_spi/include/pubsub_admin.h   |   40 +-
 .../pubsub_spi/include/pubsub_admin_metrics.h      |   96 +-
 .../pubsub/pubsub_spi/include/pubsub_constants.h   |    2 +-
 .../pubsub/pubsub_spi/include/pubsub_listeners.h   |   12 +-
 .../pubsub/pubsub_spi/include/pubsub_serializer.h  |   26 +-
 bundles/pubsub/pubsub_spi/include/pubsub_utils.h   |    4 +-
 bundles/pubsub/pubsub_spi/src/pubsub_endpoint.c    |  216 +-
 bundles/pubsub/pubsub_spi/src/pubsub_utils.c       |  192 +-
 bundles/pubsub/pubsub_spi/src/pubsub_utils_match.c |  346 +--
 .../pubsub/pubsub_topology_manager/CMakeLists.txt  |   16 +-
 .../pubsub_topology_manager/src/pstm_activator.c   |  232 +-
 .../src/pubsub_topology_manager.c                  |    6 +-
 .../src/pubsub_topology_manager.h                  |  130 +-
 bundles/pubsub/test/test/sut_activator.c           |   96 +-
 bundles/pubsub/test/test/tst_activator.cc          |   12 +-
 .../bundle_with_private_lib/src/activator.c        |   44 +-
 .../bundle_with_private_lib/tlib/include/test.h    |   28 +-
 .../bundle_with_private_lib/tlib/src/test.c        |   28 +-
 .../celix-examples/civetweb/resources/index.html   |   29 +-
 .../celix-examples/civetweb/resources/script.js    |   30 +-
 .../celix-examples/civetweb/src/bundle_activator.c |   32 +-
 .../celix-examples/dm_example/api/include/phase1.h |   36 +-
 .../celix-examples/dm_example/api/include/phase2.h |   36 +-
 .../dm_example/phase1/src/phase1_activator.c       |   82 +-
 .../dm_example/phase1/src/phase1_cmp.c             |   61 +-
 .../dm_example/phase1/src/phase1_cmp.h             |   32 +-
 .../dm_example/phase2a/src/phase2a_activator.c     |   80 +-
 .../dm_example/phase2a/src/phase2a_cmp.c           |   55 +-
 .../dm_example/phase2a/src/phase2a_cmp.h           |   32 +-
 .../dm_example/phase2b/src/phase2b_activator.c     |   92 +-
 .../dm_example/phase2b/src/phase2b_cmp.c           |   55 +-
 .../dm_example/phase2b/src/phase2b_cmp.h           |   32 +-
 .../dm_example/phase3/src/phase3_activator.c       |   88 +-
 .../dm_example/phase3/src/phase3_cmp.c             |   55 +-
 .../dm_example/phase3/src/phase3_cmp.h             |   32 +-
 examples/celix-examples/embedding/src/main.c       |   58 +-
 .../celix-examples/export_import/CMakeLists.txt    |   81 +-
 .../celix-examples/export_import/include/test.h    |   28 +-
 .../celix-examples/export_import/include/test2.h   |   28 +-
 .../celix-examples/export_import/src/activator.c   |   63 +-
 examples/celix-examples/export_import/src/test.c   |   28 +-
 examples/celix-examples/export_import/src/test2.c  |   28 +-
 .../hello_world_c/src/bundle_activator.c           |   29 +-
 .../hello_world_cxx/src/BundleActivator.cc         |   28 +-
 .../log_service_example/src/activator.c            |   70 +-
 .../services_example_c/api/example_calc.h          |   28 +-
 .../src/dynamic_consumer_example.c                 |   28 +-
 .../src/dynamic_provider_example.c                 |   34 +-
 .../src/simple_consumer_example.c                  |   28 +-
 .../src/simple_provider_example.c                  |   28 +-
 .../services_example_cxx/api/example.h             |   38 +-
 .../track_tracker_example/src/activator.c          |   29 +-
 libs/utils/include/array_list.h                    |   32 +-
 libs/utils/include/celix_array_list.h              |   28 +-
 libs/utils/include/celix_errno.h                   |   34 +-
 libs/utils/include/celix_filter.h                  |   28 +-
 libs/utils/include/celix_properties.h              |   28 +-
 libs/utils/include/celix_threads.h                 |   40 +-
 libs/utils/include/celix_utils_api.h               |   28 +-
 libs/utils/include/celixbool.h                     |   34 +-
 libs/utils/include/exports.h                       |   32 +-
 libs/utils/include/filter.h                        |   28 +-
 libs/utils/include/hash_map.h                      |   46 +-
 libs/utils/include/ip_utils.h                      |    4 +-
 libs/utils/include/linked_list.h                   |   32 +-
 libs/utils/include/linked_list_iterator.h          |   32 +-
 libs/utils/include/properties.h                    |   32 +-
 libs/utils/include/utils.h                         |   32 +-
 libs/utils/include/version.h                       |   74 +-
 libs/utils/include/version_range.h                 |   52 +-
 libs/utils/private/test/array_list_test.cpp        |  823 +++----
 libs/utils/private/test/celix_threads_test.cpp     |  587 ++---
 libs/utils/private/test/filter_test.cpp            |    4 +-
 libs/utils/private/test/hash_map_test.cpp          | 2247 ++++++++++----------
 libs/utils/private/test/ip_utils_test.cpp          |   14 +-
 libs/utils/private/test/linked_list_test.cpp       | 1071 +++++-----
 libs/utils/private/test/properties_test.cpp        |  335 ++-
 libs/utils/private/test/thread_pool_test.cpp       |  125 +-
 libs/utils/private/test/utils_test.cpp             |  451 ++--
 libs/utils/private/test/version_range_test.cpp     |  368 ++--
 libs/utils/private/test/version_test.cpp           |  514 ++---
 libs/utils/src/array_list.c                        |  659 +++---
 libs/utils/src/array_list_private.h                |   52 +-
 libs/utils/src/celix_threads.c                     |  136 +-
 libs/utils/src/filter.c                            |  942 ++++----
 libs/utils/src/hash_map.c                          |  785 +++----
 libs/utils/src/hash_map_private.h                  |   64 +-
 libs/utils/src/ip_utils.c                          |    4 +-
 libs/utils/src/linked_list.c                       |  281 +--
 libs/utils/src/linked_list_iterator.c              |  199 +-
 libs/utils/src/linked_list_private.h               |   44 +-
 libs/utils/src/properties.c                        |  638 +++---
 libs/utils/src/utils.c                             |  187 +-
 libs/utils/src/version.c                           |  396 ++--
 libs/utils/src/version_private.h                   |   37 +-
 libs/utils/src/version_range.c                     |  278 +--
 libs/utils/src/version_range_private.h             |   37 +-
 137 files changed, 8615 insertions(+), 8620 deletions(-)


[celix] 03/03: Using celix_properties_t* in pubsub and updated formatting

Posted by rl...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

rlenferink pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/celix.git

commit 163735a3c0856e11786e61d0d25042315b3d95b6
Author: Roy Lenferink <le...@gmail.com>
AuthorDate: Wed Jul 17 19:23:59 2019 +0200

    Using celix_properties_t* in pubsub and updated formatting
---
 .../pubsub/examples/pubsub/common/include/poi.h    |  28 +-
 .../examples/pubsub/publisher/CMakeLists.txt       |  16 +-
 .../private/include/pubsub_publisher_private.h     |  14 +-
 .../publisher/private/src/pubsub_publisher.c       | 171 ++++----
 .../examples/pubsub/publisher2/CMakeLists.txt      |  16 +-
 .../examples/pubsub/subscriber/CMakeLists.txt      |  16 +-
 .../private/include/pubsub_subscriber_private.h    |   6 +-
 .../subscriber/private/src/pubsub_subscriber.c     |  38 +-
 bundles/pubsub/keygen/CMakeLists.txt               |  26 +-
 bundles/pubsub/keygen/ed_file.c                    | 450 ++++++++++-----------
 bundles/pubsub/keygen/makecert.c                   |  41 +-
 bundles/pubsub/mock/tst/pubsubmock_test.cc         |   8 +-
 bundles/pubsub/pubsub_admin_nanomsg/CMakeLists.txt |  56 +--
 .../src/pubsub_nanomsg_admin.cc                    |   2 +-
 .../src/pubsub_nanomsg_admin.h                     |   2 +-
 .../src/pubsub_nanomsg_common.cc                   |   2 +-
 .../src/pubsub_nanomsg_topic_receiver.cc           |   4 +-
 .../src/pubsub_nanomsg_topic_sender.cc             |   6 +-
 .../src/pubsub_psa_nanomsg_constants.h             |  12 +-
 bundles/pubsub/pubsub_admin_udp_mc/CMakeLists.txt  |  20 +-
 bundles/pubsub/pubsub_admin_zmq/CMakeLists.txt     |  86 ++--
 .../pubsub/pubsub_admin_zmq/src/psa_activator.c    | 160 ++++----
 .../src/pubsub_psa_zmq_constants.h                 |  16 +-
 .../pubsub/pubsub_admin_zmq/src/pubsub_zmq_admin.c |   2 +-
 .../pubsub_admin_zmq/src/pubsub_zmq_common.c       |   2 +-
 .../src/pubsub_zmq_topic_receiver.c                |  12 +-
 .../pubsub_admin_zmq/src/pubsub_zmq_topic_sender.c |  30 +-
 bundles/pubsub/pubsub_admin_zmq/src/zmq_crypto.c   | 361 ++++++++---------
 bundles/pubsub/pubsub_admin_zmq/src/zmq_crypto.h   |   4 +-
 .../pubsub/pubsub_api/include/pubsub/publisher.h   |   8 +-
 .../pubsub/pubsub_api/include/pubsub/subscriber.h  |   4 +-
 bundles/pubsub/pubsub_discovery/CMakeLists.txt     |  12 +-
 .../pubsub/pubsub_discovery/src/psd_activator.c    | 110 ++---
 .../pubsub_discovery/src/pubsub_discovery_impl.c   |   2 +-
 .../pubsub_discovery/src/pubsub_discovery_impl.h   |  60 +--
 .../pubsub/pubsub_serializer_json/CMakeLists.txt   |   8 +-
 .../src/ps_json_serializer_activator.c             |  38 +-
 .../src/pubsub_serializer_impl.c                   | 439 ++++++++++----------
 .../src/pubsub_serializer_impl.h                   |   2 +-
 bundles/pubsub/pubsub_spi/CMakeLists.txt           |  12 +-
 bundles/pubsub/pubsub_spi/include/pubsub_admin.h   |  40 +-
 .../pubsub_spi/include/pubsub_admin_metrics.h      |  96 ++---
 .../pubsub/pubsub_spi/include/pubsub_constants.h   |   2 +-
 .../pubsub/pubsub_spi/include/pubsub_listeners.h   |  12 +-
 .../pubsub/pubsub_spi/include/pubsub_serializer.h  |  26 +-
 bundles/pubsub/pubsub_spi/include/pubsub_utils.h   |   4 +-
 bundles/pubsub/pubsub_spi/src/pubsub_endpoint.c    | 216 +++++-----
 bundles/pubsub/pubsub_spi/src/pubsub_utils.c       | 192 ++++-----
 bundles/pubsub/pubsub_spi/src/pubsub_utils_match.c | 346 ++++++++--------
 .../pubsub/pubsub_topology_manager/CMakeLists.txt  |  16 +-
 .../pubsub_topology_manager/src/pstm_activator.c   | 232 +++++------
 .../src/pubsub_topology_manager.c                  |   6 +-
 .../src/pubsub_topology_manager.h                  | 130 +++---
 bundles/pubsub/test/test/sut_activator.c           |  96 ++---
 bundles/pubsub/test/test/tst_activator.cc          |  12 +-
 55 files changed, 1859 insertions(+), 1869 deletions(-)

diff --git a/bundles/pubsub/examples/pubsub/common/include/poi.h b/bundles/pubsub/examples/pubsub/common/include/poi.h
index c98007a..de2f196 100644
--- a/bundles/pubsub/examples/pubsub/common/include/poi.h
+++ b/bundles/pubsub/examples/pubsub/common/include/poi.h
@@ -20,33 +20,33 @@
  * poi.h
  *
  *  \date       Nov 12, 2015
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef POI_H_
 #define POI_H_
 
-#define MIN_LAT	-90.0F
-#define MAX_LAT	 90.0F
-#define MIN_LON	-180.0F
-#define MAX_LON	 180.0F
+#define MIN_LAT -90.0F
+#define MAX_LAT  90.0F
+#define MIN_LON -180.0F
+#define MAX_LON  180.0F
 
-#define MSG_POI_NAME	"poi" //Has to match the message name in the msg descriptor!
+#define MSG_POI_NAME "poi" //Has to match the message name in the msg descriptor!
 
 struct poi{
-	double lat;
-	double lon;
+    double lat;
+    double lon;
 };
 
 typedef struct poi1 poi1_t;
 
 struct location{
-	struct poi position;
-	char* name;
-	char* description;
-	char* extra;
-	char* data;
+    struct poi position;
+    char* name;
+    char* description;
+    char* extra;
+    char* data;
 };
 
 typedef struct location* location_t;
diff --git a/bundles/pubsub/examples/pubsub/publisher/CMakeLists.txt b/bundles/pubsub/examples/pubsub/publisher/CMakeLists.txt
index 00b528c..c68d533 100644
--- a/bundles/pubsub/examples/pubsub/publisher/CMakeLists.txt
+++ b/bundles/pubsub/examples/pubsub/publisher/CMakeLists.txt
@@ -19,31 +19,31 @@ add_celix_bundle(celix_pubsub_poi_publisher
     SYMBOLIC_NAME "apache_celix_pubsub_poi_publisher"
     VERSION "1.0.0"
     SOURCES 
-    	private/src/ps_pub_activator.c
-    	private/src/pubsub_publisher.c
+        private/src/ps_pub_activator.c
+        private/src/pubsub_publisher.c
 )
 
 target_link_libraries(celix_pubsub_poi_publisher PRIVATE Celix::framework Celix::pubsub_api)
 target_include_directories(celix_pubsub_poi_publisher PRIVATE private/include)
 
 celix_bundle_files(celix_pubsub_poi_publisher
-		${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/msg_poi1.descriptor
-		${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/msg_poi2.descriptor
+        ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/msg_poi1.descriptor
+        ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/msg_poi2.descriptor
     DESTINATION "META-INF/descriptors"
 )
 
 celix_bundle_files(celix_pubsub_poi_publisher
-		${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/poi1.properties
-		${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/poi2.properties
+        ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/poi1.properties
+        ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/poi2.properties
     DESTINATION "META-INF/topics/pub"
 )
 
 celix_bundle_files(celix_pubsub_poi_publisher
-		${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/keys/publisher
+        ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/keys/publisher
     DESTINATION "META-INF/keys"
 )
 
 celix_bundle_files(celix_pubsub_poi_publisher
-		${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/keys/subscriber/public
+        ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/keys/subscriber/public
     DESTINATION "META-INF/keys/subscriber"
 )
diff --git a/bundles/pubsub/examples/pubsub/publisher/private/include/pubsub_publisher_private.h b/bundles/pubsub/examples/pubsub/publisher/private/include/pubsub_publisher_private.h
index d12ad3a..a124a9b 100644
--- a/bundles/pubsub/examples/pubsub/publisher/private/include/pubsub_publisher_private.h
+++ b/bundles/pubsub/examples/pubsub/publisher/private/include/pubsub_publisher_private.h
@@ -25,18 +25,18 @@
 #include "pubsub/publisher.h"
 
 struct pubsub_sender {
-	array_list_pt trackers;
-	const char *ident;
-	hash_map_pt tid_map; //service -> tid
-	long bundleId;
+    array_list_pt trackers;
+    const char *ident;
+    hash_map_pt tid_map; //service -> tid
+    long bundleId;
 };
 
 typedef struct pubsub_sender * pubsub_sender_pt;
 
 typedef struct send_thread_struct{
-	pubsub_publisher_pt service;
-	pubsub_sender_pt publisher;
-	const char *topic;
+    pubsub_publisher_pt service;
+    pubsub_sender_pt publisher;
+    const char *topic;
 } *send_thread_struct_pt;
 
 pubsub_sender_pt publisher_create(array_list_pt trackers, const char* ident,long bundleId);
diff --git a/bundles/pubsub/examples/pubsub/publisher/private/src/pubsub_publisher.c b/bundles/pubsub/examples/pubsub/publisher/private/src/pubsub_publisher.c
index 8c685e7..de6f21b 100644
--- a/bundles/pubsub/examples/pubsub/publisher/private/src/pubsub_publisher.c
+++ b/bundles/pubsub/examples/pubsub/publisher/private/src/pubsub_publisher.c
@@ -20,8 +20,8 @@
  * pubsub_publisher.c
  *
  *  \date       Sep 21, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #include <stdlib.h>
@@ -38,132 +38,131 @@
 
 static bool stop=false;
 
-static double randCoordinate(double min, double max){
+static double randCoordinate(double min, double max) {
 
-	double ret = min + (((double)random()) / (((double)RAND_MAX)/(max-min))) ;
+    double ret = min + (((double)random()) / (((double)RAND_MAX)/(max-min))) ;
 
-	return ret;
+    return ret;
 
 }
 
-static void* send_thread(void* arg){
+static void* send_thread(void* arg) {
 
-	send_thread_struct_pt st_struct = (send_thread_struct_pt)arg;
+    send_thread_struct_pt st_struct = (send_thread_struct_pt)arg;
 
-	pubsub_publisher_pt publish_svc = (pubsub_publisher_pt)st_struct->service;
-	pubsub_sender_pt publisher = (pubsub_sender_pt)st_struct->publisher;
+    pubsub_publisher_pt publish_svc = (pubsub_publisher_pt)st_struct->service;
+    pubsub_sender_pt publisher = (pubsub_sender_pt)st_struct->publisher;
 
-	char fwUUID[9];
-	memset(fwUUID,0,9);
-	memcpy(fwUUID,publisher->ident,8);
+    char fwUUID[9];
+    memset(fwUUID,0,9);
+    memcpy(fwUUID,publisher->ident,8);
 
-	//poi_t point = calloc(1,sizeof(*point));
-	location_t place = calloc(1,sizeof(*place));
+    //poi_t point = calloc(1,sizeof(*point));
+    location_t place = calloc(1,sizeof(*place));
 
-	char* desc = calloc(64,sizeof(char));
-	snprintf(desc,64,"fw-%s [TID=%lu]", fwUUID, (unsigned long)pthread_self());
+    char* desc = calloc(64,sizeof(char));
+    snprintf(desc,64,"fw-%s [TID=%lu]", fwUUID, (unsigned long)pthread_self());
 
-	char* name = calloc(64,sizeof(char));
-	snprintf(name,64,"Bundle#%ld",publisher->bundleId);
+    char* name = calloc(64,sizeof(char));
+    snprintf(name,64,"Bundle#%ld",publisher->bundleId);
 
-	place->name = name;
-	place->description = desc;
-	place->extra = "extra value";
-	printf("TOPIC : %s\n",st_struct->topic);
-	unsigned int msgId = 0;
-	if( publish_svc->localMsgTypeIdForMsgType(publish_svc->handle,st_struct->topic,&msgId) == 0 ){
+    place->name = name;
+    place->description = desc;
+    place->extra = "extra value";
+    printf("TOPIC : %s\n",st_struct->topic);
+    unsigned int msgId = 0;
+    if (publish_svc->localMsgTypeIdForMsgType(publish_svc->handle,st_struct->topic,&msgId) == 0) {
 
-		while(stop==false){
-			place->position.lat = randCoordinate(MIN_LAT,MAX_LAT);
-			place->position.lon = randCoordinate(MIN_LON,MAX_LON);
-			int nr_char = (int)randCoordinate(5,100000);
-			place->data = calloc(nr_char, 1);
-			for(int i = 0; i < (nr_char-1); i++) {
-				place->data[i] = i%10 + '0';
-			}
-			place->data[nr_char-1] = '\0';
-			if(publish_svc->send) {
-				if(publish_svc->send(publish_svc->handle,msgId,place)==0){
-					printf("Sent %s [%f, %f] (%s, %s) data len = %d\n",st_struct->topic, place->position.lat, place->position.lon,place->name,place->description, nr_char);
-				}
-			} else {
-				printf("No send for %s\n", st_struct->topic);
-			}
+        while (stop == false) {
+            place->position.lat = randCoordinate(MIN_LAT,MAX_LAT);
+            place->position.lon = randCoordinate(MIN_LON,MAX_LON);
+            int nr_char = (int)randCoordinate(5,100000);
+            place->data = calloc(nr_char, 1);
+            for (int i = 0; i < (nr_char-1); i++) {
+                place->data[i] = i%10 + '0';
+            }
+            place->data[nr_char-1] = '\0';
+            if (publish_svc->send) {
+                if (publish_svc->send(publish_svc->handle,msgId,place) == 0) {
+                    printf("Sent %s [%f, %f] (%s, %s) data len = %d\n",st_struct->topic, place->position.lat, place->position.lon,place->name,place->description, nr_char);
+                }
+            } else {
+                printf("No send for %s\n", st_struct->topic);
+            }
 
-			free(place->data);
-			sleep(2);
-		}
-	}
-	else{
-		printf("PUBLISHER: Cannot retrieve msgId for message '%s'\n",MSG_POI_NAME);
-	}
+            free(place->data);
+            sleep(2);
+        }
+    } else {
+        printf("PUBLISHER: Cannot retrieve msgId for message '%s'\n",MSG_POI_NAME);
+    }
 
-	free(place->description);
-	free(place->name);
-	free(place);
+    free(place->description);
+    free(place->name);
+    free(place);
 
-	free(st_struct);
+    free(st_struct);
 
 
-	return NULL;
+    return NULL;
 
 }
 
 pubsub_sender_pt publisher_create(array_list_pt trackers,const char* ident,long bundleId) {
-	pubsub_sender_pt publisher = malloc(sizeof(*publisher));
+    pubsub_sender_pt publisher = malloc(sizeof(*publisher));
 
-	publisher->trackers = trackers;
-	publisher->ident = ident;
-	publisher->bundleId = bundleId;
-	publisher->tid_map = hashMap_create(NULL, NULL, NULL, NULL);
+    publisher->trackers = trackers;
+    publisher->ident = ident;
+    publisher->bundleId = bundleId;
+    publisher->tid_map = hashMap_create(NULL, NULL, NULL, NULL);
 
-	return publisher;
+    return publisher;
 }
 
 void publisher_start(pubsub_sender_pt client) {
-	printf("PUBLISHER: starting up...\n");
+    printf("PUBLISHER: starting up...\n");
 }
 
 void publisher_stop(pubsub_sender_pt client) {
-	printf("PUBLISHER: stopping...\n");
+    printf("PUBLISHER: stopping...\n");
 }
 
 void publisher_destroy(pubsub_sender_pt client) {
-	hashMap_destroy(client->tid_map, false, false);
-	client->trackers = NULL;
-	client->ident = NULL;
-	free(client);
+    hashMap_destroy(client->tid_map, false, false);
+    client->trackers = NULL;
+    client->ident = NULL;
+    free(client);
 }
 
 void publisher_publishSvcAdded(void * handle, void *svc, const celix_properties_t *props) {
-	pubsub_publisher_pt publish_svc = (pubsub_publisher_pt)svc;
-	pubsub_sender_pt manager = (pubsub_sender_pt)handle;
-
-	printf("PUBLISHER: new publish service exported (%s).\n",manager->ident);
-
-	send_thread_struct_pt data = calloc(1,sizeof(struct send_thread_struct));
-	data->service = publish_svc;
-	data->publisher = manager;
-	data->topic = celix_properties_get(props, PUBSUB_PUBLISHER_TOPIC, "!ERROR!");
-	celix_thread_t *tid = malloc(sizeof(*tid));
-	stop=false;
-	celixThread_create(tid,NULL,send_thread,(void*)data);
-	hashMap_put(manager->tid_map, publish_svc, tid);
+    pubsub_publisher_pt publish_svc = (pubsub_publisher_pt)svc;
+    pubsub_sender_pt manager = (pubsub_sender_pt)handle;
+
+    printf("PUBLISHER: new publish service exported (%s).\n",manager->ident);
+
+    send_thread_struct_pt data = calloc(1,sizeof(struct send_thread_struct));
+    data->service = publish_svc;
+    data->publisher = manager;
+    data->topic = celix_properties_get(props, PUBSUB_PUBLISHER_TOPIC, "!ERROR!");
+    celix_thread_t *tid = malloc(sizeof(*tid));
+    stop=false;
+    celixThread_create(tid,NULL,send_thread,(void*)data);
+    hashMap_put(manager->tid_map, publish_svc, tid);
 }
 
 void publisher_publishSvcRemoved(void * handle, void *svc, const celix_properties_t *props) {
-	pubsub_sender_pt manager = (pubsub_sender_pt)handle;
-	celix_thread_t *tid = hashMap_get(manager->tid_map, svc);
+    pubsub_sender_pt manager = (pubsub_sender_pt)handle;
+    celix_thread_t *tid = hashMap_get(manager->tid_map, svc);
 
 #if defined(__APPLE__) && defined(__MACH__)
-	uint64_t threadid;
-	pthread_threadid_np(tid->thread, &threadid);
-	printf("PUBLISHER: publish service unexporting (%s) %llu!\n",manager->ident, threadid);
+    uint64_t threadid;
+    pthread_threadid_np(tid->thread, &threadid);
+    printf("PUBLISHER: publish service unexporting (%s) %llu!\n",manager->ident, threadid);
 #else
-	printf("PUBLISHER: publish service unexporting (%s) %li!\n",manager->ident, tid->thread);
+    printf("PUBLISHER: publish service unexporting (%s) %li!\n",manager->ident, tid->thread);
 #endif
 
-	stop=true;
-	celixThread_join(*tid,NULL);
-	free(tid);
+    stop=true;
+    celixThread_join(*tid,NULL);
+    free(tid);
 }
diff --git a/bundles/pubsub/examples/pubsub/publisher2/CMakeLists.txt b/bundles/pubsub/examples/pubsub/publisher2/CMakeLists.txt
index e59d793..a29968b 100644
--- a/bundles/pubsub/examples/pubsub/publisher2/CMakeLists.txt
+++ b/bundles/pubsub/examples/pubsub/publisher2/CMakeLists.txt
@@ -19,32 +19,32 @@ add_celix_bundle(celix_pubsub_poi_publisher2
     SYMBOLIC_NAME "apache_celix_pubsub_poi_publisher2"
     VERSION "1.0.0"
     SOURCES 
-    	../publisher/private/src/ps_pub_activator.c
-    	../publisher/private/src/pubsub_publisher.c
+        ../publisher/private/src/ps_pub_activator.c
+        ../publisher/private/src/pubsub_publisher.c
 )
 target_link_libraries(celix_pubsub_poi_publisher2 PRIVATE Celix::framework Celix::pubsub_api)
 target_include_directories(celix_pubsub_poi_publisher2 PRIVATE ../publisher/private/include)
 
 
 celix_bundle_files(celix_pubsub_poi_publisher2
-	${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/msg_poi1.descriptor
-	${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/msg_poi2.descriptor
+    ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/msg_poi1.descriptor
+    ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/msg_poi2.descriptor
     DESTINATION "META-INF/descriptors"
 )
 
 celix_bundle_files(celix_pubsub_poi_publisher2
-		${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/poi1.properties
-		${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/poi2.properties
+        ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/poi1.properties
+        ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/poi2.properties
     DESTINATION "META-INF/topics/pub"
 )
 
 celix_bundle_files(celix_pubsub_poi_publisher2
-		${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/keys/publisher
+        ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/keys/publisher
     DESTINATION "META-INF/keys"
 )
 
 celix_bundle_files(celix_pubsub_poi_publisher2
-	${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/keys/subscriber/public
+    ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/keys/subscriber/public
     DESTINATION "META-INF/keys/subscriber"
 )
 
diff --git a/bundles/pubsub/examples/pubsub/subscriber/CMakeLists.txt b/bundles/pubsub/examples/pubsub/subscriber/CMakeLists.txt
index 05afa04..94acdb2 100644
--- a/bundles/pubsub/examples/pubsub/subscriber/CMakeLists.txt
+++ b/bundles/pubsub/examples/pubsub/subscriber/CMakeLists.txt
@@ -19,8 +19,8 @@ add_celix_bundle(celix_pubsub_poi_subscriber
     SYMBOLIC_NAME "apache_celix_pubsub_poi_subscriber" 
     VERSION "1.0.0"
     SOURCES 
-    	private/src/ps_sub_activator.c
-		private/src/pubsub_subscriber.c
+        private/src/ps_sub_activator.c
+        private/src/pubsub_subscriber.c
 )
 
 target_link_libraries(celix_pubsub_poi_subscriber PRIVATE Celix::framework Celix::pubsub_api)
@@ -28,23 +28,23 @@ target_include_directories(celix_pubsub_poi_subscriber PRIVATE private/include)
 
 
 celix_bundle_files(celix_pubsub_poi_subscriber
-	    ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/msg_poi1.descriptor
-	    ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/msg_poi2.descriptor
+        ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/msg_poi1.descriptor
+        ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/msg_poi2.descriptor
     DESTINATION "META-INF/descriptors"
 )
 
 celix_bundle_files(celix_pubsub_poi_subscriber
-		${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/poi1.properties
-		${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/poi2.properties
+        ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/poi1.properties
+        ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/pubsub/msg_descriptors/poi2.properties
     DESTINATION "META-INF/topics/sub"
 )
 
 celix_bundle_files(celix_pubsub_poi_subscriber
-		${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/keys/subscriber
+        ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/keys/subscriber
     DESTINATION "META-INF/keys"
 )
 
 celix_bundle_files(celix_pubsub_poi_subscriber
-		${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/keys/publisher/public
+        ${PROJECT_SOURCE_DIR}/bundles/pubsub/examples/keys/publisher/public
     DESTINATION "META-INF/keys/publisher"
 )
diff --git a/bundles/pubsub/examples/pubsub/subscriber/private/include/pubsub_subscriber_private.h b/bundles/pubsub/examples/pubsub/subscriber/private/include/pubsub_subscriber_private.h
index 6e14fa3..2aa93a6 100644
--- a/bundles/pubsub/examples/pubsub/subscriber/private/include/pubsub_subscriber_private.h
+++ b/bundles/pubsub/examples/pubsub/subscriber/private/include/pubsub_subscriber_private.h
@@ -20,8 +20,8 @@
  * pubsub_subscriber_private.h
  *
  *  \date       Sep 21, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef PUBSUB_SUBSCRIBER_PRIVATE_H_
@@ -35,7 +35,7 @@
 #include "pubsub/subscriber.h"
 
 struct pubsub_receiver {
-	char * name;
+    char *name;
 };
 
 typedef struct pubsub_receiver* pubsub_receiver_pt;
diff --git a/bundles/pubsub/examples/pubsub/subscriber/private/src/pubsub_subscriber.c b/bundles/pubsub/examples/pubsub/subscriber/private/src/pubsub_subscriber.c
index 7b7ac1d..2303fea 100644
--- a/bundles/pubsub/examples/pubsub/subscriber/private/src/pubsub_subscriber.c
+++ b/bundles/pubsub/examples/pubsub/subscriber/private/src/pubsub_subscriber.c
@@ -20,8 +20,8 @@
  * pubsub_subscriber.c
  *
  *  \date       Sep 21, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #include <stdlib.h>
@@ -31,33 +31,33 @@
 #include "pubsub_subscriber_private.h"
 
 pubsub_receiver_pt subscriber_create(char* topics) {
-	pubsub_receiver_pt sub = calloc(1,sizeof(*sub));
-	sub->name = strdup(topics);
-	return sub;
+    pubsub_receiver_pt sub = calloc(1,sizeof(*sub));
+    sub->name = strdup(topics);
+    return sub;
 }
 
 
-void subscriber_start(pubsub_receiver_pt subscriber){
-	printf("Subscriber started...\n");
+void subscriber_start(pubsub_receiver_pt subscriber) {
+    printf("Subscriber started...\n");
 }
 
-void subscriber_stop(pubsub_receiver_pt subscriber){
-	printf("Subscriber stopped...\n");
+void subscriber_stop(pubsub_receiver_pt subscriber) {
+    printf("Subscriber stopped...\n");
 }
 
-void subscriber_destroy(pubsub_receiver_pt subscriber){
-	if(subscriber->name!=NULL){
-		free(subscriber->name);
-	}
-	subscriber->name=NULL;
-	free(subscriber);
+void subscriber_destroy(pubsub_receiver_pt subscriber) {
+    if (subscriber->name != NULL) {
+        free(subscriber->name);
+    }
+    subscriber->name=NULL;
+    free(subscriber);
 }
 
-int pubsub_subscriber_recv(void* handle, const char* msgType, unsigned int msgTypeId, void* msg, bool* release){
+int pubsub_subscriber_recv(void* handle, const char* msgType, unsigned int msgTypeId, void* msg, bool* release) {
 
-	location_t place = (location_t)msg;
-	printf("Recv (%s): [%f, %f] (%s, %s, %s, len data %li)\n", msgType, place->position.lat, place->position.lon, place->name, place->description, place->extra, (long)(strlen(place->data) + 1));
+    location_t place = (location_t)msg;
+    printf("Recv (%s): [%f, %f] (%s, %s, %s, len data %li)\n", msgType, place->position.lat, place->position.lon, place->name, place->description, place->extra, (long)(strlen(place->data) + 1));
 
-	return 0;
+    return 0;
 
 }
diff --git a/bundles/pubsub/keygen/CMakeLists.txt b/bundles/pubsub/keygen/CMakeLists.txt
index bc42173..991648e 100644
--- a/bundles/pubsub/keygen/CMakeLists.txt
+++ b/bundles/pubsub/keygen/CMakeLists.txt
@@ -17,18 +17,18 @@
 
 if (BUILD_ZMQ_SECURITY)
 
-	find_package(ZMQ REQUIRED)
-	find_package(CZMQ REQUIRED)
-	find_package(OpenSSL 1.1.0 REQUIRED)
-	
-	include_directories("${ZMQ_INCLUDE_DIR}")
-	include_directories("${CZMQ_INCLUDE_DIR}")
-	include_directories("${OPENSSL_INCLUDE_DIR}")
-	
-	add_executable(makecert makecert.c)
-	target_link_libraries(makecert ${CZMQ_LIBRARIES})
-	
-	add_executable(ed_file ed_file.c)
-	target_link_libraries(ed_file ${ZMQ_LIBRARIES} ${CZMQ_LIBRARIES} ${OPENSSL_CRYPTO_LIBRARY})
+    find_package(ZMQ REQUIRED)
+    find_package(CZMQ REQUIRED)
+    find_package(OpenSSL 1.1.0 REQUIRED)
+    
+    include_directories("${ZMQ_INCLUDE_DIR}")
+    include_directories("${CZMQ_INCLUDE_DIR}")
+    include_directories("${OPENSSL_INCLUDE_DIR}")
+    
+    add_executable(makecert makecert.c)
+    target_link_libraries(makecert ${CZMQ_LIBRARIES})
+    
+    add_executable(ed_file ed_file.c)
+    target_link_libraries(ed_file ${ZMQ_LIBRARIES} ${CZMQ_LIBRARIES} ${OPENSSL_CRYPTO_LIBRARY})
 
 endif()
diff --git a/bundles/pubsub/keygen/ed_file.c b/bundles/pubsub/keygen/ed_file.c
index a6aa125..4cf1907 100644
--- a/bundles/pubsub/keygen/ed_file.c
+++ b/bundles/pubsub/keygen/ed_file.c
@@ -20,8 +20,8 @@
  * ed_file.c
  *
  *  \date       Dec 2, 2016
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #include <czmq.h>
@@ -49,261 +49,261 @@ static void parse_key_line(char *line, char **key, char **iv);
 
 int main(int argc, const char* argv[])
 {
-	if (argc < 4){
-		printf("Usage: %s <key_file> <input_file> <output_file> [options]\n", argv[0]);
-		printf("Default behavior: encrypting a file\n");
-		printf("Options:\n");
-		printf("\t-d\tSpecify to decrypt a file\n");
-		printf("\n");
-		return EXIT_FAILURE;
-	}
-
-	int rc = 0;
-
-	const char* keys_file_path = argv[1];
-	const char* input_file_path = argv[2];
-	const char* output_file_path = argv[3];
-
-	bool decryptParam = false;
-	if (argc > 4 && strcmp(argv[4], "-d") == 0){
-		decryptParam = true;
-	}
-
-	if (!zsys_file_exists(keys_file_path)){
-		printf("Keys file '%s' doesn't exist!\n", keys_file_path);
-		return EXIT_FAILURE;
-	}
-
-	if (!zsys_file_exists(input_file_path)){
-		printf("Input file does not exist!\n");
-		return EXIT_FAILURE;
-	}
-
-	char* keys_data = read_keys_file_content(keys_file_path);
-	if (keys_data == NULL){
-		return EXIT_FAILURE;
-	}
-
-	char* key = NULL;
-	char* iv = NULL;
-	parse_key_lines(keys_data, &key, &iv);
-	free(keys_data);
-
-	if (key == NULL || iv == NULL){
-		printf("Loading AES key and/or AES iv failed!\n");
-		free(key);
-		free(iv);
-		return EXIT_FAILURE;
-	}
-
-	printf("Using AES Key \t\t'%s'\n", key);
-	printf("Using AES IV \t\t'%s'\n", iv);
-	printf("Input file path \t'%s'\n", input_file_path);
-	printf("Output file path \t'%s'\n", output_file_path);
-	printf("Decrypting \t\t'%s'\n\n", (decryptParam) ? "true" : "false");
-
-	unsigned char key_digest[EVP_MAX_MD_SIZE];
-	unsigned char iv_digest[EVP_MAX_MD_SIZE];
-	generate_sha256_hash((char*) key, key_digest);
-	generate_sha256_hash((char*) iv, iv_digest);
-
-	zchunk_t* input_chunk = zchunk_slurp (input_file_path, 0);
-	if (input_chunk == NULL){
-		printf("Input file not correct!\n");
-		free(key);
-		free(iv);
-		return EXIT_FAILURE;
-	}
-
-	//Load input data from file
-	int input_file_size = (int) zchunk_size (input_chunk);
-	char* input_file_data = zchunk_strdup(input_chunk);
-	zchunk_destroy (&input_chunk);
-
-	int output_len;
-	unsigned char output[input_file_size];
-	if (decryptParam){
-		output_len = decrypt_aes((unsigned char*) input_file_data, input_file_size, key_digest, iv_digest, output);
-		output[output_len] = '\0';
-	}else{
-		output_len = encrypt_aes((unsigned char*) input_file_data, input_file_size, key_digest, iv_digest, output);
-	}
-
-	//Write output data to file
-	zfile_t* output_file = zfile_new (".", output_file_path);
-	zchunk_t* output_chunk = zchunk_new(output, output_len);
-	rc = zfile_output (output_file);
-	if (rc != 0){
-		printf("Problem with opening file for writing!\n");
-		zchunk_destroy (&output_chunk);
-		zfile_close (output_file);
-		zfile_destroy (&output_file);
-		free(input_file_data);
-		free(key);
-		free(iv);
-
-		return EXIT_FAILURE;
-	}
-
-	rc = zfile_write (output_file, output_chunk, 0);
-	if (rc != 0){
-		printf("Problem with writing output to file!\n");
-	}
-	printf("Output written to file:\n");
-	if (decryptParam){
-		printf("%s\n", output);
-	}else{
-		BIO_dump_fp (stdout, (const char *) output, output_len);
-	}
-
-	zchunk_destroy (&output_chunk);
-	zfile_close (output_file);
-	zfile_destroy (&output_file);
-	free(input_file_data);
-	free(key);
-	free(iv);
-
-	return EXIT_SUCCESS;
+    if (argc < 4) {
+        printf("Usage: %s <key_file> <input_file> <output_file> [options]\n", argv[0]);
+        printf("Default behavior: encrypting a file\n");
+        printf("Options:\n");
+        printf("\t-d\tSpecify to decrypt a file\n");
+        printf("\n");
+        return EXIT_FAILURE;
+    }
+
+    int rc = 0;
+
+    const char* keys_file_path = argv[1];
+    const char* input_file_path = argv[2];
+    const char* output_file_path = argv[3];
+
+    bool decryptParam = false;
+    if (argc > 4 && strcmp(argv[4], "-d") == 0) {
+        decryptParam = true;
+    }
+
+    if (!zsys_file_exists(keys_file_path)) {
+        printf("Keys file '%s' doesn't exist!\n", keys_file_path);
+        return EXIT_FAILURE;
+    }
+
+    if (!zsys_file_exists(input_file_path)) {
+        printf("Input file does not exist!\n");
+        return EXIT_FAILURE;
+    }
+
+    char* keys_data = read_keys_file_content(keys_file_path);
+    if (keys_data == NULL) {
+        return EXIT_FAILURE;
+    }
+
+    char* key = NULL;
+    char* iv = NULL;
+    parse_key_lines(keys_data, &key, &iv);
+    free(keys_data);
+
+    if (key == NULL || iv == NULL) {
+        printf("Loading AES key and/or AES iv failed!\n");
+        free(key);
+        free(iv);
+        return EXIT_FAILURE;
+    }
+
+    printf("Using AES Key \t\t'%s'\n", key);
+    printf("Using AES IV \t\t'%s'\n", iv);
+    printf("Input file path \t'%s'\n", input_file_path);
+    printf("Output file path \t'%s'\n", output_file_path);
+    printf("Decrypting \t\t'%s'\n\n", (decryptParam) ? "true" : "false");
+
+    unsigned char key_digest[EVP_MAX_MD_SIZE];
+    unsigned char iv_digest[EVP_MAX_MD_SIZE];
+    generate_sha256_hash((char*) key, key_digest);
+    generate_sha256_hash((char*) iv, iv_digest);
+
+    zchunk_t* input_chunk = zchunk_slurp (input_file_path, 0);
+    if (input_chunk == NULL) {
+        printf("Input file not correct!\n");
+        free(key);
+        free(iv);
+        return EXIT_FAILURE;
+    }
+
+    //Load input data from file
+    int input_file_size = (int) zchunk_size (input_chunk);
+    char* input_file_data = zchunk_strdup(input_chunk);
+    zchunk_destroy (&input_chunk);
+
+    int output_len;
+    unsigned char output[input_file_size];
+    if (decryptParam) {
+        output_len = decrypt_aes((unsigned char*) input_file_data, input_file_size, key_digest, iv_digest, output);
+        output[output_len] = '\0';
+    }else{
+        output_len = encrypt_aes((unsigned char*) input_file_data, input_file_size, key_digest, iv_digest, output);
+    }
+
+    //Write output data to file
+    zfile_t* output_file = zfile_new (".", output_file_path);
+    zchunk_t* output_chunk = zchunk_new(output, output_len);
+    rc = zfile_output (output_file);
+    if (rc != 0) {
+        printf("Problem with opening file for writing!\n");
+        zchunk_destroy (&output_chunk);
+        zfile_close (output_file);
+        zfile_destroy (&output_file);
+        free(input_file_data);
+        free(key);
+        free(iv);
+
+        return EXIT_FAILURE;
+    }
+
+    rc = zfile_write (output_file, output_chunk, 0);
+    if (rc != 0) {
+        printf("Problem with writing output to file!\n");
+    }
+    printf("Output written to file:\n");
+    if (decryptParam) {
+        printf("%s\n", output);
+    }else{
+        BIO_dump_fp (stdout, (const char *) output, output_len);
+    }
+
+    zchunk_destroy (&output_chunk);
+    zfile_close (output_file);
+    zfile_destroy (&output_file);
+    free(input_file_data);
+    free(key);
+    free(iv);
+
+    return EXIT_SUCCESS;
 }
 
 int generate_sha256_hash(char* text, unsigned char* digest)
 {
-	unsigned int digest_len;
+    unsigned int digest_len;
 
-	EVP_MD_CTX * mdctx = EVP_MD_CTX_new();
-	EVP_DigestInit_ex(mdctx, EVP_sha256(), NULL);
-	EVP_DigestUpdate(mdctx, text, strlen(text));
-	EVP_DigestFinal_ex(mdctx, digest, &digest_len);
-	EVP_MD_CTX_free(mdctx);
+    EVP_MD_CTX * mdctx = EVP_MD_CTX_new();
+    EVP_DigestInit_ex(mdctx, EVP_sha256(), NULL);
+    EVP_DigestUpdate(mdctx, text, strlen(text));
+    EVP_DigestFinal_ex(mdctx, digest, &digest_len);
+    EVP_MD_CTX_free(mdctx);
 
-	return digest_len;
+    return digest_len;
 }
 
 int encrypt_aes(unsigned char *plaintext, int plaintext_len, unsigned char *key, unsigned char *iv, unsigned char *ciphertext)
 {
-	int len;
-	int ciphertext_len;
+    int len;
+    int ciphertext_len;
 
-	EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
+    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
 
-	EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv);
-	EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len);
-	ciphertext_len = len;
-	EVP_EncryptFinal_ex(ctx, ciphertext + len, &len);
-	ciphertext_len += len;
+    EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv);
+    EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len);
+    ciphertext_len = len;
+    EVP_EncryptFinal_ex(ctx, ciphertext + len, &len);
+    ciphertext_len += len;
 
-	EVP_CIPHER_CTX_free(ctx);
+    EVP_CIPHER_CTX_free(ctx);
 
-	return ciphertext_len;
+    return ciphertext_len;
 }
 
 int decrypt_aes(unsigned char *ciphertext, int ciphertext_len, unsigned char *key, unsigned char *iv, unsigned char *plaintext)
 {
-	int len;
-	int plaintext_len;
+    int len;
+    int plaintext_len;
 
-	EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
+    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
 
-	EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv);
-	EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len);
-	plaintext_len = len;
-	EVP_DecryptFinal_ex(ctx, plaintext + len, &len);
-	plaintext_len += len;
+    EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv);
+    EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len);
+    plaintext_len = len;
+    EVP_DecryptFinal_ex(ctx, plaintext + len, &len);
+    plaintext_len += len;
 
-	EVP_CIPHER_CTX_free(ctx);
+    EVP_CIPHER_CTX_free(ctx);
 
-	return plaintext_len;
+    return plaintext_len;
 }
 
-static char* read_keys_file_content(const char *keys_file_path){
-	char* keys_file_full_path = strndup(keys_file_path, MAX_KEY_FILE_LENGTH);
-	char* keys_file_name = NULL;
-
-	char* sep_kf_at = strrchr(keys_file_path, '/');
-	if (sep_kf_at != NULL){
-		*sep_kf_at = '\0';
-		keys_file_name = sep_kf_at + 1;
-	}else{
-		keys_file_name = (char*) keys_file_path;
-		keys_file_path = (const char*) ".";
-	}
-
-	printf("Keys file path: %s\n", keys_file_full_path);
-
-	int rc = 0;
-
-	zfile_t* keys_file = zfile_new (keys_file_path, keys_file_name);
-	rc = zfile_input (keys_file);
-	if (rc != 0){
-		printf("Keys file '%s' not readable!\n", keys_file_full_path);
-		zfile_destroy(&keys_file);
-		free(keys_file_full_path);
-		return NULL;
-	}
-
-	ssize_t keys_file_size = zsys_file_size (keys_file_full_path);
-	zchunk_t* keys_chunk = zfile_read (keys_file, keys_file_size, 0);
-	if (keys_chunk == NULL){
-		printf("Can't read file '%s'!\n", keys_file_full_path);
-		zfile_close(keys_file);
-		zfile_destroy(&keys_file);
-		free(keys_file_full_path);
-		return NULL;
-	}
-
-	char* keys_data = zchunk_strdup(keys_chunk);
-	zchunk_destroy(&keys_chunk);
-	zfile_close(keys_file);
-	zfile_destroy (&keys_file);
-
-	return keys_data;
+static char* read_keys_file_content(const char *keys_file_path) {
+    char* keys_file_full_path = strndup(keys_file_path, MAX_KEY_FILE_LENGTH);
+    char* keys_file_name = NULL;
+
+    char* sep_kf_at = strrchr(keys_file_path, '/');
+    if (sep_kf_at != NULL) {
+        *sep_kf_at = '\0';
+        keys_file_name = sep_kf_at + 1;
+    }else{
+        keys_file_name = (char*) keys_file_path;
+        keys_file_path = (const char*) ".";
+    }
+
+    printf("Keys file path: %s\n", keys_file_full_path);
+
+    int rc = 0;
+
+    zfile_t* keys_file = zfile_new (keys_file_path, keys_file_name);
+    rc = zfile_input (keys_file);
+    if (rc != 0) {
+        printf("Keys file '%s' not readable!\n", keys_file_full_path);
+        zfile_destroy(&keys_file);
+        free(keys_file_full_path);
+        return NULL;
+    }
+
+    ssize_t keys_file_size = zsys_file_size (keys_file_full_path);
+    zchunk_t* keys_chunk = zfile_read (keys_file, keys_file_size, 0);
+    if (keys_chunk == NULL) {
+        printf("Can't read file '%s'!\n", keys_file_full_path);
+        zfile_close(keys_file);
+        zfile_destroy(&keys_file);
+        free(keys_file_full_path);
+        return NULL;
+    }
+
+    char* keys_data = zchunk_strdup(keys_chunk);
+    zchunk_destroy(&keys_chunk);
+    zfile_close(keys_file);
+    zfile_destroy (&keys_file);
+
+    return keys_data;
 }
 
-static void parse_key_lines(char *keysBuffer, char **key, char **iv){
-	char *line = NULL, *saveLinePointer = NULL;
+static void parse_key_lines(char *keysBuffer, char **key, char **iv) {
+    char *line = NULL, *saveLinePointer = NULL;
 
-	bool firstTime = true;
-	do {
-		if (firstTime){
-			line = strtok_r(keysBuffer, "\n", &saveLinePointer);
-			firstTime = false;
-		}else {
-			line = strtok_r(NULL, "\n", &saveLinePointer);
-		}
+    bool firstTime = true;
+    do {
+        if (firstTime) {
+            line = strtok_r(keysBuffer, "\n", &saveLinePointer);
+            firstTime = false;
+        }else {
+            line = strtok_r(NULL, "\n", &saveLinePointer);
+        }
 
-		if (line == NULL){
-			break;
-		}
+        if (line == NULL) {
+            break;
+        }
 
-		parse_key_line(line, key, iv);
+        parse_key_line(line, key, iv);
 
-	} while((*key == NULL || *iv == NULL) && line != NULL);
+    } while ((*key == NULL || *iv == NULL) && line != NULL);
 
 }
 
-static void parse_key_line(char *line, char **key, char **iv){
-	char *detectedKey = NULL, *detectedValue= NULL;
-
-	char* sep_at = strchr(line, ':');
-	if (sep_at == NULL){
-		return;
-	}
-
-	*sep_at = '\0'; // overwrite first separator, creating two strings.
-	detectedKey = line;
-	detectedValue = sep_at + 1;
-
-	if (detectedKey == NULL || detectedValue == NULL){
-		return;
-	}
-	if (detectedKey[0] == '\0' || detectedValue[0] == '\0'){
-		return;
-	}
-
-	if (*key == NULL && strcmp(detectedKey, KEY_TO_GET) == 0){
-		*key = strndup(detectedValue, AES_KEY_LENGTH);
-	} else if (*iv == NULL && strcmp(detectedKey, IV_TO_GET) == 0){
-		*iv = strndup(detectedValue, AES_IV_LENGTH);
-	}
+static void parse_key_line(char *line, char **key, char **iv) {
+    char *detectedKey = NULL, *detectedValue= NULL;
+
+    char* sep_at = strchr(line, ':');
+    if (sep_at == NULL) {
+        return;
+    }
+
+    *sep_at = '\0'; // overwrite first separator, creating two strings.
+    detectedKey = line;
+    detectedValue = sep_at + 1;
+
+    if (detectedKey == NULL || detectedValue == NULL) {
+        return;
+    }
+    if (detectedKey[0] == '\0' || detectedValue[0] == '\0') {
+        return;
+    }
+
+    if (*key == NULL && strcmp(detectedKey, KEY_TO_GET) == 0) {
+        *key = strndup(detectedValue, AES_KEY_LENGTH);
+    } else if (*iv == NULL && strcmp(detectedKey, IV_TO_GET) == 0) {
+        *iv = strndup(detectedValue, AES_IV_LENGTH);
+    }
 }
 
diff --git a/bundles/pubsub/keygen/makecert.c b/bundles/pubsub/keygen/makecert.c
index 7552631..75ba5b5 100644
--- a/bundles/pubsub/keygen/makecert.c
+++ b/bundles/pubsub/keygen/makecert.c
@@ -20,36 +20,35 @@
  * makecert.c
  *
  *  \date       Dec 2, 2016
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #include <string.h>
 
 #include "czmq.h"
 
-int main (int argc, const char * argv[])
-{
+int main (int argc, const char * argv[]) {
 
-	const char * cert_name_public = "certificate.pub";
-	const char * cert_name_secret = "certificate.key";
-	if (argc == 3 && strcmp(argv[1], argv[2]) != 0){
-		cert_name_public = argv[1];
-		cert_name_secret = argv[2];
-	}
+    const char * cert_name_public = "certificate.pub";
+    const char * cert_name_secret = "certificate.key";
+    if (argc == 3 && strcmp(argv[1], argv[2]) != 0) {
+        cert_name_public = argv[1];
+        cert_name_secret = argv[2];
+    }
 
-	zcert_t * cert = zcert_new();
+    zcert_t * cert = zcert_new();
 
-	char *timestr = zclock_timestr ();
-	zcert_set_meta (cert, "date-created", timestr);
-	free (timestr);
+    char *timestr = zclock_timestr ();
+    zcert_set_meta (cert, "date-created", timestr);
+    free (timestr);
 
-	zcert_save_public(cert, cert_name_public);
-	zcert_save_secret(cert, cert_name_secret);
-	zcert_print (cert);
-	printf("\n");
-	printf("I: CURVE certificate created in %s and %s\n", cert_name_public, cert_name_secret);
-	zcert_destroy (&cert);
+    zcert_save_public(cert, cert_name_public);
+    zcert_save_secret(cert, cert_name_secret);
+    zcert_print (cert);
+    printf("\n");
+    printf("I: CURVE certificate created in %s and %s\n", cert_name_public, cert_name_secret);
+    zcert_destroy (&cert);
 
-	return 0;
+    return 0;
 }
diff --git a/bundles/pubsub/mock/tst/pubsubmock_test.cc b/bundles/pubsub/mock/tst/pubsubmock_test.cc
index 116d877..f546bf3 100644
--- a/bundles/pubsub/mock/tst/pubsubmock_test.cc
+++ b/bundles/pubsub/mock/tst/pubsubmock_test.cc
@@ -35,8 +35,8 @@ static void* mockHandle = (void*)0x42;
 
 TEST_GROUP(pubsubmock) {
     void setup(void) {
-    	//setup mock
-    	pubsub_publisherMock_init(&mockSrv, mockHandle);
+        //setup mock
+        pubsub_publisherMock_init(&mockSrv, mockHandle);
     }
 
     void teardown() {
@@ -51,8 +51,8 @@ TEST(pubsubmock, publishermock) {
 
     mock(PUBSUB_PUBLISHERMOCK_SCOPE).expectOneCall(PUBSUB_PUBLISHERMOCK_LOCAL_MSG_TYPE_ID_FOR_MSG_TYPE_METHOD)
         .withParameter("handle", mockHandle)
-	.withParameter("msgType", mockFqn)
-	.withOutputParameterReturning("msgTypeId", &mockOutputTypeId, sizeof(mockOutputTypeId));
+    .withParameter("msgType", mockFqn)
+    .withOutputParameterReturning("msgTypeId", &mockOutputTypeId, sizeof(mockOutputTypeId));
 
     mock(PUBSUB_PUBLISHERMOCK_SCOPE).expectOneCall(PUBSUB_PUBLISHERMOCK_SEND_METHOD)
         .withParameter("handle", mockHandle)
diff --git a/bundles/pubsub/pubsub_admin_nanomsg/CMakeLists.txt b/bundles/pubsub/pubsub_admin_nanomsg/CMakeLists.txt
index ab9806e..86a5000 100644
--- a/bundles/pubsub/pubsub_admin_nanomsg/CMakeLists.txt
+++ b/bundles/pubsub/pubsub_admin_nanomsg/CMakeLists.txt
@@ -17,35 +17,35 @@
 
 if (BUILD_PUBSUB_PSA_NANOMSG)
 
-	find_package(NanoMsg REQUIRED)
-	find_package(Jansson REQUIRED)
+    find_package(NanoMsg REQUIRED)
+    find_package(Jansson REQUIRED)
 
-	add_celix_bundle(celix_pubsub_admin_nanomsg
-		BUNDLE_SYMBOLICNAME "apache_celix_pubsub_admin_nanomsg"
-		VERSION "1.0.0"
-		GROUP "Celix/PubSub"
-		SOURCES
-			src/psa_nanomsg_activator.cc
-			src/pubsub_nanomsg_admin.cc
-			src/pubsub_nanomsg_topic_sender.cc
-			src/pubsub_nanomsg_topic_receiver.cc
-			src/pubsub_nanomsg_common.cc
-	)
+    add_celix_bundle(celix_pubsub_admin_nanomsg
+        BUNDLE_SYMBOLICNAME "apache_celix_pubsub_admin_nanomsg"
+        VERSION "1.0.0"
+        GROUP "Celix/PubSub"
+        SOURCES
+            src/psa_nanomsg_activator.cc
+            src/pubsub_nanomsg_admin.cc
+            src/pubsub_nanomsg_topic_sender.cc
+            src/pubsub_nanomsg_topic_receiver.cc
+            src/pubsub_nanomsg_common.cc
+    )
 
-	set_target_properties(celix_pubsub_admin_nanomsg PROPERTIES INSTALL_RPATH "$ORIGIN")
-	target_link_libraries(celix_pubsub_admin_nanomsg PRIVATE
-			Celix::pubsub_spi
-			Celix::framework Celix::dfi Celix::log_helper
-			${NANOMSG_LIBRARIES}
-	)
-	target_include_directories(celix_pubsub_admin_nanomsg PRIVATE
-		${NANOMSG_INCLUDE_DIR}
-		${JANSSON_INCLUDE_DIR}
-		src
-		../pubsub_topology_manager/src
-	)
+    set_target_properties(celix_pubsub_admin_nanomsg PROPERTIES INSTALL_RPATH "$ORIGIN")
+    target_link_libraries(celix_pubsub_admin_nanomsg PRIVATE
+            Celix::pubsub_spi
+            Celix::framework Celix::dfi Celix::log_helper
+            ${NANOMSG_LIBRARIES}
+    )
+    target_include_directories(celix_pubsub_admin_nanomsg PRIVATE
+        ${NANOMSG_INCLUDE_DIR}
+        ${JANSSON_INCLUDE_DIR}
+        src
+        ../pubsub_topology_manager/src
+    )
 
-	install_celix_bundle(celix_pubsub_admin_nanomsg EXPORT celix COMPONENT pubsub)
-	target_link_libraries(celix_pubsub_admin_nanomsg PRIVATE Celix::shell_api)
-	add_library(Celix::pubsub_admin_nanomsg ALIAS celix_pubsub_admin_nanomsg)
+    install_celix_bundle(celix_pubsub_admin_nanomsg EXPORT celix COMPONENT pubsub)
+    target_link_libraries(celix_pubsub_admin_nanomsg PRIVATE Celix::shell_api)
+    add_library(Celix::pubsub_admin_nanomsg ALIAS celix_pubsub_admin_nanomsg)
 endif()
diff --git a/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_admin.cc b/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_admin.cc
index 7e34838..27b264d 100644
--- a/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_admin.cc
+++ b/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_admin.cc
@@ -236,7 +236,7 @@ void pubsub_nanomsg_admin::removeSerializerSvc(void */*svc*/, const celix_proper
         auto &entry = kvsm->second;
         {
             std::lock_guard<std::mutex> senderLock(topicSenders.mutex);
-            for(auto it = topicSenders.map.begin(); it != topicSenders.map.end(); /*nothing*/) {
+            for (auto it = topicSenders.map.begin(); it != topicSenders.map.end(); /*nothing*/) {
                 auto &sender = it->second;
                 if (entry.svcId == sender.getSerializerSvcId()) {
                     it = topicSenders.map.erase(it);
diff --git a/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_admin.h b/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_admin.h
index 0a1615a..7fd35a6 100644
--- a/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_admin.h
+++ b/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_admin.h
@@ -38,7 +38,7 @@
 #define PUBSUB_NANOMSG_VERBOSE_DEFAULT  true
 
 #define PUBSUB_NANOMSG_PSA_IP_KEY       "PSA_IP"
-#define PUBSUB_NANOMSG_PSA_ITF_KEY		"PSA_INTERFACE"
+#define PUBSUB_NANOMSG_PSA_ITF_KEY      "PSA_INTERFACE"
 
 #define PUBSUB_NANOMSG_DEFAULT_IP       "127.0.0.1"
 
diff --git a/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_common.cc b/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_common.cc
index 7e97bab..b791ee2 100644
--- a/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_common.cc
+++ b/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_common.cc
@@ -33,7 +33,7 @@ bool celix::pubsub::nanomsg::checkVersion(version_pt msgVersion, const celix::pu
     if (msgVersion!=NULL) {
         version_getMajor(msgVersion,&major);
         version_getMinor(msgVersion,&minor);
-        if(hdr->major==((unsigned char)major)){ /* Different major means incompatible */
+        if (hdr->major==((unsigned char)major)) { /* Different major means incompatible */
             check = (hdr->minor>=((unsigned char)minor)); /* Compatible only if the provider has a minor equals or greater (means compatible update) */
         }
     }
diff --git a/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_topic_receiver.cc b/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_topic_receiver.cc
index 031d1ba..dabf72e 100644
--- a/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_topic_receiver.cc
+++ b/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_topic_receiver.cc
@@ -124,7 +124,7 @@ pubsub::nanomsg::topic_receiver::~topic_receiver() {
 
         {
             std::lock_guard<std::mutex> _lock(subscribers.mutex);
-            for(auto elem : subscribers.map) {
+            for (auto elem : subscribers.map) {
                 serializer->destroySerializerMap(serializer->handle, elem.second.msgTypes);
             }
             subscribers.map.clear();
@@ -257,7 +257,7 @@ void pubsub::nanomsg::topic_receiver::processMsgForSubscriberEntry(psa_nanomsg_s
         bool validVersion = celix::pubsub::nanomsg::checkVersion(msgSer->msgVersion, hdr);
         if (validVersion) {
             celix_status_t status = msgSer->deserialize(msgSer, payload, payloadSize, &deserializedMsg);
-            if(status == CELIX_SUCCESS) {
+            if (status == CELIX_SUCCESS) {
                 bool release = false;
                 svc->receive(svc->handle, msgSer->msgName, msgSer->msgId, deserializedMsg, &release);
                 if (release) {
diff --git a/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_topic_sender.cc b/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_topic_sender.cc
index 10920bf..378199c 100644
--- a/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_topic_sender.cc
+++ b/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_nanomsg_topic_sender.cc
@@ -64,7 +64,7 @@ pubsub::nanomsg::pubsub_nanomsg_topic_sender::pubsub_nanomsg_topic_sender(celix_
     }
 
     int rv = -1, retry=0;
-    while(rv == -1 && retry < NANOMSG_BIND_MAX_RETRY ) {
+    while (rv == -1 && retry < NANOMSG_BIND_MAX_RETRY ) {
         /* Randomized part due to same bundle publishing on different topics */
         unsigned int port = rand_range(_basePort,_maxPort);
         std::stringstream _url;
@@ -252,14 +252,14 @@ static void delay_first_send_for_late_joiners(celix::pubsub::nanomsg::LogHelper&
 
     static bool firstSend = true;
 
-    if(firstSend){
+    if (firstSend) {
         logHelper.INFO("PSA_UDP_MC_TP: Delaying first send for late joiners...\n");
         sleep(FIRST_SEND_DELAY_IN_SECONDS);
         firstSend = false;
     }
 }
 
-static unsigned int rand_range(unsigned int min, unsigned int max){
+static unsigned int rand_range(unsigned int min, unsigned int max) {
     double scaled = ((double)random())/((double)RAND_MAX);
     return (unsigned int)((max-min+1)*scaled + min);
 }
diff --git a/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_psa_nanomsg_constants.h b/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_psa_nanomsg_constants.h
index 9b8882b..5632e1d 100644
--- a/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_psa_nanomsg_constants.h
+++ b/bundles/pubsub/pubsub_admin_nanomsg/src/pubsub_psa_nanomsg_constants.h
@@ -30,13 +30,13 @@
 #define PSA_NANOMSG_DEFAULT_BASE_PORT               5501
 #define PSA_NANOMSG_DEFAULT_MAX_PORT                6000
 
-#define PSA_NANOMSG_DEFAULT_QOS_SAMPLE_SCORE 	    30
-#define PSA_NANOMSG_DEFAULT_QOS_CONTROL_SCORE 	    70
-#define PSA_NANOMSG_DEFAULT_SCORE 				    30
+#define PSA_NANOMSG_DEFAULT_QOS_SAMPLE_SCORE        30
+#define PSA_NANOMSG_DEFAULT_QOS_CONTROL_SCORE       70
+#define PSA_NANOMSG_DEFAULT_SCORE                   30
 
-#define PSA_NANOMSG_QOS_SAMPLE_SCORE_KEY 		    "PSA_NANOMSG_QOS_SAMPLE_SCORE"
-#define PSA_NANOMSG_QOS_CONTROL_SCORE_KEY 		    "PSA_NANOMSG_QOS_CONTROL_SCORE"
-#define PSA_NANOMSG_DEFAULT_SCORE_KEY 			    "PSA_NANOMSG_DEFAULT_SCORE"
+#define PSA_NANOMSG_QOS_SAMPLE_SCORE_KEY            "PSA_NANOMSG_QOS_SAMPLE_SCORE"
+#define PSA_NANOMSG_QOS_CONTROL_SCORE_KEY           "PSA_NANOMSG_QOS_CONTROL_SCORE"
+#define PSA_NANOMSG_DEFAULT_SCORE_KEY               "PSA_NANOMSG_DEFAULT_SCORE"
 
 
 #endif /* PUBSUB_PSA_NANOMSG_CONSTANTS_H_ */
diff --git a/bundles/pubsub/pubsub_admin_udp_mc/CMakeLists.txt b/bundles/pubsub/pubsub_admin_udp_mc/CMakeLists.txt
index e5ed16f..8b87422 100644
--- a/bundles/pubsub/pubsub_admin_udp_mc/CMakeLists.txt
+++ b/bundles/pubsub/pubsub_admin_udp_mc/CMakeLists.txt
@@ -18,20 +18,20 @@
 find_package(Jansson REQUIRED)
 
 add_celix_bundle(celix_pubsub_admin_udp_multicast
-	BUNDLE_SYMBOLICNAME "apache_celix_pubsub_admin_udp_multicast"
-	VERSION "1.0.0"
-	GROUP "Celix/PubSub"
-	SOURCES
+    BUNDLE_SYMBOLICNAME "apache_celix_pubsub_admin_udp_multicast"
+    VERSION "1.0.0"
+    GROUP "Celix/PubSub"
+    SOURCES
         src/psa_activator.c
-		src/pubsub_udpmc_admin.c
-		src/pubsub_udpmc_topic_sender.c
-		src/pubsub_udpmc_topic_receiver.c
-		src/pubsub_udpmc_common.c
+        src/pubsub_udpmc_admin.c
+        src/pubsub_udpmc_topic_sender.c
+        src/pubsub_udpmc_topic_receiver.c
+        src/pubsub_udpmc_common.c
         src/large_udp.c
 )
 target_include_directories(celix_pubsub_admin_udp_multicast PRIVATE
-		src
-		${JANSSON_INCLUDE_DIR}
+        src
+        ${JANSSON_INCLUDE_DIR}
 )
 set_target_properties(celix_pubsub_admin_udp_multicast PROPERTIES INSTALL_RPATH "$ORIGIN")
 target_link_libraries(celix_pubsub_admin_udp_multicast PRIVATE Celix::pubsub_spi Celix::framework Celix::dfi Celix::log_helper Celix::utils)
diff --git a/bundles/pubsub/pubsub_admin_zmq/CMakeLists.txt b/bundles/pubsub/pubsub_admin_zmq/CMakeLists.txt
index e2d346b..bcf6199 100644
--- a/bundles/pubsub/pubsub_admin_zmq/CMakeLists.txt
+++ b/bundles/pubsub/pubsub_admin_zmq/CMakeLists.txt
@@ -17,54 +17,54 @@
 
 if (BUILD_PUBSUB_PSA_ZMQ)
 
-	find_package(ZMQ REQUIRED)
-	find_package(CZMQ REQUIRED)
-	find_package(Jansson REQUIRED)
-	find_package(UUID REQUIRED)
+    find_package(ZMQ REQUIRED)
+    find_package(CZMQ REQUIRED)
+    find_package(Jansson REQUIRED)
+    find_package(UUID REQUIRED)
 
-	if(NOT UUID_LIBRARY)
-		#i.e. not found for OSX
-		set(UUID_LIBRARY "")
-		set(UUID_INCLUDE_DIRS "")
-	endif()
+    if(NOT UUID_LIBRARY)
+        #i.e. not found for OSX
+        set(UUID_LIBRARY "")
+        set(UUID_INCLUDE_DIRS "")
+    endif()
 
-	if (BUILD_ZMQ_SECURITY)
-		add_definitions(-DBUILD_WITH_ZMQ_SECURITY=1)
+    if (BUILD_ZMQ_SECURITY)
+        add_definitions(-DBUILD_WITH_ZMQ_SECURITY=1)
 
-		find_package(OpenSSL 1.1.0 REQUIRED)
-		include_directories("${OPENSSL_INCLUDE_DIR}")
+        find_package(OpenSSL 1.1.0 REQUIRED)
+        include_directories("${OPENSSL_INCLUDE_DIR}")
 
-		set (ZMQ_CRYPTO_C "src/zmq_crypto.c")
-	endif()
+        set (ZMQ_CRYPTO_C "src/zmq_crypto.c")
+    endif()
 
-	add_celix_bundle(celix_pubsub_admin_zmq
-		BUNDLE_SYMBOLICNAME "apache_celix_pubsub_admin_zmq"
-		VERSION "1.0.0"
-		GROUP "Celix/PubSub"
-		SOURCES
-			src/psa_activator.c
-			src/pubsub_zmq_admin.c
-			src/pubsub_zmq_topic_sender.c
-			src/pubsub_zmq_topic_receiver.c
-			src/pubsub_zmq_common.c
-			${ZMQ_CRYPTO_C}
-	)
+    add_celix_bundle(celix_pubsub_admin_zmq
+        BUNDLE_SYMBOLICNAME "apache_celix_pubsub_admin_zmq"
+        VERSION "1.0.0"
+        GROUP "Celix/PubSub"
+        SOURCES
+            src/psa_activator.c
+            src/pubsub_zmq_admin.c
+            src/pubsub_zmq_topic_sender.c
+            src/pubsub_zmq_topic_receiver.c
+            src/pubsub_zmq_common.c
+            ${ZMQ_CRYPTO_C}
+    )
 
-	set_target_properties(celix_pubsub_admin_zmq PROPERTIES INSTALL_RPATH "$ORIGIN")
-	target_link_libraries(celix_pubsub_admin_zmq PRIVATE
-			Celix::pubsub_spi
-			Celix::framework Celix::dfi Celix::log_helper Celix::utils
-			${ZMQ_LIBRARIES} ${CZMQ_LIBRARIES} ${OPENSSL_CRYPTO_LIBRARY}
-	)
-	target_include_directories(celix_pubsub_admin_zmq PRIVATE
-		${ZMQ_INCLUDE_DIR}
-		${CZMQ_INCLUDE_DIR}
-		${JANSSON_INCLUDE_DIR}
-		${UUID_INCLUDE_DIRS}
-		src
-	)
+    set_target_properties(celix_pubsub_admin_zmq PROPERTIES INSTALL_RPATH "$ORIGIN")
+    target_link_libraries(celix_pubsub_admin_zmq PRIVATE
+            Celix::pubsub_spi
+            Celix::framework Celix::dfi Celix::log_helper Celix::utils
+            ${ZMQ_LIBRARIES} ${CZMQ_LIBRARIES} ${OPENSSL_CRYPTO_LIBRARY}
+    )
+    target_include_directories(celix_pubsub_admin_zmq PRIVATE
+        ${ZMQ_INCLUDE_DIR}
+        ${CZMQ_INCLUDE_DIR}
+        ${JANSSON_INCLUDE_DIR}
+        ${UUID_INCLUDE_DIRS}
+        src
+    )
 
-	install_celix_bundle(celix_pubsub_admin_zmq EXPORT celix COMPONENT pubsub)
-	target_link_libraries(celix_pubsub_admin_zmq PRIVATE Celix::shell_api)
-	add_library(Celix::pubsub_admin_zmq ALIAS celix_pubsub_admin_zmq)
+    install_celix_bundle(celix_pubsub_admin_zmq EXPORT celix COMPONENT pubsub)
+    target_link_libraries(celix_pubsub_admin_zmq PRIVATE Celix::shell_api)
+    add_library(Celix::pubsub_admin_zmq ALIAS celix_pubsub_admin_zmq)
 endif()
diff --git a/bundles/pubsub/pubsub_admin_zmq/src/psa_activator.c b/bundles/pubsub/pubsub_admin_zmq/src/psa_activator.c
index 75b23a9..d1df6aa 100644
--- a/bundles/pubsub/pubsub_admin_zmq/src/psa_activator.c
+++ b/bundles/pubsub/pubsub_admin_zmq/src/psa_activator.c
@@ -29,99 +29,99 @@
 #include "command.h"
 
 typedef struct psa_zmq_activator {
-	log_helper_t *logHelper;
+    log_helper_t *logHelper;
 
-	pubsub_zmq_admin_t *admin;
+    pubsub_zmq_admin_t *admin;
 
-	long serializersTrackerId;
+    long serializersTrackerId;
 
-	pubsub_admin_service_t adminService;
-	long adminSvcId;
+    pubsub_admin_service_t adminService;
+    long adminSvcId;
 
-	pubsub_admin_metrics_service_t adminMetricsService;
-	long adminMetricsSvcId;
+    pubsub_admin_metrics_service_t adminMetricsService;
+    long adminMetricsSvcId;
 
-	command_service_t cmdSvc;
-	long cmdSvcId;
+    command_service_t cmdSvc;
+    long cmdSvcId;
 } psa_zmq_activator_t;
 
 int psa_zmq_start(psa_zmq_activator_t *act, celix_bundle_context_t *ctx) {
-	act->adminSvcId = -1L;
-	act->cmdSvcId = -1L;
-	act->serializersTrackerId = -1L;
-
-	logHelper_create(ctx, &act->logHelper);
-	logHelper_start(act->logHelper);
-
-	act->admin = pubsub_zmqAdmin_create(ctx, act->logHelper);
-	celix_status_t status = act->admin != NULL ? CELIX_SUCCESS : CELIX_BUNDLE_EXCEPTION;
-
-	//track serializers
-	if (status == CELIX_SUCCESS) {
-		celix_service_tracking_options_t opts = CELIX_EMPTY_SERVICE_TRACKING_OPTIONS;
-		opts.filter.serviceName = PUBSUB_SERIALIZER_SERVICE_NAME;
-		opts.filter.ignoreServiceLanguage = true;
-		opts.callbackHandle = act->admin;
-		opts.addWithProperties = pubsub_zmqAdmin_addSerializerSvc;
-		opts.removeWithProperties = pubsub_zmqAdmin_removeSerializerSvc;
-		act->serializersTrackerId = celix_bundleContext_trackServicesWithOptions(ctx, &opts);
-	}
-
-	//register pubsub admin service
-	if (status == CELIX_SUCCESS) {
-		pubsub_admin_service_t *psaSvc = &act->adminService;
-		psaSvc->handle = act->admin;
-		psaSvc->matchPublisher = pubsub_zmqAdmin_matchPublisher;
-		psaSvc->matchSubscriber = pubsub_zmqAdmin_matchSubscriber;
-		psaSvc->matchDiscoveredEndpoint = pubsub_zmqAdmin_matchDiscoveredEndpoint;
-		psaSvc->setupTopicSender = pubsub_zmqAdmin_setupTopicSender;
-		psaSvc->teardownTopicSender = pubsub_zmqAdmin_teardownTopicSender;
-		psaSvc->setupTopicReceiver = pubsub_zmqAdmin_setupTopicReceiver;
-		psaSvc->teardownTopicReceiver = pubsub_zmqAdmin_teardownTopicReceiver;
-		psaSvc->addDiscoveredEndpoint = pubsub_zmqAdmin_addDiscoveredEndpoint;
-		psaSvc->removeDiscoveredEndpoint = pubsub_zmqAdmin_removeDiscoveredEndpoint;
-
-		celix_properties_t *props = celix_properties_create();
-		celix_properties_set(props, PUBSUB_ADMIN_SERVICE_TYPE, PUBSUB_ZMQ_ADMIN_TYPE);
-
-		act->adminSvcId = celix_bundleContext_registerService(ctx, psaSvc, PUBSUB_ADMIN_SERVICE_NAME, props);
-	}
-
-	if (status == CELIX_SUCCESS) {
-		act->adminMetricsService.handle = act->admin;
-		act->adminMetricsService.metrics = pubsub_zmqAdmin_metrics;
-
-		celix_properties_t *props = celix_properties_create();
-		celix_properties_set(props, PUBSUB_ADMIN_SERVICE_TYPE, PUBSUB_ZMQ_ADMIN_TYPE);
-
-		act->adminMetricsSvcId = celix_bundleContext_registerService(ctx, &act->adminMetricsService, PUBSUB_ADMIN_METRICS_SERVICE_NAME, props);
-	}
-
-	//register shell command service
-	{
-		act->cmdSvc.handle = act->admin;
-		act->cmdSvc.executeCommand = pubsub_zmqAdmin_executeCommand;
-		celix_properties_t *props = celix_properties_create();
-		celix_properties_set(props, OSGI_SHELL_COMMAND_NAME, "psa_zmq");
-		celix_properties_set(props, OSGI_SHELL_COMMAND_USAGE, "psa_zmq");
-		celix_properties_set(props, OSGI_SHELL_COMMAND_DESCRIPTION, "Print the information about the TopicSender and TopicReceivers for the ZMQ PSA");
-		act->cmdSvcId = celix_bundleContext_registerService(ctx, &act->cmdSvc, OSGI_SHELL_COMMAND_SERVICE_NAME, props);
-	}
-
-	return status;
+    act->adminSvcId = -1L;
+    act->cmdSvcId = -1L;
+    act->serializersTrackerId = -1L;
+
+    logHelper_create(ctx, &act->logHelper);
+    logHelper_start(act->logHelper);
+
+    act->admin = pubsub_zmqAdmin_create(ctx, act->logHelper);
+    celix_status_t status = act->admin != NULL ? CELIX_SUCCESS : CELIX_BUNDLE_EXCEPTION;
+
+    //track serializers
+    if (status == CELIX_SUCCESS) {
+        celix_service_tracking_options_t opts = CELIX_EMPTY_SERVICE_TRACKING_OPTIONS;
+        opts.filter.serviceName = PUBSUB_SERIALIZER_SERVICE_NAME;
+        opts.filter.ignoreServiceLanguage = true;
+        opts.callbackHandle = act->admin;
+        opts.addWithProperties = pubsub_zmqAdmin_addSerializerSvc;
+        opts.removeWithProperties = pubsub_zmqAdmin_removeSerializerSvc;
+        act->serializersTrackerId = celix_bundleContext_trackServicesWithOptions(ctx, &opts);
+    }
+
+    //register pubsub admin service
+    if (status == CELIX_SUCCESS) {
+        pubsub_admin_service_t *psaSvc = &act->adminService;
+        psaSvc->handle = act->admin;
+        psaSvc->matchPublisher = pubsub_zmqAdmin_matchPublisher;
+        psaSvc->matchSubscriber = pubsub_zmqAdmin_matchSubscriber;
+        psaSvc->matchDiscoveredEndpoint = pubsub_zmqAdmin_matchDiscoveredEndpoint;
+        psaSvc->setupTopicSender = pubsub_zmqAdmin_setupTopicSender;
+        psaSvc->teardownTopicSender = pubsub_zmqAdmin_teardownTopicSender;
+        psaSvc->setupTopicReceiver = pubsub_zmqAdmin_setupTopicReceiver;
+        psaSvc->teardownTopicReceiver = pubsub_zmqAdmin_teardownTopicReceiver;
+        psaSvc->addDiscoveredEndpoint = pubsub_zmqAdmin_addDiscoveredEndpoint;
+        psaSvc->removeDiscoveredEndpoint = pubsub_zmqAdmin_removeDiscoveredEndpoint;
+
+        celix_properties_t *props = celix_properties_create();
+        celix_properties_set(props, PUBSUB_ADMIN_SERVICE_TYPE, PUBSUB_ZMQ_ADMIN_TYPE);
+
+        act->adminSvcId = celix_bundleContext_registerService(ctx, psaSvc, PUBSUB_ADMIN_SERVICE_NAME, props);
+    }
+
+    if (status == CELIX_SUCCESS) {
+        act->adminMetricsService.handle = act->admin;
+        act->adminMetricsService.metrics = pubsub_zmqAdmin_metrics;
+
+        celix_properties_t *props = celix_properties_create();
+        celix_properties_set(props, PUBSUB_ADMIN_SERVICE_TYPE, PUBSUB_ZMQ_ADMIN_TYPE);
+
+        act->adminMetricsSvcId = celix_bundleContext_registerService(ctx, &act->adminMetricsService, PUBSUB_ADMIN_METRICS_SERVICE_NAME, props);
+    }
+
+    //register shell command service
+    {
+        act->cmdSvc.handle = act->admin;
+        act->cmdSvc.executeCommand = pubsub_zmqAdmin_executeCommand;
+        celix_properties_t *props = celix_properties_create();
+        celix_properties_set(props, OSGI_SHELL_COMMAND_NAME, "psa_zmq");
+        celix_properties_set(props, OSGI_SHELL_COMMAND_USAGE, "psa_zmq");
+        celix_properties_set(props, OSGI_SHELL_COMMAND_DESCRIPTION, "Print the information about the TopicSender and TopicReceivers for the ZMQ PSA");
+        act->cmdSvcId = celix_bundleContext_registerService(ctx, &act->cmdSvc, OSGI_SHELL_COMMAND_SERVICE_NAME, props);
+    }
+
+    return status;
 }
 
 int psa_zmq_stop(psa_zmq_activator_t *act, celix_bundle_context_t *ctx) {
-	celix_bundleContext_unregisterService(ctx, act->adminSvcId);
-	celix_bundleContext_unregisterService(ctx, act->cmdSvcId);
-	celix_bundleContext_unregisterService(ctx, act->adminMetricsSvcId);
-	celix_bundleContext_stopTracker(ctx, act->serializersTrackerId);
-	pubsub_zmqAdmin_destroy(act->admin);
+    celix_bundleContext_unregisterService(ctx, act->adminSvcId);
+    celix_bundleContext_unregisterService(ctx, act->cmdSvcId);
+    celix_bundleContext_unregisterService(ctx, act->adminMetricsSvcId);
+    celix_bundleContext_stopTracker(ctx, act->serializersTrackerId);
+    pubsub_zmqAdmin_destroy(act->admin);
 
-	logHelper_stop(act->logHelper);
-	logHelper_destroy(&act->logHelper);
+    logHelper_stop(act->logHelper);
+    logHelper_destroy(&act->logHelper);
 
-	return CELIX_SUCCESS;
+    return CELIX_SUCCESS;
 }
 
 CELIX_GEN_BUNDLE_ACTIVATOR(psa_zmq_activator_t, psa_zmq_start, psa_zmq_stop);
diff --git a/bundles/pubsub/pubsub_admin_zmq/src/pubsub_psa_zmq_constants.h b/bundles/pubsub/pubsub_admin_zmq/src/pubsub_psa_zmq_constants.h
index d719e2f..e2665c0 100644
--- a/bundles/pubsub/pubsub_admin_zmq/src/pubsub_psa_zmq_constants.h
+++ b/bundles/pubsub/pubsub_admin_zmq/src/pubsub_psa_zmq_constants.h
@@ -17,8 +17,6 @@
  * under the License.
  */
 
-
-
 #ifndef PUBSUB_PSA_ZMQ_CONSTANTS_H_
 #define PUBSUB_PSA_ZMQ_CONSTANTS_H_
 
@@ -29,13 +27,13 @@
 #define PSA_ZMQ_DEFAULT_BASE_PORT               5501
 #define PSA_ZMQ_DEFAULT_MAX_PORT                6000
 
-#define PSA_ZMQ_DEFAULT_QOS_SAMPLE_SCORE 	    30
-#define PSA_ZMQ_DEFAULT_QOS_CONTROL_SCORE 	    70
-#define PSA_ZMQ_DEFAULT_SCORE 				    30
+#define PSA_ZMQ_DEFAULT_QOS_SAMPLE_SCORE        30
+#define PSA_ZMQ_DEFAULT_QOS_CONTROL_SCORE       70
+#define PSA_ZMQ_DEFAULT_SCORE                   30
 
-#define PSA_ZMQ_QOS_SAMPLE_SCORE_KEY 		    "PSA_ZMQ_QOS_SAMPLE_SCORE"
-#define PSA_ZMQ_QOS_CONTROL_SCORE_KEY 		    "PSA_ZMQ_QOS_CONTROL_SCORE"
-#define PSA_ZMQ_DEFAULT_SCORE_KEY 			    "PSA_ZMQ_DEFAULT_SCORE"
+#define PSA_ZMQ_QOS_SAMPLE_SCORE_KEY            "PSA_ZMQ_QOS_SAMPLE_SCORE"
+#define PSA_ZMQ_QOS_CONTROL_SCORE_KEY           "PSA_ZMQ_QOS_CONTROL_SCORE"
+#define PSA_ZMQ_DEFAULT_SCORE_KEY               "PSA_ZMQ_DEFAULT_SCORE"
 
 
 #define PSA_ZMQ_METRICS_ENABLED "PSA_ZMQ_METRICS_ENABLED"
@@ -49,7 +47,7 @@
 #define PUBSUB_ZMQ_VERBOSE_DEFAULT  true
 
 #define PUBSUB_ZMQ_PSA_IP_KEY       "PSA_IP"
-#define PUBSUB_ZMQ_PSA_ITF_KEY		"PSA_INTERFACE"
+#define PUBSUB_ZMQ_PSA_ITF_KEY      "PSA_INTERFACE"
 #define PUBSUB_ZMQ_NR_THREADS_KEY   "PSA_ZMQ_NR_THREADS"
 
 #define PUBSUB_ZMQ_DEFAULT_IP       "127.0.0.1"
diff --git a/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_admin.c b/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_admin.c
index acf8182..bb0890f 100644
--- a/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_admin.c
+++ b/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_admin.c
@@ -243,7 +243,7 @@ void pubsub_zmqAdmin_destroy(pubsub_zmq_admin_t *psa) {
     celixThreadMutex_destroy(&psa->serializers.mutex);
     hashMap_destroy(psa->serializers.map, false, false);
 
-    if (psa->zmq_auth != NULL){
+    if (psa->zmq_auth != NULL) {
         zactor_destroy(&psa->zmq_auth);
     }
 
diff --git a/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_common.c b/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_common.c
index 18996e4..145798b 100644
--- a/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_common.c
+++ b/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_common.c
@@ -38,7 +38,7 @@ bool psa_zmq_checkVersion(version_pt msgVersion, const pubsub_zmq_msg_header_t *
     if (msgVersion!=NULL) {
         version_getMajor(msgVersion,&major);
         version_getMinor(msgVersion,&minor);
-        if(hdr->major==((unsigned char)major)){ /* Different major means incompatible */
+        if (hdr->major==((unsigned char)major)) { /* Different major means incompatible */
             check = (hdr->minor>=((unsigned char)minor)); /* Compatible only if the provider has a minor equals or greater (means compatible update) */
         }
     }
diff --git a/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_topic_receiver.c b/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_topic_receiver.c
index 95bac2d..24c3686 100644
--- a/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_topic_receiver.c
+++ b/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_topic_receiver.c
@@ -38,7 +38,7 @@
 #define PSA_ZMQ_RECV_TIMEOUT 1000
 
 #ifndef UUID_STR_LEN
-#define UUID_STR_LEN	37
+#define UUID_STR_LEN 37
 #endif
 
 
@@ -145,7 +145,7 @@ pubsub_zmq_topic_receiver_t* pubsub_zmqTopicReceiver_create(celix_bundle_context
 
 #ifdef BUILD_WITH_ZMQ_SECURITY
     char* keys_bundle_dir = pubsub_getKeysBundleDir(bundle_context);
-    if (keys_bundle_dir == NULL){
+    if (keys_bundle_dir == NULL) {
         return CELIX_SERVICE_EXCEPTION;
     }
 
@@ -166,13 +166,13 @@ pubsub_zmq_topic_receiver_t* pubsub_zmqTopicReceiver_create(celix_bundle_context
     printf("PSA_ZMQ_PSA_ZMQ_TS: Loading publisher key '%s'\n", pub_cert_path);
 
     zcert_t* sub_cert = get_zcert_from_encoded_file((char *) keys_file_path, (char *) keys_file_name, sub_cert_path);
-    if (sub_cert == NULL){
+    if (sub_cert == NULL) {
         printf("PSA_ZMQ_PSA_ZMQ_TS: Cannot load key '%s'\n", sub_cert_path);
         return CELIX_SERVICE_EXCEPTION;
     }
 
     zcert_t* pub_cert = zcert_load(pub_cert_path);
-    if (pub_cert == NULL){
+    if (pub_cert == NULL) {
         zcert_destroy(&sub_cert);
         printf("PSA_ZMQ_PSA_ZMQ_TS: Cannot load key '%s'\n", pub_cert_path);
         return CELIX_SERVICE_EXCEPTION;
@@ -665,7 +665,7 @@ pubsub_admin_receiver_metrics_t* pubsub_zmqTopicReceiver_metrics(pubsub_zmq_topi
                 psa_zmq_subscriber_metrics_entry_t *metrics = hashMapIterator_nextValue(&iter3);
                 result->msgTypes[i].typeId = metrics->msgTypeId;
                 pubsub_msg_serializer_t *msgSer = hashMap_get(entry->msgTypes, (void*)(uintptr_t)metrics->msgTypeId);
-		if (msgSer) {
+                if (msgSer) {
                     snprintf(result->msgTypes[i].typeFqn, PUBSUB_AMDIN_METRICS_NAME_MAX, "%s", msgSer->msgName);
                     uuid_copy(result->msgTypes[i].origins[k].originUUID, metrics->origin);
                     result->msgTypes[i].origins[k].nrOfMessagesReceived = metrics->nrOfMessagesReceived;
@@ -700,7 +700,7 @@ static void psa_zmq_connectToAllRequestedConnections(pubsub_zmq_topic_receiver_t
         hash_map_iterator_t iter = hashMapIterator_construct(receiver->requestedConnections.map);
         while (hashMapIterator_hasNext(&iter)) {
             psa_zmq_requested_connection_entry_t *entry = hashMapIterator_nextValue(&iter);
-            if (!entry->connected){
+            if (!entry->connected) {
                 if (zmq_connect(receiver->zmqSock, entry->url) == 0) {
                     entry->connected = true;
                 } else {
diff --git a/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_topic_sender.c b/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_topic_sender.c
index d245be6..8166d4c 100644
--- a/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_topic_sender.c
+++ b/bundles/pubsub/pubsub_admin_zmq/src/pubsub_zmq_topic_sender.c
@@ -136,17 +136,17 @@ pubsub_zmq_topic_sender_t* pubsub_zmqTopicSender_create(
     //setting up zmq socket for ZMQ TopicSender
     {
 #ifdef BUILD_WITH_ZMQ_SECURITY
-        char* secure_topics = NULL;
-    	bundleContext_getProperty(bundle_context, "SECURE_TOPICS", (const char **) &secure_topics);
+        char *secure_topics = NULL;
+        bundleContext_getProperty(bundle_context, "SECURE_TOPICS", (const char **) &secure_topics);
 
-        if (secure_topics){
+        if (secure_topics) {
             array_list_pt secure_topics_list = pubsub_getTopicsFromString(secure_topics);
 
             int i;
             int secure_topics_size = arrayList_size(secure_topics_list);
-            for (i = 0; i < secure_topics_size; i++){
+            for (i = 0; i < secure_topics_size; i++) {
                 char* top = arrayList_get(secure_topics_list, i);
-                if (strcmp(pubEP->topic, top) == 0){
+                if (strcmp(pubEP->topic, top) == 0) {
                     printf("PSA_ZMQ_TP: Secure topic: '%s'\n", top);
                     pubEP->is_secure = true;
                 }
@@ -158,9 +158,9 @@ pubsub_zmq_topic_sender_t* pubsub_zmqTopicSender_create(
         }
 
         zcert_t* pub_cert = NULL;
-        if (pubEP->is_secure){
+        if (pubEP->is_secure) {
             char* keys_bundle_dir = pubsub_getKeysBundleDir(bundle_context);
-            if (keys_bundle_dir == NULL){
+            if (keys_bundle_dir == NULL) {
                 return CELIX_SERVICE_EXCEPTION;
             }
 
@@ -177,7 +177,7 @@ pubsub_zmq_topic_sender_t* pubsub_zmqTopicSender_create(
             printf("PSA_ZMQ_TP: Loading key '%s'\n", cert_path);
 
             pub_cert = get_zcert_from_encoded_file((char *) keys_file_path, (char *) keys_file_name, cert_path);
-            if (pub_cert == NULL){
+            if (pub_cert == NULL) {
                 printf("PSA_ZMQ_TP: Cannot load key '%s'\n", cert_path);
                 printf("PSA_ZMQ_TP: Topic '%s' NOT SECURED !\n", pubEP->topic);
                 pubEP->is_secure = false;
@@ -189,16 +189,16 @@ pubsub_zmq_topic_sender_t* pubsub_zmqTopicSender_create(
         if (zmqSocket==NULL) {
 #ifdef BUILD_WITH_ZMQ_SECURITY
             if (pubEP->is_secure) {
-				zcert_destroy(&pub_cert);
-			}
+                zcert_destroy(&pub_cert);
+            }
 #endif
             perror("Error for zmq_socket");
         }
 #ifdef BUILD_WITH_ZMQ_SECURITY
         if (pubEP->is_secure) {
-		    zcert_apply (pub_cert, socket); // apply certificate to socket
-		    zsock_set_curve_server (socket, true); // setup the publisher's socket to use the curve functions
-	    }
+            zcert_apply (pub_cert, socket); // apply certificate to socket
+            zsock_set_curve_server (socket, true); // setup the publisher's socket to use the curve functions
+        }
 #endif
 
         if (zmqSocket != NULL && staticBindUrl != NULL) {
@@ -624,14 +624,14 @@ static void delay_first_send_for_late_joiners(pubsub_zmq_topic_sender_t *sender)
 
     static bool firstSend = true;
 
-    if(firstSend){
+    if (firstSend) {
         L_INFO("PSA_ZMQ_TP: Delaying first send for late joiners...\n");
         sleep(FIRST_SEND_DELAY_IN_SECONDS);
         firstSend = false;
     }
 }
 
-static unsigned int rand_range(unsigned int min, unsigned int max){
+static unsigned int rand_range(unsigned int min, unsigned int max) {
     double scaled = ((double)random())/((double)RAND_MAX);
     return (unsigned int)((max-min+1)*scaled + min);
 }
diff --git a/bundles/pubsub/pubsub_admin_zmq/src/zmq_crypto.c b/bundles/pubsub/pubsub_admin_zmq/src/zmq_crypto.c
index 5ec7be1..5a3f176 100644
--- a/bundles/pubsub/pubsub_admin_zmq/src/zmq_crypto.c
+++ b/bundles/pubsub/pubsub_admin_zmq/src/zmq_crypto.c
@@ -20,8 +20,8 @@
  * zmq_crypto.c
  *
  *  \date       Dec 2, 2016
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #include "zmq_crypto.h"
@@ -50,232 +50,229 @@ static void extract_keys_from_buffer(unsigned char *input, int inputlen, char **
  * Return a valid zcert_t from an encoded file
  * Caller is responsible for freeing by calling zcert_destroy(zcert** cert);
  */
-zcert_t* get_zcert_from_encoded_file(char* keysFilePath, char* keysFileName, char* file_path)
-{
+zcert_t* get_zcert_from_encoded_file(char* keysFilePath, char* keysFileName, char* file_path) {
 
-	if (keysFilePath == NULL){
-		keysFilePath = DEFAULT_KEYS_FILE_PATH;
-	}
+    if (keysFilePath == NULL) {
+        keysFilePath = DEFAULT_KEYS_FILE_PATH;
+    }
 
-	if (keysFileName == NULL){
-		keysFileName = DEFAULT_KEYS_FILE_NAME;
-	}
+    if (keysFileName == NULL) {
+        keysFileName = DEFAULT_KEYS_FILE_NAME;
+    }
 
-	char* keys_data = read_file_content(keysFilePath, keysFileName);
-	if (keys_data == NULL){
-		return NULL;
-	}
+    char* keys_data = read_file_content(keysFilePath, keysFileName);
+    if (keys_data == NULL) {
+        return NULL;
+    }
 
-	char *key = NULL;
-	char *iv = NULL;
-	parse_key_lines(keys_data, &key, &iv);
-	free(keys_data);
+    char *key = NULL;
+    char *iv = NULL;
+    parse_key_lines(keys_data, &key, &iv);
+    free(keys_data);
 
-	if (key == NULL || iv == NULL){
-		free(key);
-		free(iv);
+    if (key == NULL || iv == NULL) {
+        free(key);
+        free(iv);
 
-		printf("CRYPTO: Loading AES key and/or AES iv failed!\n");
-		return NULL;
-	}
+        printf("CRYPTO: Loading AES key and/or AES iv failed!\n");
+        return NULL;
+    }
 
-	//At this point, we know an aes key and iv are stored and loaded
+    //At this point, we know an aes key and iv are stored and loaded
 
-	// generate sha256 hashes
-	unsigned char key_digest[EVP_MAX_MD_SIZE];
-	unsigned char iv_digest[EVP_MAX_MD_SIZE];
-	generate_sha256_hash((char*) key, key_digest);
-	generate_sha256_hash((char*) iv, iv_digest);
+    // generate sha256 hashes
+    unsigned char key_digest[EVP_MAX_MD_SIZE];
+    unsigned char iv_digest[EVP_MAX_MD_SIZE];
+    generate_sha256_hash((char*) key, key_digest);
+    generate_sha256_hash((char*) iv, iv_digest);
 
-	zchunk_t* encoded_secret = zchunk_slurp (file_path, 0);
-	if (encoded_secret == NULL){
-		free(key);
-		free(iv);
+    zchunk_t *encoded_secret = zchunk_slurp(file_path, 0);
+    if (encoded_secret == NULL) {
+        free(key);
+        free(iv);
 
-		return NULL;
-	}
+        return NULL;
+    }
 
-	int encoded_secret_size = (int) zchunk_size (encoded_secret);
-	char* encoded_secret_data = zchunk_strdup(encoded_secret);
-	zchunk_destroy (&encoded_secret);
+    int encoded_secret_size = (int) zchunk_size(encoded_secret);
+    char *encoded_secret_data = zchunk_strdup(encoded_secret);
+    zchunk_destroy(&encoded_secret);
 
-	// Decryption of data
-	int decryptedtext_len;
-	unsigned char decryptedtext[encoded_secret_size];
-	decryptedtext_len = decrypt((unsigned char *) encoded_secret_data, encoded_secret_size, key_digest, iv_digest, decryptedtext);
-	decryptedtext[decryptedtext_len] = '\0';
+    // Decryption of data
+    int decryptedtext_len;
+    unsigned char decryptedtext[encoded_secret_size];
+    decryptedtext_len = decrypt((unsigned char *) encoded_secret_data, encoded_secret_size, key_digest, iv_digest, decryptedtext);
+    decryptedtext[decryptedtext_len] = '\0';
 
-	EVP_cleanup();
+    EVP_cleanup();
 
-	free(encoded_secret_data);
-	free(key);
-	free(iv);
+    free(encoded_secret_data);
+    free(key);
+    free(iv);
 
-	// The public and private keys are retrieved
-	char* public_text = NULL;
-	char* secret_text = NULL;
+    // The public and private keys are retrieved
+    char *public_text = NULL;
+    char *secret_text = NULL;
 
-	extract_keys_from_buffer(decryptedtext, decryptedtext_len, &public_text, &secret_text);
+    extract_keys_from_buffer(decryptedtext, decryptedtext_len, &public_text, &secret_text);
 
-	byte public_key [32] = { 0 };
-	byte secret_key [32] = { 0 };
+    byte public_key [32] = { 0 };
+    byte secret_key [32] = { 0 };
 
-	zmq_z85_decode (public_key, public_text);
-	zmq_z85_decode (secret_key, secret_text);
+    zmq_z85_decode(public_key, public_text);
+    zmq_z85_decode(secret_key, secret_text);
 
-	zcert_t* cert_loaded = zcert_new_from(public_key, secret_key);
+    zcert_t *cert_loaded = zcert_new_from(public_key, secret_key);
 
-	free(public_text);
-	free(secret_text);
+    free(public_text);
+    free(secret_text);
 
-	return cert_loaded;
+    return cert_loaded;
 }
 
-int generate_sha256_hash(char* text, unsigned char* digest)
-{
-	unsigned int digest_len;
+int generate_sha256_hash(char* text, unsigned char* digest) {
+    unsigned int digest_len;
 
-	EVP_MD_CTX * mdctx = EVP_MD_CTX_new();
-	EVP_DigestInit_ex(mdctx, EVP_sha256(), NULL);
-	EVP_DigestUpdate(mdctx, text, strlen(text));
-	EVP_DigestFinal_ex(mdctx, digest, &digest_len);
-	EVP_MD_CTX_free(mdctx);
+    EVP_MD_CTX *mdctx = EVP_MD_CTX_new();
+    EVP_DigestInit_ex(mdctx, EVP_sha256(), NULL);
+    EVP_DigestUpdate(mdctx, text, strlen(text));
+    EVP_DigestFinal_ex(mdctx, digest, &digest_len);
+    EVP_MD_CTX_free(mdctx);
 
-	return digest_len;
+    return digest_len;
 }
 
-int decrypt(unsigned char *ciphertext, int ciphertext_len, unsigned char *key, unsigned char *iv, unsigned char *plaintext)
-{
-	int len;
-	int plaintext_len;
+int decrypt(unsigned char *ciphertext, int ciphertext_len, unsigned char *key, unsigned char *iv, unsigned char *plaintext) {
+    int len;
+    int plaintext_len;
 
-	EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
+    EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
 
-	EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv);
-	EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len);
-	plaintext_len = len;
-	EVP_DecryptFinal_ex(ctx, plaintext + len, &len);
-	plaintext_len += len;
+    EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv);
+    EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len);
+    plaintext_len = len;
+    EVP_DecryptFinal_ex(ctx, plaintext + len, &len);
+    plaintext_len += len;
 
-	EVP_CIPHER_CTX_free(ctx);
+    EVP_CIPHER_CTX_free(ctx);
 
-	return plaintext_len;
+    return plaintext_len;
 }
 
 /**
  * Caller is responsible for freeing the returned value
  */
-static char* read_file_content(char* filePath, char* fileName){
-
-	char fileNameWithPath[MAX_FILE_PATH_LENGTH];
-	snprintf(fileNameWithPath, MAX_FILE_PATH_LENGTH, "%s/%s", filePath, fileName);
-	int rc = 0;
-
-	if (!zsys_file_exists(fileNameWithPath)){
-		printf("CRYPTO: Keys file '%s' doesn't exist!\n", fileNameWithPath);
-		return NULL;
-	}
-
-	zfile_t* keys_file = zfile_new (filePath, fileName);
-	rc = zfile_input (keys_file);
-	if (rc != 0){
-		zfile_destroy(&keys_file);
-		printf("CRYPTO: Keys file '%s' not readable!\n", fileNameWithPath);
-		return NULL;
-	}
-
-	ssize_t keys_file_size = zsys_file_size (fileNameWithPath);
-	zchunk_t* keys_chunk = zfile_read (keys_file, keys_file_size, 0);
-	if (keys_chunk == NULL){
-		zfile_close(keys_file);
-		zfile_destroy(&keys_file);
-		printf("CRYPTO: Can't read file '%s'!\n", fileNameWithPath);
-		return NULL;
-	}
-
-	char* keys_data = zchunk_strdup(keys_chunk);
-	zchunk_destroy(&keys_chunk);
-	zfile_close(keys_file);
-	zfile_destroy (&keys_file);
-
-	return keys_data;
+static char* read_file_content(char* filePath, char* fileName) {
+
+    char fileNameWithPath[MAX_FILE_PATH_LENGTH];
+    snprintf(fileNameWithPath, MAX_FILE_PATH_LENGTH, "%s/%s", filePath, fileName);
+    int rc = 0;
+
+    if (!zsys_file_exists(fileNameWithPath)) {
+        printf("CRYPTO: Keys file '%s' doesn't exist!\n", fileNameWithPath);
+        return NULL;
+    }
+
+    zfile_t *keys_file = zfile_new (filePath, fileName);
+    rc = zfile_input (keys_file);
+    if (rc != 0) {
+        zfile_destroy(&keys_file);
+        printf("CRYPTO: Keys file '%s' not readable!\n", fileNameWithPath);
+        return NULL;
+    }
+
+    ssize_t keys_file_size = zsys_file_size (fileNameWithPath);
+    zchunk_t *keys_chunk = zfile_read (keys_file, keys_file_size, 0);
+    if (keys_chunk == NULL) {
+        zfile_close(keys_file);
+        zfile_destroy(&keys_file);
+        printf("CRYPTO: Can't read file '%s'!\n", fileNameWithPath);
+        return NULL;
+    }
+
+    char *keys_data = zchunk_strdup(keys_chunk);
+    zchunk_destroy(&keys_chunk);
+    zfile_close(keys_file);
+    zfile_destroy (&keys_file);
+
+    return keys_data;
 }
 
-static void parse_key_lines(char *keysBuffer, char **key, char **iv){
-	char *line = NULL, *saveLinePointer = NULL;
+static void parse_key_lines(char *keysBuffer, char **key, char **iv) {
+    char *line = NULL, *saveLinePointer = NULL;
 
-	bool firstTime = true;
-	do {
-		if (firstTime){
-			line = strtok_r(keysBuffer, "\n", &saveLinePointer);
-			firstTime = false;
-		}else {
-			line = strtok_r(NULL, "\n", &saveLinePointer);
-		}
+    bool firstTime = true;
+    do {
+        if (firstTime) {
+            line = strtok_r(keysBuffer, "\n", &saveLinePointer);
+            firstTime = false;
+        } else {
+            line = strtok_r(NULL, "\n", &saveLinePointer);
+        }
 
-		if (line == NULL){
-			break;
-		}
+        if (line == NULL) {
+            break;
+        }
 
-		parse_key_line(line, key, iv);
+        parse_key_line(line, key, iv);
 
-	} while((*key == NULL || *iv == NULL) && line != NULL);
+    } while ((*key == NULL || *iv == NULL) && line != NULL);
 
 }
 
-static void parse_key_line(char *line, char **key, char **iv){
-	char *detectedKey = NULL, *detectedValue= NULL;
-
-	char* sep_at = strchr(line, ':');
-	if (sep_at == NULL){
-		return;
-	}
-
-	*sep_at = '\0'; // overwrite first separator, creating two strings.
-	detectedKey = line;
-	detectedValue = sep_at + 1;
-
-	if (detectedKey == NULL || detectedValue == NULL){
-		return;
-	}
-	if (detectedKey[0] == '\0' || detectedValue[0] == '\0'){
-		return;
-	}
-
-	if (*key == NULL && strcmp(detectedKey, KEY_TO_GET) == 0){
-		*key = strndup(detectedValue, AES_KEY_LENGTH);
-	} else if (*iv == NULL && strcmp(detectedKey, IV_TO_GET) == 0){
-		*iv = strndup(detectedValue, AES_IV_LENGTH);
-	}
+static void parse_key_line(char *line, char **key, char **iv) {
+    char *detectedKey = NULL, *detectedValue= NULL;
+
+    char *sep_at = strchr(line, ':');
+    if (sep_at == NULL) {
+        return;
+    }
+
+    *sep_at = '\0'; // overwrite first separator, creating two strings.
+    detectedKey = line;
+    detectedValue = sep_at + 1;
+
+    if (detectedKey == NULL || detectedValue == NULL) {
+        return;
+    }
+    if (detectedKey[0] == '\0' || detectedValue[0] == '\0') {
+        return;
+    }
+
+    if (*key == NULL && strcmp(detectedKey, KEY_TO_GET) == 0) {
+        *key = strndup(detectedValue, AES_KEY_LENGTH);
+    } else if (*iv == NULL && strcmp(detectedKey, IV_TO_GET) == 0) {
+        *iv = strndup(detectedValue, AES_IV_LENGTH);
+    }
 }
 
 static void extract_keys_from_buffer(unsigned char *input, int inputlen, char **publicKey, char **secretKey) {
-	// Load decrypted text buffer
-	zchunk_t* secret_decrypted = zchunk_new(input, inputlen);
-	if (secret_decrypted == NULL){
-		printf("CRYPTO: Failed to create zchunk\n");
-		return;
-	}
-
-	zconfig_t* secret_config = zconfig_chunk_load (secret_decrypted);
-	zchunk_destroy (&secret_decrypted);
-	if (secret_config == NULL){
-		printf("CRYPTO: Failed to create zconfig\n");
-		return;
-	}
-
-	// Extract public and secret key from text buffer
-	char* public_text = zconfig_get (secret_config, "/curve/public-key", NULL);
-	char* secret_text = zconfig_get (secret_config, "/curve/secret-key", NULL);
-
-	if (public_text == NULL || secret_text == NULL){
-		zconfig_destroy(&secret_config);
-		printf("CRYPTO: Loading public / secret key from text-buffer failed!\n");
-		return;
-	}
-
-	*publicKey = strndup(public_text, ZMQ_KEY_LENGTH + 1);
-	*secretKey = strndup(secret_text, ZMQ_KEY_LENGTH + 1);
-
-	zconfig_destroy(&secret_config);
+    // Load decrypted text buffer
+    zchunk_t *secret_decrypted = zchunk_new(input, inputlen);
+    if (secret_decrypted == NULL) {
+        printf("CRYPTO: Failed to create zchunk\n");
+        return;
+    }
+
+    zconfig_t *secret_config = zconfig_chunk_load(secret_decrypted);
+    zchunk_destroy (&secret_decrypted);
+    if (secret_config == NULL) {
+        printf("CRYPTO: Failed to create zconfig\n");
+        return;
+    }
+
+    // Extract public and secret key from text buffer
+    char *public_text = zconfig_get(secret_config, "/curve/public-key", NULL);
+    char *secret_text = zconfig_get(secret_config, "/curve/secret-key", NULL);
+
+    if (public_text == NULL || secret_text == NULL) {
+        zconfig_destroy(&secret_config);
+        printf("CRYPTO: Loading public / secret key from text-buffer failed!\n");
+        return;
+    }
+
+    *publicKey = strndup(public_text, ZMQ_KEY_LENGTH + 1);
+    *secretKey = strndup(secret_text, ZMQ_KEY_LENGTH + 1);
+
+    zconfig_destroy(&secret_config);
 }
diff --git a/bundles/pubsub/pubsub_admin_zmq/src/zmq_crypto.h b/bundles/pubsub/pubsub_admin_zmq/src/zmq_crypto.h
index 82fe576..0eef8f1 100644
--- a/bundles/pubsub/pubsub_admin_zmq/src/zmq_crypto.h
+++ b/bundles/pubsub/pubsub_admin_zmq/src/zmq_crypto.h
@@ -20,8 +20,8 @@
  * zmq_crypto.h
  *
  *  \date       Dec 2, 2016
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef ZMQ_CRYPTO_H_
diff --git a/bundles/pubsub/pubsub_api/include/pubsub/publisher.h b/bundles/pubsub/pubsub_api/include/pubsub/publisher.h
index 161557b..96483d8 100644
--- a/bundles/pubsub/pubsub_api/include/pubsub/publisher.h
+++ b/bundles/pubsub/pubsub_api/include/pubsub/publisher.h
@@ -20,8 +20,8 @@
  * publisher.h
  *
  *  \date       Jan 7, 2016
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef __PUBSUB_PUBLISHER_H_
@@ -30,14 +30,14 @@
 #include <stdlib.h>
 
 #define PUBSUB_PUBLISHER_SERVICE_NAME           "pubsub.publisher"
-#define PUBSUB_PUBLISHER_SERVICE_VERSION	    "3.0.0"
+#define PUBSUB_PUBLISHER_SERVICE_VERSION        "3.0.0"
  
 //properties
 #define PUBSUB_PUBLISHER_TOPIC                  "topic"
 #define PUBSUB_PUBLISHER_SCOPE                  "scope"
 #define PUBSUB_PUBLISHER_CONFIG                 "pubsub.config"
  
-#define PUBSUB_PUBLISHER_SCOPE_DEFAULT			"default"
+#define PUBSUB_PUBLISHER_SCOPE_DEFAULT          "default"
 
  
  
diff --git a/bundles/pubsub/pubsub_api/include/pubsub/subscriber.h b/bundles/pubsub/pubsub_api/include/pubsub/subscriber.h
index 23a9e9b..3debad9 100644
--- a/bundles/pubsub/pubsub_api/include/pubsub/subscriber.h
+++ b/bundles/pubsub/pubsub_api/include/pubsub/subscriber.h
@@ -20,8 +20,8 @@
  * subscriber.h
  *
  *  \date       Jan 7, 2016
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef __PUBSUB_SUBSCRIBER_H_
diff --git a/bundles/pubsub/pubsub_discovery/CMakeLists.txt b/bundles/pubsub/pubsub_discovery/CMakeLists.txt
index c372973..a85fde6 100644
--- a/bundles/pubsub/pubsub_discovery/CMakeLists.txt
+++ b/bundles/pubsub/pubsub_discovery/CMakeLists.txt
@@ -21,20 +21,20 @@ find_package(Jansson REQUIRED)
 add_celix_bundle(celix_pubsub_discovery_etcd
     BUNDLE_SYMBOLICNAME "apache_celix_pubsub_discovery_etcd"
     VERSION "1.0.0"
-	GROUP "Celix/PubSub"
+    GROUP "Celix/PubSub"
     SOURCES
         src/psd_activator.c
         src/pubsub_discovery_impl.c
 )
 target_include_directories(celix_pubsub_discovery_etcd PRIVATE src)
 target_include_directories(celix_pubsub_discovery_etcd SYSTEM PRIVATE 
-	${CURL_INCLUDE_DIR}
-	${JANSSON_INCLUDE_DIR}
+    ${CURL_INCLUDE_DIR}
+    ${JANSSON_INCLUDE_DIR}
 )
 target_link_libraries(celix_pubsub_discovery_etcd PRIVATE
-		Celix::pubsub_spi Celix::framework Celix::etcdlib_static
-		Celix::shell_api Celix::log_helper
-		${CURL_LIBRARIES} ${JANSSON_LIBRARIES})
+        Celix::pubsub_spi Celix::framework Celix::etcdlib_static
+        Celix::shell_api Celix::log_helper
+        ${CURL_LIBRARIES} ${JANSSON_LIBRARIES})
 
 install_celix_bundle(celix_pubsub_discovery_etcd EXPORT celix COMPONENT pubsub)
 
diff --git a/bundles/pubsub/pubsub_discovery/src/psd_activator.c b/bundles/pubsub/pubsub_discovery/src/psd_activator.c
index 5201192..059098e 100644
--- a/bundles/pubsub/pubsub_discovery/src/psd_activator.c
+++ b/bundles/pubsub/pubsub_discovery/src/psd_activator.c
@@ -33,74 +33,74 @@
 #include "pubsub_discovery_impl.h"
 
 typedef struct psd_activator {
-	pubsub_discovery_t *pubsub_discovery;
+    pubsub_discovery_t *pubsub_discovery;
 
-	long publishAnnounceSvcTrackerId;
-	//service_tracker_pt pstmPublishersTracker;
+    long publishAnnounceSvcTrackerId;
+    //service_tracker_pt pstmPublishersTracker;
 
-	pubsub_announce_endpoint_listener_t listenerSvc;
-	long listenerSvcId;
+    pubsub_announce_endpoint_listener_t listenerSvc;
+    long listenerSvcId;
 
-	command_service_t cmdSvc;
-	long cmdSvcId;
+    command_service_t cmdSvc;
+    long cmdSvcId;
 
-	log_helper_t *loghelper;
+    log_helper_t *loghelper;
 } psd_activator_t;
 
 static celix_status_t psd_start(psd_activator_t *act, celix_bundle_context_t *ctx) {
-	celix_status_t status;
-
-	logHelper_create(ctx, &act->loghelper);
-	logHelper_start(act->loghelper);
-
-	act->pubsub_discovery = pubsub_discovery_create(ctx, act->loghelper);
-	// pubsub_discovery_start needs to be first to initialize
-	status = pubsub_discovery_start(act->pubsub_discovery);
-
-	celix_service_tracking_options_t opts = CELIX_EMPTY_SERVICE_TRACKING_OPTIONS;
-	opts.filter.serviceName = PUBSUB_DISCOVERED_ENDPOINT_LISTENER_SERVICE;
-	opts.callbackHandle = act->pubsub_discovery;
-	opts.addWithOwner = pubsub_discovery_discoveredEndpointsListenerAdded;
-	opts.removeWithOwner = pubsub_discovery_discoveredEndpointsListenerRemoved;
-	act->publishAnnounceSvcTrackerId = celix_bundleContext_trackServicesWithOptions(ctx, &opts);
-
-	act->listenerSvc.handle = act->pubsub_discovery;
-	act->listenerSvc.announceEndpoint = pubsub_discovery_announceEndpoint;
-	act->listenerSvc.revokeEndpoint = pubsub_discovery_revokeEndpoint;
-
-	//register shell command service
-	//register shell command
-	if (status == CELIX_SUCCESS) {
-		act->cmdSvc.handle = act->pubsub_discovery;
-		act->cmdSvc.executeCommand = pubsub_discovery_executeCommand;
-		celix_properties_t *props = celix_properties_create();
-		celix_properties_set(props, OSGI_SHELL_COMMAND_NAME, "psd_etcd");
-		celix_properties_set(props, OSGI_SHELL_COMMAND_USAGE, "psd_etcd"); //TODO add search topic/scope option
-		celix_properties_set(props, OSGI_SHELL_COMMAND_DESCRIPTION, "Overview of discovered/announced endpoints from/to ETCD");
-		act->cmdSvcId = celix_bundleContext_registerService(ctx, &act->cmdSvc, OSGI_SHELL_COMMAND_SERVICE_NAME, props);
-	}
-
-	if (status == CELIX_SUCCESS) {
-		act->listenerSvcId = celix_bundleContext_registerService(ctx, &act->listenerSvc, PUBSUB_ANNOUNCE_ENDPOINT_LISTENER_SERVICE, NULL);
-	} else {
-		act->listenerSvcId = -1L;
-	}
-
-	return status;
+    celix_status_t status;
+
+    logHelper_create(ctx, &act->loghelper);
+    logHelper_start(act->loghelper);
+
+    act->pubsub_discovery = pubsub_discovery_create(ctx, act->loghelper);
+    // pubsub_discovery_start needs to be first to initialize
+    status = pubsub_discovery_start(act->pubsub_discovery);
+
+    celix_service_tracking_options_t opts = CELIX_EMPTY_SERVICE_TRACKING_OPTIONS;
+    opts.filter.serviceName = PUBSUB_DISCOVERED_ENDPOINT_LISTENER_SERVICE;
+    opts.callbackHandle = act->pubsub_discovery;
+    opts.addWithOwner = pubsub_discovery_discoveredEndpointsListenerAdded;
+    opts.removeWithOwner = pubsub_discovery_discoveredEndpointsListenerRemoved;
+    act->publishAnnounceSvcTrackerId = celix_bundleContext_trackServicesWithOptions(ctx, &opts);
+
+    act->listenerSvc.handle = act->pubsub_discovery;
+    act->listenerSvc.announceEndpoint = pubsub_discovery_announceEndpoint;
+    act->listenerSvc.revokeEndpoint = pubsub_discovery_revokeEndpoint;
+
+    //register shell command service
+    //register shell command
+    if (status == CELIX_SUCCESS) {
+        act->cmdSvc.handle = act->pubsub_discovery;
+        act->cmdSvc.executeCommand = pubsub_discovery_executeCommand;
+        celix_properties_t *props = celix_properties_create();
+        celix_properties_set(props, OSGI_SHELL_COMMAND_NAME, "psd_etcd");
+        celix_properties_set(props, OSGI_SHELL_COMMAND_USAGE, "psd_etcd"); //TODO add search topic/scope option
+        celix_properties_set(props, OSGI_SHELL_COMMAND_DESCRIPTION, "Overview of discovered/announced endpoints from/to ETCD");
+        act->cmdSvcId = celix_bundleContext_registerService(ctx, &act->cmdSvc, OSGI_SHELL_COMMAND_SERVICE_NAME, props);
+    }
+
+    if (status == CELIX_SUCCESS) {
+        act->listenerSvcId = celix_bundleContext_registerService(ctx, &act->listenerSvc, PUBSUB_ANNOUNCE_ENDPOINT_LISTENER_SERVICE, NULL);
+    } else {
+        act->listenerSvcId = -1L;
+    }
+
+    return status;
 }
 
 static celix_status_t psd_stop(psd_activator_t *act, celix_bundle_context_t *ctx) {
-	celix_bundleContext_stopTracker(ctx, act->publishAnnounceSvcTrackerId);
-	celix_bundleContext_unregisterService(ctx, act->listenerSvcId);
-	celix_bundleContext_unregisterService(ctx, act->cmdSvcId);
+    celix_bundleContext_stopTracker(ctx, act->publishAnnounceSvcTrackerId);
+    celix_bundleContext_unregisterService(ctx, act->listenerSvcId);
+    celix_bundleContext_unregisterService(ctx, act->cmdSvcId);
 
-	celix_status_t status = pubsub_discovery_stop(act->pubsub_discovery);
-	pubsub_discovery_destroy(act->pubsub_discovery);
+    celix_status_t status = pubsub_discovery_stop(act->pubsub_discovery);
+    pubsub_discovery_destroy(act->pubsub_discovery);
 
-	logHelper_stop(act->loghelper);
-	logHelper_destroy(&act->loghelper);
+    logHelper_stop(act->loghelper);
+    logHelper_destroy(&act->loghelper);
 
-	return status;
+    return status;
 }
 
 
diff --git a/bundles/pubsub/pubsub_discovery/src/pubsub_discovery_impl.c b/bundles/pubsub/pubsub_discovery/src/pubsub_discovery_impl.c
index 4adfbbd..f96ba39 100644
--- a/bundles/pubsub/pubsub_discovery/src/pubsub_discovery_impl.c
+++ b/bundles/pubsub/pubsub_discovery/src/pubsub_discovery_impl.c
@@ -526,7 +526,7 @@ static void pubsub_discovery_removeDiscoveredEndpoint(pubsub_discovery_t *disc,
 }
 
 celix_properties_t* pubsub_discovery_parseEndpoint(pubsub_discovery_t *disc, const char *key, const char* etcdValue) {
-    properties_t *props = celix_properties_create();
+    celix_properties_t *props = celix_properties_create();
 
     // etcdValue contains the json formatted string
     json_error_t error;
diff --git a/bundles/pubsub/pubsub_discovery/src/pubsub_discovery_impl.h b/bundles/pubsub/pubsub_discovery/src/pubsub_discovery_impl.h
index 61c41e4..6a51902 100644
--- a/bundles/pubsub/pubsub_discovery/src/pubsub_discovery_impl.h
+++ b/bundles/pubsub/pubsub_discovery/src/pubsub_discovery_impl.h
@@ -33,56 +33,56 @@
 #define PUBSUB_ETCD_DISCOVERY_DEFAULT_VERBOSE false
 
 
-#define PUBSUB_DISCOVERY_SERVER_IP_KEY 		    "PUBSUB_DISCOVERY_ETCD_SERVER_IP"
-#define PUBSUB_DISCOVERY_SERVER_PORT_KEY 		"PUBSUB_DISCOVERY_ETCD_SERVER_PORT"
-#define PUBSUB_DISCOVERY_SERVER_PATH_KEY 		"PUBSUB_DISCOVERY_ETCD_ROOT_PATH"
+#define PUBSUB_DISCOVERY_SERVER_IP_KEY          "PUBSUB_DISCOVERY_ETCD_SERVER_IP"
+#define PUBSUB_DISCOVERY_SERVER_PORT_KEY        "PUBSUB_DISCOVERY_ETCD_SERVER_PORT"
+#define PUBSUB_DISCOVERY_SERVER_PATH_KEY        "PUBSUB_DISCOVERY_ETCD_ROOT_PATH"
 #define PUBSUB_DISCOVERY_ETCD_TTL_KEY           "PUBSUB_DISCOVERY_ETCD_TTL"
 
 
-#define PUBSUB_DISCOVERY_SERVER_IP_DEFAULT 		"127.0.0.1"
-#define PUBSUB_DISCOVERY_SERVER_PORT_DEFAULT	2379
-#define PUBSUB_DISCOVERY_SERVER_PATH_DEFAULT 	"pubsub/"
+#define PUBSUB_DISCOVERY_SERVER_IP_DEFAULT      "127.0.0.1"
+#define PUBSUB_DISCOVERY_SERVER_PORT_DEFAULT    2379
+#define PUBSUB_DISCOVERY_SERVER_PATH_DEFAULT    "pubsub/"
 #define PUBSUB_DISCOVERY_ETCD_TTL_DEFAULT       30
 
 typedef struct pubsub_discovery {
-	bundle_context_pt context;
-	log_helper_t *logHelper;
+    bundle_context_pt context;
+    log_helper_t *logHelper;
 
-	celix_thread_mutex_t discoveredEndpointsMutex; //when locked with EndpointsListenersMutex -> first lock this
-	hash_map_pt discoveredEndpoints; //<key = uuid,celix_properties_t /*endpoint*/>>
+    celix_thread_mutex_t discoveredEndpointsMutex; //when locked with EndpointsListenersMutex -> first lock this
+    hash_map_pt discoveredEndpoints; //<key = uuid,celix_properties_t /*endpoint*/>>
 
-	celix_thread_mutex_t announcedEndpointsMutex;
-	hash_map_pt announcedEndpoints; //<key = char* (etcd key),pubsub_announce_entry_t /*endpoint*/>>
+    celix_thread_mutex_t announcedEndpointsMutex;
+    hash_map_pt announcedEndpoints; //<key = char* (etcd key),pubsub_announce_entry_t /*endpoint*/>>
 
-	celix_thread_mutex_t discoveredEndpointsListenersMutex;
-	hash_map_pt discoveredEndpointsListeners; //key=svcId, value=pubsub_discovered_endpoint_listener_t
+    celix_thread_mutex_t discoveredEndpointsListenersMutex;
+    hash_map_pt discoveredEndpointsListeners; //key=svcId, value=pubsub_discovered_endpoint_listener_t
 
-	//NOTE using pthread instead of celix mutex/cond so that condwait with abs time using a MONOTONIC clock can be used
-	pthread_mutex_t waitMutex;
-	pthread_cond_t  waitCond;
+    //NOTE using pthread instead of celix mutex/cond so that condwait with abs time using a MONOTONIC clock can be used
+    pthread_mutex_t waitMutex;
+    pthread_cond_t  waitCond;
 
-	celix_thread_mutex_t runningMutex;
+    celix_thread_mutex_t runningMutex;
     bool running;
     celix_thread_t watchThread;
     celix_thread_t refreshTTLThread;
 
 
     //configurable by config/env.
-	const char *pubsubPath;
-	bool verbose;
-	int ttlForEntries;
-	int sleepInsecBetweenTTLRefresh;
-	const char *fwUUID;
+    const char *pubsubPath;
+    bool verbose;
+    int ttlForEntries;
+    int sleepInsecBetweenTTLRefresh;
+    const char *fwUUID;
 } pubsub_discovery_t;
 
 typedef struct pubsub_announce_entry {
-	char *key; //etcd key
-	bool isSet; //whether the value is already set (in case of unavailable etcd server this can linger)
-	int refreshCount;
-	int setCount;
-	int errorCount;
-	celix_properties_t *properties; //the endpoint properties
-	struct timespec createTime; //from MONOTONIC clock
+    char *key; //etcd key
+    bool isSet; //whether the value is already set (in case of unavailable etcd server this can linger)
+    int refreshCount;
+    int setCount;
+    int errorCount;
+    celix_properties_t *properties; //the endpoint properties
+    struct timespec createTime; //from MONOTONIC clock
 } pubsub_announce_entry_t;
 
 
diff --git a/bundles/pubsub/pubsub_serializer_json/CMakeLists.txt b/bundles/pubsub/pubsub_serializer_json/CMakeLists.txt
index 010e864..0231d81 100644
--- a/bundles/pubsub/pubsub_serializer_json/CMakeLists.txt
+++ b/bundles/pubsub/pubsub_serializer_json/CMakeLists.txt
@@ -21,14 +21,14 @@ find_package(Jansson REQUIRED)
 add_celix_bundle(celix_pubsub_serializer_json
     BUNDLE_SYMBOLICNAME "apache_celix_pubsub_serializer_json"
     VERSION "1.0.0"
-	GROUP "Celix/PubSub"
+    GROUP "Celix/PubSub"
     SOURCES
         src/ps_json_serializer_activator.c
-		src/pubsub_serializer_impl.c
+        src/pubsub_serializer_impl.c
 )
 target_include_directories(celix_pubsub_serializer_json PRIVATE
-	src
-	${JANSSON_INCLUDE_DIR}
+    src
+    ${JANSSON_INCLUDE_DIR}
 )
 set_target_properties(celix_pubsub_serializer_json PROPERTIES INSTALL_RPATH "$ORIGIN")
 target_link_libraries(celix_pubsub_serializer_json PRIVATE Celix::pubsub_spi Celix::framework Celix::dfi ${JANSSON_LIBRARIES} Celix::log_helper)
diff --git a/bundles/pubsub/pubsub_serializer_json/src/ps_json_serializer_activator.c b/bundles/pubsub/pubsub_serializer_json/src/ps_json_serializer_activator.c
index 21f6a7d..4a77a71 100644
--- a/bundles/pubsub/pubsub_serializer_json/src/ps_json_serializer_activator.c
+++ b/bundles/pubsub/pubsub_serializer_json/src/ps_json_serializer_activator.c
@@ -24,36 +24,36 @@
 #include "pubsub_serializer_impl.h"
 
 typedef struct psjs_activator {
-	pubsub_json_serializer_t* serializer;
+    pubsub_json_serializer_t* serializer;
 
-	pubsub_serializer_service_t serializerSvc;
-	long serializerSvcId;
+    pubsub_serializer_service_t serializerSvc;
+    long serializerSvcId;
 } psjs_activator_t;
 
 static int psjs_start(psjs_activator_t *act, celix_bundle_context_t *ctx) {
-	act->serializerSvcId = -1L;
+    act->serializerSvcId = -1L;
 
-	celix_status_t status = pubsubSerializer_create(ctx, &(act->serializer));
-	if (status == CELIX_SUCCESS) {
-		act->serializerSvc.handle = act->serializer;
+    celix_status_t status = pubsubSerializer_create(ctx, &(act->serializer));
+    if (status == CELIX_SUCCESS) {
+        act->serializerSvc.handle = act->serializer;
 
-		act->serializerSvc.createSerializerMap = pubsubSerializer_createSerializerMap;
-		act->serializerSvc.destroySerializerMap = pubsubSerializer_destroySerializerMap;
+        act->serializerSvc.createSerializerMap = pubsubSerializer_createSerializerMap;
+        act->serializerSvc.destroySerializerMap = pubsubSerializer_destroySerializerMap;
 
-		/* Set serializer type */
-		celix_properties_t *props = celix_properties_create();
-		celix_properties_set(props, PUBSUB_SERIALIZER_TYPE_KEY, PUBSUB_JSON_SERIALIZER_TYPE);
+        /* Set serializer type */
+        celix_properties_t *props = celix_properties_create();
+        celix_properties_set(props, PUBSUB_SERIALIZER_TYPE_KEY, PUBSUB_JSON_SERIALIZER_TYPE);
 
-		act->serializerSvcId = celix_bundleContext_registerService(ctx, &act->serializerSvc, PUBSUB_SERIALIZER_SERVICE_NAME, props);
-	}
-	return status;
+        act->serializerSvcId = celix_bundleContext_registerService(ctx, &act->serializerSvc, PUBSUB_SERIALIZER_SERVICE_NAME, props);
+    }
+    return status;
 }
 
 static int psjs_stop(psjs_activator_t *act, celix_bundle_context_t *ctx) {
-	celix_bundleContext_unregisterService(ctx, act->serializerSvcId);
-	act->serializerSvcId = -1L;
-	pubsubSerializer_destroy(act->serializer);
-	return CELIX_SUCCESS;
+    celix_bundleContext_unregisterService(ctx, act->serializerSvcId);
+    act->serializerSvcId = -1L;
+    pubsubSerializer_destroy(act->serializer);
+    return CELIX_SUCCESS;
 }
 
 CELIX_GEN_BUNDLE_ACTIVATOR(psjs_activator_t, psjs_start, psjs_stop)
\ No newline at end of file
diff --git a/bundles/pubsub/pubsub_serializer_json/src/pubsub_serializer_impl.c b/bundles/pubsub/pubsub_serializer_json/src/pubsub_serializer_impl.c
index 3bc5364..4dc9916 100644
--- a/bundles/pubsub/pubsub_serializer_json/src/pubsub_serializer_impl.c
+++ b/bundles/pubsub/pubsub_serializer_json/src/pubsub_serializer_impl.c
@@ -34,12 +34,12 @@
 
 #include "pubsub_serializer_impl.h"
 
-#define SYSTEM_BUNDLE_ARCHIVE_PATH 		"CELIX_FRAMEWORK_EXTENDER_PATH"
+#define SYSTEM_BUNDLE_ARCHIVE_PATH  "CELIX_FRAMEWORK_EXTENDER_PATH"
 #define MAX_PATH_LEN    1024
 
 struct pubsub_json_serializer {
-	bundle_context_pt bundle_context;
-	log_helper_pt loghelper;
+    bundle_context_pt bundle_context;
+    log_helper_pt loghelper;
 };
 
 
@@ -50,11 +50,11 @@ static void pubsubMsgSerializer_freeMsg(void* handle, void *msg);
 
 
 typedef struct pubsub_json_msg_serializer_impl {
-	dyn_message_type *msgType;
+    dyn_message_type *msgType;
 
-	unsigned int msgId;
-	const char* msgName;
-	version_pt msgVersion;
+    unsigned int msgId;
+    const char* msgName;
+    version_pt msgVersion;
 } pubsub_json_msg_serializer_impl_t;
 
 static char* pubsubSerializer_getMsgDescriptionDir(bundle_pt bundle);
@@ -63,277 +63,274 @@ static void pubsubSerializer_fillMsgSerializerMap(hash_map_pt msgTypesMap,bundle
 
 
 static void dfi_log(void *handle, int level, const char *file, int line, const char *msg, ...) {
-	va_list ap;
-	pubsub_json_serializer_t *serializer = handle;
-	char *logStr = NULL;
-	va_start(ap, msg);
-	vasprintf(&logStr, msg, ap);
-	va_end(ap);
-	logHelper_log(serializer->loghelper, level, "FILE:%s, LINE:%i, MSG:%s", file, line, logStr);
-	free(logStr);
+    va_list ap;
+    pubsub_json_serializer_t *serializer = handle;
+    char *logStr = NULL;
+    va_start(ap, msg);
+    vasprintf(&logStr, msg, ap);
+    va_end(ap);
+    logHelper_log(serializer->loghelper, level, "FILE:%s, LINE:%i, MSG:%s", file, line, logStr);
+    free(logStr);
 }
 
 celix_status_t pubsubSerializer_create(bundle_context_pt context, pubsub_json_serializer_t** serializer) {
-	celix_status_t status = CELIX_SUCCESS;
+    celix_status_t status = CELIX_SUCCESS;
 
-	*serializer = calloc(1, sizeof(**serializer));
+    *serializer = calloc(1, sizeof(**serializer));
 
-	if (!*serializer) {
-		status = CELIX_ENOMEM;
-	}
-	else{
+    if (!*serializer) {
+        status = CELIX_ENOMEM;
+    }
+    else{
 
-		(*serializer)->bundle_context= context;
+        (*serializer)->bundle_context= context;
 
-		if (logHelper_create(context, &(*serializer)->loghelper) == CELIX_SUCCESS) {
-			logHelper_start((*serializer)->loghelper);
-			jsonSerializer_logSetup(dfi_log, (*serializer), 1);
-			dynFunction_logSetup(dfi_log, (*serializer), 1);
-			dynType_logSetup(dfi_log, (*serializer), 1);
-			dynCommon_logSetup(dfi_log, (*serializer), 1);
-		}
+        if (logHelper_create(context, &(*serializer)->loghelper) == CELIX_SUCCESS) {
+            logHelper_start((*serializer)->loghelper);
+            jsonSerializer_logSetup(dfi_log, (*serializer), 1);
+            dynFunction_logSetup(dfi_log, (*serializer), 1);
+            dynType_logSetup(dfi_log, (*serializer), 1);
+            dynCommon_logSetup(dfi_log, (*serializer), 1);
+        }
 
-	}
+    }
 
-	return status;
+    return status;
 }
 
 celix_status_t pubsubSerializer_destroy(pubsub_json_serializer_t* serializer) {
-	celix_status_t status = CELIX_SUCCESS;
+    celix_status_t status = CELIX_SUCCESS;
 
-	logHelper_stop(serializer->loghelper);
-	logHelper_destroy(&serializer->loghelper);
+    logHelper_stop(serializer->loghelper);
+    logHelper_destroy(&serializer->loghelper);
 
-	free(serializer);
+    free(serializer);
 
-	return status;
+    return status;
 }
 
 celix_status_t pubsubSerializer_createSerializerMap(void *handle, bundle_pt bundle, hash_map_pt* serializerMap) {
-	celix_status_t status = CELIX_SUCCESS;
-	pubsub_json_serializer_t *serializer = handle;
-
-	hash_map_pt map = hashMap_create(NULL, NULL, NULL, NULL);
-
-	if (map != NULL) {
-		pubsubSerializer_fillMsgSerializerMap(map, bundle);
-	} else {
-		logHelper_log(serializer->loghelper, OSGI_LOGSERVICE_ERROR, "Cannot allocate memory for msg map");
-		status = CELIX_ENOMEM;
-	}
-
-	if (status == CELIX_SUCCESS) {
-		*serializerMap = map;
-	}
-	return status;
+    celix_status_t status = CELIX_SUCCESS;
+    pubsub_json_serializer_t *serializer = handle;
+
+    hash_map_pt map = hashMap_create(NULL, NULL, NULL, NULL);
+
+    if (map != NULL) {
+        pubsubSerializer_fillMsgSerializerMap(map, bundle);
+    } else {
+        logHelper_log(serializer->loghelper, OSGI_LOGSERVICE_ERROR, "Cannot allocate memory for msg map");
+        status = CELIX_ENOMEM;
+    }
+
+    if (status == CELIX_SUCCESS) {
+        *serializerMap = map;
+    }
+    return status;
 }
 
 celix_status_t pubsubSerializer_destroySerializerMap(void* handle __attribute__((unused)), hash_map_pt serializerMap) {
-	celix_status_t status = CELIX_SUCCESS;
-	//pubsub_json_serializer_t *serializer = handle;
-	if (serializerMap == NULL) {
-		return CELIX_ILLEGAL_ARGUMENT;
-	}
-
-	hash_map_iterator_t iter = hashMapIterator_construct(serializerMap);
-	while (hashMapIterator_hasNext(&iter)) {
-		pubsub_msg_serializer_t* msgSerializer = hashMapIterator_nextValue(&iter);
-		pubsub_json_msg_serializer_impl_t *impl = msgSerializer->handle;
-		dyn_message_type *dynMsg = impl->msgType;
-		dynMessage_destroy(dynMsg); //note msgSer->name and msgSer->version owned by dynType
-		free(msgSerializer); //also contains the service struct.
-		free(impl);
-	}
-
-	hashMap_destroy(serializerMap, false, false);
-
-	return status;
+    celix_status_t status = CELIX_SUCCESS;
+    //pubsub_json_serializer_t *serializer = handle;
+    if (serializerMap == NULL) {
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+
+    hash_map_iterator_t iter = hashMapIterator_construct(serializerMap);
+    while (hashMapIterator_hasNext(&iter)) {
+        pubsub_msg_serializer_t* msgSerializer = hashMapIterator_nextValue(&iter);
+        pubsub_json_msg_serializer_impl_t *impl = msgSerializer->handle;
+        dyn_message_type *dynMsg = impl->msgType;
+        dynMessage_destroy(dynMsg); //note msgSer->name and msgSer->version owned by dynType
+        free(msgSerializer); //also contains the service struct.
+        free(impl);
+    }
+
+    hashMap_destroy(serializerMap, false, false);
+
+    return status;
 }
 
 
 celix_status_t pubsubMsgSerializer_serialize(void *handle, const void* msg, void** out, size_t *outLen) {
-	celix_status_t status = CELIX_SUCCESS;
+    celix_status_t status = CELIX_SUCCESS;
 
-	pubsub_json_msg_serializer_impl_t *impl = handle;
+    pubsub_json_msg_serializer_impl_t *impl = handle;
 
-	char *jsonOutput = NULL;
-	dyn_type* dynType = NULL;
-	dyn_message_type *dynMsg = impl->msgType;
-	dynMessage_getMessageType(dynMsg, &dynType);
+    char *jsonOutput = NULL;
+    dyn_type* dynType = NULL;
+    dyn_message_type *dynMsg = impl->msgType;
+    dynMessage_getMessageType(dynMsg, &dynType);
 
-	if (jsonSerializer_serialize(dynType, msg, &jsonOutput) != 0){
-		status = CELIX_BUNDLE_EXCEPTION;
-	}
+    if (jsonSerializer_serialize(dynType, msg, &jsonOutput) != 0) {
+        status = CELIX_BUNDLE_EXCEPTION;
+    }
 
-	if (status == CELIX_SUCCESS) {
-		*out = jsonOutput;
-		*outLen = strlen(jsonOutput) + 1;
-	}
+    if (status == CELIX_SUCCESS) {
+        *out = jsonOutput;
+        *outLen = strlen(jsonOutput) + 1;
+    }
 
-	return status;
+    return status;
 }
 
 celix_status_t pubsubMsgSerializer_deserialize(void* handle, const void* input, size_t inputLen, void **out) {
-	celix_status_t status = CELIX_SUCCESS;
-	pubsub_json_msg_serializer_impl_t *impl = handle;
-	void *msg = NULL;
-	dyn_type* dynType = NULL;
-	dyn_message_type *dynMsg = impl->msgType;
-	dynMessage_getMessageType(dynMsg, &dynType);
-
-	if (jsonSerializer_deserialize(dynType, (const char*)input, &msg) != 0) {
-		status = CELIX_BUNDLE_EXCEPTION;
-	}
-	else{
-		*out = msg;
-	}
-
-	return status;
+    celix_status_t status = CELIX_SUCCESS;
+    pubsub_json_msg_serializer_impl_t *impl = handle;
+    void *msg = NULL;
+    dyn_type* dynType = NULL;
+    dyn_message_type *dynMsg = impl->msgType;
+    dynMessage_getMessageType(dynMsg, &dynType);
+
+    if (jsonSerializer_deserialize(dynType, (const char*)input, &msg) != 0) {
+        status = CELIX_BUNDLE_EXCEPTION;
+    }
+    else{
+        *out = msg;
+    }
+
+    return status;
 }
 
 void pubsubMsgSerializer_freeMsg(void* handle, void *msg) {
-	pubsub_json_msg_serializer_impl_t *impl = handle;
-	dyn_type* dynType = NULL;
-	dyn_message_type *dynMsg = impl->msgType;
-	dynMessage_getMessageType(dynMsg, &dynType);
-	if (dynType != NULL) {
-		dynType_free(dynType, msg);
-	}
+    pubsub_json_msg_serializer_impl_t *impl = handle;
+    dyn_type* dynType = NULL;
+    dyn_message_type *dynMsg = impl->msgType;
+    dynMessage_getMessageType(dynMsg, &dynType);
+    if (dynType != NULL) {
+        dynType_free(dynType, msg);
+    }
 }
 
 
 static void pubsubSerializer_fillMsgSerializerMap(hash_map_pt msgSerializers, bundle_pt bundle) {
-	char* root = NULL;
-	char* metaInfPath = NULL;
+    char* root = NULL;
+    char* metaInfPath = NULL;
 
-	root = pubsubSerializer_getMsgDescriptionDir(bundle);
+    root = pubsubSerializer_getMsgDescriptionDir(bundle);
 
-	if(root != NULL){
-		asprintf(&metaInfPath, "%s/META-INF/descriptors", root);
+    if (root != NULL) {
+        asprintf(&metaInfPath, "%s/META-INF/descriptors", root);
 
-		pubsubSerializer_addMsgSerializerFromBundle(root, bundle, msgSerializers);
-		pubsubSerializer_addMsgSerializerFromBundle(metaInfPath, bundle, msgSerializers);
+        pubsubSerializer_addMsgSerializerFromBundle(root, bundle, msgSerializers);
+        pubsubSerializer_addMsgSerializerFromBundle(metaInfPath, bundle, msgSerializers);
 
-		free(metaInfPath);
-		free(root);
-	}
+        free(metaInfPath);
+        free(root);
+    }
 }
 
 static char* pubsubSerializer_getMsgDescriptionDir(bundle_pt bundle)
 {
-	char *root = NULL;
+    char *root = NULL;
 
-	bool isSystemBundle = false;
-	bundle_isSystemBundle(bundle, &isSystemBundle);
+    bool isSystemBundle = false;
+    bundle_isSystemBundle(bundle, &isSystemBundle);
 
-	if(isSystemBundle == true) {
-		bundle_context_pt context;
-		bundle_getContext(bundle, &context);
+    if (isSystemBundle == true) {
+        bundle_context_pt context;
+        bundle_getContext(bundle, &context);
 
-		const char *prop = NULL;
+        const char *prop = NULL;
 
-		bundleContext_getProperty(context, SYSTEM_BUNDLE_ARCHIVE_PATH, &prop);
+        bundleContext_getProperty(context, SYSTEM_BUNDLE_ARCHIVE_PATH, &prop);
 
-		if(prop != NULL) {
-			root = strdup(prop);
-		} else {
-			root = getcwd(NULL, 0);
-		}
-	} else {
-		bundle_getEntry(bundle, ".", &root);
-	}
+        if (prop != NULL) {
+            root = strdup(prop);
+        } else {
+            root = getcwd(NULL, 0);
+        }
+    } else {
+        bundle_getEntry(bundle, ".", &root);
+    }
 
-	return root;
+    return root;
 }
 
 
 static void pubsubSerializer_addMsgSerializerFromBundle(const char *root, bundle_pt bundle, hash_map_pt msgSerializers)
 {
-	char path[MAX_PATH_LEN];
-	struct dirent *entry = NULL;
-	DIR *dir = opendir(root);
-
-	if(dir) {
-		entry = readdir(dir);
-	}
-
-	while (entry != NULL) {
-
-		if (strstr(entry->d_name, ".descriptor") != NULL) {
-
-			printf("DMU: Parsing entry '%s'\n", entry->d_name);
-
-			snprintf(path, MAX_PATH_LEN, "%s/%s", root, entry->d_name);
-			FILE *stream = fopen(path,"r");
-
-			if (stream != NULL){
-				dyn_message_type* msgType = NULL;
-
-				int rc = dynMessage_parse(stream, &msgType);
-				if (rc == 0 && msgType != NULL) {
-
-					char* msgName = NULL;
-					rc += dynMessage_getName(msgType,&msgName);
-
-					version_pt msgVersion = NULL;
-					rc += dynMessage_getVersion(msgType, &msgVersion);
-
-					if(rc == 0 && msgName != NULL && msgVersion != NULL){
-
-						unsigned int msgId = utils_stringHash(msgName);
-
-						pubsub_msg_serializer_t *msgSerializer = calloc(1,sizeof(*msgSerializer));
-						pubsub_json_msg_serializer_impl_t *impl = calloc(1, sizeof(*impl));
-
-						impl->msgType = msgType;
-						impl->msgId = msgId;
-						impl->msgName = msgName;
-						impl->msgVersion = msgVersion;
-
-						msgSerializer->handle = impl;
-						msgSerializer->msgId = impl->msgId;
-						msgSerializer->msgName = impl->msgName;
-						msgSerializer->msgVersion = impl->msgVersion;
-						msgSerializer->serialize = (void*) pubsubMsgSerializer_serialize;
-						msgSerializer->deserialize = (void*) pubsubMsgSerializer_deserialize;
-						msgSerializer->freeMsg = (void*) pubsubMsgSerializer_freeMsg;
-
-						bool clash = hashMap_containsKey(msgSerializers, (void*)(uintptr_t)msgId);
-						if (clash){
-							printf("Cannot add msg %s. clash in msg id %d!!\n", msgName, msgId);
-							free(msgSerializer);
-							free(impl);
-							dynMessage_destroy(msgType);
-						}
-						else if (msgId != 0){
-							printf("Adding %u : %s\n", msgId, msgName);
-							hashMap_put(msgSerializers, (void*)(uintptr_t)msgId, msgSerializer);
-						}
-						else{
-							printf("Error creating msg serializer\n");
-							free(impl);
-							free(msgSerializer);
-							dynMessage_destroy(msgType);
-						}
-
-					}
-					else{
-						printf("Cannot retrieve name and/or version from msg\n");
-					}
-
-				} else{
-					printf("DMU: cannot parse message from descriptor %s\n.",path);
-				}
-				fclose(stream);
-			}else{
-				printf("DMU: cannot open descriptor file %s\n.",path);
-			}
-
-		}
-		entry = readdir(dir);
-	}
-
-	if(dir) {
-		closedir(dir);
-	}
+    char path[MAX_PATH_LEN];
+    struct dirent *entry = NULL;
+    DIR *dir = opendir(root);
+
+    if (dir) {
+        entry = readdir(dir);
+    }
+
+    while (entry != NULL) {
+
+        if (strstr(entry->d_name, ".descriptor") != NULL) {
+
+            printf("DMU: Parsing entry '%s'\n", entry->d_name);
+
+            snprintf(path, MAX_PATH_LEN, "%s/%s", root, entry->d_name);
+            FILE *stream = fopen(path,"r");
+
+            if (stream != NULL) {
+                dyn_message_type* msgType = NULL;
+
+                int rc = dynMessage_parse(stream, &msgType);
+                if (rc == 0 && msgType != NULL) {
+
+                    char* msgName = NULL;
+                    rc += dynMessage_getName(msgType,&msgName);
+
+                    version_pt msgVersion = NULL;
+                    rc += dynMessage_getVersion(msgType, &msgVersion);
+
+                    if (rc == 0 && msgName != NULL && msgVersion != NULL) {
+
+                        unsigned int msgId = utils_stringHash(msgName);
+
+                        pubsub_msg_serializer_t *msgSerializer = calloc(1,sizeof(*msgSerializer));
+                        pubsub_json_msg_serializer_impl_t *impl = calloc(1, sizeof(*impl));
+
+                        impl->msgType = msgType;
+                        impl->msgId = msgId;
+                        impl->msgName = msgName;
+                        impl->msgVersion = msgVersion;
+
+                        msgSerializer->handle = impl;
+                        msgSerializer->msgId = impl->msgId;
+                        msgSerializer->msgName = impl->msgName;
+                        msgSerializer->msgVersion = impl->msgVersion;
+                        msgSerializer->serialize = (void*) pubsubMsgSerializer_serialize;
+                        msgSerializer->deserialize = (void*) pubsubMsgSerializer_deserialize;
+                        msgSerializer->freeMsg = (void*) pubsubMsgSerializer_freeMsg;
+
+                        bool clash = hashMap_containsKey(msgSerializers, (void*)(uintptr_t)msgId);
+                        if (clash) {
+                            printf("Cannot add msg %s. clash in msg id %d!!\n", msgName, msgId);
+                            free(msgSerializer);
+                            free(impl);
+                            dynMessage_destroy(msgType);
+                        } else if (msgId != 0) {
+                            printf("Adding %u : %s\n", msgId, msgName);
+                            hashMap_put(msgSerializers, (void*)(uintptr_t)msgId, msgSerializer);
+                        } else {
+                            printf("Error creating msg serializer\n");
+                            free(impl);
+                            free(msgSerializer);
+                            dynMessage_destroy(msgType);
+                        }
+
+                    } else {
+                        printf("Cannot retrieve name and/or version from msg\n");
+                    }
+
+                } else {
+                    printf("DMU: cannot parse message from descriptor %s\n.",path);
+                }
+                fclose(stream);
+            } else {
+                printf("DMU: cannot open descriptor file %s\n.",path);
+            }
+
+        }
+        entry = readdir(dir);
+    }
+
+    if (dir) {
+        closedir(dir);
+    }
 }
diff --git a/bundles/pubsub/pubsub_serializer_json/src/pubsub_serializer_impl.h b/bundles/pubsub/pubsub_serializer_json/src/pubsub_serializer_impl.h
index 72ec18d..f44f6b2 100644
--- a/bundles/pubsub/pubsub_serializer_json/src/pubsub_serializer_impl.h
+++ b/bundles/pubsub/pubsub_serializer_json/src/pubsub_serializer_impl.h
@@ -27,7 +27,7 @@
 
 #include "pubsub_serializer.h"
 
-#define PUBSUB_JSON_SERIALIZER_TYPE	"json"
+#define PUBSUB_JSON_SERIALIZER_TYPE "json"
 
 typedef struct pubsub_json_serializer pubsub_json_serializer_t;
 
diff --git a/bundles/pubsub/pubsub_spi/CMakeLists.txt b/bundles/pubsub/pubsub_spi/CMakeLists.txt
index ae4d89c..509c760 100644
--- a/bundles/pubsub/pubsub_spi/CMakeLists.txt
+++ b/bundles/pubsub/pubsub_spi/CMakeLists.txt
@@ -18,22 +18,22 @@
 find_package(UUID REQUIRED)
 
 if(NOT UUID_LIBRARY)
-	#i.e. not found for OSX
-	set(UUID_LIBRARY "")
-	set(UUID_INCLUDE_DIRS "")
+    #i.e. not found for OSX
+    set(UUID_LIBRARY "")
+    set(UUID_INCLUDE_DIRS "")
 endif()
 
 add_library(pubsub_spi STATIC
         src/pubsub_utils_match.c
         src/pubsub_endpoint.c
         src/pubsub_utils.c
-		    src/pubsub_admin_metrics.c
+            src/pubsub_admin_metrics.c
 )
 target_include_directories(pubsub_spi SYSTEM PRIVATE ${UUID_INCLUDE_DIRS})
 set_target_properties(pubsub_spi PROPERTIES OUTPUT_NAME "celix_pubsub_spi")
 target_include_directories(pubsub_spi PUBLIC
-		$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
-		$<INSTALL_INTERFACE:include/celix/pubsub_spi>
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
+        $<INSTALL_INTERFACE:include/celix/pubsub_spi>
 )
 target_link_libraries(pubsub_spi PUBLIC Celix::framework Celix::pubsub_api)
 
diff --git a/bundles/pubsub/pubsub_spi/include/pubsub_admin.h b/bundles/pubsub/pubsub_spi/include/pubsub_admin.h
index 643322c..5735ef1 100644
--- a/bundles/pubsub/pubsub_spi/include/pubsub_admin.h
+++ b/bundles/pubsub/pubsub_spi/include/pubsub_admin.h
@@ -20,8 +20,8 @@
  * pubsub_admin.h
  *
  *  \date       Sep 30, 2011
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef PUBSUB_ADMIN_H_
@@ -31,33 +31,33 @@
 #include "celix_bundle.h"
 #include "celix_filter.h"
 
-#define PUBSUB_ADMIN_SERVICE_NAME		"pubsub_admin"
-#define PUBSUB_ADMIN_SERVICE_VERSION	"3.0.0"
-#define PUBSUB_ADMIN_SERVICE_RANGE		"[3,4)"
+#define PUBSUB_ADMIN_SERVICE_NAME       "pubsub_admin"
+#define PUBSUB_ADMIN_SERVICE_VERSION    "3.0.0"
+#define PUBSUB_ADMIN_SERVICE_RANGE      "[3,4)"
 
 //expected service properties
-#define PUBSUB_ADMIN_SERVICE_TYPE		"psa_type"
+#define PUBSUB_ADMIN_SERVICE_TYPE       "psa_type"
 
-#define PUBSUB_ADMIN_FULL_MATCH_SCORE	100.0F
-#define PUBSUB_ADMIN_NO_MATCH_SCORE	    0.0F
+#define PUBSUB_ADMIN_FULL_MATCH_SCORE   100.0F
+#define PUBSUB_ADMIN_NO_MATCH_SCORE     0.0F
 
 struct pubsub_admin_service {
-	void *handle;
+    void *handle;
 
-	celix_status_t (*matchPublisher)(void *handle, long svcRequesterBndId, const celix_filter_t *svcFilter, celix_properties_t **outTopicProperties, double *outScopre, long *outSerializerSvcId);
-	celix_status_t (*matchSubscriber)(void *handle, long svcProviderBndId, const celix_properties_t *svcProperties, celix_properties_t **outTopicProperties, double *outScore, long *outSerializerSvcId);
-	celix_status_t (*matchDiscoveredEndpoint)(void *handle, const celix_properties_t *endpoint, bool *match);
+    celix_status_t (*matchPublisher)(void *handle, long svcRequesterBndId, const celix_filter_t *svcFilter, celix_properties_t **outTopicProperties, double *outScopre, long *outSerializerSvcId);
+    celix_status_t (*matchSubscriber)(void *handle, long svcProviderBndId, const celix_properties_t *svcProperties, celix_properties_t **outTopicProperties, double *outScore, long *outSerializerSvcId);
+    celix_status_t (*matchDiscoveredEndpoint)(void *handle, const celix_properties_t *endpoint, bool *match);
 
-	//note endpoint is owned by caller
-	celix_status_t (*setupTopicSender)(void *handle, const char *scope, const char *topic, const celix_properties_t *topicProperties, long serializerSvcId, celix_properties_t **publisherEndpoint);
-	celix_status_t (*teardownTopicSender)(void *handle, const char *scope, const char *topic);
+    //note endpoint is owned by caller
+    celix_status_t (*setupTopicSender)(void *handle, const char *scope, const char *topic, const celix_properties_t *topicProperties, long serializerSvcId, celix_properties_t **publisherEndpoint);
+    celix_status_t (*teardownTopicSender)(void *handle, const char *scope, const char *topic);
 
-	//note endpoint is owned by caller
-	celix_status_t (*setupTopicReceiver)(void *handle, const char *scope, const char *topic, const celix_properties_t *topicProperties, long serializerSvcId, celix_properties_t **subscriberEndpoint);
-	celix_status_t (*teardownTopicReceiver)(void *handle, const char *scope, const char *topic);
+    //note endpoint is owned by caller
+    celix_status_t (*setupTopicReceiver)(void *handle, const char *scope, const char *topic, const celix_properties_t *topicProperties, long serializerSvcId, celix_properties_t **subscriberEndpoint);
+    celix_status_t (*teardownTopicReceiver)(void *handle, const char *scope, const char *topic);
 
-	celix_status_t (*addDiscoveredEndpoint)(void *handle, const celix_properties_t *endpoint);
-	celix_status_t (*removeDiscoveredEndpoint)(void *handle, const celix_properties_t *endpoint);
+    celix_status_t (*addDiscoveredEndpoint)(void *handle, const celix_properties_t *endpoint);
+    celix_status_t (*removeDiscoveredEndpoint)(void *handle, const celix_properties_t *endpoint);
 };
 
 typedef struct pubsub_admin_service pubsub_admin_service_t;
diff --git a/bundles/pubsub/pubsub_spi/include/pubsub_admin_metrics.h b/bundles/pubsub/pubsub_spi/include/pubsub_admin_metrics.h
index 51be204..e6b1e24 100644
--- a/bundles/pubsub/pubsub_spi/include/pubsub_admin_metrics.h
+++ b/bundles/pubsub/pubsub_spi/include/pubsub_admin_metrics.h
@@ -24,59 +24,59 @@
 #include <sys/time.h>
 #include "celix_array_list.h"
 
-#define PUBSUB_ADMIN_METRICS_SERVICE_NAME	"pubsub_admin_metrics [version 1.0]"
+#define PUBSUB_ADMIN_METRICS_SERVICE_NAME   "pubsub_admin_metrics [version 1.0]"
 
-#define PUBSUB_AMDIN_METRICS_NAME_MAX   1024
+#define PUBSUB_AMDIN_METRICS_NAME_MAX       1024
 
 typedef struct pubsub_admin_sender_msg_type_metrics {
-	long bndId;
-	char typeFqn[PUBSUB_AMDIN_METRICS_NAME_MAX];
-	unsigned int typeId;
-	unsigned long nrOfMessagesSend;
-	unsigned long nrOfMessagesSendFailed;
-	unsigned long nrOfSerializationErrors;
-	struct timespec lastMessageSend;
-	double averageTimeBetweenMessagesInSeconds;
-	double averageSerializationTimeInSeconds;
+    long bndId;
+    char typeFqn[PUBSUB_AMDIN_METRICS_NAME_MAX];
+    unsigned int typeId;
+    unsigned long nrOfMessagesSend;
+    unsigned long nrOfMessagesSendFailed;
+    unsigned long nrOfSerializationErrors;
+    struct timespec lastMessageSend;
+    double averageTimeBetweenMessagesInSeconds;
+    double averageSerializationTimeInSeconds;
 } pubsub_admin_sender_msg_type_metrics_t;
 
 typedef struct pubsub_admin_sender_metrics {
-	char scope[PUBSUB_AMDIN_METRICS_NAME_MAX];
-	char topic[PUBSUB_AMDIN_METRICS_NAME_MAX];
-	unsigned long nrOfUnknownMessagesRetrieved;
-	unsigned int nrOfmsgMetrics;
-	pubsub_admin_sender_msg_type_metrics_t *msgMetrics; //size = nrOfMessageTypes
+    char scope[PUBSUB_AMDIN_METRICS_NAME_MAX];
+    char topic[PUBSUB_AMDIN_METRICS_NAME_MAX];
+    unsigned long nrOfUnknownMessagesRetrieved;
+    unsigned int nrOfmsgMetrics;
+    pubsub_admin_sender_msg_type_metrics_t *msgMetrics; //size = nrOfMessageTypes
 } pubsub_admin_sender_metrics_t;
 
 typedef struct pubsub_admin_receiver_metrics {
-	char scope[PUBSUB_AMDIN_METRICS_NAME_MAX];
-	char topic[PUBSUB_AMDIN_METRICS_NAME_MAX];
-	unsigned long nrOfMsgTypes;
-	struct {
-		unsigned int typeId;
-		char typeFqn[PUBSUB_AMDIN_METRICS_NAME_MAX];
-		int nrOfOrigins;
-		struct {
-			uuid_t originUUID;
-			unsigned long nrOfMessagesReceived;
-			unsigned long nrOfSerializationErrors;
-			unsigned long nrOfMissingSeqNumbers;
-			struct timespec lastMessageReceived;
-			double averageTimeBetweenMessagesInSeconds;
-			double averageSerializationTimeInSeconds;
-			double averageDelayInSeconds;
-			double minDelayInSeconds;
-			double maxDelayInSeconds;
-		} *origins;
-	} *msgTypes;
+    char scope[PUBSUB_AMDIN_METRICS_NAME_MAX];
+    char topic[PUBSUB_AMDIN_METRICS_NAME_MAX];
+    unsigned long nrOfMsgTypes;
+    struct {
+        unsigned int typeId;
+        char typeFqn[PUBSUB_AMDIN_METRICS_NAME_MAX];
+        int nrOfOrigins;
+        struct {
+            uuid_t originUUID;
+            unsigned long nrOfMessagesReceived;
+            unsigned long nrOfSerializationErrors;
+            unsigned long nrOfMissingSeqNumbers;
+            struct timespec lastMessageReceived;
+            double averageTimeBetweenMessagesInSeconds;
+            double averageSerializationTimeInSeconds;
+            double averageDelayInSeconds;
+            double minDelayInSeconds;
+            double maxDelayInSeconds;
+        } *origins;
+    } *msgTypes;
 } pubsub_admin_receiver_metrics_t;
 
 
 typedef struct pubsub_admin_metrics {
-	char psaType[PUBSUB_AMDIN_METRICS_NAME_MAX];
+    char psaType[PUBSUB_AMDIN_METRICS_NAME_MAX];
 
-	celix_array_list_t *senders; //entry type = pubsub_admin_sender_metrics_t
-	celix_array_list_t *receivers;//entry type = pubsub_admin_receiver_metrics_t
+    celix_array_list_t *senders; //entry type = pubsub_admin_sender_metrics_t
+    celix_array_list_t *receivers;//entry type = pubsub_admin_receiver_metrics_t
 
 } pubsub_admin_metrics_t;
 
@@ -86,15 +86,15 @@ typedef struct pubsub_admin_metrics {
  * Expected service properties: PUBSUB_ADMIN_SERVICE_TYPE
  */
 struct pubsub_admin_metrics_service {
-	void *handle;
-
-	/**
-	 * Creates a metrics struct for the PSA. The caller is owner of the data and
-	 * should use pubsub_freePubSubAdminMetrics (part of pubsub_spi) to release the data.
-	 * @param handle
-	 * @return The metrics or NULL if no metrics can be created.
-	 */
-	pubsub_admin_metrics_t* (*metrics)(void *handle);
+    void *handle;
+
+    /**
+     * Creates a metrics struct for the PSA. The caller is owner of the data and
+     * should use pubsub_freePubSubAdminMetrics (part of pubsub_spi) to release the data.
+     * @param handle
+     * @return The metrics or NULL if no metrics can be created.
+     */
+    pubsub_admin_metrics_t* (*metrics)(void *handle);
 };
 
 void pubsub_freePubSubAdminMetrics(pubsub_admin_metrics_t *metrics);
diff --git a/bundles/pubsub/pubsub_spi/include/pubsub_constants.h b/bundles/pubsub/pubsub_spi/include/pubsub_constants.h
index 327acf9..5b40ca9 100644
--- a/bundles/pubsub/pubsub_spi/include/pubsub_constants.h
+++ b/bundles/pubsub/pubsub_spi/include/pubsub_constants.h
@@ -20,7 +20,7 @@
 #ifndef PUBSUB_CONSTANTS_H_
 #define PUBSUB_CONSTANTS_H_
 
-#define PUBSUB_ADMIN_TYPE_KEY	   "pubsub.config"
+#define PUBSUB_ADMIN_TYPE_KEY      "pubsub.config"
 #define PUBSUB_SERIALIZER_TYPE_KEY "pubsub.serializer"
 
 /**
diff --git a/bundles/pubsub/pubsub_spi/include/pubsub_listeners.h b/bundles/pubsub/pubsub_spi/include/pubsub_listeners.h
index c0bbc24..52847ba 100644
--- a/bundles/pubsub/pubsub_spi/include/pubsub_listeners.h
+++ b/bundles/pubsub/pubsub_spi/include/pubsub_listeners.h
@@ -27,10 +27,10 @@
 
 //Informs the topology manager that pub/sub endpoints are discovered in the network
 struct pubsub_discovered_endpoint_listener {
-	void *handle;
+    void *handle;
 
-	celix_status_t (*addDiscoveredEndpoint)(void *handle, const celix_properties_t *properties);
-	celix_status_t (*removeDiscoveredEndpoint)(void *handle, const celix_properties_t *properties);
+    celix_status_t (*addDiscoveredEndpoint)(void *handle, const celix_properties_t *properties);
+    celix_status_t (*removeDiscoveredEndpoint)(void *handle, const celix_properties_t *properties);
 };
 typedef struct pubsub_discovered_endpoint_listener pubsub_discovered_endpoint_listener_t;
 
@@ -40,10 +40,10 @@ typedef struct pubsub_discovered_endpoint_listener pubsub_discovered_endpoint_li
 
 //Informs the pubsub discoveries to announce/revoke endpoint
 struct pubsub_announce_endpoint_listener {
-	void *handle;
+    void *handle;
 
-	celix_status_t (*announceEndpoint)(void *handle, const celix_properties_t *properties);
-	celix_status_t (*revokeEndpoint)(void *handle, const celix_properties_t *properties);
+    celix_status_t (*announceEndpoint)(void *handle, const celix_properties_t *properties);
+    celix_status_t (*revokeEndpoint)(void *handle, const celix_properties_t *properties);
 };
 
 typedef struct pubsub_announce_endpoint_listener pubsub_announce_endpoint_listener_t;
diff --git a/bundles/pubsub/pubsub_spi/include/pubsub_serializer.h b/bundles/pubsub/pubsub_spi/include/pubsub_serializer.h
index 7aeb2e0..9d0846a 100644
--- a/bundles/pubsub/pubsub_spi/include/pubsub_serializer.h
+++ b/bundles/pubsub/pubsub_spi/include/pubsub_serializer.h
@@ -33,28 +33,28 @@
  * the extender pattern.
  */
 
-#define PUBSUB_SERIALIZER_SERVICE_NAME		"pubsub_serializer"
-#define PUBSUB_SERIALIZER_SERVICE_VERSION	"1.0.0"
-#define PUBSUB_SERIALIZER_SERVICE_RANGE		"[1,2)"
+#define PUBSUB_SERIALIZER_SERVICE_NAME      "pubsub_serializer"
+#define PUBSUB_SERIALIZER_SERVICE_VERSION   "1.0.0"
+#define PUBSUB_SERIALIZER_SERVICE_RANGE     "[1,2)"
 
 typedef struct pubsub_msg_serializer {
-	void* handle;
+    void* handle;
 
-	unsigned int msgId;
-	const char* msgName;
-	version_pt msgVersion;
+    unsigned int msgId;
+    const char* msgName;
+    version_pt msgVersion;
 
-	celix_status_t (*serialize)(void* handle, const void* input, void** out, size_t* outLen);
-	celix_status_t (*deserialize)(void* handle, const void* input, size_t inputLen, void** out); //note inputLen can be 0 if predefined size is not needed
-	void (*freeMsg)(void* handle, void* msg);
+    celix_status_t (*serialize)(void* handle, const void* input, void** out, size_t* outLen);
+    celix_status_t (*deserialize)(void* handle, const void* input, size_t inputLen, void** out); //note inputLen can be 0 if predefined size is not needed
+    void (*freeMsg)(void* handle, void* msg);
 
 } pubsub_msg_serializer_t;
 
 typedef struct pubsub_serializer_service {
-	void* handle;
+    void* handle;
 
-	celix_status_t (*createSerializerMap)(void* handle, celix_bundle_t *bundle, hash_map_pt* serializerMap);
-	celix_status_t (*destroySerializerMap)(void* handle, hash_map_pt serializerMap);
+    celix_status_t (*createSerializerMap)(void* handle, celix_bundle_t *bundle, hash_map_pt* serializerMap);
+    celix_status_t (*destroySerializerMap)(void* handle, hash_map_pt serializerMap);
 
 } pubsub_serializer_service_t;
 
diff --git a/bundles/pubsub/pubsub_spi/include/pubsub_utils.h b/bundles/pubsub/pubsub_spi/include/pubsub_utils.h
index e7e5644..7c80745 100644
--- a/bundles/pubsub/pubsub_spi/include/pubsub_utils.h
+++ b/bundles/pubsub/pubsub_spi/include/pubsub_utils.h
@@ -26,9 +26,9 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define PUBSUB_UTILS_QOS_ATTRIBUTE_KEY        "qos"
+#define PUBSUB_UTILS_QOS_ATTRIBUTE_KEY      "qos"
 #define PUBSUB_UTILS_QOS_TYPE_SAMPLE        "sample"    /* A.k.a. unreliable connection */
-#define PUBSUB_UTILS_QOS_TYPE_CONTROL        "control"    /* A.k.a. reliable connection */
+#define PUBSUB_UTILS_QOS_TYPE_CONTROL       "control"   /* A.k.a. reliable connection */
 
 
 /**
diff --git a/bundles/pubsub/pubsub_spi/src/pubsub_endpoint.c b/bundles/pubsub/pubsub_spi/src/pubsub_endpoint.c
index 59f64c8..6805b79 100644
--- a/bundles/pubsub/pubsub_spi/src/pubsub_endpoint.c
+++ b/bundles/pubsub/pubsub_spi/src/pubsub_endpoint.c
@@ -46,42 +46,42 @@ static void pubsubEndpoint_setFields(celix_properties_t *ep, const char* fwUUID,
 
     //copy topic properties
     if (topic_props != NULL) {
-		const char *key = NULL;
-		CELIX_PROPERTIES_FOR_EACH((celix_properties_t *) topic_props, key) {
-			celix_properties_set(ep, key, celix_properties_get(topic_props, key, NULL));
-		}
-	}
-
-
-	char endpointUuid[37];
-	uuid_t endpointUid;
-	uuid_generate(endpointUid);
-	uuid_unparse(endpointUid, endpointUuid);
-	celix_properties_set(ep, PUBSUB_ENDPOINT_UUID, endpointUuid);
-
-	if (fwUUID != NULL) {
-		celix_properties_set(ep, PUBSUB_ENDPOINT_FRAMEWORK_UUID, fwUUID);
-	}
-
-	if (scope != NULL) {
-		celix_properties_set(ep, PUBSUB_ENDPOINT_TOPIC_SCOPE, scope);
-	}
-
-	if (topic != NULL) {
-		celix_properties_set(ep, PUBSUB_ENDPOINT_TOPIC_NAME, topic);
-	}
-
-	if (pubsubType != NULL) {
-		celix_properties_set(ep, PUBSUB_ENDPOINT_TYPE, pubsubType);
-	}
-
-	if (adminType != NULL) {
-		celix_properties_set(ep, PUBSUB_ENDPOINT_ADMIN_TYPE, adminType);
-	}
-
-	if (serType != NULL) {
-		celix_properties_set(ep, PUBSUB_ENDPOINT_SERIALIZER, serType);
-	}
+        const char *key = NULL;
+        CELIX_PROPERTIES_FOR_EACH((celix_properties_t *) topic_props, key) {
+            celix_properties_set(ep, key, celix_properties_get(topic_props, key, NULL));
+        }
+    }
+
+
+    char endpointUuid[37];
+    uuid_t endpointUid;
+    uuid_generate(endpointUid);
+    uuid_unparse(endpointUid, endpointUuid);
+    celix_properties_set(ep, PUBSUB_ENDPOINT_UUID, endpointUuid);
+
+    if (fwUUID != NULL) {
+        celix_properties_set(ep, PUBSUB_ENDPOINT_FRAMEWORK_UUID, fwUUID);
+    }
+
+    if (scope != NULL) {
+        celix_properties_set(ep, PUBSUB_ENDPOINT_TOPIC_SCOPE, scope);
+    }
+
+    if (topic != NULL) {
+        celix_properties_set(ep, PUBSUB_ENDPOINT_TOPIC_NAME, topic);
+    }
+
+    if (pubsubType != NULL) {
+        celix_properties_set(ep, PUBSUB_ENDPOINT_TYPE, pubsubType);
+    }
+
+    if (adminType != NULL) {
+        celix_properties_set(ep, PUBSUB_ENDPOINT_ADMIN_TYPE, adminType);
+    }
+
+    if (serType != NULL) {
+        celix_properties_set(ep, PUBSUB_ENDPOINT_SERIALIZER, serType);
+    }
 }
 
 celix_properties_t* pubsubEndpoint_create(
@@ -92,67 +92,67 @@ celix_properties_t* pubsubEndpoint_create(
         const char* adminType,
         const char *serType,
         celix_properties_t *topic_props) {
-	celix_properties_t *ep = celix_properties_create();
-	pubsubEndpoint_setFields(ep, fwUUID, scope, topic, pubsubType, adminType, serType, topic_props);
-	if (!pubsubEndpoint_isValid(ep, true, true)) {
-	    celix_properties_destroy(ep);
-	    ep = NULL;
+    celix_properties_t *ep = celix_properties_create();
+    pubsubEndpoint_setFields(ep, fwUUID, scope, topic, pubsubType, adminType, serType, topic_props);
+    if (!pubsubEndpoint_isValid(ep, true, true)) {
+        celix_properties_destroy(ep);
+        ep = NULL;
     }
-	return ep;
+    return ep;
 }
 
 
 struct retrieve_topic_properties_data {
-	celix_properties_t *props;
-	const char *topic;
-	bool isPublisher;
+    celix_properties_t *props;
+    const char *topic;
+    bool isPublisher;
 };
 
 static void retrieveTopicProperties(void *handle, const celix_bundle_t *bnd) {
-	struct retrieve_topic_properties_data *data = handle;
-	data->props = pubsub_utils_getTopicProperties(bnd, data->topic, data->isPublisher);
+    struct retrieve_topic_properties_data *data = handle;
+    data->props = pubsub_utils_getTopicProperties(bnd, data->topic, data->isPublisher);
 }
 
 celix_properties_t* pubsubEndpoint_createFromSubscriberSvc(bundle_context_t* ctx, long bundleId, const celix_properties_t *svcProps) {
     celix_properties_t *ep = celix_properties_create();
 
-	const char* fwUUID = celix_bundleContext_getProperty(ctx, OSGI_FRAMEWORK_FRAMEWORK_UUID, NULL);
-	const char* scope = celix_properties_get(svcProps,  PUBSUB_SUBSCRIBER_SCOPE, PUBSUB_SUBSCRIBER_SCOPE_DEFAULT);
-	const char* topic = celix_properties_get(svcProps,  PUBSUB_SUBSCRIBER_TOPIC, NULL);
+    const char* fwUUID = celix_bundleContext_getProperty(ctx, OSGI_FRAMEWORK_FRAMEWORK_UUID, NULL);
+    const char* scope = celix_properties_get(svcProps,  PUBSUB_SUBSCRIBER_SCOPE, PUBSUB_SUBSCRIBER_SCOPE_DEFAULT);
+    const char* topic = celix_properties_get(svcProps,  PUBSUB_SUBSCRIBER_TOPIC, NULL);
 
-	struct retrieve_topic_properties_data data;
-	data.props = NULL;
-	data.isPublisher = false;
-	data.topic = topic;
-	celix_bundleContext_useBundle(ctx, bundleId, &data, retrieveTopicProperties);
+    struct retrieve_topic_properties_data data;
+    data.props = NULL;
+    data.isPublisher = false;
+    data.topic = topic;
+    celix_bundleContext_useBundle(ctx, bundleId, &data, retrieveTopicProperties);
 
-	const char *pubsubType = PUBSUB_SUBSCRIBER_ENDPOINT_TYPE;
+    const char *pubsubType = PUBSUB_SUBSCRIBER_ENDPOINT_TYPE;
 
-	pubsubEndpoint_setFields(ep, fwUUID, scope, topic, pubsubType, NULL, NULL, data.props);
+    pubsubEndpoint_setFields(ep, fwUUID, scope, topic, pubsubType, NULL, NULL, data.props);
 
-	if(data.props != NULL){
-		celix_properties_destroy(data.props); //Can be deleted since setFields invokes properties_copy
-	}
+    if (data.props != NULL) {
+        celix_properties_destroy(data.props); //Can be deleted since setFields invokes properties_copy
+    }
 
-	if (!pubsubEndpoint_isValid(ep, false, false)) {
-		celix_properties_destroy(ep);
-		ep = NULL;
-	}
-	return ep;
+    if (!pubsubEndpoint_isValid(ep, false, false)) {
+        celix_properties_destroy(ep);
+        ep = NULL;
+    }
+    return ep;
 }
 
 
 celix_properties_t* pubsubEndpoint_createFromPublisherTrackerInfo(bundle_context_t *ctx, long bundleId, const char *filter) {
     celix_properties_t *ep = celix_properties_create();
 
-	const char* fwUUID=NULL;
-	bundleContext_getProperty(ctx, OSGI_FRAMEWORK_FRAMEWORK_UUID, &fwUUID);
+    const char* fwUUID=NULL;
+    bundleContext_getProperty(ctx, OSGI_FRAMEWORK_FRAMEWORK_UUID, &fwUUID);
     assert(fwUUID != NULL);
 
-	char* topic = NULL;
-	char* scopeFromFilter = NULL;
-	pubsub_getPubSubInfoFromFilter(filter, &topic, &scopeFromFilter);
-	const char *scope = scopeFromFilter == NULL ? "default" : scopeFromFilter;
+    char* topic = NULL;
+    char* scopeFromFilter = NULL;
+    pubsub_getPubSubInfoFromFilter(filter, &topic, &scopeFromFilter);
+    const char *scope = scopeFromFilter == NULL ? "default" : scopeFromFilter;
 
     struct retrieve_topic_properties_data data;
     data.props = NULL;
@@ -161,61 +161,61 @@ celix_properties_t* pubsubEndpoint_createFromPublisherTrackerInfo(bundle_context
     celix_bundleContext_useBundle(ctx, bundleId, &data, retrieveTopicProperties);
 
     if (data.props != NULL) {
-		pubsubEndpoint_setFields(ep, fwUUID, scope, topic, PUBSUB_PUBLISHER_ENDPOINT_TYPE, NULL, NULL, data.props);
-		celix_properties_destroy(data.props); //safe to delete, properties are copied in pubsubEndpoint_setFields
+        pubsubEndpoint_setFields(ep, fwUUID, scope, topic, PUBSUB_PUBLISHER_ENDPOINT_TYPE, NULL, NULL, data.props);
+        celix_properties_destroy(data.props); //safe to delete, properties are copied in pubsubEndpoint_setFields
     }
 
-	if (!pubsubEndpoint_isValid(ep, false, false)) {
-		celix_properties_destroy(ep);
-		ep = NULL;
-	}
+    if (!pubsubEndpoint_isValid(ep, false, false)) {
+        celix_properties_destroy(ep);
+        ep = NULL;
+    }
 
-	free(topic);
-	free(scopeFromFilter);
+    free(topic);
+    free(scopeFromFilter);
 
-	return ep;
+    return ep;
 }
 
 
 bool pubsubEndpoint_equals(const celix_properties_t *psEp1, const celix_properties_t *psEp2) {
-	if (psEp1 && psEp2) {
-	    const char *uuid1 = celix_properties_get(psEp1, PUBSUB_ENDPOINT_UUID, "entry1");
+    if (psEp1 && psEp2) {
+        const char *uuid1 = celix_properties_get(psEp1, PUBSUB_ENDPOINT_UUID, "entry1");
         const char *uuid2 = celix_properties_get(psEp1, PUBSUB_ENDPOINT_UUID, "entry1");
         return strcmp(uuid1, uuid2) == 0;
-	} else {
-		return false;
-	}
+    } else {
+        return false;
+    }
 }
 
 char* pubsubEndpoint_createScopeTopicKey(const char* scope, const char* topic) {
-	char *result = NULL;
-	asprintf(&result, "%s:%s", scope, topic);
-	return result;
+    char *result = NULL;
+    asprintf(&result, "%s:%s", scope, topic);
+    return result;
 }
 
 static bool checkProp(const celix_properties_t *props, const char *key) {
-	const char *val = celix_properties_get(props, key, NULL);
-	if (val == NULL) {
-		fprintf(stderr, "[Error] Missing mandatory entry for endpoint. Missing key is '%s'\n", key);
-	}
-	return val != NULL;
+    const char *val = celix_properties_get(props, key, NULL);
+    if (val == NULL) {
+        fprintf(stderr, "[Error] Missing mandatory entry for endpoint. Missing key is '%s'\n", key);
+    }
+    return val != NULL;
 }
 
 
 bool pubsubEndpoint_isValid(const celix_properties_t *props, bool requireAdminType, bool requireSerializerType) {
-	bool p1 = checkProp(props, PUBSUB_ENDPOINT_UUID);
-	bool p2 = checkProp(props, PUBSUB_ENDPOINT_FRAMEWORK_UUID);
-	bool p3 = checkProp(props, PUBSUB_ENDPOINT_TYPE);
-	bool p4 = true;
-	if (requireAdminType) {
-		checkProp(props, PUBSUB_ENDPOINT_ADMIN_TYPE);
-	}
-	bool p5 = true;
-	if (requireSerializerType) {
-		checkProp(props, PUBSUB_ENDPOINT_SERIALIZER);
-	}
-	bool p6 = checkProp(props, PUBSUB_ENDPOINT_TOPIC_NAME);
-	bool p7 = checkProp(props, PUBSUB_ENDPOINT_TOPIC_SCOPE);
-
-	return p1 && p2 && p3 && p4 && p5 && p6 && p7;
+    bool p1 = checkProp(props, PUBSUB_ENDPOINT_UUID);
+    bool p2 = checkProp(props, PUBSUB_ENDPOINT_FRAMEWORK_UUID);
+    bool p3 = checkProp(props, PUBSUB_ENDPOINT_TYPE);
+    bool p4 = true;
+    if (requireAdminType) {
+        checkProp(props, PUBSUB_ENDPOINT_ADMIN_TYPE);
+    }
+    bool p5 = true;
+    if (requireSerializerType) {
+        checkProp(props, PUBSUB_ENDPOINT_SERIALIZER);
+    }
+    bool p6 = checkProp(props, PUBSUB_ENDPOINT_TOPIC_NAME);
+    bool p7 = checkProp(props, PUBSUB_ENDPOINT_TOPIC_SCOPE);
+
+    return p1 && p2 && p3 && p4 && p5 && p6 && p7;
 }
\ No newline at end of file
diff --git a/bundles/pubsub/pubsub_spi/src/pubsub_utils.c b/bundles/pubsub/pubsub_spi/src/pubsub_utils.c
index d1327ec..b6ed882 100644
--- a/bundles/pubsub/pubsub_spi/src/pubsub_utils.c
+++ b/bundles/pubsub/pubsub_spi/src/pubsub_utils.c
@@ -38,48 +38,48 @@
 
 
 celix_status_t pubsub_getPubSubInfoFromFilter(const char* filterstr, char **topicOut, char **scopeOut) {
-	celix_status_t status = CELIX_SUCCESS;
-	const char *topic = NULL;
-	const char *scope = NULL;
-	const char *objectClass = NULL;
-	celix_filter_t *filter = filter_create(filterstr);
-	if (filter != NULL) {
-		if (filter->operand == CELIX_FILTER_OPERAND_AND) { //only and pubsub filter valid (e.g. (&(objectClass=pubsub_publisher)(topic=example))
-			array_list_t *attributes = filter->children;
-			unsigned int i;
-			unsigned int size = arrayList_size(attributes);
-			for (i = 0; i < size; ++i) {
-				filter_t *attr = arrayList_get(attributes, i);
-				if (attr->operand == CELIX_FILTER_OPERAND_EQUAL) {
-					if (strncmp(OSGI_FRAMEWORK_OBJECTCLASS, attr->attribute, 128) == 0) {
-						objectClass = attr->value;
-					} else if (strncmp(PUBSUB_PUBLISHER_TOPIC, attr->attribute, 128) == 0) {
-						topic = attr->value;
-					} else if (strncmp(PUBSUB_PUBLISHER_SCOPE, attr->attribute, 128) == 0) {
-						scope = attr->value;
-					}
-				}
-			}
-		}
-	}
-
-	if (topic != NULL && objectClass != NULL && strncmp(objectClass, PUBSUB_PUBLISHER_SERVICE_NAME, 128) == 0) {
-		//NOTE topic must be present, scope can be present in the filter.
-		*topicOut = strdup(topic);
+    celix_status_t status = CELIX_SUCCESS;
+    const char *topic = NULL;
+    const char *scope = NULL;
+    const char *objectClass = NULL;
+    celix_filter_t *filter = celix_filter_create(filterstr);
+    if (filter != NULL) {
+        if (filter->operand == CELIX_FILTER_OPERAND_AND) { //only and pubsub filter valid (e.g. (&(objectClass=pubsub_publisher)(topic=example))
+            array_list_t *attributes = filter->children;
+            unsigned int i;
+            unsigned int size = arrayList_size(attributes);
+            for (i = 0; i < size; ++i) {
+                filter_t *attr = arrayList_get(attributes, i);
+                if (attr->operand == CELIX_FILTER_OPERAND_EQUAL) {
+                    if (strncmp(OSGI_FRAMEWORK_OBJECTCLASS, attr->attribute, 128) == 0) {
+                        objectClass = attr->value;
+                    } else if (strncmp(PUBSUB_PUBLISHER_TOPIC, attr->attribute, 128) == 0) {
+                        topic = attr->value;
+                    } else if (strncmp(PUBSUB_PUBLISHER_SCOPE, attr->attribute, 128) == 0) {
+                        scope = attr->value;
+                    }
+                }
+            }
+        }
+    }
+
+    if (topic != NULL && objectClass != NULL && strncmp(objectClass, PUBSUB_PUBLISHER_SERVICE_NAME, 128) == 0) {
+        //NOTE topic must be present, scope can be present in the filter.
+        *topicOut = strdup(topic);
                 if (scope != NULL) {
-		    *scopeOut = strdup(scope);
-		} else {
-		    *scopeOut = NULL;
-		}
-	} else {
-		*topicOut = NULL;
-		*scopeOut = NULL;
-	}
-
-	if (filter != NULL) {
+            *scopeOut = strdup(scope);
+        } else {
+            *scopeOut = NULL;
+        }
+    } else {
+        *topicOut = NULL;
+        *scopeOut = NULL;
+    }
+
+    if (filter != NULL) {
              filter_destroy(filter);
         }
-	return status;
+    return status;
 }
 
 
@@ -91,72 +91,72 @@ celix_status_t pubsub_getPubSubInfoFromFilter(const char* filterstr, char **topi
  */
 char* pubsub_getKeysBundleDir(bundle_context_pt ctx)
 {
-	array_list_pt bundles = NULL;
-	bundleContext_getBundles(ctx, &bundles);
-	int nrOfBundles = arrayList_size(bundles);
-	long bundle_id = -1;
-	char* result = NULL;
-
-	for (int i = 0; i < nrOfBundles; i++){
-		bundle_pt b = arrayList_get(bundles, i);
-
-		/* Skip bundle 0 (framework bundle) since it has no path nor revisions */
-		bundle_getBundleId(b, &bundle_id);
-		if(bundle_id==0){
-			continue;
-		}
-
-		char* dir = NULL;
-		bundle_getEntry(b, ".", &dir);
-
-		char cert_dir[MAX_KEYBUNDLE_LENGTH];
-		snprintf(cert_dir, MAX_KEYBUNDLE_LENGTH, "%s/META-INF/keys", dir);
-
-		struct stat s;
-		int err = stat(cert_dir, &s);
-		if (err != -1){
-			if (S_ISDIR(s.st_mode)){
-				result = dir;
-				break;
-			}
-		}
-
-		free(dir);
-	}
-
-	arrayList_destroy(bundles);
-
-	return result;
+    array_list_pt bundles = NULL;
+    bundleContext_getBundles(ctx, &bundles);
+    int nrOfBundles = arrayList_size(bundles);
+    long bundle_id = -1;
+    char* result = NULL;
+
+    for (int i = 0; i < nrOfBundles; i++) {
+        bundle_pt b = arrayList_get(bundles, i);
+
+        /* Skip bundle 0 (framework bundle) since it has no path nor revisions */
+        bundle_getBundleId(b, &bundle_id);
+        if (bundle_id == 0) {
+            continue;
+        }
+
+        char* dir = NULL;
+        bundle_getEntry(b, ".", &dir);
+
+        char cert_dir[MAX_KEYBUNDLE_LENGTH];
+        snprintf(cert_dir, MAX_KEYBUNDLE_LENGTH, "%s/META-INF/keys", dir);
+
+        struct stat s;
+        int err = stat(cert_dir, &s);
+        if (err != -1) {
+            if (S_ISDIR(s.st_mode)) {
+                result = dir;
+                break;
+            }
+        }
+
+        free(dir);
+    }
+
+    arrayList_destroy(bundles);
+
+    return result;
 }
 
 celix_properties_t *pubsub_utils_getTopicProperties(const celix_bundle_t *bundle, const char *topic, bool isPublisher) {
 
-	celix_properties_t *topic_props = NULL;
+    celix_properties_t *topic_props = NULL;
 
-	bool isSystemBundle = false;
-	bundle_isSystemBundle((bundle_pt)bundle, &isSystemBundle);
-	long bundleId = -1;
-	bundle_isSystemBundle((bundle_pt)bundle, &isSystemBundle);
-	bundle_getBundleId((bundle_pt)bundle,&bundleId);
+    bool isSystemBundle = false;
+    bundle_isSystemBundle((bundle_pt)bundle, &isSystemBundle);
+    long bundleId = -1;
+    bundle_isSystemBundle((bundle_pt)bundle, &isSystemBundle);
+    bundle_getBundleId((bundle_pt)bundle,&bundleId);
 
-	if(isSystemBundle == false) {
+    if (isSystemBundle == false) {
 
-		char *bundleRoot = NULL;
-		char* topicPropertiesPath = NULL;
-		bundle_getEntry((bundle_pt)bundle, ".", &bundleRoot);
+        char *bundleRoot = NULL;
+        char* topicPropertiesPath = NULL;
+        bundle_getEntry((bundle_pt)bundle, ".", &bundleRoot);
 
-		if(bundleRoot != NULL){
+        if (bundleRoot != NULL) {
 
-			asprintf(&topicPropertiesPath, "%s/META-INF/topics/%s/%s.properties", bundleRoot, isPublisher? "pub":"sub", topic);
-			topic_props = properties_load(topicPropertiesPath);
-			if(topic_props==NULL){
-				printf("PubSub: Could not load properties for %s on topic %s. Searched location %s, bundleId=%ld\n", isPublisher? "publication":"subscription", topic, topicPropertiesPath, bundleId);
-			}
+            asprintf(&topicPropertiesPath, "%s/META-INF/topics/%s/%s.properties", bundleRoot, isPublisher? "pub":"sub", topic);
+            topic_props = celix_properties_load(topicPropertiesPath);
+            if (topic_props == NULL) {
+                printf("PubSub: Could not load properties for %s on topic %s. Searched location %s, bundleId=%ld\n", isPublisher? "publication":"subscription", topic, topicPropertiesPath, bundleId);
+            }
 
-			free(topicPropertiesPath);
-			free(bundleRoot);
-		}
-	}
+            free(topicPropertiesPath);
+            free(bundleRoot);
+        }
+    }
 
-	return topic_props;
+    return topic_props;
 }
\ No newline at end of file
diff --git a/bundles/pubsub/pubsub_spi/src/pubsub_utils_match.c b/bundles/pubsub/pubsub_spi/src/pubsub_utils_match.c
index a10b45d..3d8a0bd 100644
--- a/bundles/pubsub/pubsub_spi/src/pubsub_utils_match.c
+++ b/bundles/pubsub/pubsub_spi/src/pubsub_utils_match.c
@@ -31,202 +31,202 @@
 #include "constants.h"
 
 static double getPSAScore(const char *requested_admin, const char *request_qos, const char *adminType, double sampleScore, double controlScore, double defaultScore) {
-	double score;
-	if (requested_admin != NULL && strncmp(requested_admin, adminType, strlen(adminType)) == 0) {
-		/* We got precise specification on the pubsub_admin we want */
-		//Full match
-		score = PUBSUB_ADMIN_FULL_MATCH_SCORE;
-	} else if (requested_admin != NULL) {
-		//admin type requested, but no match -> do not select this psa
-		score = PUBSUB_ADMIN_NO_MATCH_SCORE;
-	} else if (request_qos != NULL && strncmp(request_qos, PUBSUB_UTILS_QOS_TYPE_SAMPLE, strlen(PUBSUB_UTILS_QOS_TYPE_SAMPLE)) == 0) {
-		//qos match
-		score = sampleScore;
-	} else if (request_qos != NULL && strncmp(request_qos, PUBSUB_UTILS_QOS_TYPE_CONTROL, strlen(PUBSUB_UTILS_QOS_TYPE_CONTROL)) == 0) {
-		//qos match
-		score = controlScore;
-	} else if (request_qos != NULL) {
-		//note unsupported qos -> defaultScore
-		score = defaultScore;
-	} else {
-		//default match
-		score = defaultScore;
-	}
-	return score;
+    double score;
+    if (requested_admin != NULL && strncmp(requested_admin, adminType, strlen(adminType)) == 0) {
+        /* We got precise specification on the pubsub_admin we want */
+        //Full match
+        score = PUBSUB_ADMIN_FULL_MATCH_SCORE;
+    } else if (requested_admin != NULL) {
+        //admin type requested, but no match -> do not select this psa
+        score = PUBSUB_ADMIN_NO_MATCH_SCORE;
+    } else if (request_qos != NULL && strncmp(request_qos, PUBSUB_UTILS_QOS_TYPE_SAMPLE, strlen(PUBSUB_UTILS_QOS_TYPE_SAMPLE)) == 0) {
+        //qos match
+        score = sampleScore;
+    } else if (request_qos != NULL && strncmp(request_qos, PUBSUB_UTILS_QOS_TYPE_CONTROL, strlen(PUBSUB_UTILS_QOS_TYPE_CONTROL)) == 0) {
+        //qos match
+        score = controlScore;
+    } else if (request_qos != NULL) {
+        //note unsupported qos -> defaultScore
+        score = defaultScore;
+    } else {
+        //default match
+        score = defaultScore;
+    }
+    return score;
 }
 
 struct psa_serializer_selection_data {
-	const char *requested_serializer;
-	long matchingSvcId;
+    const char *requested_serializer;
+    long matchingSvcId;
 };
 
 void psa_serializer_selection_callback(void *handle, void *svc __attribute__((unused)), const celix_properties_t *props) {
-	struct psa_serializer_selection_data *data = handle;
-	const char *serType = celix_properties_get(props, PUBSUB_SERIALIZER_TYPE_KEY, NULL);
-	if (serType == NULL) {
-		fprintf(stderr, "Warning found serializer without mandatory serializer type key (%s)\n", PUBSUB_SERIALIZER_TYPE_KEY);
-	} else {
-		if (strncmp(data->requested_serializer, serType, 1024 * 1024) == 0) {
-			data->matchingSvcId = celix_properties_getAsLong(props, OSGI_FRAMEWORK_SERVICE_ID, -1L);
-		}
-	}
+    struct psa_serializer_selection_data *data = handle;
+    const char *serType = celix_properties_get(props, PUBSUB_SERIALIZER_TYPE_KEY, NULL);
+    if (serType == NULL) {
+        fprintf(stderr, "Warning found serializer without mandatory serializer type key (%s)\n", PUBSUB_SERIALIZER_TYPE_KEY);
+    } else {
+        if (strncmp(data->requested_serializer, serType, 1024 * 1024) == 0) {
+            data->matchingSvcId = celix_properties_getAsLong(props, OSGI_FRAMEWORK_SERVICE_ID, -1L);
+        }
+    }
 }
 
 static long getPSASerializer(celix_bundle_context_t *ctx, const char *requested_serializer) {
-	long svcId;
-
-	if (requested_serializer != NULL) {
-		struct psa_serializer_selection_data data;
-		data.requested_serializer = requested_serializer;
-		data.matchingSvcId = -1L;
-
-		celix_service_use_options_t opts = CELIX_EMPTY_SERVICE_USE_OPTIONS;
-		opts.filter.serviceName = PUBSUB_SERIALIZER_SERVICE_NAME;
-		opts.filter.ignoreServiceLanguage = true;
-		opts.callbackHandle = &data;
-		opts.useWithProperties = psa_serializer_selection_callback;
-		celix_bundleContext_useServicesWithOptions(ctx, &opts);
-		svcId = data.matchingSvcId;
-	} else {
-		celix_service_filter_options_t opts = CELIX_EMPTY_SERVICE_FILTER_OPTIONS;
-		opts.serviceName = PUBSUB_SERIALIZER_SERVICE_NAME;
-		opts.ignoreServiceLanguage = true;
-
-		//note findService will automatically return the highest ranking service id
-		svcId = celix_bundleContext_findServiceWithOptions(ctx, &opts);
-	}
-
-	return svcId;
+    long svcId;
+
+    if (requested_serializer != NULL) {
+        struct psa_serializer_selection_data data;
+        data.requested_serializer = requested_serializer;
+        data.matchingSvcId = -1L;
+
+        celix_service_use_options_t opts = CELIX_EMPTY_SERVICE_USE_OPTIONS;
+        opts.filter.serviceName = PUBSUB_SERIALIZER_SERVICE_NAME;
+        opts.filter.ignoreServiceLanguage = true;
+        opts.callbackHandle = &data;
+        opts.useWithProperties = psa_serializer_selection_callback;
+        celix_bundleContext_useServicesWithOptions(ctx, &opts);
+        svcId = data.matchingSvcId;
+    } else {
+        celix_service_filter_options_t opts = CELIX_EMPTY_SERVICE_FILTER_OPTIONS;
+        opts.serviceName = PUBSUB_SERIALIZER_SERVICE_NAME;
+        opts.ignoreServiceLanguage = true;
+
+        //note findService will automatically return the highest ranking service id
+        svcId = celix_bundleContext_findServiceWithOptions(ctx, &opts);
+    }
+
+    return svcId;
 }
 
 double pubsub_utils_matchPublisher(
-		celix_bundle_context_t *ctx,
-		long bundleId,
-		const char *filter,
-		const char *adminType,
-		double sampleScore,
-		double controlScore,
-		double defaultScore,
-		celix_properties_t **outTopicProperties,
-		long *outSerializerSvcId) {
-
-	celix_properties_t *ep = pubsubEndpoint_createFromPublisherTrackerInfo(ctx, bundleId, filter);
-	const char *requested_admin 		= NULL;
-	const char *requested_qos			= NULL;
-	if (ep != NULL) {
-		requested_admin = celix_properties_get(ep, PUBSUB_ENDPOINT_ADMIN_TYPE, NULL);
-		requested_qos = celix_properties_get(ep, PUBSUB_UTILS_QOS_ATTRIBUTE_KEY, NULL);
-	}
-
-	double score = getPSAScore(requested_admin, requested_qos, adminType, sampleScore, controlScore, defaultScore);
-
-	const char *requested_serializer = celix_properties_get(ep, PUBSUB_ENDPOINT_SERIALIZER, NULL);
-	long serializerSvcId = getPSASerializer(ctx, requested_serializer);
-
-	if (serializerSvcId < 0) {
-		score = PUBSUB_ADMIN_NO_MATCH_SCORE; //no serializer, no match
-	}
-
-//	printf("Score publisher service for psa type %s is %f\n", adminType, score);
-
-	if (outSerializerSvcId != NULL) {
-		*outSerializerSvcId = serializerSvcId;
-	}
-
-	if (outTopicProperties != NULL) {
-		*outTopicProperties = ep;
-	} else if (ep != NULL) {
-		celix_properties_destroy(ep);
-	}
-
-	return score;
+        celix_bundle_context_t *ctx,
+        long bundleId,
+        const char *filter,
+        const char *adminType,
+        double sampleScore,
+        double controlScore,
+        double defaultScore,
+        celix_properties_t **outTopicProperties,
+        long *outSerializerSvcId) {
+
+    celix_properties_t *ep = pubsubEndpoint_createFromPublisherTrackerInfo(ctx, bundleId, filter);
+    const char *requested_admin         = NULL;
+    const char *requested_qos            = NULL;
+    if (ep != NULL) {
+        requested_admin = celix_properties_get(ep, PUBSUB_ENDPOINT_ADMIN_TYPE, NULL);
+        requested_qos = celix_properties_get(ep, PUBSUB_UTILS_QOS_ATTRIBUTE_KEY, NULL);
+    }
+
+    double score = getPSAScore(requested_admin, requested_qos, adminType, sampleScore, controlScore, defaultScore);
+
+    const char *requested_serializer = celix_properties_get(ep, PUBSUB_ENDPOINT_SERIALIZER, NULL);
+    long serializerSvcId = getPSASerializer(ctx, requested_serializer);
+
+    if (serializerSvcId < 0) {
+        score = PUBSUB_ADMIN_NO_MATCH_SCORE; //no serializer, no match
+    }
+
+//    printf("Score publisher service for psa type %s is %f\n", adminType, score);
+
+    if (outSerializerSvcId != NULL) {
+        *outSerializerSvcId = serializerSvcId;
+    }
+
+    if (outTopicProperties != NULL) {
+        *outTopicProperties = ep;
+    } else if (ep != NULL) {
+        celix_properties_destroy(ep);
+    }
+
+    return score;
 }
 
 typedef struct pubsub_match_retrieve_topic_properties_data {
-	const char *topic;
-	bool isPublisher;
+    const char *topic;
+    bool isPublisher;
 
-	celix_properties_t *outEndpoint;
+    celix_properties_t *outEndpoint;
 } pubsub_get_topic_properties_data_t;
 
 static void getTopicPropertiesCallback(void *handle, const celix_bundle_t *bnd) {
-	pubsub_get_topic_properties_data_t *data = handle;
-	data->outEndpoint = pubsub_utils_getTopicProperties(bnd, data->topic, data->isPublisher);
+    pubsub_get_topic_properties_data_t *data = handle;
+    data->outEndpoint = pubsub_utils_getTopicProperties(bnd, data->topic, data->isPublisher);
 }
 
 double pubsub_utils_matchSubscriber(
-		celix_bundle_context_t *ctx,
-		const long svcProviderBundleId,
-		const celix_properties_t *svcProperties,
-		const char *adminType,
-		double sampleScore,
-		double controlScore,
-		double defaultScore,
-		celix_properties_t **outTopicProperties,
-		long *outSerializerSvcId) {
-
-	pubsub_get_topic_properties_data_t data;
-	data.isPublisher = false;
-	data.topic = celix_properties_get(svcProperties, PUBSUB_SUBSCRIBER_TOPIC, NULL);
-	data.outEndpoint = NULL;
-	celix_bundleContext_useBundle(ctx, svcProviderBundleId, &data, getTopicPropertiesCallback);
-
-	celix_properties_t *ep = data.outEndpoint;
-	const char *requested_admin 		= NULL;
-	const char *requested_qos			= NULL;
-	const char *requested_serializer 	= NULL;
-	if (ep != NULL) {
-		requested_admin = celix_properties_get(ep, PUBSUB_ENDPOINT_ADMIN_TYPE, NULL);
-		requested_qos = celix_properties_get(ep, PUBSUB_UTILS_QOS_ATTRIBUTE_KEY, NULL);
-		requested_serializer = celix_properties_get(ep, PUBSUB_ENDPOINT_SERIALIZER, NULL);
-	}
-
-	double score = getPSAScore(requested_admin, requested_qos, adminType, sampleScore, controlScore, defaultScore);
-
-	long serializerSvcId = getPSASerializer(ctx, requested_serializer);
-	if (serializerSvcId < 0) {
-		score = PUBSUB_ADMIN_NO_MATCH_SCORE; //no serializer, no match
-	}
-
-	if (outSerializerSvcId != NULL) {
-		*outSerializerSvcId = serializerSvcId;
-	}
-
-	if (outTopicProperties != NULL) {
-		*outTopicProperties = ep;
-	} else if (ep != NULL) {
-		celix_properties_destroy(ep);
-	}
-
-	return score;
+        celix_bundle_context_t *ctx,
+        const long svcProviderBundleId,
+        const celix_properties_t *svcProperties,
+        const char *adminType,
+        double sampleScore,
+        double controlScore,
+        double defaultScore,
+        celix_properties_t **outTopicProperties,
+        long *outSerializerSvcId) {
+
+    pubsub_get_topic_properties_data_t data;
+    data.isPublisher = false;
+    data.topic = celix_properties_get(svcProperties, PUBSUB_SUBSCRIBER_TOPIC, NULL);
+    data.outEndpoint = NULL;
+    celix_bundleContext_useBundle(ctx, svcProviderBundleId, &data, getTopicPropertiesCallback);
+
+    celix_properties_t *ep = data.outEndpoint;
+    const char *requested_admin         = NULL;
+    const char *requested_qos            = NULL;
+    const char *requested_serializer     = NULL;
+    if (ep != NULL) {
+        requested_admin = celix_properties_get(ep, PUBSUB_ENDPOINT_ADMIN_TYPE, NULL);
+        requested_qos = celix_properties_get(ep, PUBSUB_UTILS_QOS_ATTRIBUTE_KEY, NULL);
+        requested_serializer = celix_properties_get(ep, PUBSUB_ENDPOINT_SERIALIZER, NULL);
+    }
+
+    double score = getPSAScore(requested_admin, requested_qos, adminType, sampleScore, controlScore, defaultScore);
+
+    long serializerSvcId = getPSASerializer(ctx, requested_serializer);
+    if (serializerSvcId < 0) {
+        score = PUBSUB_ADMIN_NO_MATCH_SCORE; //no serializer, no match
+    }
+
+    if (outSerializerSvcId != NULL) {
+        *outSerializerSvcId = serializerSvcId;
+    }
+
+    if (outTopicProperties != NULL) {
+        *outTopicProperties = ep;
+    } else if (ep != NULL) {
+        celix_properties_destroy(ep);
+    }
+
+    return score;
 }
 
 bool pubsub_utils_matchEndpoint(
-		celix_bundle_context_t *ctx,
-		const celix_properties_t *ep,
-		const char *adminType,
-		long *outSerializerSvcId) {
-
-	bool psaMatch = false;
-	const char *configured_admin = celix_properties_get(ep, PUBSUB_ENDPOINT_ADMIN_TYPE, NULL);
-	if (configured_admin != NULL) {
-		psaMatch = strncmp(configured_admin, adminType, strlen(adminType)) == 0;
-	}
-
-	bool serMatch = false;
-	long serializerSvcId = -1L;
-	if (psaMatch) {
-		const char *configured_serializer = celix_properties_get(ep, PUBSUB_ENDPOINT_SERIALIZER, NULL);
-		serializerSvcId = getPSASerializer(ctx, configured_serializer);
-		serMatch = serializerSvcId >= 0;
-	}
-
-	bool match = psaMatch && serMatch;
-//	printf("Match for endpoint for psa type %s is %s\n", adminType, match ? "true" : "false");
-
-	if (outSerializerSvcId != NULL) {
-		*outSerializerSvcId = serializerSvcId;
-	}
-
-	return match;
+        celix_bundle_context_t *ctx,
+        const celix_properties_t *ep,
+        const char *adminType,
+        long *outSerializerSvcId) {
+
+    bool psaMatch = false;
+    const char *configured_admin = celix_properties_get(ep, PUBSUB_ENDPOINT_ADMIN_TYPE, NULL);
+    if (configured_admin != NULL) {
+        psaMatch = strncmp(configured_admin, adminType, strlen(adminType)) == 0;
+    }
+
+    bool serMatch = false;
+    long serializerSvcId = -1L;
+    if (psaMatch) {
+        const char *configured_serializer = celix_properties_get(ep, PUBSUB_ENDPOINT_SERIALIZER, NULL);
+        serializerSvcId = getPSASerializer(ctx, configured_serializer);
+        serMatch = serializerSvcId >= 0;
+    }
+
+    bool match = psaMatch && serMatch;
+//    printf("Match for endpoint for psa type %s is %s\n", adminType, match ? "true" : "false");
+
+    if (outSerializerSvcId != NULL) {
+        *outSerializerSvcId = serializerSvcId;
+    }
+
+    return match;
 }
diff --git a/bundles/pubsub/pubsub_topology_manager/CMakeLists.txt b/bundles/pubsub/pubsub_topology_manager/CMakeLists.txt
index 4bba4c5..1f2e1b9 100644
--- a/bundles/pubsub/pubsub_topology_manager/CMakeLists.txt
+++ b/bundles/pubsub/pubsub_topology_manager/CMakeLists.txt
@@ -18,26 +18,26 @@
 find_package(UUID REQUIRED)
 
 if(NOT UUID_LIBRARY)
-	#i.e. not found for OSX
-	set(UUID_LIBRARY "")
-	set(UUID_INCLUDE_DIRS "")
+    #i.e. not found for OSX
+    set(UUID_LIBRARY "")
+    set(UUID_INCLUDE_DIRS "")
 endif()
 
 add_celix_bundle(celix_pubsub_topology_manager
     BUNDLE_SYMBOLICNAME "apache_celix_pubsub_topology_manager"
     VERSION "1.0.0"
-	GROUP "Celix/PubSub"
+    GROUP "Celix/PubSub"
     SOURCES
-    	src/pstm_activator.c
-    	src/pubsub_topology_manager.c
-    	src/pubsub_topology_manager.h
+        src/pstm_activator.c
+        src/pubsub_topology_manager.c
+        src/pubsub_topology_manager.h
 )
 target_link_libraries(celix_pubsub_topology_manager PRIVATE Celix::framework Celix::log_helper Celix::pubsub_spi Celix::shell_api)
 target_include_directories(celix_pubsub_topology_manager PRIVATE ${UUID_INCLUDE_DIRS})
 
 get_target_property(DESC Celix::pubsub_spi TOPIC_INFO_DESCRIPTOR)
 celix_bundle_files(celix_pubsub_topology_manager
-	${DESC}
+    ${DESC}
     DESTINATION "META-INF/descriptors/services"
 )
 
diff --git a/bundles/pubsub/pubsub_topology_manager/src/pstm_activator.c b/bundles/pubsub/pubsub_topology_manager/src/pstm_activator.c
index 93f6836..b4811a2 100644
--- a/bundles/pubsub/pubsub_topology_manager/src/pstm_activator.c
+++ b/bundles/pubsub/pubsub_topology_manager/src/pstm_activator.c
@@ -33,140 +33,140 @@
 #include "pubsub_listeners.h"
 
 typedef struct pstm_activator {
-	pubsub_topology_manager_t *manager;
+    pubsub_topology_manager_t *manager;
 
-	long pubsubDiscoveryTrackerId;
-	long pubsubAdminTrackerId;
-	long pubsubSubscribersTrackerId;
-	long pubsubPublishServiceTrackerId;
-	long pubsubPSAMetricsTrackerId;
+    long pubsubDiscoveryTrackerId;
+    long pubsubAdminTrackerId;
+    long pubsubSubscribersTrackerId;
+    long pubsubPublishServiceTrackerId;
+    long pubsubPSAMetricsTrackerId;
 
-	pubsub_discovered_endpoint_listener_t discListenerSvc;
-	long discListenerSvcId;
+    pubsub_discovered_endpoint_listener_t discListenerSvc;
+    long discListenerSvcId;
 
 
-	command_service_t shellCmdSvc;
-	long shellCmdSvcId;
+    command_service_t shellCmdSvc;
+    long shellCmdSvcId;
 
 
-	log_helper_pt loghelper;
+    log_helper_pt loghelper;
 } pstm_activator_t;
 
 
 static int pstm_start(pstm_activator_t *act, celix_bundle_context_t *ctx) {
-	celix_status_t status;
-
-	act->discListenerSvcId = -1L;
-	act->pubsubSubscribersTrackerId = -1L;
-	act->pubsubAdminTrackerId = -1L;
-	act->pubsubDiscoveryTrackerId = -1L;
-	act->pubsubPublishServiceTrackerId = -1L;
-	act->pubsubPSAMetricsTrackerId = -1L;
-	act->shellCmdSvcId = -1L;
-
-	logHelper_create(ctx, &act->loghelper);
-	logHelper_start(act->loghelper);
-
-	status = pubsub_topologyManager_create(ctx, act->loghelper, &act->manager);
-
-	//track pubsub announce endpoint listener services (pubsub discovery components)
-	if (status == CELIX_SUCCESS) {
-		celix_service_tracking_options_t opts = CELIX_EMPTY_SERVICE_TRACKING_OPTIONS;
-		opts.addWithProperties = pubsub_topologyManager_pubsubAnnounceEndpointListenerAdded;
-		opts.removeWithProperties = pubsub_topologyManager_pubsubAnnounceEndpointListenerRemoved;
-		opts.callbackHandle = act->manager;
-		opts.filter.serviceName = PUBSUB_ANNOUNCE_ENDPOINT_LISTENER_SERVICE;
-		act->pubsubDiscoveryTrackerId = celix_bundleContext_trackServicesWithOptions(ctx, &opts);
-	}
-
-	//track pubsub admin service (psa components)
-	if (status == CELIX_SUCCESS) {
-		celix_service_tracking_options_t opts = CELIX_EMPTY_SERVICE_TRACKING_OPTIONS;
-		opts.addWithProperties = pubsub_topologyManager_psaAdded;
-		opts.removeWithProperties = pubsub_topologyManager_psaRemoved;
-		opts.callbackHandle = act->manager;
-		opts.filter.serviceName = PUBSUB_ADMIN_SERVICE_NAME;
+    celix_status_t status;
+
+    act->discListenerSvcId = -1L;
+    act->pubsubSubscribersTrackerId = -1L;
+    act->pubsubAdminTrackerId = -1L;
+    act->pubsubDiscoveryTrackerId = -1L;
+    act->pubsubPublishServiceTrackerId = -1L;
+    act->pubsubPSAMetricsTrackerId = -1L;
+    act->shellCmdSvcId = -1L;
+
+    logHelper_create(ctx, &act->loghelper);
+    logHelper_start(act->loghelper);
+
+    status = pubsub_topologyManager_create(ctx, act->loghelper, &act->manager);
+
+    //track pubsub announce endpoint listener services (pubsub discovery components)
+    if (status == CELIX_SUCCESS) {
+        celix_service_tracking_options_t opts = CELIX_EMPTY_SERVICE_TRACKING_OPTIONS;
+        opts.addWithProperties = pubsub_topologyManager_pubsubAnnounceEndpointListenerAdded;
+        opts.removeWithProperties = pubsub_topologyManager_pubsubAnnounceEndpointListenerRemoved;
+        opts.callbackHandle = act->manager;
+        opts.filter.serviceName = PUBSUB_ANNOUNCE_ENDPOINT_LISTENER_SERVICE;
+        act->pubsubDiscoveryTrackerId = celix_bundleContext_trackServicesWithOptions(ctx, &opts);
+    }
+
+    //track pubsub admin service (psa components)
+    if (status == CELIX_SUCCESS) {
+        celix_service_tracking_options_t opts = CELIX_EMPTY_SERVICE_TRACKING_OPTIONS;
+        opts.addWithProperties = pubsub_topologyManager_psaAdded;
+        opts.removeWithProperties = pubsub_topologyManager_psaRemoved;
+        opts.callbackHandle = act->manager;
+        opts.filter.serviceName = PUBSUB_ADMIN_SERVICE_NAME;
         opts.filter.ignoreServiceLanguage = true;
-		act->pubsubAdminTrackerId = celix_bundleContext_trackServicesWithOptions(ctx, &opts);
-	}
-
-	//track subscriber service
-	if (status == CELIX_SUCCESS) {
-		celix_service_tracking_options_t opts = CELIX_EMPTY_SERVICE_TRACKING_OPTIONS;
-		opts.addWithOwner = pubsub_topologyManager_subscriberAdded;
-		opts.removeWithOwner = pubsub_topologyManager_subscriberRemoved;
-		opts.callbackHandle = act->manager;
-		opts.filter.serviceName = PUBSUB_SUBSCRIBER_SERVICE_NAME;
+        act->pubsubAdminTrackerId = celix_bundleContext_trackServicesWithOptions(ctx, &opts);
+    }
+
+    //track subscriber service
+    if (status == CELIX_SUCCESS) {
+        celix_service_tracking_options_t opts = CELIX_EMPTY_SERVICE_TRACKING_OPTIONS;
+        opts.addWithOwner = pubsub_topologyManager_subscriberAdded;
+        opts.removeWithOwner = pubsub_topologyManager_subscriberRemoved;
+        opts.callbackHandle = act->manager;
+        opts.filter.serviceName = PUBSUB_SUBSCRIBER_SERVICE_NAME;
         opts.filter.ignoreServiceLanguage = true;
-		act->pubsubSubscribersTrackerId = celix_bundleContext_trackServicesWithOptions(ctx, &opts);
-	}
-
-
-	//track requests for publisher services
-	if (status == CELIX_SUCCESS) {
-		act->pubsubPublishServiceTrackerId = celix_bundleContext_trackServiceTrackers(ctx,
-																					  PUBSUB_PUBLISHER_SERVICE_NAME,
-																					  act->manager,
-																					  pubsub_topologyManager_publisherTrackerAdded,
-																					  pubsub_topologyManager_publisherTrackerRemoved);
-	}
-
-	if (status == CELIX_SUCCESS) {
-		celix_service_tracking_options_t opts = CELIX_EMPTY_SERVICE_TRACKING_OPTIONS;
-		opts.callbackHandle = act->manager;
-		opts.addWithProperties = pubsub_topologyManager_addMetricsService;
-		opts.removeWithProperties = pubsub_topologyManager_removeMetricsService;
-		opts.filter.serviceName = PUBSUB_ADMIN_METRICS_SERVICE_NAME;
-		act->pubsubPSAMetricsTrackerId = celix_bundleContext_trackServicesWithOptions(ctx, &opts);
-	}
-
-	//register discovered endpoints listener service (called by pubsub discovery components)
-	if (status == CELIX_SUCCESS) {
-		act->discListenerSvc.handle = act->manager;
-		act->discListenerSvc.addDiscoveredEndpoint = pubsub_topologyManager_addDiscoveredEndpoint;
-		act->discListenerSvc.removeDiscoveredEndpoint = pubsub_topologyManager_removeDiscoveredEndpoint;
-		act->discListenerSvcId = celix_bundleContext_registerService(ctx, &act->discListenerSvc, PUBSUB_DISCOVERED_ENDPOINT_LISTENER_SERVICE, NULL);
-	}
-
-	//register shell command
-	if (status == CELIX_SUCCESS) {
-		act->shellCmdSvc.handle = act->manager;
-		act->shellCmdSvc.executeCommand = pubsub_topologyManager_shellCommand;
-		celix_properties_t *props = celix_properties_create();
-		celix_properties_set(props, OSGI_SHELL_COMMAND_NAME, "pstm");
-		celix_properties_set(props, OSGI_SHELL_COMMAND_USAGE, "pstm [topology|metrics]"); //TODO add search topic/scope option
-		celix_properties_set(props, OSGI_SHELL_COMMAND_DESCRIPTION, "pubsub_topology_info: Overview of Topology information for PubSub");
-		act->shellCmdSvcId = celix_bundleContext_registerService(ctx, &act->shellCmdSvc, OSGI_SHELL_COMMAND_SERVICE_NAME, props);
-	}
-
-	//TODO add tracker for pubsub_serializer and
-	//1) on remove reset sender/receivers entries
-	//2) on add indicate that topic/senders should be reevaluated.
-
-	/* NOTE: Enable those line in order to remotely expose the topic_info service
-	celix_properties_t *props = celix_properties_create();
-	celix_properties_set(props, OSGI_RSA_SERVICE_EXPORTED_INTERFACES, PUBSUB_TOPIC_INFO_SERVICE);
-	status += bundleContext_registerService(context, (char *) PUBSUB_TOPIC_INFO_SERVICE, activator->topicInfo, props, &activator->topicInfoService);
-	*/
-
-	return 0;
+        act->pubsubSubscribersTrackerId = celix_bundleContext_trackServicesWithOptions(ctx, &opts);
+    }
+
+
+    //track requests for publisher services
+    if (status == CELIX_SUCCESS) {
+        act->pubsubPublishServiceTrackerId = celix_bundleContext_trackServiceTrackers(ctx,
+                                                                                      PUBSUB_PUBLISHER_SERVICE_NAME,
+                                                                                      act->manager,
+                                                                                      pubsub_topologyManager_publisherTrackerAdded,
+                                                                                      pubsub_topologyManager_publisherTrackerRemoved);
+    }
+
+    if (status == CELIX_SUCCESS) {
+        celix_service_tracking_options_t opts = CELIX_EMPTY_SERVICE_TRACKING_OPTIONS;
+        opts.callbackHandle = act->manager;
+        opts.addWithProperties = pubsub_topologyManager_addMetricsService;
+        opts.removeWithProperties = pubsub_topologyManager_removeMetricsService;
+        opts.filter.serviceName = PUBSUB_ADMIN_METRICS_SERVICE_NAME;
+        act->pubsubPSAMetricsTrackerId = celix_bundleContext_trackServicesWithOptions(ctx, &opts);
+    }
+
+    //register discovered endpoints listener service (called by pubsub discovery components)
+    if (status == CELIX_SUCCESS) {
+        act->discListenerSvc.handle = act->manager;
+        act->discListenerSvc.addDiscoveredEndpoint = pubsub_topologyManager_addDiscoveredEndpoint;
+        act->discListenerSvc.removeDiscoveredEndpoint = pubsub_topologyManager_removeDiscoveredEndpoint;
+        act->discListenerSvcId = celix_bundleContext_registerService(ctx, &act->discListenerSvc, PUBSUB_DISCOVERED_ENDPOINT_LISTENER_SERVICE, NULL);
+    }
+
+    //register shell command
+    if (status == CELIX_SUCCESS) {
+        act->shellCmdSvc.handle = act->manager;
+        act->shellCmdSvc.executeCommand = pubsub_topologyManager_shellCommand;
+        celix_properties_t *props = celix_properties_create();
+        celix_properties_set(props, OSGI_SHELL_COMMAND_NAME, "pstm");
+        celix_properties_set(props, OSGI_SHELL_COMMAND_USAGE, "pstm [topology|metrics]"); //TODO add search topic/scope option
+        celix_properties_set(props, OSGI_SHELL_COMMAND_DESCRIPTION, "pubsub_topology_info: Overview of Topology information for PubSub");
+        act->shellCmdSvcId = celix_bundleContext_registerService(ctx, &act->shellCmdSvc, OSGI_SHELL_COMMAND_SERVICE_NAME, props);
+    }
+
+    //TODO add tracker for pubsub_serializer and
+    //1) on remove reset sender/receivers entries
+    //2) on add indicate that topic/senders should be reevaluated.
+
+    /* NOTE: Enable those line in order to remotely expose the topic_info service
+    celix_properties_t *props = celix_properties_create();
+    celix_properties_set(props, OSGI_RSA_SERVICE_EXPORTED_INTERFACES, PUBSUB_TOPIC_INFO_SERVICE);
+    status += bundleContext_registerService(context, (char *) PUBSUB_TOPIC_INFO_SERVICE, activator->topicInfo, props, &activator->topicInfoService);
+    */
+
+    return 0;
 }
 
 static int pstm_stop(pstm_activator_t *act, celix_bundle_context_t *ctx) {
-	celix_bundleContext_stopTracker(ctx, act->pubsubSubscribersTrackerId);
-	celix_bundleContext_stopTracker(ctx, act->pubsubDiscoveryTrackerId);
-	celix_bundleContext_stopTracker(ctx, act->pubsubAdminTrackerId);
-	celix_bundleContext_stopTracker(ctx, act->pubsubPublishServiceTrackerId);
-	celix_bundleContext_stopTracker(ctx, act->pubsubPSAMetricsTrackerId);
-	celix_bundleContext_unregisterService(ctx, act->discListenerSvcId);
-	celix_bundleContext_unregisterService(ctx, act->shellCmdSvcId);
+    celix_bundleContext_stopTracker(ctx, act->pubsubSubscribersTrackerId);
+    celix_bundleContext_stopTracker(ctx, act->pubsubDiscoveryTrackerId);
+    celix_bundleContext_stopTracker(ctx, act->pubsubAdminTrackerId);
+    celix_bundleContext_stopTracker(ctx, act->pubsubPublishServiceTrackerId);
+    celix_bundleContext_stopTracker(ctx, act->pubsubPSAMetricsTrackerId);
+    celix_bundleContext_unregisterService(ctx, act->discListenerSvcId);
+    celix_bundleContext_unregisterService(ctx, act->shellCmdSvcId);
 
-	pubsub_topologyManager_destroy(act->manager);
+    pubsub_topologyManager_destroy(act->manager);
 
-	logHelper_stop(act->loghelper);
-	logHelper_destroy(&act->loghelper);
+    logHelper_stop(act->loghelper);
+    logHelper_destroy(&act->loghelper);
 
-	return 0;
+    return 0;
 }
 
 CELIX_GEN_BUNDLE_ACTIVATOR(pstm_activator_t, pstm_start, pstm_stop);
diff --git a/bundles/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.c b/bundles/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.c
index 1c0748a..294b0de 100644
--- a/bundles/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.c
+++ b/bundles/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.c
@@ -43,7 +43,7 @@
 #define PSTM_PSA_HANDLING_SLEEPTIME_IN_SECONDS       30L
 
 #ifndef UUID_STR_LEN
-#define UUID_STR_LEN	37
+#define UUID_STR_LEN    37
 #endif
 
 static void *pstm_psaHandlingThread(void *data);
@@ -214,8 +214,8 @@ void pubsub_topologyManager_psaAdded(void *handle, void *svc, const celix_proper
     if (needsRematchCount > 0) {
         logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO,
                       "A PSA is added after at least one active publisher/provided. \
-				It is preferred that all PSA are started before publiser/subscriber are started!\n\
-				Current topic/sender count is %i", needsRematchCount);
+                It is preferred that all PSA are started before publiser/subscriber are started!\n\
+                Current topic/sender count is %i", needsRematchCount);
     }
 
 }
diff --git a/bundles/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.h b/bundles/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.h
index ed13a47..9dcc13a 100644
--- a/bundles/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.h
+++ b/bundles/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.h
@@ -31,80 +31,80 @@
 #include "pubsub/publisher.h"
 #include "pubsub/subscriber.h"
 
-#define PUBSUB_TOPOLOGY_MANAGER_VERBOSE_KEY 		"PUBSUB_TOPOLOGY_MANAGER_VERBOSE"
-#define PUBSUB_TOPOLOGY_MANAGER_DEFAULT_VERBOSE		false
+#define PUBSUB_TOPOLOGY_MANAGER_VERBOSE_KEY         "PUBSUB_TOPOLOGY_MANAGER_VERBOSE"
+#define PUBSUB_TOPOLOGY_MANAGER_DEFAULT_VERBOSE     false
 
 
 typedef struct pubsub_topology_manager {
-	bundle_context_pt context;
-
-	struct {
-		celix_thread_mutex_t mutex;
-		hash_map_t *map; //key = svcId, value = pubsub_admin_t*
-	} pubsubadmins;
-
-	struct {
-		celix_thread_mutex_t mutex;
-		hash_map_t *map; //key = uuid , value = pstm_discovered_endpoint_entry_t
-	} discoveredEndpoints;
-
-	struct {
-		celix_thread_mutex_t mutex;
-		hash_map_t *map; //key = scope/topic key, value = pstm_topic_receiver_or_sender_entry_t*
-	} topicReceivers;
-
-	struct {
-		celix_thread_mutex_t mutex;
-		hash_map_t *map; //key = scope/topic key, value = pstm_topic_receiver_or_sender_entry_t*
-	} topicSenders;
-
-	struct {
-		celix_thread_mutex_t mutex;
-		celix_array_list_t *list; //<pubsub_announce_endpoint_listener_t*>
-	} announceEndpointListeners;
-
-	struct {
-		celix_thread_mutex_t mutex;
-		hash_map_t *map; //key = svcId, value = pubsub_admin_metrics_service_t*
-	} psaMetrics;
-
-	struct {
-		celix_thread_t thread;
-		celix_thread_mutex_t mutex; //protect running and condition
-		celix_thread_cond_t cond;
-		bool running;
-	} psaHandling;
-
-	log_helper_pt loghelper;
-
-	bool verbose;
+    bundle_context_pt context;
+
+    struct {
+        celix_thread_mutex_t mutex;
+        hash_map_t *map; //key = svcId, value = pubsub_admin_t*
+    } pubsubadmins;
+
+    struct {
+        celix_thread_mutex_t mutex;
+        hash_map_t *map; //key = uuid , value = pstm_discovered_endpoint_entry_t
+    } discoveredEndpoints;
+
+    struct {
+        celix_thread_mutex_t mutex;
+        hash_map_t *map; //key = scope/topic key, value = pstm_topic_receiver_or_sender_entry_t*
+    } topicReceivers;
+
+    struct {
+        celix_thread_mutex_t mutex;
+        hash_map_t *map; //key = scope/topic key, value = pstm_topic_receiver_or_sender_entry_t*
+    } topicSenders;
+
+    struct {
+        celix_thread_mutex_t mutex;
+        celix_array_list_t *list; //<pubsub_announce_endpoint_listener_t*>
+    } announceEndpointListeners;
+
+    struct {
+        celix_thread_mutex_t mutex;
+        hash_map_t *map; //key = svcId, value = pubsub_admin_metrics_service_t*
+    } psaMetrics;
+
+    struct {
+        celix_thread_t thread;
+        celix_thread_mutex_t mutex; //protect running and condition
+        celix_thread_cond_t cond;
+        bool running;
+    } psaHandling;
+
+    log_helper_pt loghelper;
+
+    bool verbose;
 } pubsub_topology_manager_t;
 
 typedef struct pstm_discovered_endpoint_entry {
-	const char *uuid;
-	long selectedPsaSvcId; // -1L, indicates no selected psa
-	int usageCount; //note that discovered endpoints can be found multiple times by different pubsub discovery components
-	celix_properties_t *endpoint;
+    const char *uuid;
+    long selectedPsaSvcId; // -1L, indicates no selected psa
+    int usageCount; //note that discovered endpoints can be found multiple times by different pubsub discovery components
+    celix_properties_t *endpoint;
 } pstm_discovered_endpoint_entry_t;
 
 typedef struct pstm_topic_receiver_or_sender_entry {
-	bool needsMatch; //true if a psa needs to be selected or if a new psa has to be considered.
-
-	char *scopeAndTopicKey; //key of the combined value of the scope and topic
-	celix_properties_t *endpoint;
-	char *topic;
-	char *scope;
-	int usageCount; //nr of subscriber service for the topic receiver (matching scope & topic)
-	long selectedPsaSvcId;
-	long selectedSerializerSvcId;
-	long bndId;
-	celix_properties_t *topicProperties; //found in META-INF/(pub|sub)/(topic).properties
-
-	//for sender entry
-	celix_filter_t *publisherFilter;
-
-	//for receiver entry
-	celix_properties_t *subscriberProperties;
+    bool needsMatch; //true if a psa needs to be selected or if a new psa has to be considered.
+
+    char *scopeAndTopicKey; //key of the combined value of the scope and topic
+    celix_properties_t *endpoint;
+    char *topic;
+    char *scope;
+    int usageCount; //nr of subscriber service for the topic receiver (matching scope & topic)
+    long selectedPsaSvcId;
+    long selectedSerializerSvcId;
+    long bndId;
+    celix_properties_t *topicProperties; //found in META-INF/(pub|sub)/(topic).properties
+
+    //for sender entry
+    celix_filter_t *publisherFilter;
+
+    //for receiver entry
+    celix_properties_t *subscriberProperties;
 } pstm_topic_receiver_or_sender_entry_t;
 
 celix_status_t pubsub_topologyManager_create(bundle_context_pt context, log_helper_pt logHelper, pubsub_topology_manager_t **manager);
diff --git a/bundles/pubsub/test/test/sut_activator.c b/bundles/pubsub/test/test/sut_activator.c
index 7fed1ff..adb6598 100644
--- a/bundles/pubsub/test/test/sut_activator.c
+++ b/bundles/pubsub/test/test/sut_activator.c
@@ -30,86 +30,86 @@ static void sut_pubSet(void *handle, void *service);
 static void* sut_sendThread(void *data);
 
 struct activator {
-	long pubTrkId;
+    long pubTrkId;
 
-	pthread_t sendThread;
+    pthread_t sendThread;
 
-	pthread_mutex_t mutex;
-	bool running;
-	pubsub_publisher_t* pubSvc;
+    pthread_mutex_t mutex;
+    bool running;
+    pubsub_publisher_t* pubSvc;
 };
 
 celix_status_t bnd_start(struct activator *act, celix_bundle_context_t *ctx) {
 
-	char filter[512];
-	snprintf(filter, 512, "(%s=%s)", PUBSUB_PUBLISHER_TOPIC, "ping");
-	celix_service_tracking_options_t opts = CELIX_EMPTY_SERVICE_TRACKING_OPTIONS;
-	opts.set = sut_pubSet;
-	opts.callbackHandle = act;
-	opts.filter.serviceName = PUBSUB_PUBLISHER_SERVICE_NAME;
-	opts.filter.filter = filter;
-	act->pubTrkId = celix_bundleContext_trackServicesWithOptions(ctx, &opts);
+    char filter[512];
+    snprintf(filter, 512, "(%s=%s)", PUBSUB_PUBLISHER_TOPIC, "ping");
+    celix_service_tracking_options_t opts = CELIX_EMPTY_SERVICE_TRACKING_OPTIONS;
+    opts.set = sut_pubSet;
+    opts.callbackHandle = act;
+    opts.filter.serviceName = PUBSUB_PUBLISHER_SERVICE_NAME;
+    opts.filter.filter = filter;
+    act->pubTrkId = celix_bundleContext_trackServicesWithOptions(ctx, &opts);
 
-	act->running = true;
-	pthread_create(&act->sendThread, NULL, sut_sendThread, act);
+    act->running = true;
+    pthread_create(&act->sendThread, NULL, sut_sendThread, act);
 
-	return CELIX_SUCCESS;
+    return CELIX_SUCCESS;
 }
 
 celix_status_t bnd_stop(struct activator *act, celix_bundle_context_t *ctx) {
-	pthread_mutex_lock(&act->mutex);
-	act->running = false;
-	pthread_mutex_unlock(&act->mutex);
-	pthread_join(act->sendThread, NULL);
-	pthread_mutex_destroy(&act->mutex);
-
-	celix_bundleContext_stopTracker(ctx, act->pubTrkId);
-	return CELIX_SUCCESS;
+    pthread_mutex_lock(&act->mutex);
+    act->running = false;
+    pthread_mutex_unlock(&act->mutex);
+    pthread_join(act->sendThread, NULL);
+    pthread_mutex_destroy(&act->mutex);
+
+    celix_bundleContext_stopTracker(ctx, act->pubTrkId);
+    return CELIX_SUCCESS;
 }
 
 CELIX_GEN_BUNDLE_ACTIVATOR(struct activator, bnd_start, bnd_stop);
 
 static void sut_pubSet(void *handle, void *service) {
-	struct activator* act = handle;
-	pthread_mutex_lock(&act->mutex);
-	act->pubSvc = service;
-	pthread_mutex_unlock(&act->mutex);
+    struct activator* act = handle;
+    pthread_mutex_lock(&act->mutex);
+    act->pubSvc = service;
+    pthread_mutex_unlock(&act->mutex);
 }
 
 static void* sut_sendThread(void *data) {
-	struct activator *act = data;
+    struct activator *act = data;
 
-	pthread_mutex_lock(&act->mutex);
-	bool running = act->running;
-	pthread_mutex_unlock(&act->mutex);
+    pthread_mutex_lock(&act->mutex);
+    bool running = act->running;
+    pthread_mutex_unlock(&act->mutex);
 
-	unsigned int msgId = 0;
-	msg_t msg;
-	msg.seqNr = 1;
+    unsigned int msgId = 0;
+    msg_t msg;
+    msg.seqNr = 1;
 
-	while (running) {
-		pthread_mutex_lock(&act->mutex);
-		if (act->pubSvc != NULL) {
-		    if (msgId == 0) {
-		        act->pubSvc->localMsgTypeIdForMsgType(act->pubSvc->handle, MSG_NAME, &msgId);
-		    }
+    while (running) {
+        pthread_mutex_lock(&act->mutex);
+        if (act->pubSvc != NULL) {
+            if (msgId == 0) {
+                act->pubSvc->localMsgTypeIdForMsgType(act->pubSvc->handle, MSG_NAME, &msgId);
+            }
 
-			act->pubSvc->send(act->pubSvc->handle, msgId, &msg);
+            act->pubSvc->send(act->pubSvc->handle, msgId, &msg);
             if (msg.seqNr % 1000 == 0) {
                 printf("Send %i messages\n", msg.seqNr);
             }
 
-		    msg.seqNr += 1;
+            msg.seqNr += 1;
 
         }
         pthread_mutex_unlock(&act->mutex);
 
-		usleep(10000);
+        usleep(10000);
 
-		pthread_mutex_lock(&act->mutex);
-		running = act->running;
-		pthread_mutex_unlock(&act->mutex);
-	}
+        pthread_mutex_lock(&act->mutex);
+        running = act->running;
+        pthread_mutex_unlock(&act->mutex);
+    }
     printf("Send %i messages\n", msg.seqNr);
 
     return NULL;
diff --git a/bundles/pubsub/test/test/tst_activator.cc b/bundles/pubsub/test/test/tst_activator.cc
index 71dc5fc..4430adb 100644
--- a/bundles/pubsub/test/test/tst_activator.cc
+++ b/bundles/pubsub/test/test/tst_activator.cc
@@ -89,13 +89,13 @@ static int tst_receive(void *handle, const char * /*msgType*/, unsigned int /*ms
 
 TEST_GROUP(PUBSUB_INT_GROUP)
 {
-	void setup() {
-	    //nop
-	}
+    void setup() {
+        //nop
+    }
 
-	void teardown() {
-		//nop
-	}
+    void teardown() {
+        //nop
+    }
 };
 
 TEST(PUBSUB_INT_GROUP, recvTest) {


[celix] 01/03: Updated utils to use celix_properties_t* instead of properties_pt

Posted by rl...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

rlenferink pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/celix.git

commit eb199825e4be4cf01a2963370c28b200a732303c
Author: Roy Lenferink <le...@gmail.com>
AuthorDate: Wed Jul 17 18:36:16 2019 +0200

    Updated utils to use celix_properties_t* instead of properties_pt
    
    Updated license headers and formatting as well
---
 libs/utils/include/array_list.h                |   32 +-
 libs/utils/include/celix_array_list.h          |   28 +-
 libs/utils/include/celix_errno.h               |   34 +-
 libs/utils/include/celix_filter.h              |   28 +-
 libs/utils/include/celix_properties.h          |   28 +-
 libs/utils/include/celix_threads.h             |   40 +-
 libs/utils/include/celix_utils_api.h           |   28 +-
 libs/utils/include/celixbool.h                 |   34 +-
 libs/utils/include/exports.h                   |   32 +-
 libs/utils/include/filter.h                    |   28 +-
 libs/utils/include/hash_map.h                  |   46 +-
 libs/utils/include/ip_utils.h                  |    4 +-
 libs/utils/include/linked_list.h               |   32 +-
 libs/utils/include/linked_list_iterator.h      |   32 +-
 libs/utils/include/properties.h                |   32 +-
 libs/utils/include/utils.h                     |   32 +-
 libs/utils/include/version.h                   |   74 +-
 libs/utils/include/version_range.h             |   52 +-
 libs/utils/private/test/array_list_test.cpp    |  823 ++++-----
 libs/utils/private/test/celix_threads_test.cpp |  587 ++++---
 libs/utils/private/test/filter_test.cpp        |    4 +-
 libs/utils/private/test/hash_map_test.cpp      | 2247 ++++++++++++------------
 libs/utils/private/test/ip_utils_test.cpp      |   14 +-
 libs/utils/private/test/linked_list_test.cpp   | 1071 +++++------
 libs/utils/private/test/properties_test.cpp    |  335 ++--
 libs/utils/private/test/thread_pool_test.cpp   |  125 +-
 libs/utils/private/test/utils_test.cpp         |  451 ++---
 libs/utils/private/test/version_range_test.cpp |  368 ++--
 libs/utils/private/test/version_test.cpp       |  514 +++---
 libs/utils/src/array_list.c                    |  659 +++----
 libs/utils/src/array_list_private.h            |   52 +-
 libs/utils/src/celix_threads.c                 |  136 +-
 libs/utils/src/filter.c                        |  942 +++++-----
 libs/utils/src/hash_map.c                      |  785 ++++-----
 libs/utils/src/hash_map_private.h              |   64 +-
 libs/utils/src/ip_utils.c                      |    4 +-
 libs/utils/src/linked_list.c                   |  281 +--
 libs/utils/src/linked_list_iterator.c          |  199 +--
 libs/utils/src/linked_list_private.h           |   44 +-
 libs/utils/src/properties.c                    |  638 +++----
 libs/utils/src/utils.c                         |  187 +-
 libs/utils/src/version.c                       |  396 ++---
 libs/utils/src/version_private.h               |   37 +-
 libs/utils/src/version_range.c                 |  278 +--
 libs/utils/src/version_range_private.h         |   37 +-
 45 files changed, 5951 insertions(+), 5943 deletions(-)

diff --git a/libs/utils/include/array_list.h b/libs/utils/include/array_list.h
index 9262984..a0c8bd4 100644
--- a/libs/utils/include/array_list.h
+++ b/libs/utils/include/array_list.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * array_list.h
  *
  *  \date       Aug 4, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef ARRAY_LIST_H_
diff --git a/libs/utils/include/celix_array_list.h b/libs/utils/include/celix_array_list.h
index 4bb3e7b..7184bfd 100644
--- a/libs/utils/include/celix_array_list.h
+++ b/libs/utils/include/celix_array_list.h
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #include "celixbool.h"
diff --git a/libs/utils/include/celix_errno.h b/libs/utils/include/celix_errno.h
index b51540b..0636d99 100644
--- a/libs/utils/include/celix_errno.h
+++ b/libs/utils/include/celix_errno.h
@@ -1,27 +1,27 @@
-/*
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * celix_errno.h
  *
  *  \date       Feb 15, 2011
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 /*!
   \file
diff --git a/libs/utils/include/celix_filter.h b/libs/utils/include/celix_filter.h
index 4d0d7fa..a6a9e15 100644
--- a/libs/utils/include/celix_filter.h
+++ b/libs/utils/include/celix_filter.h
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #ifndef CELIX_FILTER_H_
diff --git a/libs/utils/include/celix_properties.h b/libs/utils/include/celix_properties.h
index fbc59ab..b86c297 100644
--- a/libs/utils/include/celix_properties.h
+++ b/libs/utils/include/celix_properties.h
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #include <stdio.h>
diff --git a/libs/utils/include/celix_threads.h b/libs/utils/include/celix_threads.h
index a4bc54c..af33a99 100644
--- a/libs/utils/include/celix_threads.h
+++ b/libs/utils/include/celix_threads.h
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * celix_threads.h
@@ -37,8 +37,8 @@ extern "C" {
 #endif
 
 struct celix_thread {
-	bool threadInitialized;
-	pthread_t thread;
+    bool threadInitialized;
+    pthread_t thread;
 };
 
 typedef pthread_once_t celix_thread_once_t;
@@ -79,10 +79,10 @@ typedef pthread_mutexattr_t celix_thread_mutexattr_t;
 
 //MUTEX TYPES
 enum {
-	CELIX_THREAD_MUTEX_NORMAL,
-	CELIX_THREAD_MUTEX_RECURSIVE,
-	CELIX_THREAD_MUTEX_ERRORCHECK,
-	CELIX_THREAD_MUTEX_DEFAULT
+    CELIX_THREAD_MUTEX_NORMAL,
+    CELIX_THREAD_MUTEX_RECURSIVE,
+    CELIX_THREAD_MUTEX_ERRORCHECK,
+    CELIX_THREAD_MUTEX_DEFAULT
 };
 
 
diff --git a/libs/utils/include/celix_utils_api.h b/libs/utils/include/celix_utils_api.h
index 48324c3..afe9ba7 100644
--- a/libs/utils/include/celix_utils_api.h
+++ b/libs/utils/include/celix_utils_api.h
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #ifndef CELIX_CELIX_UTILS_API_H_
diff --git a/libs/utils/include/celixbool.h b/libs/utils/include/celixbool.h
index 526392b..50fa7c6 100644
--- a/libs/utils/include/celixbool.h
+++ b/libs/utils/include/celixbool.h
@@ -1,27 +1,27 @@
-/*
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * celixbool.h
  *
  *  \date       Jun 16, 2011
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef CELIXBOOL_H_
diff --git a/libs/utils/include/exports.h b/libs/utils/include/exports.h
index b128c88..23b6146 100644
--- a/libs/utils/include/exports.h
+++ b/libs/utils/include/exports.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * exports.h
  *
  *  \date       Jun 16, 2011
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef EXPORTS_H_
diff --git a/libs/utils/include/filter.h b/libs/utils/include/filter.h
index 105925c..b972c11 100644
--- a/libs/utils/include/filter.h
+++ b/libs/utils/include/filter.h
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #ifndef FILTER_H_
diff --git a/libs/utils/include/hash_map.h b/libs/utils/include/hash_map.h
index d9d1b66..ec030c1 100644
--- a/libs/utils/include/hash_map.h
+++ b/libs/utils/include/hash_map.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * hash_map.h
  *
  *  \date       Jul 21, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef HASH_MAP_H_
@@ -41,11 +41,11 @@ typedef struct hashMap* hash_map_pt;
 typedef struct hashMap hash_map_t;
 
 struct hashMapIterator {
-	hash_map_pt map;
-	hash_map_entry_pt next;
-	hash_map_entry_pt current;
-	int expectedModCount;
-	int index;
+    hash_map_pt map;
+    hash_map_entry_pt next;
+    hash_map_entry_pt current;
+    int expectedModCount;
+    int index;
 };
 
 typedef struct hashMapIterator hash_map_iterator_t;
@@ -56,8 +56,8 @@ typedef struct hashMapValues *hash_map_values_pt;
 typedef struct hashMapEntrySet *hash_map_entry_set_pt;
 
 UTILS_EXPORT hash_map_pt hashMap_create(unsigned int (*keyHash)(const void *), unsigned int (*valueHash)(const void *),
-										int (*keyEquals)(const void *, const void *),
-										int (*valueEquals)(const void *, const void *));
+                                        int (*keyEquals)(const void *, const void *),
+                                        int (*valueEquals)(const void *, const void *));
 
 UTILS_EXPORT void hashMap_destroy(hash_map_pt map, bool freeKeys, bool freeValues);
 
diff --git a/libs/utils/include/ip_utils.h b/libs/utils/include/ip_utils.h
index d95a14a..8f8fe5c 100644
--- a/libs/utils/include/ip_utils.h
+++ b/libs/utils/include/ip_utils.h
@@ -20,8 +20,8 @@
  * ip_utils.h
  *
  *  \date       Jun 24, 2019
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef IP_UTILS_H_
diff --git a/libs/utils/include/linked_list.h b/libs/utils/include/linked_list.h
index 04c1162..e5d449e 100644
--- a/libs/utils/include/linked_list.h
+++ b/libs/utils/include/linked_list.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * linked_list.h
  *
  *  \date       Jul 16, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef LINKED_LIST_H_
diff --git a/libs/utils/include/linked_list_iterator.h b/libs/utils/include/linked_list_iterator.h
index f765d5d..393d4cc 100644
--- a/libs/utils/include/linked_list_iterator.h
+++ b/libs/utils/include/linked_list_iterator.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * linked_list_iterator.h
  *
  *  \date       Jul 16, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef LINKED_LIST_ITERATOR_H_
diff --git a/libs/utils/include/properties.h b/libs/utils/include/properties.h
index f0070bd..c295eb5 100644
--- a/libs/utils/include/properties.h
+++ b/libs/utils/include/properties.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * properties.h
  *
  *  \date       Apr 27, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef PROPERTIES_H_
diff --git a/libs/utils/include/utils.h b/libs/utils/include/utils.h
index 11a200f..78d025d 100644
--- a/libs/utils/include/utils.h
+++ b/libs/utils/include/utils.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * utils.h
  *
  *  \date       Jul 27, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef UTILS_H_
diff --git a/libs/utils/include/version.h b/libs/utils/include/version.h
index 88e146a..50a91f7 100644
--- a/libs/utils/include/version.h
+++ b/libs/utils/include/version.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * version.h
  *
  *  \date       Jul 12, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef VERSION_H_
@@ -50,10 +50,10 @@ typedef struct version *version_pt;
  *        the empty string.
  * @param version The created version_pt
  * @return Status code indication failure or success:
- * 		- CELIX_SUCCESS when no errors are encountered.
- * 		- CELIX_ENOMEM If allocating memory for <code>version</code> failed.
- * 		- CELIX_ILLEGAL_ARGUMENT If the numerical components are negative
- * 		  or the qualifier string is invalid.
+ *         - CELIX_SUCCESS when no errors are encountered.
+ *         - CELIX_ENOMEM If allocating memory for <code>version</code> failed.
+ *         - CELIX_ILLEGAL_ARGUMENT If the numerical components are negative
+ *           or the qualifier string is invalid.
  */
 celix_status_t version_createVersion(int major, int minor, int micro, char *qualifier, version_pt *version);
 
@@ -65,10 +65,10 @@ celix_status_t version_destroy(version_pt version);
  * @param version The version to clone
  * @param clone The cloned version
  * @return Status code indication failure or success:
- * 		- CELIX_SUCCESS when no errors are encountered.
- * 		- CELIX_ENOMEM If allocating memory for <code>version</code> failed.
- * 		- CELIX_ILLEGAL_ARGUMENT If the numerical components are negative
- * 		  or the qualifier string is invalid.
+ *         - CELIX_SUCCESS when no errors are encountered.
+ *         - CELIX_ENOMEM If allocating memory for <code>version</code> failed.
+ *         - CELIX_ILLEGAL_ARGUMENT If the numerical components are negative
+ *           or the qualifier string is invalid.
  */
 celix_status_t version_clone(version_pt version, version_pt *clone);
 
@@ -93,10 +93,10 @@ celix_status_t version_clone(version_pt version, version_pt *clone);
  * @param versionStr String representation of the version identifier.
  * @param version The created version_pt
  * @return Status code indication failure or success:
- * 		- CELIX_SUCCESS when no errors are encountered.
- * 		- CELIX_ENOMEM If allocating memory for <code>version</code> failed.
- * 		- CELIX_ILLEGAL_ARGUMENT If the numerical components are negative,
- * 		  	the qualifier string is invalid or <code>versionStr</code> is improperly formatted.
+ *         - CELIX_SUCCESS when no errors are encountered.
+ *         - CELIX_ENOMEM If allocating memory for <code>version</code> failed.
+ *         - CELIX_ILLEGAL_ARGUMENT If the numerical components are negative,
+ *               the qualifier string is invalid or <code>versionStr</code> is improperly formatted.
  */
 celix_status_t version_createVersionFromString(const char *versionStr, version_pt *version);
 
@@ -105,10 +105,10 @@ celix_status_t version_createVersionFromString(const char *versionStr, version_p
  *
  * @param version The created version_pt
  * @return Status code indication failure or success:
- * 		- CELIX_SUCCESS when no errors are encountered.
- * 		- CELIX_ENOMEM If allocating memory for <code>version</code> failed.
- * 		- CELIX_ILLEGAL_ARGUMENT If the numerical components are negative,
- * 		  	the qualifier string is invalid or <code>versionStr</code> is improperly formatted.
+ *         - CELIX_SUCCESS when no errors are encountered.
+ *         - CELIX_ENOMEM If allocating memory for <code>version</code> failed.
+ *         - CELIX_ILLEGAL_ARGUMENT If the numerical components are negative,
+ *               the qualifier string is invalid or <code>versionStr</code> is improperly formatted.
  */
 celix_status_t version_createEmptyVersion(version_pt *version);
 
@@ -143,7 +143,7 @@ celix_status_t version_getQualifier(version_pt version, const char **qualifier);
  * @param result A negative integer, zero, or a positive integer if <code>version</code> is
  *         less than, equal to, or greater than the <code>compare</code>.
  * @return Status code indication failure or success:
- * 		- CELIX_SUCCESS when no errors are encountered.
+ *         - CELIX_SUCCESS when no errors are encountered.
  */
 celix_status_t version_compareTo(version_pt version, version_pt compare, int *result);
 
@@ -159,7 +159,7 @@ celix_status_t version_compareTo(version_pt version, version_pt compare, int *re
  * @param version The <code>version_pt</code> to get the string representation from.
  * @param string Pointer to the string (char *) in which the result will be placed.
  * @return Status code indication failure or success:
- * 		- CELIX_SUCCESS when no errors are encountered.
+ *         - CELIX_SUCCESS when no errors are encountered.
  */
 celix_status_t version_toString(version_pt version, char **string);
 
@@ -175,7 +175,7 @@ celix_status_t version_toString(version_pt version, char **string);
  * @param version The reference provider <code>version_pt</code> .
  * @param Boolean indicating if the versions are compatible
  * @return Status code indication failure or success:
- * 		- CELIX_SUCCESS when no errors are encountered.
+ *         - CELIX_SUCCESS when no errors are encountered.
  */
 celix_status_t version_isCompatible(version_pt user, version_pt provider, bool *isCompatible);
 
diff --git a/libs/utils/include/version_range.h b/libs/utils/include/version_range.h
index b661cd3..e93d52b 100644
--- a/libs/utils/include/version_range.h
+++ b/libs/utils/include/version_range.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * version_range.h
  *
  *  \date       Jul 12, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef VERSION_RANGE_H_
@@ -54,8 +54,8 @@ typedef struct versionRange *version_range_pt;
  * @param isHighInclusive True if upper bound should be included in the range
  * @param versionRange The created range
  * @return Status code indication failure or success:
- * 		- CELIX_SUCCESS when no errors are encountered.
- * 		- CELIX_ENOMEM If allocating memory for <code>versionRange</code> failed.
+ *         - CELIX_SUCCESS when no errors are encountered.
+ *         - CELIX_ENOMEM If allocating memory for <code>versionRange</code> failed.
  */
 celix_status_t
 versionRange_createVersionRange(version_pt low, bool isLowInclusive, version_pt high, bool isHighInclusive,
@@ -63,12 +63,12 @@ versionRange_createVersionRange(version_pt low, bool isLowInclusive, version_pt
 
 /**
  * Creates an infinite version range using ::version_createEmptyVersion for the low version,
- * 	NULL for the high version and high and low inclusive set to true.
+ *     NULL for the high version and high and low inclusive set to true.
  *
  * @param range The created range
  * @return Status code indication failure or success:
- * 		- CELIX_SUCCESS when no errors are encountered.
- * 		- CELIX_ENOMEM If allocating memory for <code>range</code> failed.
+ *         - CELIX_SUCCESS when no errors are encountered.
+ *         - CELIX_ENOMEM If allocating memory for <code>range</code> failed.
  */
 celix_status_t versionRange_createInfiniteVersionRange(version_range_pt *range);
 
@@ -81,7 +81,7 @@ celix_status_t versionRange_destroy(version_range_pt range);
  * @param version The version to check.
  * @param inRange True if the specified version is included in this version range, false otherwise.
  * @return Status code indication failure or success:
- * 		- CELIX_SUCCESS when no errors are encountered.
+ *         - CELIX_SUCCESS when no errors are encountered.
  */
 celix_status_t versionRange_isInRange(version_range_pt versionRange, version_pt version, bool *inRange);
 
@@ -146,10 +146,10 @@ celix_status_t versionRange_getHighVersion(version_range_pt versionRange, versio
  * @param rangeStr String representation of the version range.
  * @param range The created version_range_pt.
  * @return Status code indication failure or success:
- * 		- CELIX_SUCCESS when no errors are encountered.
- * 		- CELIX_ENOMEM If allocating memory for <code>versionRange</code> failed.
- * 		- CELIX_ILLEGAL_ARGUMENT If the numerical components are negative,
- * 		  	the qualifier string is invalid or <code>versionStr</code> is impropertly formatted.
+ *         - CELIX_SUCCESS when no errors are encountered.
+ *         - CELIX_ENOMEM If allocating memory for <code>versionRange</code> failed.
+ *         - CELIX_ILLEGAL_ARGUMENT If the numerical components are negative,
+ *               the qualifier string is invalid or <code>versionStr</code> is impropertly formatted.
  */
 celix_status_t versionRange_parse(const char *rangeStr, version_range_pt *range);
 
diff --git a/libs/utils/private/test/array_list_test.cpp b/libs/utils/private/test/array_list_test.cpp
index 4c908e3..8a4a965 100644
--- a/libs/utils/private/test/array_list_test.cpp
+++ b/libs/utils/private/test/array_list_test.cpp
@@ -1,28 +1,29 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * array_list_test.cpp
  *
- * 	\date       Sep 15, 2015
- *  \author    	Menno van der Graaf & Alexander
- *  \copyright	Apache License, Version 2.0
+ *  \date       Sep 15, 2015
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -40,544 +41,544 @@ extern "C"
 }
 
 int main(int argc, char** argv) {
-	return RUN_ALL_TESTS(argc, argv);
+    return RUN_ALL_TESTS(argc, argv);
 }
 
 static char* my_strdup(const char* s){
-	char *d = (char*) malloc (strlen (s) + 1);
-	if (d == NULL) return NULL;
-	strcpy (d,s);
-	return d;
+    char *d = (char*) malloc (strlen (s) + 1);
+    if (d == NULL) return NULL;
+    strcpy (d,s);
+    return d;
 }
 
 //----------------------TESTS GROUP DEFINES----------------------
 
 TEST_GROUP(array_list) {
-	array_list_pt list;
-
-	void setup(){
-		arrayList_create(&list);
-	}
-	void teardown() {
-		arrayList_destroy(list);
-	}
+    array_list_pt list;
+
+    void setup(){
+        arrayList_create(&list);
+    }
+    void teardown() {
+        arrayList_destroy(list);
+    }
 };
 
 TEST_GROUP(array_list_iterator) {
-	array_list_pt list;
-
-	void setup(){
-		arrayList_create(&list);
-	}
-	void teardown() {
-		arrayList_destroy(list);
-	}
+    array_list_pt list;
+
+    void setup(){
+        arrayList_create(&list);
+    }
+    void teardown() {
+        arrayList_destroy(list);
+    }
 };
 
 //----------------------ARRAY LIST TESTS----------------------
 
 TEST(array_list, create) {
-	CHECK_C(list != NULL);
-	LONGS_EQUAL(0, list->size);
+    CHECK_C(list != NULL);
+    LONGS_EQUAL(0, list->size);
 }
 
 TEST(array_list, trimToSize) {
-	char * entry = my_strdup("entry");
-	arrayList_clear(list);
+    char * entry = my_strdup("entry");
+    arrayList_clear(list);
 
-	arrayList_add(list, entry);
-	LONGS_EQUAL(1, list->size);
-	LONGS_EQUAL(10, list->capacity);
+    arrayList_add(list, entry);
+    LONGS_EQUAL(1, list->size);
+    LONGS_EQUAL(10, list->capacity);
 
-	arrayList_trimToSize(list);
-	LONGS_EQUAL(1, list->size);
-	LONGS_EQUAL(1, list->capacity);
+    arrayList_trimToSize(list);
+    LONGS_EQUAL(1, list->size);
+    LONGS_EQUAL(1, list->capacity);
 
-	free(entry);
+    free(entry);
 }
 
 TEST(array_list, ensureCapacity) {
-	int i;
-	arrayList_clear(list);
-
-	LONGS_EQUAL(10, list->capacity);
-	LONGS_EQUAL(0, list->size);
-
-	for (i = 0; i < 100; i++) {
-		char * entry = my_strdup("entry");
-		arrayList_add(list, entry);
-	}
-	LONGS_EQUAL(133, list->capacity);
-	LONGS_EQUAL(100, list->size);
-
-	for (i = 99; i >= 0; i--) {
-		free(arrayList_remove(list, i));
-	}
+    int i;
+    arrayList_clear(list);
+
+    LONGS_EQUAL(10, list->capacity);
+    LONGS_EQUAL(0, list->size);
+
+    for (i = 0; i < 100; i++) {
+        char * entry = my_strdup("entry");
+        arrayList_add(list, entry);
+    }
+    LONGS_EQUAL(133, list->capacity);
+    LONGS_EQUAL(100, list->size);
+
+    for (i = 99; i >= 0; i--) {
+        free(arrayList_remove(list, i));
+    }
 }
 
 TEST(array_list, clone) {
-	int i;
-	arrayList_clear(list);
-
-	LONGS_EQUAL(10, list->capacity);
-	LONGS_EQUAL(0, list->size);
-
-	for (i = 0; i < 12; i++) {
-		bool added;
-		char entry[11];
-		sprintf(entry, "|%s|%d|", "entry", i);
-		added = arrayList_add(list, my_strdup(entry));
-		CHECK(added);
-	}
-	LONGS_EQUAL(16, list->capacity);
-	LONGS_EQUAL(12, list->size);
-
-	array_list_pt clone = NULL;
-	clone = arrayList_clone(list);
-
-	LONGS_EQUAL(16, clone->capacity);
-	LONGS_EQUAL(12, clone->size);
-
-	unsigned int j;
-	for (j = 0; j < 12; j++) {
-		void *entry = NULL;
-		char entrys[11];
-		sprintf(entrys, "|%s|%d|", "entry", j);
-
-		entry = arrayList_get(clone, j);
-		STRCMP_EQUAL((char *) entry, entrys);
-	}
-
-	for (i = 11; i >= 0; i--) {
-		free(arrayList_remove(list, i));
-	}
-	arrayList_destroy(clone);
+    int i;
+    arrayList_clear(list);
+
+    LONGS_EQUAL(10, list->capacity);
+    LONGS_EQUAL(0, list->size);
+
+    for (i = 0; i < 12; i++) {
+        bool added;
+        char entry[11];
+        sprintf(entry, "|%s|%d|", "entry", i);
+        added = arrayList_add(list, my_strdup(entry));
+        CHECK(added);
+    }
+    LONGS_EQUAL(16, list->capacity);
+    LONGS_EQUAL(12, list->size);
+
+    array_list_pt clone = NULL;
+    clone = arrayList_clone(list);
+
+    LONGS_EQUAL(16, clone->capacity);
+    LONGS_EQUAL(12, clone->size);
+
+    unsigned int j;
+    for (j = 0; j < 12; j++) {
+        void *entry = NULL;
+        char entrys[11];
+        sprintf(entrys, "|%s|%d|", "entry", j);
+
+        entry = arrayList_get(clone, j);
+        STRCMP_EQUAL((char *) entry, entrys);
+    }
+
+    for (i = 11; i >= 0; i--) {
+        free(arrayList_remove(list, i));
+    }
+    arrayList_destroy(clone);
 }
 
 TEST(array_list, size){
-	char * entry = my_strdup("entry");
-	char * entry2 = my_strdup("entry");
-	char * entry3 = my_strdup("entry");
-	arrayList_clear(list);
-	LONGS_EQUAL(0, list->size);
+    char * entry = my_strdup("entry");
+    char * entry2 = my_strdup("entry");
+    char * entry3 = my_strdup("entry");
+    arrayList_clear(list);
+    LONGS_EQUAL(0, list->size);
 
-	arrayList_add(list, entry);
-	LONGS_EQUAL(1, list->size);
+    arrayList_add(list, entry);
+    LONGS_EQUAL(1, list->size);
 
-	arrayList_add(list, entry2);
-	LONGS_EQUAL(2, list->size);
+    arrayList_add(list, entry2);
+    LONGS_EQUAL(2, list->size);
 
-	arrayList_add(list, entry3);
-	LONGS_EQUAL(3, list->size);
+    arrayList_add(list, entry3);
+    LONGS_EQUAL(3, list->size);
 
-	free(entry);
-	free(entry2);
-	free(entry3);
+    free(entry);
+    free(entry2);
+    free(entry3);
 }
 
 TEST(array_list, isEmpty){
-	arrayList_clear(list);
-	LONGS_EQUAL(0, list->size);
-	CHECK(arrayList_isEmpty(list));
+    arrayList_clear(list);
+    LONGS_EQUAL(0, list->size);
+    CHECK(arrayList_isEmpty(list));
 }
 
 TEST(array_list, contains){
-	char * entry = my_strdup("entry");
-	char * entry2 = my_strdup("entry2");
-	char * entry3 = NULL;
-	bool contains;
+    char * entry = my_strdup("entry");
+    char * entry2 = my_strdup("entry2");
+    char * entry3 = NULL;
+    bool contains;
 
-	arrayList_clear(list);
+    arrayList_clear(list);
 
-	arrayList_add(list, entry);
+    arrayList_add(list, entry);
 
-	arrayList_add(list, entry2);
+    arrayList_add(list, entry2);
 
-	CHECK(arrayList_contains(list, entry));
-	CHECK(arrayList_contains(list, entry2));
-	contains = arrayList_contains(list, NULL);
-	CHECK(!contains);
+    CHECK(arrayList_contains(list, entry));
+    CHECK(arrayList_contains(list, entry2));
+    contains = arrayList_contains(list, NULL);
+    CHECK(!contains);
 
-	arrayList_add(list, entry3);
+    arrayList_add(list, entry3);
 
-	CHECK(arrayList_contains(list, entry3));
+    CHECK(arrayList_contains(list, entry3));
 
-	free(entry);
-	free(entry2);
+    free(entry);
+    free(entry2);
 }
 
 TEST(array_list, indexOf){
-	char * entry = my_strdup("entry");
-	char * entry2 = my_strdup("entry2");
+    char * entry = my_strdup("entry");
+    char * entry2 = my_strdup("entry2");
 
-	arrayList_clear(list);
+    arrayList_clear(list);
 
-	arrayList_add(list, entry);
+    arrayList_add(list, entry);
 
-	arrayList_add(list, entry2);
-	arrayList_add(list, entry2);
-	arrayList_add(list, entry2);
-	arrayList_add(list, entry2);
+    arrayList_add(list, entry2);
+    arrayList_add(list, entry2);
+    arrayList_add(list, entry2);
+    arrayList_add(list, entry2);
 
-	LONGS_EQUAL(0, arrayList_indexOf(list, entry));
-	LONGS_EQUAL(1, arrayList_indexOf(list, entry2));
-	LONGS_EQUAL(0, arrayList_lastIndexOf(list, entry));
-	LONGS_EQUAL(4, arrayList_lastIndexOf(list, entry2));
+    LONGS_EQUAL(0, arrayList_indexOf(list, entry));
+    LONGS_EQUAL(1, arrayList_indexOf(list, entry2));
+    LONGS_EQUAL(0, arrayList_lastIndexOf(list, entry));
+    LONGS_EQUAL(4, arrayList_lastIndexOf(list, entry2));
 
-	free(entry);
-	free(entry2);
+    free(entry);
+    free(entry2);
 }
 
 TEST(array_list, get){
-	char * entry = my_strdup("entry");
-	char * entry2 = my_strdup("entry2");
-	char * entry3 = NULL;
-	char * get;
+    char * entry = my_strdup("entry");
+    char * entry2 = my_strdup("entry2");
+    char * entry3 = NULL;
+    char * get;
 
-	arrayList_clear(list);
+    arrayList_clear(list);
 
-	arrayList_add(list, entry);
-	arrayList_add(list, entry2);
+    arrayList_add(list, entry);
+    arrayList_add(list, entry2);
 
-	get = (char*) arrayList_get(list, 0);
-	STRCMP_EQUAL(entry, get);
+    get = (char*) arrayList_get(list, 0);
+    STRCMP_EQUAL(entry, get);
 
-	get = (char*) arrayList_get(list, 1);
-	STRCMP_EQUAL(entry2, get);
+    get = (char*) arrayList_get(list, 1);
+    STRCMP_EQUAL(entry2, get);
 
-	arrayList_add(list, entry3);
+    arrayList_add(list, entry3);
 
-	get = (char*) arrayList_get(list, 2);
-	CHECK(get == NULL);
+    get = (char*) arrayList_get(list, 2);
+    CHECK(get == NULL);
 
-	get = (char*) arrayList_get(list, 42);
-	CHECK(get == NULL);
+    get = (char*) arrayList_get(list, 42);
+    CHECK(get == NULL);
 
-	free(entry);
-	free(entry2);
+    free(entry);
+    free(entry2);
 }
 
 TEST(array_list, set){
-	char * entry = my_strdup("entry");
-	char * entry2 = my_strdup("entry2");
-	char * entry3 = my_strdup("entry3");
-	char * get;
-	char * old;
+    char * entry = my_strdup("entry");
+    char * entry2 = my_strdup("entry2");
+    char * entry3 = my_strdup("entry3");
+    char * get;
+    char * old;
 
-	arrayList_clear(list);
+    arrayList_clear(list);
 
-	arrayList_add(list, entry);
-	arrayList_add(list, entry2);
+    arrayList_add(list, entry);
+    arrayList_add(list, entry2);
 
-	get = (char*) arrayList_get(list, 1);
-	STRCMP_EQUAL(entry2, get);
+    get = (char*) arrayList_get(list, 1);
+    STRCMP_EQUAL(entry2, get);
 
-	old = (char*) arrayList_set(list, 1, entry3);
-	STRCMP_EQUAL(entry2, old);
-	get = (char*) arrayList_get(list, 1);
-	STRCMP_EQUAL(entry3, get);
+    old = (char*) arrayList_set(list, 1, entry3);
+    STRCMP_EQUAL(entry2, old);
+    get = (char*) arrayList_get(list, 1);
+    STRCMP_EQUAL(entry3, get);
 
-	free(entry);
-	free(entry2);
-	free(entry3);
+    free(entry);
+    free(entry2);
+    free(entry3);
 }
 
 TEST(array_list, add){
-	char * entry = my_strdup("entry");
-	char * entry2 = my_strdup("entry2");
-	char * entry3 = my_strdup("entry3");
-	char * get;
+    char * entry = my_strdup("entry");
+    char * entry2 = my_strdup("entry2");
+    char * entry3 = my_strdup("entry3");
+    char * get;
 
-	arrayList_clear(list);
+    arrayList_clear(list);
 
-	arrayList_add(list, entry);
-	arrayList_add(list, entry2);
+    arrayList_add(list, entry);
+    arrayList_add(list, entry2);
 
-	get = (char*) arrayList_get(list, 1);
-	STRCMP_EQUAL(entry2, get);
+    get = (char*) arrayList_get(list, 1);
+    STRCMP_EQUAL(entry2, get);
 
-	arrayList_addIndex(list, 1, entry3);
+    arrayList_addIndex(list, 1, entry3);
 
-	get = (char*) arrayList_get(list, 1);
-	STRCMP_EQUAL(entry3, get);
+    get = (char*) arrayList_get(list, 1);
+    STRCMP_EQUAL(entry3, get);
 
-	get = (char*) arrayList_get(list, 2);
-	STRCMP_EQUAL(entry2, get);
+    get = (char*) arrayList_get(list, 2);
+    STRCMP_EQUAL(entry2, get);
 
-	free(entry);
-	free(entry2);
-	free(entry3);
+    free(entry);
+    free(entry2);
+    free(entry3);
 }
 
 TEST(array_list, addAll){
-	char * entry = my_strdup("entry");
-	char * entry2 = my_strdup("entry2");
-	char * entry3 = my_strdup("entry3");
-	char * get;
-	array_list_pt toAdd;
-	bool changed;
+    char * entry = my_strdup("entry");
+    char * entry2 = my_strdup("entry2");
+    char * entry3 = my_strdup("entry3");
+    char * get;
+    array_list_pt toAdd;
+    bool changed;
 
-	arrayList_clear(list);
+    arrayList_clear(list);
 
-	arrayList_create(&toAdd);
-	arrayList_add(toAdd, entry);
-	arrayList_add(toAdd, entry2);
+    arrayList_create(&toAdd);
+    arrayList_add(toAdd, entry);
+    arrayList_add(toAdd, entry2);
 
-	arrayList_add(list, entry3);
+    arrayList_add(list, entry3);
 
-	get = (char*) arrayList_get(list, 0);
-	STRCMP_EQUAL(entry3, get);
+    get = (char*) arrayList_get(list, 0);
+    STRCMP_EQUAL(entry3, get);
 
-	changed = arrayList_addAll(list, toAdd);
-	CHECK(changed);
-	LONGS_EQUAL(3, arrayList_size(list));
+    changed = arrayList_addAll(list, toAdd);
+    CHECK(changed);
+    LONGS_EQUAL(3, arrayList_size(list));
 
-	get = (char*) arrayList_get(list, 1);
-	STRCMP_EQUAL(entry, get);
+    get = (char*) arrayList_get(list, 1);
+    STRCMP_EQUAL(entry, get);
 
-	get = (char*) arrayList_get(list, 2);
-	STRCMP_EQUAL(entry2, get);
+    get = (char*) arrayList_get(list, 2);
+    STRCMP_EQUAL(entry2, get);
 
-	free(entry);
-	free(entry2);
-	free(entry3);
-	arrayList_destroy(toAdd);
+    free(entry);
+    free(entry2);
+    free(entry3);
+    arrayList_destroy(toAdd);
 }
 
 TEST(array_list, remove){
-	char * entry = my_strdup("entry");
-	char * entry2 = my_strdup("entry2");
-	char * entry3 = my_strdup("entry3");
-	char * get;
-	char * removed;
+    char * entry = my_strdup("entry");
+    char * entry2 = my_strdup("entry2");
+    char * entry3 = my_strdup("entry3");
+    char * get;
+    char * removed;
 
-	arrayList_clear(list);
+    arrayList_clear(list);
 
-	arrayList_add(list, entry);
-	arrayList_add(list, entry2);
+    arrayList_add(list, entry);
+    arrayList_add(list, entry2);
 
-	get = (char*) arrayList_get(list, 1);
-	STRCMP_EQUAL(entry2, get);
+    get = (char*) arrayList_get(list, 1);
+    STRCMP_EQUAL(entry2, get);
 
-	// Remove first entry
-	removed = (char*) arrayList_remove(list, 0);
-	STRCMP_EQUAL(entry, removed);
+    // Remove first entry
+    removed = (char*) arrayList_remove(list, 0);
+    STRCMP_EQUAL(entry, removed);
 
-	// Check the new first entry
-	get = (char*) arrayList_get(list, 0);
-	STRCMP_EQUAL(entry2, get);
+    // Check the new first entry
+    get = (char*) arrayList_get(list, 0);
+    STRCMP_EQUAL(entry2, get);
 
-	// Add a new entry
-	arrayList_add(list, entry3);
+    // Add a new entry
+    arrayList_add(list, entry3);
 
-	get = (char*) arrayList_get(list, 1);
-	STRCMP_EQUAL(entry3, get);
+    get = (char*) arrayList_get(list, 1);
+    STRCMP_EQUAL(entry3, get);
 
-	free(entry);
-	free(entry2);
-	free(entry3);
+    free(entry);
+    free(entry2);
+    free(entry3);
 }
 
 TEST(array_list, removeElement){
-	char * entry = my_strdup("entry");
-	char * entry2 = my_strdup("entry2");
-	char * entry3 = my_strdup("entry3");
-	char * get;
+    char * entry = my_strdup("entry");
+    char * entry2 = my_strdup("entry2");
+    char * entry3 = my_strdup("entry3");
+    char * get;
 
-	arrayList_clear(list);
+    arrayList_clear(list);
 
-	arrayList_add(list, entry);
-	arrayList_add(list, entry2);
+    arrayList_add(list, entry);
+    arrayList_add(list, entry2);
 
-	// Remove entry
-	CHECK(arrayList_removeElement(list, entry));
+    // Remove entry
+    CHECK(arrayList_removeElement(list, entry));
 
-	// Check the new first element
-	get = (char*) arrayList_get(list, 0);
-	STRCMP_EQUAL(entry2, get);
+    // Check the new first element
+    get = (char*) arrayList_get(list, 0);
+    STRCMP_EQUAL(entry2, get);
 
-	// Add a new entry
-	arrayList_add(list, entry3);
+    // Add a new entry
+    arrayList_add(list, entry3);
 
-	get = (char*) arrayList_get(list, 1);
-	STRCMP_EQUAL(entry3, get);
+    get = (char*) arrayList_get(list, 1);
+    STRCMP_EQUAL(entry3, get);
 
-	free(entry);
-	free(entry2);
-	free(entry3);
+    free(entry);
+    free(entry2);
+    free(entry3);
 }
 
 TEST(array_list, clear){
-	char * entry = my_strdup("entry");
-	char * entry2 = my_strdup("entry2");
+    char * entry = my_strdup("entry");
+    char * entry2 = my_strdup("entry2");
 
-	arrayList_clear(list);
+    arrayList_clear(list);
 
-	arrayList_add(list, entry);
-	arrayList_add(list, entry2);
+    arrayList_add(list, entry);
+    arrayList_add(list, entry2);
 
-	LONGS_EQUAL(2, arrayList_size(list));
-	arrayList_clear(list);
-	LONGS_EQUAL(0, arrayList_size(list));
+    LONGS_EQUAL(2, arrayList_size(list));
+    arrayList_clear(list);
+    LONGS_EQUAL(0, arrayList_size(list));
 
-	free(entry);
-	free(entry2);
+    free(entry);
+    free(entry2);
 }
 
 //----------------------ARRAY LIST ITERATOR TESTS----------------------
 
 TEST(array_list_iterator, create){
-	array_list_iterator_pt it_list = arrayListIterator_create(list);
-	CHECK(it_list != NULL);
-	POINTERS_EQUAL(list, it_list->list);
-	arrayListIterator_destroy(it_list);
+    array_list_iterator_pt it_list = arrayListIterator_create(list);
+    CHECK(it_list != NULL);
+    POINTERS_EQUAL(list, it_list->list);
+    arrayListIterator_destroy(it_list);
 }
 
 TEST(array_list_iterator, hasNext){
-	char * entry = my_strdup("entry");
-	char * entry2 = my_strdup("entry2");
-	char * entry3 = my_strdup("entry3");
-	array_list_iterator_pt it_list;
-
-	arrayList_add(list, entry);
-	arrayList_add(list, entry2);
-	arrayList_add(list, entry3);
-	it_list = arrayListIterator_create(list);
-	CHECK(arrayListIterator_hasNext(it_list));
-
-	arrayListIterator_next(it_list);
-	CHECK(arrayListIterator_hasNext(it_list));
-
-	arrayListIterator_next(it_list);
-	CHECK(arrayListIterator_hasNext(it_list));
-
-	arrayListIterator_next(it_list);
-	CHECK(!arrayListIterator_hasNext(it_list));
-
-	free(entry);
-	free(entry2);
-	free(entry3);
-	arrayListIterator_destroy(it_list);
+    char * entry = my_strdup("entry");
+    char * entry2 = my_strdup("entry2");
+    char * entry3 = my_strdup("entry3");
+    array_list_iterator_pt it_list;
+
+    arrayList_add(list, entry);
+    arrayList_add(list, entry2);
+    arrayList_add(list, entry3);
+    it_list = arrayListIterator_create(list);
+    CHECK(arrayListIterator_hasNext(it_list));
+
+    arrayListIterator_next(it_list);
+    CHECK(arrayListIterator_hasNext(it_list));
+
+    arrayListIterator_next(it_list);
+    CHECK(arrayListIterator_hasNext(it_list));
+
+    arrayListIterator_next(it_list);
+    CHECK(!arrayListIterator_hasNext(it_list));
+
+    free(entry);
+    free(entry2);
+    free(entry3);
+    arrayListIterator_destroy(it_list);
 }
 
 TEST(array_list_iterator, hasPrevious){
-	char * entry = my_strdup("entry");
-	char * entry2 = my_strdup("entry2");
-	char * entry3 = my_strdup("entry3");
-	array_list_iterator_pt it_list;
-
-	arrayList_add(list, entry);
-	arrayList_add(list, entry2);
-	arrayList_add(list, entry3);
-
-	it_list = arrayListIterator_create(list);
-	arrayListIterator_next(it_list);
-	arrayListIterator_next(it_list);
-	arrayListIterator_next(it_list);
-	CHECK(arrayListIterator_hasPrevious(it_list));
-
-	arrayListIterator_previous(it_list);
-	CHECK(arrayListIterator_hasPrevious(it_list));
-
-	arrayListIterator_previous(it_list);
-	CHECK(arrayListIterator_hasPrevious(it_list));
-
-	arrayListIterator_previous(it_list);
-	CHECK(!arrayListIterator_hasPrevious(it_list));
-
-	free(entry);
-	free(entry2);
-	free(entry3);
-	arrayListIterator_destroy(it_list);
+    char * entry = my_strdup("entry");
+    char * entry2 = my_strdup("entry2");
+    char * entry3 = my_strdup("entry3");
+    array_list_iterator_pt it_list;
+
+    arrayList_add(list, entry);
+    arrayList_add(list, entry2);
+    arrayList_add(list, entry3);
+
+    it_list = arrayListIterator_create(list);
+    arrayListIterator_next(it_list);
+    arrayListIterator_next(it_list);
+    arrayListIterator_next(it_list);
+    CHECK(arrayListIterator_hasPrevious(it_list));
+
+    arrayListIterator_previous(it_list);
+    CHECK(arrayListIterator_hasPrevious(it_list));
+
+    arrayListIterator_previous(it_list);
+    CHECK(arrayListIterator_hasPrevious(it_list));
+
+    arrayListIterator_previous(it_list);
+    CHECK(!arrayListIterator_hasPrevious(it_list));
+
+    free(entry);
+    free(entry2);
+    free(entry3);
+    arrayListIterator_destroy(it_list);
 }
 
 TEST(array_list_iterator, next){
-	char * entry = my_strdup("entry");
-	char * entry2 = my_strdup("entry2");
-	char * entry3 = my_strdup("entry3");
-	array_list_iterator_pt it_list;
-
-	arrayList_add(list, entry);
-	arrayList_add(list, entry2);
-	arrayList_add(list, entry3);
-	it_list = arrayListIterator_create(list);
-	STRCMP_EQUAL(entry, (char*) arrayListIterator_next(it_list));
-	STRCMP_EQUAL(entry2, (char*) arrayListIterator_next(it_list));
-	STRCMP_EQUAL(entry3, (char*) arrayListIterator_next(it_list));
-	POINTERS_EQUAL(NULL, arrayListIterator_next(it_list));
-
-	//mess up the expected and real changecount, code should check and handle
-	arrayList_add(list, entry);
-	arrayListIterator_next(it_list);
-
-	free(entry);
-	free(entry2);
-	free(entry3);
-	arrayListIterator_destroy(it_list);
+    char * entry = my_strdup("entry");
+    char * entry2 = my_strdup("entry2");
+    char * entry3 = my_strdup("entry3");
+    array_list_iterator_pt it_list;
+
+    arrayList_add(list, entry);
+    arrayList_add(list, entry2);
+    arrayList_add(list, entry3);
+    it_list = arrayListIterator_create(list);
+    STRCMP_EQUAL(entry, (char*) arrayListIterator_next(it_list));
+    STRCMP_EQUAL(entry2, (char*) arrayListIterator_next(it_list));
+    STRCMP_EQUAL(entry3, (char*) arrayListIterator_next(it_list));
+    POINTERS_EQUAL(NULL, arrayListIterator_next(it_list));
+
+    //mess up the expected and real changecount, code should check and handle
+    arrayList_add(list, entry);
+    arrayListIterator_next(it_list);
+
+    free(entry);
+    free(entry2);
+    free(entry3);
+    arrayListIterator_destroy(it_list);
 }
 
 TEST(array_list_iterator, previous){
-	char * value = my_strdup("entry");
-	char * value2 = my_strdup("entry2");
-	char * value3 = my_strdup("entry3");
-	array_list_iterator_pt it_list;
-
-	arrayList_add(list, value);
-	arrayList_add(list, value2);
-	arrayList_add(list, value3);
-	it_list = arrayListIterator_create(list);
-
-	arrayListIterator_next(it_list);
-	arrayListIterator_next(it_list);
-	arrayListIterator_next(it_list);
-	STRCMP_EQUAL(value3, (char*) arrayListIterator_previous(it_list));
-	STRCMP_EQUAL(value2, (char*) arrayListIterator_previous(it_list));
-	STRCMP_EQUAL(value, (char*) arrayListIterator_previous(it_list));
-	POINTERS_EQUAL(NULL, arrayListIterator_previous(it_list));
-
-	//mess up the expected and real changecount, code should check and handle
-	arrayListIterator_destroy(it_list);
-	it_list = arrayListIterator_create(list);
-	arrayList_add(list, value);
-	arrayListIterator_previous(it_list);
-
-	free(value);
-	free(value2);
-	free(value3);
-	arrayListIterator_destroy(it_list);
+    char * value = my_strdup("entry");
+    char * value2 = my_strdup("entry2");
+    char * value3 = my_strdup("entry3");
+    array_list_iterator_pt it_list;
+
+    arrayList_add(list, value);
+    arrayList_add(list, value2);
+    arrayList_add(list, value3);
+    it_list = arrayListIterator_create(list);
+
+    arrayListIterator_next(it_list);
+    arrayListIterator_next(it_list);
+    arrayListIterator_next(it_list);
+    STRCMP_EQUAL(value3, (char*) arrayListIterator_previous(it_list));
+    STRCMP_EQUAL(value2, (char*) arrayListIterator_previous(it_list));
+    STRCMP_EQUAL(value, (char*) arrayListIterator_previous(it_list));
+    POINTERS_EQUAL(NULL, arrayListIterator_previous(it_list));
+
+    //mess up the expected and real changecount, code should check and handle
+    arrayListIterator_destroy(it_list);
+    it_list = arrayListIterator_create(list);
+    arrayList_add(list, value);
+    arrayListIterator_previous(it_list);
+
+    free(value);
+    free(value2);
+    free(value3);
+    arrayListIterator_destroy(it_list);
 }
 
 TEST(array_list_iterator, remove){
-	char * value = my_strdup("entry");
-	char * value2 = my_strdup("entry2");
-	char * value3 = my_strdup("entry3");
-	array_list_iterator_pt it_list;
-
-	arrayList_add(list, value);
-	arrayList_add(list, value2);
-	arrayList_add(list, value3);
-	it_list = arrayListIterator_create(list);
-
-	LONGS_EQUAL(3, list->size);
-	STRCMP_EQUAL(value, (char*) arrayList_get(list, 0));
-	STRCMP_EQUAL(value2, (char*) arrayList_get(list, 1));
-	STRCMP_EQUAL(value3, (char*) arrayList_get(list, 2));
-
-	arrayListIterator_next(it_list);
-	arrayListIterator_next(it_list);
-	arrayListIterator_remove(it_list);
-	LONGS_EQUAL(2, list->size);
-	STRCMP_EQUAL(value, (char*) arrayList_get(list, 0));
-	STRCMP_EQUAL(value3, (char*) arrayList_get(list, 1));
-
-	//mess up the expected and real changecount, code should check and handle
-	arrayList_add(list, value);
-	arrayListIterator_remove(it_list);
-
-	free(value);
-	free(value2);
-	free(value3);
-	arrayListIterator_destroy(it_list);
+    char * value = my_strdup("entry");
+    char * value2 = my_strdup("entry2");
+    char * value3 = my_strdup("entry3");
+    array_list_iterator_pt it_list;
+
+    arrayList_add(list, value);
+    arrayList_add(list, value2);
+    arrayList_add(list, value3);
+    it_list = arrayListIterator_create(list);
+
+    LONGS_EQUAL(3, list->size);
+    STRCMP_EQUAL(value, (char*) arrayList_get(list, 0));
+    STRCMP_EQUAL(value2, (char*) arrayList_get(list, 1));
+    STRCMP_EQUAL(value3, (char*) arrayList_get(list, 2));
+
+    arrayListIterator_next(it_list);
+    arrayListIterator_next(it_list);
+    arrayListIterator_remove(it_list);
+    LONGS_EQUAL(2, list->size);
+    STRCMP_EQUAL(value, (char*) arrayList_get(list, 0));
+    STRCMP_EQUAL(value3, (char*) arrayList_get(list, 1));
+
+    //mess up the expected and real changecount, code should check and handle
+    arrayList_add(list, value);
+    arrayListIterator_remove(it_list);
+
+    free(value);
+    free(value2);
+    free(value3);
+    arrayListIterator_destroy(it_list);
 }
 
 
diff --git a/libs/utils/private/test/celix_threads_test.cpp b/libs/utils/private/test/celix_threads_test.cpp
index 1565c3a..7520445 100644
--- a/libs/utils/private/test/celix_threads_test.cpp
+++ b/libs/utils/private/test/celix_threads_test.cpp
@@ -1,28 +1,29 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * array_list_test.cpp
  *
- * 	\date       Sep 15, 2015
- *  \author    	Menno van der Graaf & Alexander
- *  \copyright	Apache License, Version 2.0
+ *  \date       Sep 15, 2015
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -40,36 +41,36 @@ extern "C" {
 
 
 static char* my_strdup(const char* s) {
-	if (s == NULL) {
-		return NULL;
-	}
+    if (s == NULL) {
+        return NULL;
+    }
 
-	size_t len = strlen(s);
+    size_t len = strlen(s);
 
-	char *d = (char*) calloc(len + 1, sizeof(char));
+    char *d = (char*) calloc(len + 1, sizeof(char));
 
-	if (d == NULL) {
-		return NULL;
-	}
+    if (d == NULL) {
+        return NULL;
+    }
 
-	strncpy(d, s, len);
-	return d;
+    strncpy(d, s, len);
+    return d;
 }
 
 static int celix_thread_t_equals(const void * object, const void * compareTo){
-	celix_thread_t * thread1 = (celix_thread_t*) object;
-	celix_thread_t * thread2 = (celix_thread_t*) compareTo;
+    celix_thread_t * thread1 = (celix_thread_t*) object;
+    celix_thread_t * thread2 = (celix_thread_t*) compareTo;
 
-	return thread1->thread == thread2->thread &&
-			thread1->threadInitialized == thread2->threadInitialized;
+    return thread1->thread == thread2->thread &&
+            thread1->threadInitialized == thread2->threadInitialized;
 }
 
 static const char * celix_thread_t_toString(const void * object){
-	celix_thread_t * thread = (celix_thread_t*) object;
-	char buff[512];
-	snprintf(buff, 512, "thread: %lu, threadInitialized: %s", (unsigned long)thread->thread, (thread->threadInitialized ? "true" : "false"));
+    celix_thread_t * thread = (celix_thread_t*) object;
+    char buff[512];
+    snprintf(buff, 512, "thread: %lu, threadInitialized: %s", (unsigned long)thread->thread, (thread->threadInitialized ? "true" : "false"));
 
-	return my_strdup(buff);
+    return my_strdup(buff);
 }
 
 //----------------------TEST THREAD FUNCTION DECLARATIONS----------------------
@@ -86,446 +87,446 @@ static int thread_test_func_recur_lock(celix_thread_mutex_t*, int);
 static void * thread_test_func_kill(void*);
 static void thread_test_func_kill_handler(int);
 struct func_param{
-	int i, i2;
-	celix_thread_mutex_t mu, mu2;
-	celix_thread_cond_t cond, cond2;
-	celix_thread_once_t once_control;
-	celix_thread_rwlock_t rwlock;
+    int i, i2;
+    celix_thread_mutex_t mu, mu2;
+    celix_thread_cond_t cond, cond2;
+    celix_thread_once_t once_control;
+    celix_thread_rwlock_t rwlock;
 };
 }
 
 int main(int argc, char** argv) {
-	return RUN_ALL_TESTS(argc, argv);
+    return RUN_ALL_TESTS(argc, argv);
 }
 
 //----------------------TESTGROUP DEFINES----------------------
 
 TEST_GROUP(celix_thread) {
-	celix_thread thread;
+    celix_thread thread;
 
-	void setup(void) {
-	}
+    void setup(void) {
+    }
 
-	void teardown(void) {
-	}
+    void teardown(void) {
+    }
 };
 
 TEST_GROUP(celix_thread_kill) {
-	celix_thread thread;
-	struct sigaction sigact, sigactold;
+    celix_thread thread;
+    struct sigaction sigact, sigactold;
 
-	void setup(void) {
-		memset(&sigact, 0, sizeof(sigact));
-		sigact.sa_handler = thread_test_func_kill_handler;
-		sigaction(SIGUSR1, &sigact, &sigactold);
+    void setup(void) {
+        memset(&sigact, 0, sizeof(sigact));
+        sigact.sa_handler = thread_test_func_kill_handler;
+        sigaction(SIGUSR1, &sigact, &sigactold);
 
-		mock_c()->installComparator("celix_thread_t", celix_thread_t_equals, celix_thread_t_toString);
-	}
+        mock_c()->installComparator("celix_thread_t", celix_thread_t_equals, celix_thread_t_toString);
+    }
 
-	void teardown(void) {
-		sigaction(SIGUSR1, &sigactold, &sigact);
+    void teardown(void) {
+        sigaction(SIGUSR1, &sigactold, &sigact);
 
-		mock_c()->removeAllComparatorsAndCopiers();
-	}
+        mock_c()->removeAllComparatorsAndCopiers();
+    }
 };
 
 TEST_GROUP(celix_thread_mutex) {
-	celix_thread thread;
-	celix_thread_mutex_t mu;
+    celix_thread thread;
+    celix_thread_mutex_t mu;
 
-	void setup(void) {
-	}
+    void setup(void) {
+    }
 
-	void teardown(void) {
-	}
+    void teardown(void) {
+    }
 };
 
 TEST_GROUP(celix_thread_condition) {
-	celix_thread thread;
-	celix_thread_mutex_t mu;
-	celix_thread_cond_t cond;
+    celix_thread thread;
+    celix_thread_mutex_t mu;
+    celix_thread_cond_t cond;
 
-	void setup(void) {
-	}
+    void setup(void) {
+    }
 
-	void teardown(void) {
-	}
+    void teardown(void) {
+    }
 };
 
 TEST_GROUP(celix_thread_rwlock) {
-	celix_thread thread;
+    celix_thread thread;
 
-	void setup(void) {
-	}
+    void setup(void) {
+    }
 
-	void teardown(void) {
-	}
+    void teardown(void) {
+    }
 };
 
 //----------------------CELIX THREADS TESTS----------------------
 
 TEST(celix_thread, create) {
-	int ret;
-	char * test_str;
+    int ret;
+    char * test_str;
 
-	ret = celixThread_create(&thread, NULL, &thread_test_func_create,
-			&test_str);
-	LONGS_EQUAL(CELIX_SUCCESS, ret);
-	celixThread_join(thread, NULL);
+    ret = celixThread_create(&thread, NULL, &thread_test_func_create,
+            &test_str);
+    LONGS_EQUAL(CELIX_SUCCESS, ret);
+    celixThread_join(thread, NULL);
 
-	CHECK(test_str != NULL);
-	STRCMP_EQUAL("SUCCESS", test_str);
+    CHECK(test_str != NULL);
+    STRCMP_EQUAL("SUCCESS", test_str);
 
-	free(test_str);
+    free(test_str);
 }
 
 TEST(celix_thread, exit) {
-	int ret, *status;
+    int ret, *status;
 
-	ret = celixThread_create(&thread, NULL, &thread_test_func_exit, NULL);
-	LONGS_EQUAL(CELIX_SUCCESS, ret);
-	celixThread_join(thread, (void**) &status);
-	LONGS_EQUAL(666, *status);
-	free(status);
+    ret = celixThread_create(&thread, NULL, &thread_test_func_exit, NULL);
+    LONGS_EQUAL(CELIX_SUCCESS, ret);
+    celixThread_join(thread, (void**) &status);
+    LONGS_EQUAL(666, *status);
+    free(status);
 }
 
 //HORRIBLE TEST
 TEST(celix_thread, detach) {
-	int ret;
+    int ret;
 
-	celixThread_create(&thread, NULL, thread_test_func_detach, NULL);
-	ret = celixThread_detach(thread);
-	LONGS_EQUAL(CELIX_SUCCESS, ret);
+    celixThread_create(&thread, NULL, thread_test_func_detach, NULL);
+    ret = celixThread_detach(thread);
+    LONGS_EQUAL(CELIX_SUCCESS, ret);
 }
 
 TEST(celix_thread, self) {
-	celix_thread thread2;
+    celix_thread thread2;
 
-	celixThread_create(&thread, NULL, thread_test_func_self, &thread2);
-	celixThread_join(thread, NULL);
-	CHECK(celixThread_equals(thread, thread2));
+    celixThread_create(&thread, NULL, thread_test_func_self, &thread2);
+    celixThread_join(thread, NULL);
+    CHECK(celixThread_equals(thread, thread2));
 }
 
 TEST(celix_thread, initialized) {
-	CHECK(!celixThread_initialized(thread));
-	celixThread_create(&thread, NULL, thread_test_func_detach, NULL);
-	CHECK(celixThread_initialized(thread));
-	celixThread_detach(thread);
+    CHECK(!celixThread_initialized(thread));
+    celixThread_create(&thread, NULL, thread_test_func_detach, NULL);
+    CHECK(celixThread_initialized(thread));
+    celixThread_detach(thread);
 }
 
 TEST(celix_thread, once) {
-	int *status;
-	celix_thread thread2;
-	struct func_param * params = (struct func_param*) calloc(1,
-				sizeof(struct func_param));
+    int *status;
+    celix_thread thread2;
+    struct func_param * params = (struct func_param*) calloc(1,
+                sizeof(struct func_param));
 
-	mock().expectOneCall("thread_test_func_once_init");
+    mock().expectOneCall("thread_test_func_once_init");
 
-	celixThread_create(&thread, NULL, &thread_test_func_once, params);
-	celixThread_join(thread, (void**) &status);
+    celixThread_create(&thread, NULL, &thread_test_func_once, params);
+    celixThread_join(thread, (void**) &status);
 
-	celixThread_create(&thread2, NULL, &thread_test_func_once, params);
-	celixThread_join(thread2, (void**) &status);
+    celixThread_create(&thread2, NULL, &thread_test_func_once, params);
+    celixThread_join(thread2, (void**) &status);
 
-	free(params);
+    free(params);
 
-	mock().checkExpectations();
-	mock().clear();
+    mock().checkExpectations();
+    mock().clear();
 }
 //----------------------CELIX THREADS KILL TESTS----------------------
 TEST(celix_thread_kill, kill){
-	int * ret;
-	celixThread_create(&thread, NULL, thread_test_func_kill, NULL);
-	sleep(2);
+    int * ret;
+    celixThread_create(&thread, NULL, thread_test_func_kill, NULL);
+    sleep(2);
 
-	mock().expectOneCall("thread_test_func_kill_handler")
-			.withParameter("signo", SIGUSR1)
-			.withParameterOfType("celix_thread_t", "inThread", (const void*) &thread);
+    mock().expectOneCall("thread_test_func_kill_handler")
+            .withParameter("signo", SIGUSR1)
+            .withParameterOfType("celix_thread_t", "inThread", (const void*) &thread);
 
-	celixThread_kill(thread, SIGUSR1);
-	celixThread_join(thread, (void**)&ret);
+    celixThread_kill(thread, SIGUSR1);
+    celixThread_join(thread, (void**)&ret);
 
-	LONGS_EQUAL(-1, *ret);
-	free(ret);
+    LONGS_EQUAL(-1, *ret);
+    free(ret);
 
-	mock().checkExpectations();
-	mock().clear();
+    mock().checkExpectations();
+    mock().clear();
 }
 
 //----------------------CELIX THREADS MUTEX TESTS----------------------
 
 TEST(celix_thread_mutex, create) {
-	LONGS_EQUAL(CELIX_SUCCESS, celixThreadMutex_create(&mu, NULL));
-	LONGS_EQUAL(CELIX_SUCCESS, celixThreadMutex_destroy(&mu));
+    LONGS_EQUAL(CELIX_SUCCESS, celixThreadMutex_create(&mu, NULL));
+    LONGS_EQUAL(CELIX_SUCCESS, celixThreadMutex_destroy(&mu));
 }
 
 //check normal lock behaviour
 TEST(celix_thread_mutex, lock) {
-	struct func_param * params = (struct func_param*) calloc(1,
-			sizeof(struct func_param));
+    struct func_param * params = (struct func_param*) calloc(1,
+            sizeof(struct func_param));
 
-	celixThreadMutex_create(&params->mu, NULL);
+    celixThreadMutex_create(&params->mu, NULL);
 
-	celixThreadMutex_lock(&params->mu);
-	celixThread_create(&thread, NULL, thread_test_func_lock, params);
+    celixThreadMutex_lock(&params->mu);
+    celixThread_create(&thread, NULL, thread_test_func_lock, params);
 
-	sleep(2);
+    sleep(2);
 
-	LONGS_EQUAL(0, params->i);
+    LONGS_EQUAL(0, params->i);
 
-	//possible race condition, not perfect test
-	celixThreadMutex_unlock(&params->mu);
+    //possible race condition, not perfect test
+    celixThreadMutex_unlock(&params->mu);
 
-	sleep(2);
+    sleep(2);
 
-	celixThreadMutex_lock(&params->mu2);
-	LONGS_EQUAL(666, params->i);
-	celixThreadMutex_unlock(&params->mu2);
-	celixThread_join(thread, NULL);
-	free(params);
+    celixThreadMutex_lock(&params->mu2);
+    LONGS_EQUAL(666, params->i);
+    celixThreadMutex_unlock(&params->mu2);
+    celixThread_join(thread, NULL);
+    free(params);
 }
 
 TEST(celix_thread_mutex, attrCreate) {
-	celix_thread_mutexattr_t mu_attr;
-	LONGS_EQUAL(CELIX_SUCCESS, celixThreadMutexAttr_create(&mu_attr));
-	LONGS_EQUAL(CELIX_SUCCESS, celixThreadMutexAttr_destroy(&mu_attr));
+    celix_thread_mutexattr_t mu_attr;
+    LONGS_EQUAL(CELIX_SUCCESS, celixThreadMutexAttr_create(&mu_attr));
+    LONGS_EQUAL(CELIX_SUCCESS, celixThreadMutexAttr_destroy(&mu_attr));
 }
 
 TEST(celix_thread_mutex, attrSettype) {
-	celix_thread_mutex_t mu;
-	celix_thread_mutexattr_t mu_attr;
-	celixThreadMutexAttr_create(&mu_attr);
-
-	//test recursive mutex
-	celixThreadMutexAttr_settype(&mu_attr, CELIX_THREAD_MUTEX_RECURSIVE);
-	celixThreadMutex_create(&mu, &mu_attr);
-	//if program doesnt deadlock: success! also check factorial of 10, for reasons unknown
-	LONGS_EQUAL(3628800, thread_test_func_recur_lock(&mu, 10));
-	celixThreadMutex_destroy(&mu);
-
-	//test deadlock check mutex
-	celixThreadMutexAttr_settype(&mu_attr, CELIX_THREAD_MUTEX_ERRORCHECK);
-	celixThreadMutex_create(&mu, &mu_attr);
-	//get deadlock error
-	celixThreadMutex_lock(&mu);
-	CHECK(celixThreadMutex_lock(&mu) != CELIX_SUCCESS);
-	//do not get deadlock error
-	celixThreadMutex_unlock(&mu);
-	LONGS_EQUAL(CELIX_SUCCESS, celixThreadMutex_lock(&mu));
-	//get unlock error
-	celixThreadMutex_unlock(&mu);
-	CHECK(celixThreadMutex_unlock(&mu) != CELIX_SUCCESS);
-
-	celixThreadMutex_destroy(&mu);
-	celixThreadMutexAttr_destroy(&mu_attr);
+    celix_thread_mutex_t mu;
+    celix_thread_mutexattr_t mu_attr;
+    celixThreadMutexAttr_create(&mu_attr);
+
+    //test recursive mutex
+    celixThreadMutexAttr_settype(&mu_attr, CELIX_THREAD_MUTEX_RECURSIVE);
+    celixThreadMutex_create(&mu, &mu_attr);
+    //if program doesnt deadlock: success! also check factorial of 10, for reasons unknown
+    LONGS_EQUAL(3628800, thread_test_func_recur_lock(&mu, 10));
+    celixThreadMutex_destroy(&mu);
+
+    //test deadlock check mutex
+    celixThreadMutexAttr_settype(&mu_attr, CELIX_THREAD_MUTEX_ERRORCHECK);
+    celixThreadMutex_create(&mu, &mu_attr);
+    //get deadlock error
+    celixThreadMutex_lock(&mu);
+    CHECK(celixThreadMutex_lock(&mu) != CELIX_SUCCESS);
+    //do not get deadlock error
+    celixThreadMutex_unlock(&mu);
+    LONGS_EQUAL(CELIX_SUCCESS, celixThreadMutex_lock(&mu));
+    //get unlock error
+    celixThreadMutex_unlock(&mu);
+    CHECK(celixThreadMutex_unlock(&mu) != CELIX_SUCCESS);
+
+    celixThreadMutex_destroy(&mu);
+    celixThreadMutexAttr_destroy(&mu_attr);
 }
 
 //----------------------CELIX THREAD CONDITIONS TESTS----------------------
 
 TEST(celix_thread_condition, init) {
-	LONGS_EQUAL(CELIX_SUCCESS, celixThreadCondition_init(&cond, NULL));
-	LONGS_EQUAL(CELIX_SUCCESS, celixThreadCondition_destroy(&cond));
+    LONGS_EQUAL(CELIX_SUCCESS, celixThreadCondition_init(&cond, NULL));
+    LONGS_EQUAL(CELIX_SUCCESS, celixThreadCondition_destroy(&cond));
 }
 
 //test wait and signal
 TEST(celix_thread_condition, wait) {
-	struct func_param * param = (struct func_param*) calloc(1,
-			sizeof(struct func_param));
-	celixThreadMutex_create(&param->mu, NULL);
-	celixThreadCondition_init(&param->cond, NULL);
+    struct func_param * param = (struct func_param*) calloc(1,
+            sizeof(struct func_param));
+    celixThreadMutex_create(&param->mu, NULL);
+    celixThreadCondition_init(&param->cond, NULL);
 
-	celixThreadMutex_lock(&param->mu);
+    celixThreadMutex_lock(&param->mu);
 
-	sleep(2);
+    sleep(2);
 
-	celixThread_create(&thread, NULL, thread_test_func_cond_wait, param);
-	LONGS_EQUAL(0, param->i);
+    celixThread_create(&thread, NULL, thread_test_func_cond_wait, param);
+    LONGS_EQUAL(0, param->i);
 
-	celixThreadCondition_wait(&param->cond, &param->mu);
-	LONGS_EQUAL(666, param->i);
-	celixThreadMutex_unlock(&param->mu);
+    celixThreadCondition_wait(&param->cond, &param->mu);
+    LONGS_EQUAL(666, param->i);
+    celixThreadMutex_unlock(&param->mu);
 
-	celixThread_join(thread, NULL);
-	free(param);
+    celixThread_join(thread, NULL);
+    free(param);
 }
 
 //test wait and broadcast on multiple threads
 TEST(celix_thread_condition, broadcast) {
-	celix_thread_t thread2;
-	struct func_param * param = (struct func_param*) calloc(1,sizeof(struct func_param));
-	celixThreadMutex_create(&param->mu, NULL);
-	celixThreadMutex_create(&param->mu2, NULL);
-	celixThreadCondition_init(&param->cond, NULL);
+    celix_thread_t thread2;
+    struct func_param * param = (struct func_param*) calloc(1,sizeof(struct func_param));
+    celixThreadMutex_create(&param->mu, NULL);
+    celixThreadMutex_create(&param->mu2, NULL);
+    celixThreadCondition_init(&param->cond, NULL);
 
-	celixThread_create(&thread, NULL, thread_test_func_cond_broadcast, param);
-	celixThread_create(&thread2, NULL, thread_test_func_cond_broadcast, param);
+    celixThread_create(&thread, NULL, thread_test_func_cond_broadcast, param);
+    celixThread_create(&thread2, NULL, thread_test_func_cond_broadcast, param);
 
-	sleep(1);
-	celixThreadMutex_lock(&param->mu);
-	LONGS_EQUAL(0, param->i);
-	celixThreadMutex_unlock(&param->mu);
+    sleep(1);
+    celixThreadMutex_lock(&param->mu);
+    LONGS_EQUAL(0, param->i);
+    celixThreadMutex_unlock(&param->mu);
 
-	celixThreadMutex_lock(&param->mu);
-	celixThreadCondition_broadcast(&param->cond);
-	celixThreadMutex_unlock(&param->mu);
-	sleep(1);
-	celixThreadMutex_lock(&param->mu);
-	LONGS_EQUAL(2, param->i);
-	celixThreadMutex_unlock(&param->mu);
+    celixThreadMutex_lock(&param->mu);
+    celixThreadCondition_broadcast(&param->cond);
+    celixThreadMutex_unlock(&param->mu);
+    sleep(1);
+    celixThreadMutex_lock(&param->mu);
+    LONGS_EQUAL(2, param->i);
+    celixThreadMutex_unlock(&param->mu);
 
-	celixThread_join(thread, NULL);
-	celixThread_join(thread2, NULL);
-	free(param);
+    celixThread_join(thread, NULL);
+    celixThread_join(thread2, NULL);
+    free(param);
 }
 
 //----------------------CELIX READ-WRITE LOCK TESTS----------------------
 
 TEST(celix_thread_rwlock, create){
-	celix_thread_rwlock_t lock;
-	celix_status_t status;
-	status = celixThreadRwlock_create(&lock, NULL);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	status = celixThreadRwlock_destroy(&lock);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
+    celix_thread_rwlock_t lock;
+    celix_status_t status;
+    status = celixThreadRwlock_create(&lock, NULL);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    status = celixThreadRwlock_destroy(&lock);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
 }
 
 TEST(celix_thread_rwlock, readLock){
-	int status;
-	celix_thread_rwlock_t lock;
-	//struct func_param * param = (struct func_param*) calloc(1,sizeof(struct func_param));
+    int status;
+    celix_thread_rwlock_t lock;
+    //struct func_param * param = (struct func_param*) calloc(1,sizeof(struct func_param));
 
-	celixThreadRwlock_create(&lock, NULL);
+    celixThreadRwlock_create(&lock, NULL);
 
-	status = celixThreadRwlock_readLock(&lock);
-	LONGS_EQUAL(0, status);
-	status = celixThreadRwlock_readLock(&lock);
-	LONGS_EQUAL(0, status);
-	status = celixThreadRwlock_unlock(&lock);
-	LONGS_EQUAL(0, status);
-	status = celixThreadRwlock_unlock(&lock);
-	LONGS_EQUAL(0, status);
+    status = celixThreadRwlock_readLock(&lock);
+    LONGS_EQUAL(0, status);
+    status = celixThreadRwlock_readLock(&lock);
+    LONGS_EQUAL(0, status);
+    status = celixThreadRwlock_unlock(&lock);
+    LONGS_EQUAL(0, status);
+    status = celixThreadRwlock_unlock(&lock);
+    LONGS_EQUAL(0, status);
 
-	celixThreadRwlock_destroy(&lock);
+    celixThreadRwlock_destroy(&lock);
 }
 
 TEST(celix_thread_rwlock, writeLock){
-	int status;
-	celix_thread_rwlock_t lock;
-	celixThreadRwlock_create(&lock, NULL);
+    int status;
+    celix_thread_rwlock_t lock;
+    celixThreadRwlock_create(&lock, NULL);
 
-	status = celixThreadRwlock_writeLock(&lock);
-	LONGS_EQUAL(0, status);
-	status = celixThreadRwlock_writeLock(&lock);
-	//EDEADLK ErNo: Resource deadlock avoided
-	LONGS_EQUAL(EDEADLK, status);
+    status = celixThreadRwlock_writeLock(&lock);
+    LONGS_EQUAL(0, status);
+    status = celixThreadRwlock_writeLock(&lock);
+    //EDEADLK ErNo: Resource deadlock avoided
+    LONGS_EQUAL(EDEADLK, status);
 
-	celixThreadRwlock_unlock(&lock);
+    celixThreadRwlock_unlock(&lock);
 }
 
 TEST(celix_thread_rwlock, attr){
-	celix_thread_rwlockattr_t attr;
-	celixThreadRwlockAttr_create(&attr);
-	celixThreadRwlockAttr_destroy(&attr);
+    celix_thread_rwlockattr_t attr;
+    celixThreadRwlockAttr_create(&attr);
+    celixThreadRwlockAttr_destroy(&attr);
 }
 
 //----------------------TEST THREAD FUNCTION DEFINES----------------------
 extern "C" {
 static void * thread_test_func_create(void * arg) {
-	char ** test_str = (char**) arg;
-	*test_str = my_strdup("SUCCESS");
+    char ** test_str = (char**) arg;
+    *test_str = my_strdup("SUCCESS");
 
-	return NULL;
+    return NULL;
 }
 
 static void * thread_test_func_exit(void *) {
-	int *pi = (int*) calloc(1, sizeof(int));
-	*pi = 666;
+    int *pi = (int*) calloc(1, sizeof(int));
+    *pi = 666;
 
-	celixThread_exit(pi);
-	return NULL;
+    celixThread_exit(pi);
+    return NULL;
 }
 
 static void * thread_test_func_detach(void *) {
-	return NULL;
+    return NULL;
 }
 
 static void * thread_test_func_self(void * arg) {
-	*((celix_thread*) arg) = celixThread_self();
-	return NULL;
+    *((celix_thread*) arg) = celixThread_self();
+    return NULL;
 }
 
 static void * thread_test_func_once(void * arg) {
-	struct func_param *param = (struct func_param *) arg;
-	celixThread_once(&param->once_control, thread_test_func_once_init);
+    struct func_param *param = (struct func_param *) arg;
+    celixThread_once(&param->once_control, thread_test_func_once_init);
 
-	return NULL;
+    return NULL;
 }
 
 static void thread_test_func_once_init(void) {
-	mock_c()->actualCall("thread_test_func_once_init");
+    mock_c()->actualCall("thread_test_func_once_init");
 }
 
 static void * thread_test_func_lock(void *arg) {
-	struct func_param *param = (struct func_param *) arg;
+    struct func_param *param = (struct func_param *) arg;
 
-	celixThreadMutex_lock(&param->mu2);
-	celixThreadMutex_lock(&param->mu);
-	param->i = 666;
-	celixThreadMutex_unlock(&param->mu);
-	celixThreadMutex_unlock(&param->mu2);
+    celixThreadMutex_lock(&param->mu2);
+    celixThreadMutex_lock(&param->mu);
+    param->i = 666;
+    celixThreadMutex_unlock(&param->mu);
+    celixThreadMutex_unlock(&param->mu2);
 
-	return NULL;
+    return NULL;
 }
 
 static void * thread_test_func_cond_wait(void *arg) {
-	struct func_param *param = (struct func_param *) arg;
+    struct func_param *param = (struct func_param *) arg;
 
-	celixThreadMutex_lock(&param->mu);
+    celixThreadMutex_lock(&param->mu);
 
-	param->i = 666;
+    param->i = 666;
 
-	celixThreadCondition_signal(&param->cond);
-	celixThreadMutex_unlock(&param->mu);
-	return NULL;
+    celixThreadCondition_signal(&param->cond);
+    celixThreadMutex_unlock(&param->mu);
+    return NULL;
 }
 
 static void * thread_test_func_cond_broadcast(void *arg) {
-	struct func_param *param = (struct func_param *) arg;
+    struct func_param *param = (struct func_param *) arg;
 
-	celixThreadMutex_lock(&param->mu);
-	celixThreadCondition_wait(&param->cond, &param->mu);
-	celixThreadMutex_unlock(&param->mu);
-	celixThreadMutex_lock(&param->mu);
-	param->i++;
-	celixThreadMutex_unlock(&param->mu);
-	return NULL;
+    celixThreadMutex_lock(&param->mu);
+    celixThreadCondition_wait(&param->cond, &param->mu);
+    celixThreadMutex_unlock(&param->mu);
+    celixThreadMutex_lock(&param->mu);
+    param->i++;
+    celixThreadMutex_unlock(&param->mu);
+    return NULL;
 }
 
 static int thread_test_func_recur_lock(celix_thread_mutex_t *mu, int i) {
-	int temp;
-	if (i == 1) {
-		return 1;
-	} else {
-		celixThreadMutex_lock(mu);
-		temp = thread_test_func_recur_lock(mu, i - 1);
-		temp *= i;
-		celixThreadMutex_unlock(mu);
-		return temp;
-	}
+    int temp;
+    if (i == 1) {
+        return 1;
+    } else {
+        celixThreadMutex_lock(mu);
+        temp = thread_test_func_recur_lock(mu, i - 1);
+        temp *= i;
+        celixThreadMutex_unlock(mu);
+        return temp;
+    }
 }
 
 static void * thread_test_func_kill(void __attribute__((unused)) *arg){
-	int * ret = (int*) malloc(sizeof(*ret));
-	//sleep for a about a minute, or until a kill signal (USR1) is received
-	*ret = usleep(60000000);
-	return ret;
+    int * ret = (int*) malloc(sizeof(*ret));
+    //sleep for a about a minute, or until a kill signal (USR1) is received
+    *ret = usleep(60000000);
+    return ret;
 }
 
 static void thread_test_func_kill_handler(int signo){
-	celix_thread_t inThread = celixThread_self();
+    celix_thread_t inThread = celixThread_self();
 
-	mock_c()->actualCall("thread_test_func_kill_handler")
-			->withLongIntParameters("signo", signo)
-			->withParameterOfType("celix_thread_t", "inThread", (const void*) &inThread);
+    mock_c()->actualCall("thread_test_func_kill_handler")
+            ->withLongIntParameters("signo", signo)
+            ->withParameterOfType("celix_thread_t", "inThread", (const void*) &inThread);
 }
 }
diff --git a/libs/utils/private/test/filter_test.cpp b/libs/utils/private/test/filter_test.cpp
index 696e69d..e74fc80 100644
--- a/libs/utils/private/test/filter_test.cpp
+++ b/libs/utils/private/test/filter_test.cpp
@@ -213,7 +213,7 @@ TEST(filter, match_comparators){
     CHECK_FALSE(result);
 
     //cleanup
-    properties_destroy(props);
+    celix_properties_destroy(props);
     celix_filter_destroy(filter);
     free(filter_str);
     free(key);
@@ -422,7 +422,7 @@ TEST(filter, match_operators){
     CHECK_FALSE(result);
 
     //cleanup
-    properties_destroy(props);
+    celix_properties_destroy(props);
     celix_filter_destroy(filter);
     free(filter_str);
     free(key);
diff --git a/libs/utils/private/test/hash_map_test.cpp b/libs/utils/private/test/hash_map_test.cpp
index 8a050b0..1ec9e1f 100644
--- a/libs/utils/private/test/hash_map_test.cpp
+++ b/libs/utils/private/test/hash_map_test.cpp
@@ -1,28 +1,29 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * hash_map_test.cpp
  *
- * 	\date       Sep 15, 2015
- *  \author    	Menno van der Graaf & Alexander
- *  \copyright	Apache License, Version 2.0
+ *  \date       Sep 15, 2015
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <stddef.h>
@@ -40,1453 +41,1453 @@ extern "C"
 }
 
 int main(int argc, char** argv) {
-	return RUN_ALL_TESTS(argc, argv);
+    return RUN_ALL_TESTS(argc, argv);
 }
 
 static char* my_strdup(const char* s){
-	if(s==NULL){
-		return NULL;
-	}
+    if(s==NULL){
+        return NULL;
+    }
 
-	size_t len = strlen(s);
+    size_t len = strlen(s);
 
-	char *d = (char*) calloc (len + 1,sizeof(char));
+    char *d = (char*) calloc (len + 1,sizeof(char));
 
-	if (d == NULL){
-		return NULL;
-	}
+    if (d == NULL){
+        return NULL;
+    }
 
-	strncpy (d,s,len);
-	return d;
+    strncpy (d,s,len);
+    return d;
 }
 
 //Callback functions
 unsigned int test_hashKeyChar(const void * k) {
-	char * str = (char *) k;
+    char * str = (char *) k;
 
-	unsigned int hash = 1315423911;
-	unsigned int i    = 0;
-	unsigned int len = strlen(str);
+    unsigned int hash = 1315423911;
+    unsigned int i    = 0;
+    unsigned int len = strlen(str);
 
-	for(i = 0; i < len; str++, i++)
-	{
-		hash ^= ((hash << 5) + (*str) + (hash >> 2));
-	}
+    for(i = 0; i < len; str++, i++)
+    {
+        hash ^= ((hash << 5) + (*str) + (hash >> 2));
+    }
 
-	return hash;
+    return hash;
 }
 
 unsigned int test_hashValueChar(const void * v) {
-	(void)(v);
-	return 0;
+    (void)(v);
+    return 0;
 }
 
 int test_equalsKeyChar(const void * k, const void * o) {
-	return strcmp((char *)k, (char *) o) == 0;
+    return strcmp((char *)k, (char *) o) == 0;
 }
 
 int test_equalsValueChar(const void * v, const void * o) {
-	return strcmp((char *)v, (char *) o) == 0;
+    return strcmp((char *)v, (char *) o) == 0;
 }
 
 //Tests group defines
 
 TEST_GROUP(hash_map){
-	hash_map_pt map;
-
-	void setup() {
-		map = hashMap_create(NULL, NULL, NULL, NULL);
-	}
-	void teardown() {
-		hashMap_destroy(map, false, false);
-	}
+    hash_map_pt map;
+
+    void setup() {
+        map = hashMap_create(NULL, NULL, NULL, NULL);
+    }
+    void teardown() {
+        hashMap_destroy(map, false, false);
+    }
 };
 
 TEST_GROUP(hash_map_iterator){
-	hash_map_pt map;
-	hash_map_iterator_pt it_map;
-
-	void setup() {
-		map = hashMap_create(NULL, NULL, NULL, NULL);
-	}
-	void teardown() {
-		hashMap_destroy(map, false, false);
-	}
+    hash_map_pt map;
+    hash_map_iterator_pt it_map;
+
+    void setup() {
+        map = hashMap_create(NULL, NULL, NULL, NULL);
+    }
+    void teardown() {
+        hashMap_destroy(map, false, false);
+    }
 };
 
 TEST_GROUP(hash_map_values){
-	hash_map_pt map;
-	hash_map_values_pt values;
-
-	void setup() {
-		map = hashMap_create(NULL, NULL, NULL, NULL);
-	}
-	void teardown() {
-		hashMap_destroy(map, false, false);
-	}
+    hash_map_pt map;
+    hash_map_values_pt values;
+
+    void setup() {
+        map = hashMap_create(NULL, NULL, NULL, NULL);
+    }
+    void teardown() {
+        hashMap_destroy(map, false, false);
+    }
 };
 
 TEST_GROUP(hash_map_keySet){
-	hash_map_pt map;
-	hash_map_key_set_pt key_set;
-
-	void setup() {
-		map = hashMap_create(NULL, NULL, NULL, NULL);
-	}
-	void teardown() {
-		hashMap_destroy(map, false, false);
-	}
+    hash_map_pt map;
+    hash_map_key_set_pt key_set;
+
+    void setup() {
+        map = hashMap_create(NULL, NULL, NULL, NULL);
+    }
+    void teardown() {
+        hashMap_destroy(map, false, false);
+    }
 };
 
 TEST_GROUP(hash_map_entrySet){
-	hash_map_pt map;
-	hash_map_entry_set_pt entry_set;
-
-	void setup() {
-		map = hashMap_create(NULL, NULL, NULL, NULL);
-	}
-	void teardown() {
-		hashMap_destroy(map, false, false);
-	}
+    hash_map_pt map;
+    hash_map_entry_set_pt entry_set;
+
+    void setup() {
+        map = hashMap_create(NULL, NULL, NULL, NULL);
+    }
+    void teardown() {
+        hashMap_destroy(map, false, false);
+    }
 };
 
 TEST_GROUP(hash_map_hash) {
-	hash_map_pt map;
-
-	void setup(void) {
-		map = hashMap_create(test_hashKeyChar, test_hashValueChar, test_equalsKeyChar, test_equalsValueChar);
-	}
-	void teardown() {
-		hashMap_destroy(map, false, false);
-	}
+    hash_map_pt map;
+
+    void setup(void) {
+        map = hashMap_create(test_hashKeyChar, test_hashValueChar, test_equalsKeyChar, test_equalsValueChar);
+    }
+    void teardown() {
+        hashMap_destroy(map, false, false);
+    }
 };
 
 //----------------------HASH MAP DATA MANAGEMENT TEST----------------------
 
 TEST(hash_map, create){
-	CHECK(map != NULL);
-	LONGS_EQUAL(0, map->size);
-	// This fails on windows due to dllimport providing a proxy for exported functions.
-	POINTERS_EQUAL(hashMap_equals, map->equalsKey);
-	POINTERS_EQUAL(hashMap_equals, map->equalsValue);
-	POINTERS_EQUAL(hashMap_hashCode, map->hashKey);
-	POINTERS_EQUAL(hashMap_hashCode, map->hashValue);
+    CHECK(map != NULL);
+    LONGS_EQUAL(0, map->size);
+    // This fails on windows due to dllimport providing a proxy for exported functions.
+    POINTERS_EQUAL(hashMap_equals, map->equalsKey);
+    POINTERS_EQUAL(hashMap_equals, map->equalsValue);
+    POINTERS_EQUAL(hashMap_hashCode, map->hashKey);
+    POINTERS_EQUAL(hashMap_hashCode, map->hashValue);
 }
 
 TEST(hash_map, size){
-	char* key = my_strdup("key");
-	char* value = my_strdup("value");
-	char* key2 = my_strdup("key2");
-	char* value2 = my_strdup("value2");
-	char* key3 = my_strdup("key2");
-	char* value3 = my_strdup("value3");
-
-	LONGS_EQUAL(0, map->size);
-
-	// Add one entry
-	hashMap_put(map, key, value);
-	LONGS_EQUAL(1, map->size);
-
-	// Add second entry
-	hashMap_put(map, key2, value2);
-	LONGS_EQUAL(2, map->size);
-
-	// Add entry using the same key, this does not overwrite an existing entry
-	hashMap_put(map, key3, value3);
-	LONGS_EQUAL(3, map->size);
-
-	// Clear map
-	hashMap_clear(map, true, true);
-	LONGS_EQUAL(0, map->size);
+    char* key = my_strdup("key");
+    char* value = my_strdup("value");
+    char* key2 = my_strdup("key2");
+    char* value2 = my_strdup("value2");
+    char* key3 = my_strdup("key2");
+    char* value3 = my_strdup("value3");
+
+    LONGS_EQUAL(0, map->size);
+
+    // Add one entry
+    hashMap_put(map, key, value);
+    LONGS_EQUAL(1, map->size);
+
+    // Add second entry
+    hashMap_put(map, key2, value2);
+    LONGS_EQUAL(2, map->size);
+
+    // Add entry using the same key, this does not overwrite an existing entry
+    hashMap_put(map, key3, value3);
+    LONGS_EQUAL(3, map->size);
+
+    // Clear map
+    hashMap_clear(map, true, true);
+    LONGS_EQUAL(0, map->size);
 }
 
 TEST(hash_map, isEmpty){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
 
-	LONGS_EQUAL(0, map->size);
-	CHECK(hashMap_isEmpty(map));
+    LONGS_EQUAL(0, map->size);
+    CHECK(hashMap_isEmpty(map));
 
-	// Add one entry
-	hashMap_put(map, key, value);
-	LONGS_EQUAL(1, map->size);
-	CHECK(!hashMap_isEmpty(map));
+    // Add one entry
+    hashMap_put(map, key, value);
+    LONGS_EQUAL(1, map->size);
+    CHECK(!hashMap_isEmpty(map));
 
-	// Remove entry
-	hashMap_remove(map, key);
-	LONGS_EQUAL(0, map->size);
-	CHECK(hashMap_isEmpty(map));
+    // Remove entry
+    hashMap_remove(map, key);
+    LONGS_EQUAL(0, map->size);
+    CHECK(hashMap_isEmpty(map));
 
-	free(key);
-	free(value);
+    free(key);
+    free(value);
 }
 
 TEST(hash_map, get){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * neKey = my_strdup("notExisting");
-	char * key3 = NULL;
-	char * value3 = my_strdup("value3");
-	char * get;
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * neKey = my_strdup("notExisting");
+    char * key3 = NULL;
+    char * value3 = my_strdup("value3");
+    char * get;
 
-	// Add one entry
-	hashMap_put(map, key, value);
+    // Add one entry
+    hashMap_put(map, key, value);
 
-	// Add second entry
-	hashMap_put(map, key2, value2);
+    // Add second entry
+    hashMap_put(map, key2, value2);
 
-	get = (char*) (char*) hashMap_get(map, key);
-	STRCMP_EQUAL(value, get);
+    get = (char*) (char*) hashMap_get(map, key);
+    STRCMP_EQUAL(value, get);
 
-	get = (char*) hashMap_get(map, key2);
-	STRCMP_EQUAL(value2, get);
+    get = (char*) hashMap_get(map, key2);
+    STRCMP_EQUAL(value2, get);
 
-	get = (char*) hashMap_get(map, neKey);
-	POINTERS_EQUAL(NULL, get);
+    get = (char*) hashMap_get(map, neKey);
+    POINTERS_EQUAL(NULL, get);
 
-	get = (char*) hashMap_get(map, NULL);
-	POINTERS_EQUAL(NULL, get);
+    get = (char*) hashMap_get(map, NULL);
+    POINTERS_EQUAL(NULL, get);
 
-	// Add third entry with NULL key
-	hashMap_put(map, key3, value3);
+    // Add third entry with NULL key
+    hashMap_put(map, key3, value3);
 
-	get = (char*) hashMap_get(map, NULL);
-	STRCMP_EQUAL(value3, get);
+    get = (char*) hashMap_get(map, NULL);
+    STRCMP_EQUAL(value3, get);
 
-	free(neKey);
-	hashMap_clear(map, true, true);
+    free(neKey);
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map, containsKey){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * neKey = my_strdup("notExisting");
-	char * key3 = NULL;
-	char * value3 = my_strdup("value3");
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * neKey = my_strdup("notExisting");
+    char * key3 = NULL;
+    char * value3 = my_strdup("value3");
 
-	// Add one entry
-	hashMap_put(map, key, value);
+    // Add one entry
+    hashMap_put(map, key, value);
 
-	// Add second entry
-	hashMap_put(map, key2, value2);
+    // Add second entry
+    hashMap_put(map, key2, value2);
 
-	CHECK(hashMap_containsKey(map, key));
-	CHECK(hashMap_containsKey(map, key2));
-	CHECK(!hashMap_containsKey(map, neKey));
-	CHECK(!hashMap_containsKey(map, NULL));
+    CHECK(hashMap_containsKey(map, key));
+    CHECK(hashMap_containsKey(map, key2));
+    CHECK(!hashMap_containsKey(map, neKey));
+    CHECK(!hashMap_containsKey(map, NULL));
 
-	// Add third entry with NULL key
-	hashMap_put(map, key3, value3);
+    // Add third entry with NULL key
+    hashMap_put(map, key3, value3);
 
-	CHECK(hashMap_containsKey(map, key3));
+    CHECK(hashMap_containsKey(map, key3));
 
-	free(neKey);
-	hashMap_clear(map, true, true);
+    free(neKey);
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map, getEntry){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * neKey = my_strdup("notExisting");
-	char * key3 = NULL;
-	char * value3 = my_strdup("value3");
-	hash_map_entry_pt entry;
-
-	// Add one entry
-	hashMap_put(map, key, value);
-
-	// Add second entry
-	hashMap_put(map, key2, value2);
-	entry = hashMap_getEntry(map, key);
-	STRCMP_EQUAL(key, (char*) entry->key);
-	STRCMP_EQUAL(value, (char*)entry->value);
-
-	entry = hashMap_getEntry(map, key2);
-	STRCMP_EQUAL(key2, (char*) entry->key);
-	STRCMP_EQUAL(value2, (char*) entry->value);
-
-	entry = hashMap_getEntry(map, neKey);
-	POINTERS_EQUAL(NULL, entry);
-
-	entry = hashMap_getEntry(map, NULL);
-	POINTERS_EQUAL(NULL, entry);
-
-	// Add third entry with NULL key
-	hashMap_put(map, key3, value3);
-
-	entry = hashMap_getEntry(map, key3);
-	CHECK_EQUAL(key3, entry->key);
-	STRCMP_EQUAL(value3, (char*) entry->value);
-
-	free(neKey);
-	hashMap_clear(map, true, true);
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * neKey = my_strdup("notExisting");
+    char * key3 = NULL;
+    char * value3 = my_strdup("value3");
+    hash_map_entry_pt entry;
+
+    // Add one entry
+    hashMap_put(map, key, value);
+
+    // Add second entry
+    hashMap_put(map, key2, value2);
+    entry = hashMap_getEntry(map, key);
+    STRCMP_EQUAL(key, (char*) entry->key);
+    STRCMP_EQUAL(value, (char*)entry->value);
+
+    entry = hashMap_getEntry(map, key2);
+    STRCMP_EQUAL(key2, (char*) entry->key);
+    STRCMP_EQUAL(value2, (char*) entry->value);
+
+    entry = hashMap_getEntry(map, neKey);
+    POINTERS_EQUAL(NULL, entry);
+
+    entry = hashMap_getEntry(map, NULL);
+    POINTERS_EQUAL(NULL, entry);
+
+    // Add third entry with NULL key
+    hashMap_put(map, key3, value3);
+
+    entry = hashMap_getEntry(map, key3);
+    CHECK_EQUAL(key3, entry->key);
+    STRCMP_EQUAL(value3, (char*) entry->value);
+
+    free(neKey);
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map, put){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * nkey2 = my_strdup("key2");
-	char * nvalue2 = my_strdup("value3");
-	char * key3 = NULL;
-	char * value3 = my_strdup("value3");
-	char * key4 = my_strdup("key4");
-	char * value4 = NULL;
-	char * old;
-	char * get;
-
-	// Add one entry
-	hashMap_put(map, key, value);
-
-	// Add second entry
-	hashMap_put(map, key2, value2);
-
-	get = (char*) hashMap_get(map, key);
-	STRCMP_EQUAL(value, get);
-
-	get = (char*) hashMap_get(map, key2);
-	STRCMP_EQUAL(value2, get);
-
-	// Try to add an entry with the same key, since no explicit hash function is used,
-	//   this will not overwrite an existing entry.
-	old = (char *) hashMap_put(map, nkey2, nvalue2);
-	POINTERS_EQUAL(NULL, old);
-
-	// Retrieving the values will return the correct values
-	get = (char*) hashMap_get(map, (void*)key2);
-	STRCMP_EQUAL(value2, get);
-	get = (char*) hashMap_get(map, nkey2);
-	STRCMP_EQUAL(nvalue2, get);
-
-	// Add third entry with NULL key
-	hashMap_put(map, key3, value3);
-
-	get = (char*) hashMap_get(map, key3);
-	STRCMP_EQUAL(value3, get);
-
-	// Add fourth entry with NULL value
-	hashMap_put(map, key4, value4);
-
-	get =(char*)hashMap_get(map, key4);
-	CHECK_EQUAL(value4, get);
-
-	hashMap_clear(map, true, true);
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * nkey2 = my_strdup("key2");
+    char * nvalue2 = my_strdup("value3");
+    char * key3 = NULL;
+    char * value3 = my_strdup("value3");
+    char * key4 = my_strdup("key4");
+    char * value4 = NULL;
+    char * old;
+    char * get;
+
+    // Add one entry
+    hashMap_put(map, key, value);
+
+    // Add second entry
+    hashMap_put(map, key2, value2);
+
+    get = (char*) hashMap_get(map, key);
+    STRCMP_EQUAL(value, get);
+
+    get = (char*) hashMap_get(map, key2);
+    STRCMP_EQUAL(value2, get);
+
+    // Try to add an entry with the same key, since no explicit hash function is used,
+    //   this will not overwrite an existing entry.
+    old = (char *) hashMap_put(map, nkey2, nvalue2);
+    POINTERS_EQUAL(NULL, old);
+
+    // Retrieving the values will return the correct values
+    get = (char*) hashMap_get(map, (void*)key2);
+    STRCMP_EQUAL(value2, get);
+    get = (char*) hashMap_get(map, nkey2);
+    STRCMP_EQUAL(nvalue2, get);
+
+    // Add third entry with NULL key
+    hashMap_put(map, key3, value3);
+
+    get = (char*) hashMap_get(map, key3);
+    STRCMP_EQUAL(value3, get);
+
+    // Add fourth entry with NULL value
+    hashMap_put(map, key4, value4);
+
+    get =(char*)hashMap_get(map, key4);
+    CHECK_EQUAL(value4, get);
+
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map, resize){
-	int i;
-	char key[6];
-
-	LONGS_EQUAL(0, map->size);
-	LONGS_EQUAL(16, map->tablelength);
-	LONGS_EQUAL(12, map->treshold);
-	for (i = 0; i < 12; i++) {
-		char key[6];
-		sprintf(key, "key%d", i);
-		hashMap_put(map, my_strdup(key), my_strdup(key));
-	}
-	LONGS_EQUAL(12, map->size);
-	LONGS_EQUAL(16, map->tablelength);
-	LONGS_EQUAL(12, map->treshold);
-
-	sprintf(key, "key%d", i);
-	hashMap_put(map, my_strdup(key), my_strdup(key));
-	LONGS_EQUAL(13, map->size);
-	LONGS_EQUAL(32, map->tablelength);
-	LONGS_EQUAL(24, map->treshold);
-
-	hashMap_clear(map, true, true);
+    int i;
+    char key[6];
+
+    LONGS_EQUAL(0, map->size);
+    LONGS_EQUAL(16, map->tablelength);
+    LONGS_EQUAL(12, map->treshold);
+    for (i = 0; i < 12; i++) {
+        char key[6];
+        sprintf(key, "key%d", i);
+        hashMap_put(map, my_strdup(key), my_strdup(key));
+    }
+    LONGS_EQUAL(12, map->size);
+    LONGS_EQUAL(16, map->tablelength);
+    LONGS_EQUAL(12, map->treshold);
+
+    sprintf(key, "key%d", i);
+    hashMap_put(map, my_strdup(key), my_strdup(key));
+    LONGS_EQUAL(13, map->size);
+    LONGS_EQUAL(32, map->tablelength);
+    LONGS_EQUAL(24, map->treshold);
+
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map, remove){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = NULL;
-	char * value2 = my_strdup("value2");
-	char * removeKey;
-
-	// Add one entry
-	hashMap_put(map, key, value);
-
-	// Add second entry with null key
-	hashMap_put(map, key2, value2);
-
-	// Remove non-existing entry for map
-	removeKey = my_strdup("nonexisting");
-	hashMap_remove(map, removeKey);
-	LONGS_EQUAL(2, map->size);
-	CHECK(!hashMap_isEmpty(map));
-
-	hashMap_remove(map, key);
-	LONGS_EQUAL(1, map->size);
-
-	hashMap_remove(map, key2);
-	LONGS_EQUAL(0, map->size);
-	CHECK(hashMap_isEmpty(map));
-
-	// Remove non-existing entry for empty map
-	hashMap_remove(map, removeKey);
-	LONGS_EQUAL(0, map->size);
-	CHECK(hashMap_isEmpty(map));
-
-	free(key);
-	free(value);
-	free(key2);
-	free(value2);
-	free(removeKey);
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = NULL;
+    char * value2 = my_strdup("value2");
+    char * removeKey;
+
+    // Add one entry
+    hashMap_put(map, key, value);
+
+    // Add second entry with null key
+    hashMap_put(map, key2, value2);
+
+    // Remove non-existing entry for map
+    removeKey = my_strdup("nonexisting");
+    hashMap_remove(map, removeKey);
+    LONGS_EQUAL(2, map->size);
+    CHECK(!hashMap_isEmpty(map));
+
+    hashMap_remove(map, key);
+    LONGS_EQUAL(1, map->size);
+
+    hashMap_remove(map, key2);
+    LONGS_EQUAL(0, map->size);
+    CHECK(hashMap_isEmpty(map));
+
+    // Remove non-existing entry for empty map
+    hashMap_remove(map, removeKey);
+    LONGS_EQUAL(0, map->size);
+    CHECK(hashMap_isEmpty(map));
+
+    free(key);
+    free(value);
+    free(key2);
+    free(value2);
+    free(removeKey);
 }
 
 TEST(hash_map, removeMapping){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = NULL;
-	char * value2 = my_strdup("value2");
-	hash_map_entry_pt entry1;
-	hash_map_entry_pt entry2;
-	hash_map_entry_pt removed;
-
-	// Add one entry
-	hashMap_put(map, key, value);
-
-	// Add second entry with null key
-	hashMap_put(map, key2, value2);
-
-	entry1 = hashMap_getEntry(map, key);
-	entry2 = hashMap_getEntry(map, key2);
-
-	CHECK(entry1 != NULL);
-	CHECK(entry2 != NULL);
-
-	removed = hashMap_removeMapping(map, entry1);
-	POINTERS_EQUAL(removed, entry1);
-	LONGS_EQUAL(1, map->size);
-
-	removed = hashMap_removeMapping(map, entry2);
-	POINTERS_EQUAL(removed, entry2);
-	LONGS_EQUAL(0, map->size);
-
-	// Remove unexisting entry for empty map
-	hashMap_removeMapping(map, NULL);
-	LONGS_EQUAL(0, map->size);
-	CHECK(hashMap_isEmpty(map));
-
-	free(key);
-	free(value);
-	free(key2);
-	free(value2);
-	free(entry1);
-	free(entry2);
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = NULL;
+    char * value2 = my_strdup("value2");
+    hash_map_entry_pt entry1;
+    hash_map_entry_pt entry2;
+    hash_map_entry_pt removed;
+
+    // Add one entry
+    hashMap_put(map, key, value);
+
+    // Add second entry with null key
+    hashMap_put(map, key2, value2);
+
+    entry1 = hashMap_getEntry(map, key);
+    entry2 = hashMap_getEntry(map, key2);
+
+    CHECK(entry1 != NULL);
+    CHECK(entry2 != NULL);
+
+    removed = hashMap_removeMapping(map, entry1);
+    POINTERS_EQUAL(removed, entry1);
+    LONGS_EQUAL(1, map->size);
+
+    removed = hashMap_removeMapping(map, entry2);
+    POINTERS_EQUAL(removed, entry2);
+    LONGS_EQUAL(0, map->size);
+
+    // Remove unexisting entry for empty map
+    hashMap_removeMapping(map, NULL);
+    LONGS_EQUAL(0, map->size);
+    CHECK(hashMap_isEmpty(map));
+
+    free(key);
+    free(value);
+    free(key2);
+    free(value2);
+    free(entry1);
+    free(entry2);
 }
 
 TEST(hash_map, clear){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * key3 = NULL;
-	char * value3 = my_strdup("value3");
-	char * key4 = my_strdup("key4");
-	char * value4 = NULL;
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * key3 = NULL;
+    char * value3 = my_strdup("value3");
+    char * key4 = my_strdup("key4");
+    char * value4 = NULL;
 
-	// Add one entry
-	hashMap_put(map, key, value);
+    // Add one entry
+    hashMap_put(map, key, value);
 
-	// Add second entry
-	hashMap_put(map, key2, value2);
+    // Add second entry
+    hashMap_put(map, key2, value2);
 
-	// Add third entry with NULL key
-	hashMap_put(map, key3, value3);
+    // Add third entry with NULL key
+    hashMap_put(map, key3, value3);
 
-	// Add fourth entry with NULL value
-	hashMap_put(map, key4, value4);
+    // Add fourth entry with NULL value
+    hashMap_put(map, key4, value4);
 
-	// Clear but leave keys and values intact
-	hashMap_clear(map, false, false);
-	LONGS_EQUAL(0, map->size);
+    // Clear but leave keys and values intact
+    hashMap_clear(map, false, false);
+    LONGS_EQUAL(0, map->size);
 
-	// Add one entry
-	hashMap_put(map, key, value);
+    // Add one entry
+    hashMap_put(map, key, value);
 
-	// Add second entry
-	hashMap_put(map, key2, value2);
+    // Add second entry
+    hashMap_put(map, key2, value2);
 
-	// Add third entry with NULL key
-	hashMap_put(map, key3, value3);
+    // Add third entry with NULL key
+    hashMap_put(map, key3, value3);
 
-	// Add fourth entry with NULL value
-	hashMap_put(map, key4, value4);
-	// Clear and clean up keys and values
-	hashMap_clear(map, true, true);
-	LONGS_EQUAL(0, map->size);
+    // Add fourth entry with NULL value
+    hashMap_put(map, key4, value4);
+    // Clear and clean up keys and values
+    hashMap_clear(map, true, true);
+    LONGS_EQUAL(0, map->size);
 }
 
 TEST(hash_map, containsValue){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * neValue = my_strdup("notExisting");
-	char * key3 = my_strdup("key3");
-	char * value3 = NULL;
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * neValue = my_strdup("notExisting");
+    char * key3 = my_strdup("key3");
+    char * value3 = NULL;
 
-	// Add one entry
-	hashMap_put(map, key, value);
+    // Add one entry
+    hashMap_put(map, key, value);
 
-	// Add second entry
-	hashMap_put(map, key2, value2);
+    // Add second entry
+    hashMap_put(map, key2, value2);
 
-	CHECK(hashMap_containsValue(map, value));
-	CHECK(hashMap_containsValue(map, value2));
-	CHECK(!hashMap_containsValue(map, neValue));
-	CHECK(!hashMap_containsValue(map, NULL));
+    CHECK(hashMap_containsValue(map, value));
+    CHECK(hashMap_containsValue(map, value2));
+    CHECK(!hashMap_containsValue(map, neValue));
+    CHECK(!hashMap_containsValue(map, NULL));
 
-	// Add third entry with NULL value
-	hashMap_put(map, key3, value3);
+    // Add third entry with NULL value
+    hashMap_put(map, key3, value3);
 
-	CHECK(hashMap_containsValue(map, value3));
+    CHECK(hashMap_containsValue(map, value3));
 
-	free(neValue);
-	hashMap_clear(map, true, true);
+    free(neValue);
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map, ValuestoArray){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char **array;
-	unsigned int size;
-	hash_map_values_pt values;
-
-	// Add one entry
-	hashMap_put(map, key, value);
-
-	// Add second entry
-	hashMap_put(map, key2, value2);
-
-	values = hashMapValues_create(map);
-	hashMapValues_toArray(values, (void***)&array, &size);
-	LONGS_EQUAL(2, size);
-	CHECK(hashMapValues_contains(values, array[0]));
-	CHECK(hashMapValues_contains(values, array[1]));
-
-	free(array);
-	hashMapValues_destroy(values);
-	hashMap_clear(map, true, true);
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char **array;
+    unsigned int size;
+    hash_map_values_pt values;
+
+    // Add one entry
+    hashMap_put(map, key, value);
+
+    // Add second entry
+    hashMap_put(map, key2, value2);
+
+    values = hashMapValues_create(map);
+    hashMapValues_toArray(values, (void***)&array, &size);
+    LONGS_EQUAL(2, size);
+    CHECK(hashMapValues_contains(values, array[0]));
+    CHECK(hashMapValues_contains(values, array[1]));
+
+    free(array);
+    hashMapValues_destroy(values);
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map, entryGetKey){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * key3 = NULL;
-	char * value3 = my_strdup("value3");
-	char * get;
-	hash_map_entry_pt entry;
-
-	// Add 2 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
-	hashMap_put(map, key3, value3);
-
-	entry = hashMap_getEntry(map, key);
-	get = (char*) hashMapEntry_getKey(entry);
-	STRCMP_EQUAL(key, get);
-
-	entry = hashMap_getEntry(map, key2);
-	get = (char*) hashMapEntry_getKey(entry);
-	STRCMP_EQUAL(key2, get);
-
-	entry = hashMap_getEntry(map, key3);
-	get = (char*) hashMapEntry_getKey(entry);
-	POINTERS_EQUAL(key3, get);
-
-	hashMap_clear(map, true, true);
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * key3 = NULL;
+    char * value3 = my_strdup("value3");
+    char * get;
+    hash_map_entry_pt entry;
+
+    // Add 2 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
+    hashMap_put(map, key3, value3);
+
+    entry = hashMap_getEntry(map, key);
+    get = (char*) hashMapEntry_getKey(entry);
+    STRCMP_EQUAL(key, get);
+
+    entry = hashMap_getEntry(map, key2);
+    get = (char*) hashMapEntry_getKey(entry);
+    STRCMP_EQUAL(key2, get);
+
+    entry = hashMap_getEntry(map, key3);
+    get = (char*) hashMapEntry_getKey(entry);
+    POINTERS_EQUAL(key3, get);
+
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map, entryGetValue){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * key3 = NULL;
-	char * value3 = my_strdup("value3");
-	char * get;
-	hash_map_entry_pt entry;
-
-	// Add 2 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
-	hashMap_put(map, key3, value3);
-
-	entry = hashMap_getEntry(map, key);
-	get = (char*) hashMapEntry_getValue(entry);
-	STRCMP_EQUAL(value, get);
-
-	entry = hashMap_getEntry(map, key2);
-	get = (char*) hashMapEntry_getValue(entry);
-	STRCMP_EQUAL(value2, get);
-
-	entry = hashMap_getEntry(map, key3);
-	get = (char*) hashMapEntry_getValue(entry);
-	POINTERS_EQUAL(value3, get);
-
-	hashMap_clear(map, true, true);
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * key3 = NULL;
+    char * value3 = my_strdup("value3");
+    char * get;
+    hash_map_entry_pt entry;
+
+    // Add 2 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
+    hashMap_put(map, key3, value3);
+
+    entry = hashMap_getEntry(map, key);
+    get = (char*) hashMapEntry_getValue(entry);
+    STRCMP_EQUAL(value, get);
+
+    entry = hashMap_getEntry(map, key2);
+    get = (char*) hashMapEntry_getValue(entry);
+    STRCMP_EQUAL(value2, get);
+
+    entry = hashMap_getEntry(map, key3);
+    get = (char*) hashMapEntry_getValue(entry);
+    POINTERS_EQUAL(value3, get);
+
+    hashMap_clear(map, true, true);
 }
 
 //----------------------HASH MAP ITERATOR TEST----------------------
 
 TEST(hash_map_iterator, create){
-	it_map = hashMapIterator_create(map);
-	CHECK(it_map != NULL);
-	POINTERS_EQUAL(map, it_map->map);
-	POINTERS_EQUAL(it_map->current, NULL);
-	LONGS_EQUAL(map->modificationCount, it_map->expectedModCount);
+    it_map = hashMapIterator_create(map);
+    CHECK(it_map != NULL);
+    POINTERS_EQUAL(map, it_map->map);
+    POINTERS_EQUAL(it_map->current, NULL);
+    LONGS_EQUAL(map->modificationCount, it_map->expectedModCount);
 
-	hashMapIterator_destroy(it_map);
+    hashMapIterator_destroy(it_map);
 }
 
 TEST(hash_map_iterator, hasNext){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * key3 = my_strdup("key3");
-	char * value3 = my_strdup("value3");
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * key3 = my_strdup("key3");
+    char * value3 = my_strdup("value3");
 
-	// Add one entry
-	hashMap_put(map, key, value);
+    // Add one entry
+    hashMap_put(map, key, value);
 
-	// Add second entry
-	hashMap_put(map, key2, value2);
+    // Add second entry
+    hashMap_put(map, key2, value2);
 
-	// Add third entry
-	hashMap_put(map, key3, value3);
+    // Add third entry
+    hashMap_put(map, key3, value3);
 
-	//create it_map from map
-	it_map = hashMapIterator_create(map);
+    //create it_map from map
+    it_map = hashMapIterator_create(map);
 
-	//check hasNext
-	CHECK(hashMapIterator_hasNext(it_map));
+    //check hasNext
+    CHECK(hashMapIterator_hasNext(it_map));
 
-	hashMapIterator_nextEntry(it_map);
-	CHECK(hashMapIterator_hasNext(it_map));
+    hashMapIterator_nextEntry(it_map);
+    CHECK(hashMapIterator_hasNext(it_map));
 
-	hashMapIterator_nextEntry(it_map);
-	CHECK(hashMapIterator_hasNext(it_map));
+    hashMapIterator_nextEntry(it_map);
+    CHECK(hashMapIterator_hasNext(it_map));
 
-	//third entry next points to NULL
-	hashMapIterator_nextEntry(it_map);
-	CHECK(!hashMapIterator_hasNext(it_map));
+    //third entry next points to NULL
+    hashMapIterator_nextEntry(it_map);
+    CHECK(!hashMapIterator_hasNext(it_map));
 
-	hashMapIterator_destroy(it_map);
-	hashMap_clear(map, true, true);
+    hashMapIterator_destroy(it_map);
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map_iterator, remove){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * key3 = my_strdup("key3");
-	char * value3 = my_strdup("value3");
-
-	// Add 3 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
-	hashMap_put(map, key3, value3);
-
-	//create it_map from map
-	it_map = hashMapIterator_create(map);
-
-	//try to remove current (NULL)
-	hashMapIterator_remove(it_map);
-	LONGS_EQUAL(3, map->size);
-
-	//delete the first and second entry
-	hashMapIterator_nextEntry(it_map);
-	hashMapIterator_remove(it_map);
-	hashMapIterator_nextEntry(it_map);
-	hashMapIterator_remove(it_map);
-	LONGS_EQUAL(1, map->size);
-
-	free(key);
-	free(value);
-	free(key2);
-	free(value2);
-	free(key3);
-	free(value3);
-	hashMapIterator_destroy(it_map);
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * key3 = my_strdup("key3");
+    char * value3 = my_strdup("value3");
+
+    // Add 3 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
+    hashMap_put(map, key3, value3);
+
+    //create it_map from map
+    it_map = hashMapIterator_create(map);
+
+    //try to remove current (NULL)
+    hashMapIterator_remove(it_map);
+    LONGS_EQUAL(3, map->size);
+
+    //delete the first and second entry
+    hashMapIterator_nextEntry(it_map);
+    hashMapIterator_remove(it_map);
+    hashMapIterator_nextEntry(it_map);
+    hashMapIterator_remove(it_map);
+    LONGS_EQUAL(1, map->size);
+
+    free(key);
+    free(value);
+    free(key2);
+    free(value2);
+    free(key3);
+    free(value3);
+    hashMapIterator_destroy(it_map);
 }
 
 TEST(hash_map_iterator, nextValue){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * getValue;
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * getValue;
 
-	// Add 2 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
+    // Add 2 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
 
-	//create it_map from map
-	it_map = hashMapIterator_create(map);
+    //create it_map from map
+    it_map = hashMapIterator_create(map);
 
-	getValue = (char*) hashMapIterator_nextValue(it_map);
-	CHECK(hashMap_containsValue(map, getValue));
+    getValue = (char*) hashMapIterator_nextValue(it_map);
+    CHECK(hashMap_containsValue(map, getValue));
 
-	getValue = (char*) hashMapIterator_nextValue(it_map);
-	CHECK(hashMap_containsValue(map, getValue));
+    getValue = (char*) hashMapIterator_nextValue(it_map);
+    CHECK(hashMap_containsValue(map, getValue));
 
-	getValue = (char*) hashMapIterator_nextValue(it_map);
-	POINTERS_EQUAL(NULL, getValue);
+    getValue = (char*) hashMapIterator_nextValue(it_map);
+    POINTERS_EQUAL(NULL, getValue);
 
-	hashMapIterator_destroy(it_map);
-	hashMap_clear(map, true, true);
+    hashMapIterator_destroy(it_map);
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map_iterator, nextKey){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * getKey;
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * getKey;
 
-	// Add 2 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
+    // Add 2 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
 
-	//create it_map from map
-	it_map = hashMapIterator_create(map);
+    //create it_map from map
+    it_map = hashMapIterator_create(map);
 
-	getKey = (char*) hashMapIterator_nextKey(it_map);
-	CHECK(hashMap_containsKey(map, getKey));
+    getKey = (char*) hashMapIterator_nextKey(it_map);
+    CHECK(hashMap_containsKey(map, getKey));
 
-	getKey = (char*) hashMapIterator_nextKey(it_map);
-	CHECK(hashMap_containsKey(map, getKey));
+    getKey = (char*) hashMapIterator_nextKey(it_map);
+    CHECK(hashMap_containsKey(map, getKey));
 
-	getKey = (char*) hashMapIterator_nextKey(it_map);
-	POINTERS_EQUAL(NULL, getKey);
+    getKey = (char*) hashMapIterator_nextKey(it_map);
+    POINTERS_EQUAL(NULL, getKey);
 
-	hashMapIterator_destroy(it_map);
-	hashMap_clear(map, true, true);
+    hashMapIterator_destroy(it_map);
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map_iterator, nextEntry){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * getValue;
-	hash_map_entry_pt get;
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * getValue;
+    hash_map_entry_pt get;
 
-	// Add 2 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
+    // Add 2 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
 
-	//create it_map from map
-	it_map = hashMapIterator_create(map);
+    //create it_map from map
+    it_map = hashMapIterator_create(map);
 
-	get = (hash_map_entry_pt) hashMapIterator_nextEntry(it_map);
-	getValue = (char*) hashMap_get(map, get->key);
-	STRCMP_EQUAL((char*)get->value, (char*)getValue);
+    get = (hash_map_entry_pt) hashMapIterator_nextEntry(it_map);
+    getValue = (char*) hashMap_get(map, get->key);
+    STRCMP_EQUAL((char*)get->value, (char*)getValue);
 
-	get = (hash_map_entry_pt) hashMapIterator_nextEntry(it_map);
-	getValue = (char*) hashMap_get(map, get->key);
-	STRCMP_EQUAL((char*)get->value, (char*)getValue);
+    get = (hash_map_entry_pt) hashMapIterator_nextEntry(it_map);
+    getValue = (char*) hashMap_get(map, get->key);
+    STRCMP_EQUAL((char*)get->value, (char*)getValue);
 
-	get = (hash_map_entry_pt) hashMapIterator_nextEntry(it_map);
-	POINTERS_EQUAL(NULL, get);
+    get = (hash_map_entry_pt) hashMapIterator_nextEntry(it_map);
+    POINTERS_EQUAL(NULL, get);
 
-	hashMapIterator_destroy(it_map);
-	hashMap_clear(map, true, true);
+    hashMapIterator_destroy(it_map);
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map_iterator, valuesIterator){
-	hash_map_values_pt values;
-	hash_map_iterator_pt it_val;
+    hash_map_values_pt values;
+    hash_map_iterator_pt it_val;
 
-	values = hashMapValues_create(map);
-	it_val = hashMapValues_iterator(values);
+    values = hashMapValues_create(map);
+    it_val = hashMapValues_iterator(values);
 
-	POINTERS_EQUAL(map, it_val->map);
+    POINTERS_EQUAL(map, it_val->map);
 
-	hashMapIterator_destroy(it_val);
-	hashMapValues_destroy(values);
+    hashMapIterator_destroy(it_val);
+    hashMapValues_destroy(values);
 }
 
 //----------------------HASH MAP VALUES TEST----------------------
 
 TEST(hash_map_values, create){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
 
-	// Add 2 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
+    // Add 2 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
 
-	//create Values from map
-	values = hashMapValues_create(map);
+    //create Values from map
+    values = hashMapValues_create(map);
 
-	CHECK(hashMapValues_contains(values, value));
-	CHECK(hashMapValues_contains(values, value2));
+    CHECK(hashMapValues_contains(values, value));
+    CHECK(hashMapValues_contains(values, value2));
 
-	hashMap_clear(map, true, true);
-	hashMapValues_destroy(values);
+    hashMap_clear(map, true, true);
+    hashMapValues_destroy(values);
 }
 
 TEST(hash_map_values, size){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
 
-	// Add 2 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
+    // Add 2 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
 
-	//create Values from map
-	values = hashMapValues_create(map);
+    //create Values from map
+    values = hashMapValues_create(map);
 
-	LONGS_EQUAL(2, hashMapValues_size(values));
+    LONGS_EQUAL(2, hashMapValues_size(values));
 
-	hashMap_clear(map, true, true);
-	hashMapValues_destroy(values);
+    hashMap_clear(map, true, true);
+    hashMapValues_destroy(values);
 }
 
 TEST(hash_map_values, remove){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-
-	// Add 2 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
-
-	//create Values from map
-	values = hashMapValues_create(map);
-	CHECK(hashMapValues_contains(values, value));
-	CHECK(hashMapValues_contains(values, value2));
-
-	hashMapValues_remove(values, value);
-	CHECK(!hashMapValues_contains(values, value));
-	CHECK(hashMapValues_contains(values, value2));
-
-	hashMapValues_remove(values, value2);
-	CHECK(!hashMapValues_contains(values, value));
-	CHECK(!hashMapValues_contains(values, value2));
-
-	free(key);
-	free(value);
-	free(key2);
-	free(value2);
-	hashMap_clear(map, true, true);
-	hashMapValues_destroy(values);
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+
+    // Add 2 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
+
+    //create Values from map
+    values = hashMapValues_create(map);
+    CHECK(hashMapValues_contains(values, value));
+    CHECK(hashMapValues_contains(values, value2));
+
+    hashMapValues_remove(values, value);
+    CHECK(!hashMapValues_contains(values, value));
+    CHECK(hashMapValues_contains(values, value2));
+
+    hashMapValues_remove(values, value2);
+    CHECK(!hashMapValues_contains(values, value));
+    CHECK(!hashMapValues_contains(values, value2));
+
+    free(key);
+    free(value);
+    free(key2);
+    free(value2);
+    hashMap_clear(map, true, true);
+    hashMapValues_destroy(values);
 }
 
 TEST(hash_map_values, clear){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
 
-	// Add 2 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
+    // Add 2 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
 
-	//create Values from map
-	values = hashMapValues_create(map);
+    //create Values from map
+    values = hashMapValues_create(map);
 
-	CHECK(hashMapValues_contains(values, value));
-	CHECK(hashMapValues_contains(values, value2));
-	LONGS_EQUAL(2, values->map->size);
+    CHECK(hashMapValues_contains(values, value));
+    CHECK(hashMapValues_contains(values, value2));
+    LONGS_EQUAL(2, values->map->size);
 
-	hashMapValues_clear(values);
+    hashMapValues_clear(values);
 
-	CHECK(!hashMapValues_contains(values, value));
-	CHECK(!hashMapValues_contains(values, value2));
-	LONGS_EQUAL(0, values->map->size);
+    CHECK(!hashMapValues_contains(values, value));
+    CHECK(!hashMapValues_contains(values, value2));
+    LONGS_EQUAL(0, values->map->size);
 
-	free(key);
-	free(value);
-	free(key2);
-	free(value2);
-	hashMapValues_destroy(values);
+    free(key);
+    free(value);
+    free(key2);
+    free(value2);
+    hashMapValues_destroy(values);
 }
 
 TEST(hash_map_values, isEmpty){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
 
-	// Add 2 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
+    // Add 2 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
 
-	//create Values from map
-	values = hashMapValues_create(map);
+    //create Values from map
+    values = hashMapValues_create(map);
 
-	CHECK(!hashMapValues_isEmpty(values));
+    CHECK(!hashMapValues_isEmpty(values));
 
-	hashMapValues_clear(values);
+    hashMapValues_clear(values);
 
-	CHECK(hashMapValues_isEmpty(values));
+    CHECK(hashMapValues_isEmpty(values));
 
-	free(key);
-	free(value);
-	free(key2);
-	free(value2);
-	hashMapValues_destroy(values);
+    free(key);
+    free(value);
+    free(key2);
+    free(value2);
+    hashMapValues_destroy(values);
 }
 
 //----------------------HASH MAP KEYSET TEST----------------------
 
 TEST(hash_map_keySet, create){
-	key_set = hashMapKeySet_create(map);
+    key_set = hashMapKeySet_create(map);
 
-	POINTERS_EQUAL(map, key_set->map);
+    POINTERS_EQUAL(map, key_set->map);
 
-	hashMapKeySet_destroy(key_set);
+    hashMapKeySet_destroy(key_set);
 }
 
 TEST(hash_map_keySet, size){
-	char * key = my_strdup("key");
-	char * key2 = my_strdup("key2");
+    char * key = my_strdup("key");
+    char * key2 = my_strdup("key2");
 
-	key_set = hashMapKeySet_create(map);
+    key_set = hashMapKeySet_create(map);
 
-	LONGS_EQUAL(0, hashMapKeySet_size(key_set));
+    LONGS_EQUAL(0, hashMapKeySet_size(key_set));
 
-	// Add 2 entries
-	hashMap_put(map, key, NULL);
-	hashMap_put(map, key2, NULL);
+    // Add 2 entries
+    hashMap_put(map, key, NULL);
+    hashMap_put(map, key2, NULL);
 
 
-	LONGS_EQUAL(2, hashMapKeySet_size(key_set));
+    LONGS_EQUAL(2, hashMapKeySet_size(key_set));
 
-	hashMap_clear(map, true, true);
-	hashMapKeySet_destroy(key_set);
+    hashMap_clear(map, true, true);
+    hashMapKeySet_destroy(key_set);
 }
 
 TEST(hash_map_keySet, contains){
-	char * key = my_strdup("key");
-	char * key2 = my_strdup("key2");
+    char * key = my_strdup("key");
+    char * key2 = my_strdup("key2");
 
-	key_set = hashMapKeySet_create(map);
+    key_set = hashMapKeySet_create(map);
 
-	CHECK(!hashMapKeySet_contains(key_set, key));
-	CHECK(!hashMapKeySet_contains(key_set, key2));
+    CHECK(!hashMapKeySet_contains(key_set, key));
+    CHECK(!hashMapKeySet_contains(key_set, key2));
 
-	// Add 2 entries
-	hashMap_put(map, key, NULL);
+    // Add 2 entries
+    hashMap_put(map, key, NULL);
 
-	CHECK(hashMapKeySet_contains(key_set, key));
-	CHECK(!hashMapKeySet_contains(key_set, key2));
+    CHECK(hashMapKeySet_contains(key_set, key));
+    CHECK(!hashMapKeySet_contains(key_set, key2));
 
-	hashMap_put(map, key2, NULL);
+    hashMap_put(map, key2, NULL);
 
-	CHECK(hashMapKeySet_contains(key_set, key));
-	CHECK(hashMapKeySet_contains(key_set, key2));
+    CHECK(hashMapKeySet_contains(key_set, key));
+    CHECK(hashMapKeySet_contains(key_set, key2));
 
-	hashMap_clear(map, true, true);
-	hashMapKeySet_destroy(key_set);
+    hashMap_clear(map, true, true);
+    hashMapKeySet_destroy(key_set);
 }
 
 TEST(hash_map_keySet, remove){
-	char * key = my_strdup("key");
-	char * key2 = my_strdup("key2");
+    char * key = my_strdup("key");
+    char * key2 = my_strdup("key2");
 
-	key_set = hashMapKeySet_create(map);
+    key_set = hashMapKeySet_create(map);
 
-	// Add 2 entries
-	hashMap_put(map, key, NULL);
-	hashMap_put(map, key2, NULL);
+    // Add 2 entries
+    hashMap_put(map, key, NULL);
+    hashMap_put(map, key2, NULL);
 
-	LONGS_EQUAL(2, key_set->map->size);
+    LONGS_EQUAL(2, key_set->map->size);
 
-	hashMapKeySet_remove(key_set, key);
+    hashMapKeySet_remove(key_set, key);
 
-	LONGS_EQUAL(1, key_set->map->size);
+    LONGS_EQUAL(1, key_set->map->size);
 
-	hashMapKeySet_remove(key_set, key2);
+    hashMapKeySet_remove(key_set, key2);
 
-	LONGS_EQUAL(0, key_set->map->size);
+    LONGS_EQUAL(0, key_set->map->size);
 
-	free(key);
-	free(key2);
-	hashMapKeySet_destroy(key_set);
+    free(key);
+    free(key2);
+    hashMapKeySet_destroy(key_set);
 }
 
 TEST(hash_map_keySet, clear){
-	char * key = my_strdup("key");
-	char * key2 = my_strdup("key2");
+    char * key = my_strdup("key");
+    char * key2 = my_strdup("key2");
 
-	key_set = hashMapKeySet_create(map);
+    key_set = hashMapKeySet_create(map);
 
-	// Add 2 entries
-	hashMap_put(map, key, NULL);
-	hashMap_put(map, key2, NULL);
+    // Add 2 entries
+    hashMap_put(map, key, NULL);
+    hashMap_put(map, key2, NULL);
 
-	LONGS_EQUAL(2, key_set->map->size);
+    LONGS_EQUAL(2, key_set->map->size);
 
-	hashMapKeySet_clear(key_set);
+    hashMapKeySet_clear(key_set);
 
-	LONGS_EQUAL(0, key_set->map->size);
+    LONGS_EQUAL(0, key_set->map->size);
 
-	free(key);
-	free(key2);
-	hashMapKeySet_destroy(key_set);
+    free(key);
+    free(key2);
+    hashMapKeySet_destroy(key_set);
 }
 
 TEST(hash_map_keySet, isEmpty){
-	char * key = my_strdup("key");
-	char * key2 = my_strdup("key2");
+    char * key = my_strdup("key");
+    char * key2 = my_strdup("key2");
 
-	key_set = hashMapKeySet_create(map);
+    key_set = hashMapKeySet_create(map);
 
-	CHECK(hashMapKeySet_isEmpty(key_set));
+    CHECK(hashMapKeySet_isEmpty(key_set));
 
-	// Add 2 entries
-	hashMap_put(map, key, NULL);
-	hashMap_put(map, key2, NULL);
+    // Add 2 entries
+    hashMap_put(map, key, NULL);
+    hashMap_put(map, key2, NULL);
 
-	CHECK(!hashMapKeySet_isEmpty(key_set));
+    CHECK(!hashMapKeySet_isEmpty(key_set));
 
-	hashMapKeySet_clear(key_set);
+    hashMapKeySet_clear(key_set);
 
-	CHECK(hashMapKeySet_isEmpty(key_set));
+    CHECK(hashMapKeySet_isEmpty(key_set));
 
-	free(key);
-	free(key2);
-	hashMapKeySet_destroy(key_set);
+    free(key);
+    free(key2);
+    hashMapKeySet_destroy(key_set);
 }
 
 //----------------------HASH MAP ENTRYSET TEST----------------------
 
 TEST(hash_map_entrySet, create){
-	entry_set = hashMapEntrySet_create(map);
+    entry_set = hashMapEntrySet_create(map);
 
-	POINTERS_EQUAL(map, entry_set->map);
+    POINTERS_EQUAL(map, entry_set->map);
 
-	hashMapEntrySet_destroy(entry_set);
+    hashMapEntrySet_destroy(entry_set);
 }
 
 TEST(hash_map_entrySet, size){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
 
 
-	entry_set = hashMapEntrySet_create(map);
+    entry_set = hashMapEntrySet_create(map);
 
-	LONGS_EQUAL(0, hashMapEntrySet_size(entry_set));
+    LONGS_EQUAL(0, hashMapEntrySet_size(entry_set));
 
-	// Add 2 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
+    // Add 2 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
 
 
-	LONGS_EQUAL(2, hashMapEntrySet_size(entry_set));
+    LONGS_EQUAL(2, hashMapEntrySet_size(entry_set));
 
-	hashMap_clear(map, true, true);
-	hashMapEntrySet_destroy(entry_set);
+    hashMap_clear(map, true, true);
+    hashMapEntrySet_destroy(entry_set);
 }
 
 TEST(hash_map_entrySet, contains){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
 
-	entry_set = hashMapEntrySet_create(map);
+    entry_set = hashMapEntrySet_create(map);
 
-	// Add 2 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
+    // Add 2 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
 
-	CHECK(!hashMapEntrySet_contains(entry_set, NULL));
-	CHECK(!hashMapEntrySet_contains(entry_set, hashMap_getEntry(map, key)));
-	CHECK(!hashMapEntrySet_contains(entry_set, hashMap_getEntry(map, key2)));
+    CHECK(!hashMapEntrySet_contains(entry_set, NULL));
+    CHECK(!hashMapEntrySet_contains(entry_set, hashMap_getEntry(map, key)));
+    CHECK(!hashMapEntrySet_contains(entry_set, hashMap_getEntry(map, key2)));
 
-	hashMap_clear(map, true, true);
-	hashMapEntrySet_destroy(entry_set);
+    hashMap_clear(map, true, true);
+    hashMapEntrySet_destroy(entry_set);
 }
 
 TEST(hash_map_entrySet, remove){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
 
-	entry_set = hashMapEntrySet_create(map);
+    entry_set = hashMapEntrySet_create(map);
 
-	// Add 2 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
+    // Add 2 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
 
-	CHECK(!hashMapEntrySet_remove(entry_set, (hash_map_entry_pt) NULL));
-	LONGS_EQUAL(2, entry_set->map->size);
+    CHECK(!hashMapEntrySet_remove(entry_set, (hash_map_entry_pt) NULL));
+    LONGS_EQUAL(2, entry_set->map->size);
 
-	CHECK(hashMapEntrySet_remove(entry_set, hashMap_getEntry(map, key)));
-	LONGS_EQUAL(1, entry_set->map->size);
+    CHECK(hashMapEntrySet_remove(entry_set, hashMap_getEntry(map, key)));
+    LONGS_EQUAL(1, entry_set->map->size);
 
-	CHECK(hashMapEntrySet_remove(entry_set, hashMap_getEntry(map, key2)));
-	LONGS_EQUAL(0, entry_set->map->size);
+    CHECK(hashMapEntrySet_remove(entry_set, hashMap_getEntry(map, key2)));
+    LONGS_EQUAL(0, entry_set->map->size);
 
-	free(key);
-	free(value);
-	free(key2);
-	free(value2);
-	hashMap_clear(map, false, false);
-	hashMapEntrySet_destroy(entry_set);
+    free(key);
+    free(value);
+    free(key2);
+    free(value2);
+    hashMap_clear(map, false, false);
+    hashMapEntrySet_destroy(entry_set);
 }
 
 TEST(hash_map_entrySet, clear){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
 
-	entry_set = hashMapEntrySet_create(map);
+    entry_set = hashMapEntrySet_create(map);
 
-	// Add 2 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
+    // Add 2 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
 
-	LONGS_EQUAL(2, entry_set->map->size);
+    LONGS_EQUAL(2, entry_set->map->size);
 
-	hashMapEntrySet_clear(entry_set);
+    hashMapEntrySet_clear(entry_set);
 
-	LONGS_EQUAL(0, entry_set->map->size);
+    LONGS_EQUAL(0, entry_set->map->size);
 
-	free(key);
-	free(value);
-	free(key2);
-	free(value2);
-	hashMapEntrySet_destroy(entry_set);
+    free(key);
+    free(value);
+    free(key2);
+    free(value2);
+    hashMapEntrySet_destroy(entry_set);
 }
 
 TEST(hash_map_entrySet, isEmpty){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
 
-	entry_set = hashMapEntrySet_create(map);
+    entry_set = hashMapEntrySet_create(map);
 
-	CHECK(hashMapEntrySet_isEmpty(entry_set));
+    CHECK(hashMapEntrySet_isEmpty(entry_set));
 
-	// Add 2 entries
-	hashMap_put(map, key, value);
-	hashMap_put(map, key2, value2);
+    // Add 2 entries
+    hashMap_put(map, key, value);
+    hashMap_put(map, key2, value2);
 
-	CHECK(!hashMapEntrySet_isEmpty(entry_set));
+    CHECK(!hashMapEntrySet_isEmpty(entry_set));
 
-	hashMapEntrySet_clear(entry_set);
+    hashMapEntrySet_clear(entry_set);
 
-	CHECK(hashMapEntrySet_isEmpty(entry_set));
+    CHECK(hashMapEntrySet_isEmpty(entry_set));
 
-	free(key);
-	free(value);
-	free(key2);
-	free(value2);
-	hashMapEntrySet_destroy(entry_set);
+    free(key);
+    free(value);
+    free(key2);
+    free(value2);
+    hashMapEntrySet_destroy(entry_set);
 }
 
 //----------------------HASH MAP HASH TEST----------------------
 
 TEST(hash_map_hash, get){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * getKey = my_strdup("key");
-	char * get;
-	char * neKey = my_strdup("notExisting");
-	char * key3 = NULL;
-	char * value3 = my_strdup("value3");
-
-	hashMap_clear(map, false, false);
-
-	// Add one entry
-	hashMap_put(map, key, value);
-
-	// Add second entry
-	hashMap_put(map, key2, value2);
-
-	// Get with new created key
-	get = (char*) (char*) hashMap_get(map, getKey);
-	CHECK_C(get != NULL);
-	STRCMP_EQUAL(value, get);
-
-	free(getKey);
-	getKey = my_strdup("key2");
-	get = (char*) hashMap_get(map, getKey);
-	CHECK_C(get != NULL);
-	STRCMP_EQUAL(value2, get);
-
-	get = (char*) hashMap_get(map, neKey);
-	POINTERS_EQUAL(NULL, get);
-
-	get = (char*) hashMap_get(map, NULL);
-	POINTERS_EQUAL(NULL,get);
-
-	// Add third entry with NULL key
-	hashMap_put(map, key3, value3);
-
-	get = (char*) hashMap_get(map, NULL);
-	STRCMP_EQUAL(get, value3);
-
-	free(getKey);
-	free(neKey);
-	hashMap_clear(map, true, true);
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * getKey = my_strdup("key");
+    char * get;
+    char * neKey = my_strdup("notExisting");
+    char * key3 = NULL;
+    char * value3 = my_strdup("value3");
+
+    hashMap_clear(map, false, false);
+
+    // Add one entry
+    hashMap_put(map, key, value);
+
+    // Add second entry
+    hashMap_put(map, key2, value2);
+
+    // Get with new created key
+    get = (char*) (char*) hashMap_get(map, getKey);
+    CHECK_C(get != NULL);
+    STRCMP_EQUAL(value, get);
+
+    free(getKey);
+    getKey = my_strdup("key2");
+    get = (char*) hashMap_get(map, getKey);
+    CHECK_C(get != NULL);
+    STRCMP_EQUAL(value2, get);
+
+    get = (char*) hashMap_get(map, neKey);
+    POINTERS_EQUAL(NULL, get);
+
+    get = (char*) hashMap_get(map, NULL);
+    POINTERS_EQUAL(NULL,get);
+
+    // Add third entry with NULL key
+    hashMap_put(map, key3, value3);
+
+    get = (char*) hashMap_get(map, NULL);
+    STRCMP_EQUAL(get, value3);
+
+    free(getKey);
+    free(neKey);
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map_hash, containsKey) {
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * containsKey = my_strdup("key");
-	char * key3 = NULL;
-	char * value3 = my_strdup("value3");
-
-	hashMap_clear(map, false, false);
-
-	// Add one entry
-	hashMap_put(map, key, value);
-
-	// Add second entry
-	hashMap_put(map, key2, value2);
-
-	CHECK(hashMap_containsKey(map, containsKey));
-	free(containsKey);
-	containsKey = my_strdup("key2");
-	CHECK(hashMap_containsKey(map, containsKey));
-	free(containsKey);
-	containsKey = my_strdup("notExisting");
-	CHECK(!hashMap_containsKey(map, containsKey));
-	free(containsKey);
-	containsKey = NULL;
-	CHECK(!hashMap_containsKey(map, containsKey));
-
-	// Add third entry with NULL key
-	hashMap_put(map, key3, value3);
-
-	containsKey = NULL;
-	CHECK(hashMap_containsKey(map, containsKey));
-
-	hashMap_clear(map, true, true);
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * containsKey = my_strdup("key");
+    char * key3 = NULL;
+    char * value3 = my_strdup("value3");
+
+    hashMap_clear(map, false, false);
+
+    // Add one entry
+    hashMap_put(map, key, value);
+
+    // Add second entry
+    hashMap_put(map, key2, value2);
+
+    CHECK(hashMap_containsKey(map, containsKey));
+    free(containsKey);
+    containsKey = my_strdup("key2");
+    CHECK(hashMap_containsKey(map, containsKey));
+    free(containsKey);
+    containsKey = my_strdup("notExisting");
+    CHECK(!hashMap_containsKey(map, containsKey));
+    free(containsKey);
+    containsKey = NULL;
+    CHECK(!hashMap_containsKey(map, containsKey));
+
+    // Add third entry with NULL key
+    hashMap_put(map, key3, value3);
+
+    containsKey = NULL;
+    CHECK(hashMap_containsKey(map, containsKey));
+
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map_hash, getEntry){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * getEntryKey;
-	char * key3 = NULL;
-	char * value3 = my_strdup("value3");
-	hash_map_entry_pt entry;
-
-	hashMap_clear(map, false, false);
-
-	// Add one entry
-	hashMap_put(map, key, value);
-
-	// Add second entry
-	hashMap_put(map, key2, value2);
-
-	// Get with new created key
-	getEntryKey = my_strdup("key");
-	entry = hashMap_getEntry(map, getEntryKey);
-	CHECK(entry != NULL);
-	STRCMP_EQUAL(key, (char*) entry->key);
-	STRCMP_EQUAL(value, (char*) entry->value);
-
-	free(getEntryKey);
-	getEntryKey = my_strdup("key2");
-	entry = hashMap_getEntry(map, getEntryKey);
-	CHECK(entry != NULL);
-	STRCMP_EQUAL(key2, (char*) entry->key);
-	STRCMP_EQUAL(value2, (char*) entry->value);
-
-	free(getEntryKey);
-	getEntryKey = my_strdup("notExisting");
-	entry = hashMap_getEntry(map, getEntryKey);
-	POINTERS_EQUAL(NULL, entry);
-
-	free(getEntryKey);
-	getEntryKey = NULL;
-	entry = hashMap_getEntry(map, getEntryKey);
-	POINTERS_EQUAL(NULL, entry);
-
-	// Add third entry with NULL key
-	hashMap_put(map, key3, value3);
-
-	getEntryKey = NULL;
-	entry = hashMap_getEntry(map, getEntryKey);
-	CHECK_EQUAL(key3, entry->key);
-	STRCMP_EQUAL(value3, (char*) entry->value);
-
-	hashMap_clear(map, true, true);
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * getEntryKey;
+    char * key3 = NULL;
+    char * value3 = my_strdup("value3");
+    hash_map_entry_pt entry;
+
+    hashMap_clear(map, false, false);
+
+    // Add one entry
+    hashMap_put(map, key, value);
+
+    // Add second entry
+    hashMap_put(map, key2, value2);
+
+    // Get with new created key
+    getEntryKey = my_strdup("key");
+    entry = hashMap_getEntry(map, getEntryKey);
+    CHECK(entry != NULL);
+    STRCMP_EQUAL(key, (char*) entry->key);
+    STRCMP_EQUAL(value, (char*) entry->value);
+
+    free(getEntryKey);
+    getEntryKey = my_strdup("key2");
+    entry = hashMap_getEntry(map, getEntryKey);
+    CHECK(entry != NULL);
+    STRCMP_EQUAL(key2, (char*) entry->key);
+    STRCMP_EQUAL(value2, (char*) entry->value);
+
+    free(getEntryKey);
+    getEntryKey = my_strdup("notExisting");
+    entry = hashMap_getEntry(map, getEntryKey);
+    POINTERS_EQUAL(NULL, entry);
+
+    free(getEntryKey);
+    getEntryKey = NULL;
+    entry = hashMap_getEntry(map, getEntryKey);
+    POINTERS_EQUAL(NULL, entry);
+
+    // Add third entry with NULL key
+    hashMap_put(map, key3, value3);
+
+    getEntryKey = NULL;
+    entry = hashMap_getEntry(map, getEntryKey);
+    CHECK_EQUAL(key3, entry->key);
+    STRCMP_EQUAL(value3, (char*) entry->value);
+
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map_hash, put){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * getKey = my_strdup("key");
-	char * get;
-	char * nkey2 = my_strdup("key2");
-	char * nvalue2 = my_strdup("value3");
-	char * old;
-	char * key3 = NULL;
-	char * value3 = my_strdup("value3");
-	char * key4 = my_strdup("key4");
-	char * value4 = NULL;
-
-	hashMap_clear(map, false, false);
-
-	// Add one entry
-	hashMap_put(map, key, value);
-
-	// Add second entry
-	hashMap_put(map, key2, value2);
-
-	// Get with new key
-	get = (char*) hashMap_get(map, getKey);
-	STRCMP_EQUAL(value, get);
-
-	free(getKey);
-	getKey = my_strdup("key2");
-	get = (char*) hashMap_get(map, getKey);
-	STRCMP_EQUAL(value2, get);
-
-	// Overwrite existing entry
-	old = (char *) hashMap_put(map, nkey2, nvalue2);
-	CHECK(old != NULL);
-	STRCMP_EQUAL(value2, old);
-
-	free(getKey);
-	getKey = my_strdup("key2");
-	get = (char*) hashMap_get(map, key2);
-	STRCMP_EQUAL(nvalue2, get);
-
-	// Add third entry with NULL key
-	hashMap_put(map, key3, value3);
-
-	free(getKey);
-	getKey = NULL;
-	get = (char*) hashMap_get(map, key3);
-	STRCMP_EQUAL(value3, get);
-
-	// Add fourth entry with NULL value
-	hashMap_put(map, key4, value4);
-
-	getKey = my_strdup("key4");
-	get = (char*) hashMap_get(map, key4);
-	CHECK_EQUAL(value4, get);
-
-	free(getKey);
-	free(value2);
-	free(nkey2);
-	hashMap_clear(map, true, true);
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * getKey = my_strdup("key");
+    char * get;
+    char * nkey2 = my_strdup("key2");
+    char * nvalue2 = my_strdup("value3");
+    char * old;
+    char * key3 = NULL;
+    char * value3 = my_strdup("value3");
+    char * key4 = my_strdup("key4");
+    char * value4 = NULL;
+
+    hashMap_clear(map, false, false);
+
+    // Add one entry
+    hashMap_put(map, key, value);
+
+    // Add second entry
+    hashMap_put(map, key2, value2);
+
+    // Get with new key
+    get = (char*) hashMap_get(map, getKey);
+    STRCMP_EQUAL(value, get);
+
+    free(getKey);
+    getKey = my_strdup("key2");
+    get = (char*) hashMap_get(map, getKey);
+    STRCMP_EQUAL(value2, get);
+
+    // Overwrite existing entry
+    old = (char *) hashMap_put(map, nkey2, nvalue2);
+    CHECK(old != NULL);
+    STRCMP_EQUAL(value2, old);
+
+    free(getKey);
+    getKey = my_strdup("key2");
+    get = (char*) hashMap_get(map, key2);
+    STRCMP_EQUAL(nvalue2, get);
+
+    // Add third entry with NULL key
+    hashMap_put(map, key3, value3);
+
+    free(getKey);
+    getKey = NULL;
+    get = (char*) hashMap_get(map, key3);
+    STRCMP_EQUAL(value3, get);
+
+    // Add fourth entry with NULL value
+    hashMap_put(map, key4, value4);
+
+    getKey = my_strdup("key4");
+    get = (char*) hashMap_get(map, key4);
+    CHECK_EQUAL(value4, get);
+
+    free(getKey);
+    free(value2);
+    free(nkey2);
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map_hash, remove){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = NULL;
-	char * value2 = my_strdup("value2");
-	char * removeKey = my_strdup("nonexisting");
-
-	hashMap_clear(map, false, false);
-
-	// Add one entry
-	hashMap_put(map, key, value);
-
-	// Add second entry with null key
-	hashMap_put(map, key2, value2);
-
-	// Remove non-existing entry for map
-	hashMap_remove(map, removeKey);
-	LONGS_EQUAL(2, map->size);
-	CHECK(!hashMap_isEmpty(map));
-
-	// Remove entry with new key
-	free(removeKey);
-	removeKey = my_strdup("key");
-	hashMap_remove(map, removeKey);
-	LONGS_EQUAL(1, map->size);
-
-	free(removeKey);
-	removeKey = NULL;
-	hashMap_remove(map, removeKey);
-	LONGS_EQUAL(0, map->size);
-	CHECK(hashMap_isEmpty(map));
-
-	// Remove non-existing entry for empty map
-	removeKey = my_strdup("nonexisting");
-	hashMap_remove(map, removeKey);
-	LONGS_EQUAL(0, map->size);
-	CHECK(hashMap_isEmpty(map));
-
-	free(removeKey);
-	free(key);
-	free(value);
-	free(value2);
-	hashMap_clear(map, true, true);
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = NULL;
+    char * value2 = my_strdup("value2");
+    char * removeKey = my_strdup("nonexisting");
+
+    hashMap_clear(map, false, false);
+
+    // Add one entry
+    hashMap_put(map, key, value);
+
+    // Add second entry with null key
+    hashMap_put(map, key2, value2);
+
+    // Remove non-existing entry for map
+    hashMap_remove(map, removeKey);
+    LONGS_EQUAL(2, map->size);
+    CHECK(!hashMap_isEmpty(map));
+
+    // Remove entry with new key
+    free(removeKey);
+    removeKey = my_strdup("key");
+    hashMap_remove(map, removeKey);
+    LONGS_EQUAL(1, map->size);
+
+    free(removeKey);
+    removeKey = NULL;
+    hashMap_remove(map, removeKey);
+    LONGS_EQUAL(0, map->size);
+    CHECK(hashMap_isEmpty(map));
+
+    // Remove non-existing entry for empty map
+    removeKey = my_strdup("nonexisting");
+    hashMap_remove(map, removeKey);
+    LONGS_EQUAL(0, map->size);
+    CHECK(hashMap_isEmpty(map));
+
+    free(removeKey);
+    free(key);
+    free(value);
+    free(value2);
+    hashMap_clear(map, true, true);
 }
 
 TEST(hash_map_hash, containsValue){
-	char * key = my_strdup("key");
-	char * value = my_strdup("value");
-	char * key2 = my_strdup("key2");
-	char * value2 = my_strdup("value2");
-	char * containsValue = my_strdup("value");
-	char * key3 = my_strdup("key3");
-	char * value3 = NULL;
-
-	hashMap_clear(map, false, false);
-
-	// Add one entry
-	hashMap_put(map, key, value);
-
-	// Add second entry
-	hashMap_put(map, key2, value2);
-
-	CHECK(hashMap_containsValue(map, containsValue));
-	free(containsValue);
-	containsValue = my_strdup("value2");
-	CHECK(hashMap_containsValue(map, containsValue));
-	free(containsValue);
-	containsValue = my_strdup("notExisting");
-	CHECK(!hashMap_containsValue(map, containsValue));
-	free(containsValue);
-	containsValue = NULL;
-	CHECK(!hashMap_containsValue(map, containsValue));
-
-	// Add third entry with NULL value
-	hashMap_put(map, key3, value3);
-
-	containsValue = NULL;
-	CHECK(hashMap_containsValue(map, containsValue));
-
-	hashMap_clear(map, true, true);
+    char * key = my_strdup("key");
+    char * value = my_strdup("value");
+    char * key2 = my_strdup("key2");
+    char * value2 = my_strdup("value2");
+    char * containsValue = my_strdup("value");
+    char * key3 = my_strdup("key3");
+    char * value3 = NULL;
+
+    hashMap_clear(map, false, false);
+
+    // Add one entry
+    hashMap_put(map, key, value);
+
+    // Add second entry
+    hashMap_put(map, key2, value2);
+
+    CHECK(hashMap_containsValue(map, containsValue));
+    free(containsValue);
+    containsValue = my_strdup("value2");
+    CHECK(hashMap_containsValue(map, containsValue));
+    free(containsValue);
+    containsValue = my_strdup("notExisting");
+    CHECK(!hashMap_containsValue(map, containsValue));
+    free(containsValue);
+    containsValue = NULL;
+    CHECK(!hashMap_containsValue(map, containsValue));
+
+    // Add third entry with NULL value
+    hashMap_put(map, key3, value3);
+
+    containsValue = NULL;
+    CHECK(hashMap_containsValue(map, containsValue));
+
+    hashMap_clear(map, true, true);
 }
diff --git a/libs/utils/private/test/ip_utils_test.cpp b/libs/utils/private/test/ip_utils_test.cpp
index 0a2629d..a7854b5 100644
--- a/libs/utils/private/test/ip_utils_test.cpp
+++ b/libs/utils/private/test/ip_utils_test.cpp
@@ -38,7 +38,7 @@ extern "C"
 }
 
 int main(int argc, char** argv) {
-	return RUN_ALL_TESTS(argc, argv);
+    return RUN_ALL_TESTS(argc, argv);
 }
 
 static char* my_strdup(const char* s){
@@ -59,17 +59,17 @@ static char* my_strdup(const char* s){
 }
 
 TEST_GROUP(ip_utils) {
-	void setup(void) {
-	}
+    void setup(void) {
+    }
 
-	void teardown() {
-	}
+    void teardown() {
+    }
 };
 
 TEST(ip_utils, ipToUnsignedInt){
-	char *ip = my_strdup("192.168.1.64");
+    char *ip = my_strdup("192.168.1.64");
 
-	unsigned int expected = 3232235840;
+    unsigned int expected = 3232235840;
     unsigned int actual = ipUtils_ipToUnsignedInt(ip);
     UNSIGNED_LONGS_EQUAL(expected, actual);
 
diff --git a/libs/utils/private/test/linked_list_test.cpp b/libs/utils/private/test/linked_list_test.cpp
index 1df971b..059290e 100644
--- a/libs/utils/private/test/linked_list_test.cpp
+++ b/libs/utils/private/test/linked_list_test.cpp
@@ -1,28 +1,29 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * linked_list_test.cpp
  *
- * 	\date       Sep 15, 2015
- *  \author    	Menno van der Graaf
- *  \copyright	Apache License, Version 2.0
+ *  \date       Sep 15, 2015
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
+
 #include <stdio.h>
 #include <stddef.h>
 #include <string.h>
@@ -39,756 +40,756 @@ extern "C"
 }
 
 int main(int argc, char** argv) {
-	return RUN_ALL_TESTS(argc, argv);
+    return RUN_ALL_TESTS(argc, argv);
 }
 
 static char* my_strdup(const char* s){
-	char *d = (char*) malloc (strlen (s) + 1);
-	if (d == NULL) return NULL;
-	strcpy (d,s);
-	return d;
+    char *d = (char*) malloc (strlen (s) + 1);
+    if (d == NULL) return NULL;
+    strcpy (d,s);
+    return d;
 }
 
 //----------------------TESTGROUP DEFINES----------------------
 
 TEST_GROUP(linked_list){
-	linked_list_pt list;
+    linked_list_pt list;
 
-	void setup(void) {
-		linkedList_create(&list);
-	}
+    void setup(void) {
+        linkedList_create(&list);
+    }
 
-	void teardown(void) {
-		linkedList_destroy(list);
-	}
+    void teardown(void) {
+        linkedList_destroy(list);
+    }
 };
 
 TEST_GROUP(linked_list_iterator){
-	linked_list_pt list;
+    linked_list_pt list;
 
-	void setup(void) {
-		linkedList_create(&list);
-	}
+    void setup(void) {
+        linkedList_create(&list);
+    }
 
-	void teardown(void) {
-		linkedList_destroy(list);
-	}
+    void teardown(void) {
+        linkedList_destroy(list);
+    }
 };
 
 //----------------------LINKED LIST TESTS----------------------
 
 TEST(linked_list, create){
-	CHECK(list != NULL);
-	LONGS_EQUAL(0, linkedList_size(list));
+    CHECK(list != NULL);
+    LONGS_EQUAL(0, linkedList_size(list));
 }
 
 TEST(linked_list, add){
-	char * value = my_strdup("element");
+    char * value = my_strdup("element");
 
-	LONGS_EQUAL(0, linkedList_size(list));
-	linkedList_addElement(list, value);
-	LONGS_EQUAL(1, linkedList_size(list));
+    LONGS_EQUAL(0, linkedList_size(list));
+    linkedList_addElement(list, value);
+    LONGS_EQUAL(1, linkedList_size(list));
 
-	free(value);
+    free(value);
 }
 
 TEST(linked_list, addFirst){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
 
-	STRCMP_EQUAL(value, (char*) linkedList_getFirst(list));
+    STRCMP_EQUAL(value, (char*) linkedList_getFirst(list));
 
-	linkedList_addFirst(list, value3);
+    linkedList_addFirst(list, value3);
 
-	STRCMP_EQUAL(value3, (char*) linkedList_getFirst(list));
+    STRCMP_EQUAL(value3, (char*) linkedList_getFirst(list));
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 TEST(linked_list, addLast){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
 
-	STRCMP_EQUAL(value2, (char*) linkedList_getLast(list));
+    STRCMP_EQUAL(value2, (char*) linkedList_getLast(list));
 
-	linkedList_addLast(list, value3);
+    linkedList_addLast(list, value3);
 
-	STRCMP_EQUAL(value3, (char*) linkedList_getLast(list));
+    STRCMP_EQUAL(value3, (char*) linkedList_getLast(list));
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 TEST(linked_list, addIndex){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
-	char * value4 = my_strdup("element4");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
+    char * value4 = my_strdup("element4");
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
 
-	STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
+    STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
 
-	linkedList_addIndex(list, 2, value4);
+    linkedList_addIndex(list, 2, value4);
 
-	STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
-	STRCMP_EQUAL(value4, (char*) linkedList_get(list, 2));
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 3));
+    STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
+    STRCMP_EQUAL(value4, (char*) linkedList_get(list, 2));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 3));
 
-	free(value);
-	free(value2);
-	free(value3);
-	free(value4);
+    free(value);
+    free(value2);
+    free(value3);
+    free(value4);
 }
 
 TEST(linked_list, addBefore){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
-	char * value4 = my_strdup("element4");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
+    char * value4 = my_strdup("element4");
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
 
-	STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
+    STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
 
-	linkedList_addBefore(list, value4, linkedList_entry(list, 2));
+    linkedList_addBefore(list, value4, linkedList_entry(list, 2));
 
-	STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
-	STRCMP_EQUAL(value4, (char*) linkedList_get(list, 2));
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 3));
+    STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
+    STRCMP_EQUAL(value4, (char*) linkedList_get(list, 2));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 3));
 
-	free(value);
-	free(value2);
-	free(value3);
-	free(value4);
+    free(value);
+    free(value2);
+    free(value3);
+    free(value4);
 }
 
 TEST(linked_list, remove){
-	char * value = strdup("element");
+    char * value = strdup("element");
 
-	LONGS_EQUAL(0, linkedList_size(list));
-	linkedList_addElement(list, value);
-	LONGS_EQUAL(1, linkedList_size(list));
+    LONGS_EQUAL(0, linkedList_size(list));
+    linkedList_addElement(list, value);
+    LONGS_EQUAL(1, linkedList_size(list));
 
-	linkedList_removeElement(list, value);
-	LONGS_EQUAL(0, linkedList_size(list));
+    linkedList_removeElement(list, value);
+    LONGS_EQUAL(0, linkedList_size(list));
 
-	free(value);
+    free(value);
 }
 
 TEST(linked_list, removeFirst){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
 
-	STRCMP_EQUAL(value, (char*) linkedList_getFirst(list));
+    STRCMP_EQUAL(value, (char*) linkedList_getFirst(list));
 
-	linkedList_removeFirst(list);
+    linkedList_removeFirst(list);
 
-	STRCMP_EQUAL(value2, (char*) linkedList_getFirst(list));
+    STRCMP_EQUAL(value2, (char*) linkedList_getFirst(list));
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 TEST(linked_list, removeLast){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
 
-	STRCMP_EQUAL(value3, (char*) linkedList_getLast(list));
+    STRCMP_EQUAL(value3, (char*) linkedList_getLast(list));
 
-	linkedList_removeLast(list);
+    linkedList_removeLast(list);
 
-	STRCMP_EQUAL(value2, (char*) linkedList_getLast(list));
+    STRCMP_EQUAL(value2, (char*) linkedList_getLast(list));
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 TEST(linked_list, removeElement){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	//add 6 elements
-	linkedList_addElement(list, NULL);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, NULL);
-	linkedList_addElement(list, value3);
-	LONGS_EQUAL(6, list->size);
+    //add 6 elements
+    linkedList_addElement(list, NULL);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, NULL);
+    linkedList_addElement(list, value3);
+    LONGS_EQUAL(6, list->size);
 
-	linkedList_removeElement(list, NULL);
-	linkedList_removeElement(list, NULL);
-	LONGS_EQUAL(4, list->size);
+    linkedList_removeElement(list, NULL);
+    linkedList_removeElement(list, NULL);
+    LONGS_EQUAL(4, list->size);
 
-	linkedList_removeElement(list, value2);
-	LONGS_EQUAL(3, list->size);
+    linkedList_removeElement(list, value2);
+    LONGS_EQUAL(3, list->size);
 
-	STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
-	STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
+    STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
+    STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 TEST(linked_list, removeIndex){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
 
-	STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
+    STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
 
-	linkedList_removeIndex(list, 1);
+    linkedList_removeIndex(list, 1);
 
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 1));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 1));
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 TEST(linked_list, removeEntry){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
 
-	linkedList_removeEntry(list, list->header);
-	LONGS_EQUAL(3, list->size);
+    linkedList_removeEntry(list, list->header);
+    LONGS_EQUAL(3, list->size);
 
-	linkedList_removeEntry(list, linkedList_entry(list, 0));
-	LONGS_EQUAL(2, list->size);
+    linkedList_removeEntry(list, linkedList_entry(list, 0));
+    LONGS_EQUAL(2, list->size);
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 TEST(linked_list, clone){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
-	linked_list_pt list2;
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
+    linked_list_pt list2;
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
 
-	linkedList_clone(list, &list2);
-	LONGS_EQUAL(list->size, list2->size);
-	STRCMP_EQUAL( (char*) linkedList_getFirst(list), (char*) linkedList_getFirst(list2));
-	STRCMP_EQUAL( (char*) linkedList_getLast(list), (char*) linkedList_getLast(list2));
+    linkedList_clone(list, &list2);
+    LONGS_EQUAL(list->size, list2->size);
+    STRCMP_EQUAL( (char*) linkedList_getFirst(list), (char*) linkedList_getFirst(list2));
+    STRCMP_EQUAL( (char*) linkedList_getLast(list), (char*) linkedList_getLast(list2));
 
-	free(value);
-	free(value2);
-	free(value3);
-	linkedList_destroy(list2);
+    free(value);
+    free(value2);
+    free(value3);
+    linkedList_destroy(list2);
 }
 
 TEST(linked_list, clear){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
-	LONGS_EQUAL(3, list->size);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
+    LONGS_EQUAL(3, list->size);
 
-	linkedList_clear(list);
-	LONGS_EQUAL(0, list->size);
+    linkedList_clear(list);
+    LONGS_EQUAL(0, list->size);
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 TEST(linked_list, get){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
 
-	STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
-	STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
+    STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
+    STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 TEST(linked_list, getFirst){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
 
-	STRCMP_EQUAL(value, (char*) linkedList_getFirst(list));
+    STRCMP_EQUAL(value, (char*) linkedList_getFirst(list));
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 TEST(linked_list, getLast){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
 
-	STRCMP_EQUAL(value3, (char*) linkedList_getLast(list));
+    STRCMP_EQUAL(value3, (char*) linkedList_getLast(list));
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 TEST(linked_list, set){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
 
-	STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
-	STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
+    STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
+    STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
 
-	linkedList_set(list, 1, value3);
+    linkedList_set(list, 1, value3);
 
-	STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 1));
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
+    STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 1));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 TEST(linked_list, contains){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	linkedList_addElement(list, value);
-	CHECK(linkedList_contains(list, value));
-	CHECK(!linkedList_contains(list, value2));
-	CHECK(!linkedList_contains(list, value3));
+    linkedList_addElement(list, value);
+    CHECK(linkedList_contains(list, value));
+    CHECK(!linkedList_contains(list, value2));
+    CHECK(!linkedList_contains(list, value3));
 
-	linkedList_addElement(list, value2);
-	CHECK(linkedList_contains(list, value));
-	CHECK(linkedList_contains(list, value2));
-	CHECK(!linkedList_contains(list, value3));
+    linkedList_addElement(list, value2);
+    CHECK(linkedList_contains(list, value));
+    CHECK(linkedList_contains(list, value2));
+    CHECK(!linkedList_contains(list, value3));
 
-	linkedList_addElement(list, value3);
-	CHECK(linkedList_contains(list, value));
-	CHECK(linkedList_contains(list, value2));
-	CHECK(linkedList_contains(list, value3));
+    linkedList_addElement(list, value3);
+    CHECK(linkedList_contains(list, value));
+    CHECK(linkedList_contains(list, value2));
+    CHECK(linkedList_contains(list, value3));
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 TEST(linked_list, size){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	LONGS_EQUAL(0, linkedList_size(list));
+    LONGS_EQUAL(0, linkedList_size(list));
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
 
-	LONGS_EQUAL(3, linkedList_size(list));
+    LONGS_EQUAL(3, linkedList_size(list));
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 TEST(linked_list, isEmpty){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	CHECK(linkedList_isEmpty(list));
+    CHECK(linkedList_isEmpty(list));
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
-	CHECK(!linkedList_isEmpty(list));
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
+    CHECK(!linkedList_isEmpty(list));
 
-	linkedList_clear(list);
-	CHECK(linkedList_isEmpty(list));
+    linkedList_clear(list);
+    CHECK(linkedList_isEmpty(list));
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 TEST(linked_list, entry){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
-	char * value4 = my_strdup("element4");
-	char * value5 = my_strdup("element5");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
+    char * value4 = my_strdup("element4");
+    char * value5 = my_strdup("element5");
 
-	POINTERS_EQUAL(NULL, linkedList_entry(list, 666));
+    POINTERS_EQUAL(NULL, linkedList_entry(list, 666));
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
-	linkedList_addElement(list, value4);
-	linkedList_addElement(list, value5);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
+    linkedList_addElement(list, value4);
+    linkedList_addElement(list, value5);
 
-	STRCMP_EQUAL(value2, (char*) linkedList_entry(list, 1)->element);
-	STRCMP_EQUAL(value4, (char*) linkedList_entry(list, 3)->element);
+    STRCMP_EQUAL(value2, (char*) linkedList_entry(list, 1)->element);
+    STRCMP_EQUAL(value4, (char*) linkedList_entry(list, 3)->element);
 
-	free(value);
-	free(value2);
-	free(value3);
-	free(value4);
-	free(value5);
+    free(value);
+    free(value2);
+    free(value3);
+    free(value4);
+    free(value5);
 }
 
 TEST(linked_list, indexOf){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
 
-	LONGS_EQUAL(-1, linkedList_indexOf(list, value));
-	LONGS_EQUAL(-1, linkedList_indexOf(list, value2));
-	LONGS_EQUAL(-1, linkedList_indexOf(list, value3));
-	LONGS_EQUAL(-1, linkedList_indexOf(list, NULL));
+    LONGS_EQUAL(-1, linkedList_indexOf(list, value));
+    LONGS_EQUAL(-1, linkedList_indexOf(list, value2));
+    LONGS_EQUAL(-1, linkedList_indexOf(list, value3));
+    LONGS_EQUAL(-1, linkedList_indexOf(list, NULL));
 
-	linkedList_addElement(list, value);
-	LONGS_EQUAL(0, linkedList_indexOf(list, value));
+    linkedList_addElement(list, value);
+    LONGS_EQUAL(0, linkedList_indexOf(list, value));
 
-	linkedList_addElement(list, value2);
-	LONGS_EQUAL(1, linkedList_indexOf(list, value2));
+    linkedList_addElement(list, value2);
+    LONGS_EQUAL(1, linkedList_indexOf(list, value2));
 
-	linkedList_addElement(list, value3);
-	LONGS_EQUAL(2, linkedList_indexOf(list, value3));
+    linkedList_addElement(list, value3);
+    LONGS_EQUAL(2, linkedList_indexOf(list, value3));
 
-	linkedList_addElement(list, NULL);
-	LONGS_EQUAL(3, linkedList_indexOf(list, NULL));
+    linkedList_addElement(list, NULL);
+    LONGS_EQUAL(3, linkedList_indexOf(list, NULL));
 
-	free(value);
-	free(value2);
-	free(value3);
+    free(value);
+    free(value2);
+    free(value3);
 }
 
 //----------------------LINKED LIST ITERATOR TESTS----------------------
 
 TEST(linked_list_iterator, create){
-	linked_list_iterator_pt it_list = linkedListIterator_create(list,0);
-	CHECK(it_list != NULL);
-	linkedListIterator_destroy(it_list);
+    linked_list_iterator_pt it_list = linkedListIterator_create(list,0);
+    CHECK(it_list != NULL);
+    linkedListIterator_destroy(it_list);
 
-	it_list = linkedListIterator_create(list,666);
-	POINTERS_EQUAL(NULL, it_list);
+    it_list = linkedListIterator_create(list,666);
+    POINTERS_EQUAL(NULL, it_list);
 }
 
 TEST(linked_list_iterator, hasNext){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
-	linked_list_iterator_pt it_list;
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
+    linked_list_iterator_pt it_list;
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
 
-	it_list = linkedListIterator_create(list, 0);
-	CHECK(linkedListIterator_hasNext(it_list));
+    it_list = linkedListIterator_create(list, 0);
+    CHECK(linkedListIterator_hasNext(it_list));
 
-	linkedListIterator_next(it_list);
-	CHECK(linkedListIterator_hasNext(it_list));
+    linkedListIterator_next(it_list);
+    CHECK(linkedListIterator_hasNext(it_list));
 
-	linkedListIterator_next(it_list);
-	CHECK(linkedListIterator_hasNext(it_list));
+    linkedListIterator_next(it_list);
+    CHECK(linkedListIterator_hasNext(it_list));
 
-	linkedListIterator_next(it_list);
-	CHECK(!linkedListIterator_hasNext(it_list));
+    linkedListIterator_next(it_list);
+    CHECK(!linkedListIterator_hasNext(it_list));
 
-	free(value);
-	free(value2);
-	free(value3);
-	linkedListIterator_destroy(it_list);
+    free(value);
+    free(value2);
+    free(value3);
+    linkedListIterator_destroy(it_list);
 }
 
 TEST(linked_list_iterator, hasPrevious){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
-	linked_list_iterator_pt it_list;
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
+    linked_list_iterator_pt it_list;
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
 
-	it_list = linkedListIterator_create(list, 3);
-	CHECK(linkedListIterator_hasPrevious(it_list));
+    it_list = linkedListIterator_create(list, 3);
+    CHECK(linkedListIterator_hasPrevious(it_list));
 
-	linkedListIterator_previous(it_list);
-	CHECK(linkedListIterator_hasPrevious(it_list));
+    linkedListIterator_previous(it_list);
+    CHECK(linkedListIterator_hasPrevious(it_list));
 
-	linkedListIterator_previous(it_list);
-	CHECK(linkedListIterator_hasPrevious(it_list));
+    linkedListIterator_previous(it_list);
+    CHECK(linkedListIterator_hasPrevious(it_list));
 
-	linkedListIterator_previous(it_list);
-	CHECK(!linkedListIterator_hasPrevious(it_list));
+    linkedListIterator_previous(it_list);
+    CHECK(!linkedListIterator_hasPrevious(it_list));
 
-	free(value);
-	free(value2);
-	free(value3);
-	linkedListIterator_destroy(it_list);
+    free(value);
+    free(value2);
+    free(value3);
+    linkedListIterator_destroy(it_list);
 }
 
 TEST(linked_list_iterator, next){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
-	linked_list_iterator_pt it_list;
-
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
-	it_list = linkedListIterator_create(list, 0);
-	STRCMP_EQUAL(value, (char*) linkedListIterator_next(it_list));
-	STRCMP_EQUAL(value2, (char*) linkedListIterator_next(it_list));
-	STRCMP_EQUAL(value3, (char*) linkedListIterator_next(it_list));
-	POINTERS_EQUAL(NULL, linkedListIterator_next(it_list));
-
-	//mess up the expected and real changecount, code should check and handle
-	linkedList_addElement(list, value);
-	linkedListIterator_next(it_list);
-
-	free(value);
-	free(value2);
-	free(value3);
-	linkedListIterator_destroy(it_list);
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
+    linked_list_iterator_pt it_list;
+
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
+    it_list = linkedListIterator_create(list, 0);
+    STRCMP_EQUAL(value, (char*) linkedListIterator_next(it_list));
+    STRCMP_EQUAL(value2, (char*) linkedListIterator_next(it_list));
+    STRCMP_EQUAL(value3, (char*) linkedListIterator_next(it_list));
+    POINTERS_EQUAL(NULL, linkedListIterator_next(it_list));
+
+    //mess up the expected and real changecount, code should check and handle
+    linkedList_addElement(list, value);
+    linkedListIterator_next(it_list);
+
+    free(value);
+    free(value2);
+    free(value3);
+    linkedListIterator_destroy(it_list);
 }
 
 TEST(linked_list_iterator, previous){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
-	linked_list_iterator_pt it_list;
-
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
-	it_list = linkedListIterator_create(list, 3);
-	STRCMP_EQUAL(value3, (char*) linkedListIterator_previous(it_list));
-	STRCMP_EQUAL(value2, (char*) linkedListIterator_previous(it_list));
-	STRCMP_EQUAL(value, (char*) linkedListIterator_previous(it_list));
-	POINTERS_EQUAL(NULL, linkedListIterator_previous(it_list));
-
-	//mess up the expected and real changecount, code should check and handle
-	linkedListIterator_destroy(it_list);
-	it_list = linkedListIterator_create(list, 3);
-	linkedList_addElement(list, value);
-	linkedListIterator_previous(it_list);
-
-	free(value);
-	free(value2);
-	free(value3);
-	linkedListIterator_destroy(it_list);
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
+    linked_list_iterator_pt it_list;
+
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
+    it_list = linkedListIterator_create(list, 3);
+    STRCMP_EQUAL(value3, (char*) linkedListIterator_previous(it_list));
+    STRCMP_EQUAL(value2, (char*) linkedListIterator_previous(it_list));
+    STRCMP_EQUAL(value, (char*) linkedListIterator_previous(it_list));
+    POINTERS_EQUAL(NULL, linkedListIterator_previous(it_list));
+
+    //mess up the expected and real changecount, code should check and handle
+    linkedListIterator_destroy(it_list);
+    it_list = linkedListIterator_create(list, 3);
+    linkedList_addElement(list, value);
+    linkedListIterator_previous(it_list);
+
+    free(value);
+    free(value2);
+    free(value3);
+    linkedListIterator_destroy(it_list);
 }
 
 TEST(linked_list_iterator, nextIndex){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
-	linked_list_iterator_pt it_list;
-
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
-	it_list = linkedListIterator_create(list, 0);
-	LONGS_EQUAL(0, linkedListIterator_nextIndex(it_list));
-	linkedListIterator_next(it_list);
-	LONGS_EQUAL(1, linkedListIterator_nextIndex(it_list));
-	linkedListIterator_next(it_list);
-	LONGS_EQUAL(2, linkedListIterator_nextIndex(it_list));
-
-	free(value);
-	free(value2);
-	free(value3);
-	linkedListIterator_destroy(it_list);
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
+    linked_list_iterator_pt it_list;
+
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
+    it_list = linkedListIterator_create(list, 0);
+    LONGS_EQUAL(0, linkedListIterator_nextIndex(it_list));
+    linkedListIterator_next(it_list);
+    LONGS_EQUAL(1, linkedListIterator_nextIndex(it_list));
+    linkedListIterator_next(it_list);
+    LONGS_EQUAL(2, linkedListIterator_nextIndex(it_list));
+
+    free(value);
+    free(value2);
+    free(value3);
+    linkedListIterator_destroy(it_list);
 }
 
 TEST(linked_list_iterator, previousIndex){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
-	linked_list_iterator_pt it_list;
-
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
-	it_list = linkedListIterator_create(list, 3);
-	LONGS_EQUAL(2, linkedListIterator_previousIndex(it_list));
-	linkedListIterator_previous(it_list);
-	LONGS_EQUAL(1, linkedListIterator_previousIndex(it_list));
-	linkedListIterator_previous(it_list);
-	LONGS_EQUAL(0, linkedListIterator_previousIndex(it_list));
-
-	free(value);
-	free(value2);
-	free(value3);
-	linkedListIterator_destroy(it_list);
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
+    linked_list_iterator_pt it_list;
+
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
+    it_list = linkedListIterator_create(list, 3);
+    LONGS_EQUAL(2, linkedListIterator_previousIndex(it_list));
+    linkedListIterator_previous(it_list);
+    LONGS_EQUAL(1, linkedListIterator_previousIndex(it_list));
+    linkedListIterator_previous(it_list);
+    LONGS_EQUAL(0, linkedListIterator_previousIndex(it_list));
+
+    free(value);
+    free(value2);
+    free(value3);
+    linkedListIterator_destroy(it_list);
 }
 
 TEST(linked_list_iterator, set){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
-	linked_list_iterator_pt it_list;
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
+    linked_list_iterator_pt it_list;
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
-	it_list = linkedListIterator_create(list, 0);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
+    it_list = linkedListIterator_create(list, 0);
 
-	STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
-	STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
+    STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
+    STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
 
-	linkedListIterator_set(it_list, NULL);
-	linkedListIterator_next(it_list);
-	linkedListIterator_next(it_list);
-	linkedListIterator_set(it_list, value3);
-	linkedListIterator_next(it_list);
-	linkedListIterator_set(it_list, value2);
+    linkedListIterator_set(it_list, NULL);
+    linkedListIterator_next(it_list);
+    linkedListIterator_next(it_list);
+    linkedListIterator_set(it_list, value3);
+    linkedListIterator_next(it_list);
+    linkedListIterator_set(it_list, value2);
 
-	STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 1));
-	STRCMP_EQUAL(value2, (char*) linkedList_get(list, 2));
+    STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 1));
+    STRCMP_EQUAL(value2, (char*) linkedList_get(list, 2));
 
-	//mess up the expected and real changecount, code should check and handle
-	linkedList_addElement(list, value);
-	linkedListIterator_set(it_list, value);
+    //mess up the expected and real changecount, code should check and handle
+    linkedList_addElement(list, value);
+    linkedListIterator_set(it_list, value);
 
-	free(value);
-	free(value2);
-	free(value3);
-	linkedListIterator_destroy(it_list);
+    free(value);
+    free(value2);
+    free(value3);
+    linkedListIterator_destroy(it_list);
 }
 
 TEST(linked_list_iterator, add){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
-	linked_list_iterator_pt it_list;
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
+    linked_list_iterator_pt it_list;
 
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value3);
-	it_list = linkedListIterator_create(list, 0);
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value3);
+    it_list = linkedListIterator_create(list, 0);
 
-	STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 1));
+    STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 1));
 
-	linkedListIterator_next(it_list);
-	linkedListIterator_add(it_list, value2);
+    linkedListIterator_next(it_list);
+    linkedListIterator_add(it_list, value2);
 
-	STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
-	STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
+    STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
+    STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
 
-	//mess up the expected and real changecount, code should check and handle
-	linkedList_addElement(list, value);
-	linkedListIterator_add(it_list, value2);
+    //mess up the expected and real changecount, code should check and handle
+    linkedList_addElement(list, value);
+    linkedListIterator_add(it_list, value2);
 
-	free(value);
-	free(value2);
-	free(value3);
-	linkedListIterator_destroy(it_list);
+    free(value);
+    free(value2);
+    free(value3);
+    linkedListIterator_destroy(it_list);
 }
 
 TEST(linked_list_iterator, remove){
-	char * value = my_strdup("element");
-	char * value2 = my_strdup("element2");
-	char * value3 = my_strdup("element3");
-	linked_list_iterator_pt it_list;
-
-	linkedList_addElement(list, value);
-	linkedList_addElement(list, value2);
-	linkedList_addElement(list, value3);
-	it_list = linkedListIterator_create(list, 0);
-
-	LONGS_EQUAL(3, list->size);
-	STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
-	STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
-
-	linkedListIterator_next(it_list);
-	linkedListIterator_next(it_list);
-	linkedListIterator_remove(it_list);
-	LONGS_EQUAL(2, list->size);
-	STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
-	STRCMP_EQUAL(value3, (char*) linkedList_get(list, 1));
-
-	//mess up the expected and real changecount, code should check and handle
-	linkedList_addElement(list, value);
-	linkedListIterator_remove(it_list);
-
-	free(value);
-	free(value2);
-	free(value3);
-	linkedListIterator_destroy(it_list);
+    char * value = my_strdup("element");
+    char * value2 = my_strdup("element2");
+    char * value3 = my_strdup("element3");
+    linked_list_iterator_pt it_list;
+
+    linkedList_addElement(list, value);
+    linkedList_addElement(list, value2);
+    linkedList_addElement(list, value3);
+    it_list = linkedListIterator_create(list, 0);
+
+    LONGS_EQUAL(3, list->size);
+    STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
+    STRCMP_EQUAL(value2, (char*) linkedList_get(list, 1));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 2));
+
+    linkedListIterator_next(it_list);
+    linkedListIterator_next(it_list);
+    linkedListIterator_remove(it_list);
+    LONGS_EQUAL(2, list->size);
+    STRCMP_EQUAL(value, (char*) linkedList_get(list, 0));
+    STRCMP_EQUAL(value3, (char*) linkedList_get(list, 1));
+
+    //mess up the expected and real changecount, code should check and handle
+    linkedList_addElement(list, value);
+    linkedListIterator_remove(it_list);
+
+    free(value);
+    free(value2);
+    free(value3);
+    linkedListIterator_destroy(it_list);
 }
diff --git a/libs/utils/private/test/properties_test.cpp b/libs/utils/private/test/properties_test.cpp
index e2f2134..95bf379 100644
--- a/libs/utils/private/test/properties_test.cpp
+++ b/libs/utils/private/test/properties_test.cpp
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * properties_test.cpp
@@ -37,205 +37,204 @@ extern "C" {
 }
 
 int main(int argc, char** argv) {
-	return RUN_ALL_TESTS(argc, argv);
+    return RUN_ALL_TESTS(argc, argv);
 }
 
 TEST_GROUP(properties) {
-	properties_pt properties;
+    celix_properties_t *properties;
 
-	void setup(void) {
-	}
+    void setup(void) {
+    }
 
-	void teardown() {
-		mock().checkExpectations();
-		mock().clear();
-	}
+    void teardown() {
+        mock().checkExpectations();
+        mock().clear();
+    }
 };
 
 TEST(properties, create) {
-	properties = properties_create();
-	CHECK(properties);
+    properties = celix_properties_create();
+    CHECK(properties);
 
-	properties_destroy(properties);
+    celix_properties_destroy(properties);
 }
 
 TEST(properties, load) {
-	char propertiesFile[] = "resources-test/properties.txt";
-	properties = properties_load(propertiesFile);
-	LONGS_EQUAL(4, hashMap_size(properties));
+    char propertiesFile[] = "resources-test/properties.txt";
+    properties = celix_properties_load(propertiesFile);
+    LONGS_EQUAL(4, hashMap_size(properties));
 
-	const char keyA[] = "a";
-	const char *valueA = properties_get(properties, keyA);
-	STRCMP_EQUAL("b", valueA);
+    const char keyA[] = "a";
+    const char *valueA = celix_properties_get(properties, keyA, NULL);
+    STRCMP_EQUAL("b", valueA);
 
-	const char keyNiceA[] = "nice_a";
-	const char *valueNiceA = properties_get(properties, keyNiceA);
-	STRCMP_EQUAL("nice_b", valueNiceA);
+    const char keyNiceA[] = "nice_a";
+    const char *valueNiceA = celix_properties_get(properties, keyNiceA, NULL);
+    STRCMP_EQUAL("nice_b", valueNiceA);
 
-	const char keyB[] = "b";
-	const char *valueB = properties_get(properties, keyB);
-	STRCMP_EQUAL("c \t d", valueB);
+    const char keyB[] = "b";
+    const char *valueB = celix_properties_get(properties, keyB, NULL);
+    STRCMP_EQUAL("c \t d", valueB);
 
-	properties_destroy(properties);
+    celix_properties_destroy(properties);
 }
 
 TEST(properties, asLong) {
-	celix_properties_t *props = celix_properties_create();
-	celix_properties_set(props, "t1", "42");
-	celix_properties_set(props, "t2", "-42");
-	celix_properties_set(props, "t3", "");
-	celix_properties_set(props, "t4", "42 bla"); //converts to 42
-	celix_properties_set(props, "t5", "bla");
+    celix_properties_t *props = celix_properties_create();
+    celix_properties_set(props, "t1", "42");
+    celix_properties_set(props, "t2", "-42");
+    celix_properties_set(props, "t3", "");
+    celix_properties_set(props, "t4", "42 bla"); //converts to 42
+    celix_properties_set(props, "t5", "bla");
 
-	long v = celix_properties_getAsLong(props, "t1", -1);
-	LONGS_EQUAL(42, v);
+    long v = celix_properties_getAsLong(props, "t1", -1);
+    LONGS_EQUAL(42, v);
 
-	v = celix_properties_getAsLong(props, "t2", -1);
-	LONGS_EQUAL(-42, v);
+    v = celix_properties_getAsLong(props, "t2", -1);
+    LONGS_EQUAL(-42, v);
 
-	v = celix_properties_getAsLong(props, "t3", -1);
-	LONGS_EQUAL(-1, v);
+    v = celix_properties_getAsLong(props, "t3", -1);
+    LONGS_EQUAL(-1, v);
 
-	v = celix_properties_getAsLong(props, "t4", -1);
-	LONGS_EQUAL(42, v);
+    v = celix_properties_getAsLong(props, "t4", -1);
+    LONGS_EQUAL(42, v);
 
-	v = celix_properties_getAsLong(props, "t5", -1);
-	LONGS_EQUAL(-1, v);
+    v = celix_properties_getAsLong(props, "t5", -1);
+    LONGS_EQUAL(-1, v);
 
-	v = celix_properties_getAsLong(props, "non-existing", -1);
-	LONGS_EQUAL(-1, v);
+    v = celix_properties_getAsLong(props, "non-existing", -1);
+    LONGS_EQUAL(-1, v);
 
-	celix_properties_destroy(props);
+    celix_properties_destroy(props);
 }
 
 TEST(properties, store) {
-	char propertiesFile[] = "resources-test/properties_out.txt";
-	properties = properties_create();
-	char keyA[] = "x";
-	char keyB[] = "y";
-	char valueA[] = "1";
-	char valueB[] = "2";
-	properties_set(properties, keyA, valueA);
-	properties_set(properties, keyB, valueB);
-	properties_store(properties, propertiesFile, NULL);
-
-	properties_destroy(properties);
+    char propertiesFile[] = "resources-test/properties_out.txt";
+    properties = celix_properties_create();
+    char keyA[] = "x";
+    char keyB[] = "y";
+    char valueA[] = "1";
+    char valueB[] = "2";
+    celix_properties_set(properties, keyA, valueA);
+    celix_properties_set(properties, keyB, valueB);
+    celix_properties_store(properties, propertiesFile, NULL);
+
+    celix_properties_destroy(properties);
 }
 
 TEST(properties, copy) {
-	properties_pt copy;
-	char propertiesFile[] = "resources-test/properties.txt";
-	properties = properties_load(propertiesFile);
-	LONGS_EQUAL(4, hashMap_size(properties));
+    char propertiesFile[] = "resources-test/properties.txt";
+    properties = celix_properties_load(propertiesFile);
+    LONGS_EQUAL(4, hashMap_size(properties));
 
-	properties_copy(properties, &copy);
+    celix_properties_t *copy = celix_properties_copy(properties);
 
-	char keyA[] = "a";
-	const char *valueA = properties_get(copy, keyA);
-	STRCMP_EQUAL("b", valueA);
-	const char keyB[] = "b";
-	STRCMP_EQUAL("c \t d", properties_get(copy, keyB));
+    char keyA[] = "a";
+    const char *valueA = celix_properties_get(copy, keyA, NULL);
+    STRCMP_EQUAL("b", valueA);
+    const char keyB[] = "b";
+    STRCMP_EQUAL("c \t d", celix_properties_get(copy, keyB, NULL));
 
-	properties_destroy(properties);
-	properties_destroy(copy);
+    celix_properties_destroy(properties);
+    celix_properties_destroy(copy);
 }
 
 TEST(properties, getSet) {
-	properties = properties_create();
-	char keyA[] = "x";
-	char keyB[] = "y";
-	char keyC[] = "z";
-	char valueA[] = "1";
-	char valueB[] = "2";
-	char valueC[] = "3";
-	properties_set(properties, keyA, valueA);
-	properties_set(properties, keyB, valueB);
-
-	STRCMP_EQUAL(valueA, properties_get(properties, keyA));
-	STRCMP_EQUAL(valueB, properties_get(properties, keyB));
-	STRCMP_EQUAL(valueC, properties_getWithDefault(properties, keyC, valueC));
-
-	properties_destroy(properties);
+    properties = celix_properties_create();
+    char keyA[] = "x";
+    char keyB[] = "y";
+    char keyC[] = "z";
+    char valueA[] = "1";
+    char valueB[] = "2";
+    char valueC[] = "3";
+    celix_properties_set(properties, keyA, valueA);
+    celix_properties_set(properties, keyB, valueB);
+
+    STRCMP_EQUAL(valueA, celix_properties_get(properties, keyA, NULL));
+    STRCMP_EQUAL(valueB, celix_properties_get(properties, keyB, NULL));
+    STRCMP_EQUAL(valueC, celix_properties_get(properties, keyC, valueC));
+
+    celix_properties_destroy(properties);
 }
 
 TEST(properties, longTest) {
-	properties = properties_create();
-
-	celix_properties_set(properties, "a", "2");
-	celix_properties_set(properties, "b", "-10032L");
-	celix_properties_set(properties, "c", "");
-	celix_properties_set(properties, "d", "garbage");
-
-	long a = celix_properties_getAsLong(properties, "a", -1L);
-	long b = celix_properties_getAsLong(properties, "b", -1L);
-	long c = celix_properties_getAsLong(properties, "c", -1L);
-	long d = celix_properties_getAsLong(properties, "d", -1L);
-	long e = celix_properties_getAsLong(properties, "e", -1L);
-
-	CHECK_EQUAL(2, a);
-	CHECK_EQUAL(-10032L, b);
-	CHECK_EQUAL(-1L, c);
-	CHECK_EQUAL(-1L, d);
-	CHECK_EQUAL(-1L, e);
-
-	celix_properties_setLong(properties, "a", 3L);
-	celix_properties_setLong(properties, "b", -4L);
-	a = celix_properties_getAsLong(properties, "a", -1L);
-	b = celix_properties_getAsLong(properties, "b", -1L);
-	CHECK_EQUAL(3L, a);
-	CHECK_EQUAL(-4L, b);
-
-	celix_properties_destroy(properties);
+    properties = celix_properties_create();
+
+    celix_properties_set(properties, "a", "2");
+    celix_properties_set(properties, "b", "-10032L");
+    celix_properties_set(properties, "c", "");
+    celix_properties_set(properties, "d", "garbage");
+
+    long a = celix_properties_getAsLong(properties, "a", -1L);
+    long b = celix_properties_getAsLong(properties, "b", -1L);
+    long c = celix_properties_getAsLong(properties, "c", -1L);
+    long d = celix_properties_getAsLong(properties, "d", -1L);
+    long e = celix_properties_getAsLong(properties, "e", -1L);
+
+    CHECK_EQUAL(2, a);
+    CHECK_EQUAL(-10032L, b);
+    CHECK_EQUAL(-1L, c);
+    CHECK_EQUAL(-1L, d);
+    CHECK_EQUAL(-1L, e);
+
+    celix_properties_setLong(properties, "a", 3L);
+    celix_properties_setLong(properties, "b", -4L);
+    a = celix_properties_getAsLong(properties, "a", -1L);
+    b = celix_properties_getAsLong(properties, "b", -1L);
+    CHECK_EQUAL(3L, a);
+    CHECK_EQUAL(-4L, b);
+
+    celix_properties_destroy(properties);
 }
 
 TEST(properties, boolTest) {
-	properties = properties_create();
-
-	celix_properties_set(properties, "a", "true");
-	celix_properties_set(properties, "b", "false");
-	celix_properties_set(properties, "c", "  true  ");
-	celix_properties_set(properties, "d", "garbage");
-
-	bool a = celix_properties_getAsBool(properties, "a", false);
-	bool b = celix_properties_getAsBool(properties, "b", true);
-	bool c = celix_properties_getAsBool(properties, "c", false);
-	bool d = celix_properties_getAsBool(properties, "d", true);
-	bool e = celix_properties_getAsBool(properties, "e", false);
-	bool f = celix_properties_getAsBool(properties, "f", true);
-
-	CHECK_EQUAL(true, a);
-	CHECK_EQUAL(false, b);
-	CHECK_EQUAL(true, c);
-	CHECK_EQUAL(true, d);
-	CHECK_EQUAL(false, e);
-	CHECK_EQUAL(true, f);
-
-	celix_properties_setBool(properties, "a", true);
-	celix_properties_setBool(properties, "b", false);
-	a = celix_properties_getAsBool(properties, "a", false);
-	b = celix_properties_getAsBool(properties, "b", true);
-	CHECK_EQUAL(true, a);
-	CHECK_EQUAL(false, b);
-
-	celix_properties_destroy(properties);
+    properties = celix_properties_create();
+
+    celix_properties_set(properties, "a", "true");
+    celix_properties_set(properties, "b", "false");
+    celix_properties_set(properties, "c", "  true  ");
+    celix_properties_set(properties, "d", "garbage");
+
+    bool a = celix_properties_getAsBool(properties, "a", false);
+    bool b = celix_properties_getAsBool(properties, "b", true);
+    bool c = celix_properties_getAsBool(properties, "c", false);
+    bool d = celix_properties_getAsBool(properties, "d", true);
+    bool e = celix_properties_getAsBool(properties, "e", false);
+    bool f = celix_properties_getAsBool(properties, "f", true);
+
+    CHECK_EQUAL(true, a);
+    CHECK_EQUAL(false, b);
+    CHECK_EQUAL(true, c);
+    CHECK_EQUAL(true, d);
+    CHECK_EQUAL(false, e);
+    CHECK_EQUAL(true, f);
+
+    celix_properties_setBool(properties, "a", true);
+    celix_properties_setBool(properties, "b", false);
+    a = celix_properties_getAsBool(properties, "a", false);
+    b = celix_properties_getAsBool(properties, "b", true);
+    CHECK_EQUAL(true, a);
+    CHECK_EQUAL(false, b);
+
+    celix_properties_destroy(properties);
 }
 
 TEST(properties, sizeAndIteratorTest) {
-	celix_properties_t *props = celix_properties_create();
-	CHECK_EQUAL(0, celix_properties_size(props));
-	celix_properties_set(props, "a", "1");
-	celix_properties_set(props, "b", "2");
-	CHECK_EQUAL(2, celix_properties_size(props));
-	celix_properties_set(props, "c", "  3  ");
-	celix_properties_set(props, "d", "4");
-	CHECK_EQUAL(4, celix_properties_size(props));
-
-	int count = 0;
-	const char *_key = NULL;
-	CELIX_PROPERTIES_FOR_EACH(props, _key) {
-		count++;
-	}
-	CHECK_EQUAL(4, count);
-
-	celix_properties_destroy(props);
+    celix_properties_t *props = celix_properties_create();
+    CHECK_EQUAL(0, celix_properties_size(props));
+    celix_properties_set(props, "a", "1");
+    celix_properties_set(props, "b", "2");
+    CHECK_EQUAL(2, celix_properties_size(props));
+    celix_properties_set(props, "c", "  3  ");
+    celix_properties_set(props, "d", "4");
+    CHECK_EQUAL(4, celix_properties_size(props));
+
+    int count = 0;
+    const char *_key = NULL;
+    CELIX_PROPERTIES_FOR_EACH(props, _key) {
+        count++;
+    }
+    CHECK_EQUAL(4, count);
+
+    celix_properties_destroy(props);
 }
\ No newline at end of file
diff --git a/libs/utils/private/test/thread_pool_test.cpp b/libs/utils/private/test/thread_pool_test.cpp
index 5dae4c8..004bfa1 100644
--- a/libs/utils/private/test/thread_pool_test.cpp
+++ b/libs/utils/private/test/thread_pool_test.cpp
@@ -1,28 +1,29 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * array_list_test.cpp
  *
- * 	\date       Sep 15, 2015
- *  \author    	Menno van der Graaf & Alexander
- *  \copyright	Apache License, Version 2.0
+ *  \date       Sep 15, 2015
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -42,14 +43,14 @@ int sum=0;
 
 
 void * increment(void *) {
-	celixThreadMutex_lock(&mutex);
-	sum ++;
-	celixThreadMutex_unlock(&mutex);
-	return NULL;
+    celixThreadMutex_lock(&mutex);
+    sum ++;
+    celixThreadMutex_unlock(&mutex);
+    return NULL;
 }
 
 int main(int argc, char** argv) {
-	return RUN_ALL_TESTS(argc, argv);
+    return RUN_ALL_TESTS(argc, argv);
 }
 
 
@@ -58,13 +59,13 @@ int main(int argc, char** argv) {
 //----------------------TESTGROUP DEFINES----------------------
 
 TEST_GROUP(thread_pool) {
-	threadpool	myPool;
+    threadpool    myPool;
 
-	void setup(void) {
-	}
+    void setup(void) {
+    }
 
-	void teardown(void) {
-	}
+    void teardown(void) {
+    }
 };
 
 
@@ -72,47 +73,47 @@ TEST_GROUP(thread_pool) {
 
 TEST(thread_pool, create) {
 
-	myPool = thpool_init(5);	// pool of 5 threads
-	CHECK((myPool != NULL));
-	thpool_destroy(myPool);
+    myPool = thpool_init(5);    // pool of 5 threads
+    CHECK((myPool != NULL));
+    thpool_destroy(myPool);
 }
 
 TEST(thread_pool, do_work) {
 
-	myPool = thpool_init(5);	// pool of 5 threads
-	celixThreadMutex_create(&mutex, NULL);
-	CHECK((myPool != NULL));
-	int n;
-	sum = 0;
-	int num_jobs = 1000;
-	for (n = 0; n < num_jobs; n++){
-		thpool_add_work(myPool, increment, NULL);
-	}
-	thpool_wait(myPool);
-	thpool_destroy(myPool);
-	CHECK_EQUAL(1000, sum);
-	celixThreadMutex_destroy(&mutex);
+    myPool = thpool_init(5);    // pool of 5 threads
+    celixThreadMutex_create(&mutex, NULL);
+    CHECK((myPool != NULL));
+    int n;
+    sum = 0;
+    int num_jobs = 1000;
+    for (n = 0; n < num_jobs; n++){
+        thpool_add_work(myPool, increment, NULL);
+    }
+    thpool_wait(myPool);
+    thpool_destroy(myPool);
+    CHECK_EQUAL(1000, sum);
+    celixThreadMutex_destroy(&mutex);
 }
 
 TEST(thread_pool, do_work_with_pause) {
 
-	myPool = thpool_init(5);	// pool of 5 threads
-	celixThreadMutex_create(&mutex, NULL);
-	CHECK((myPool != NULL));
-	int n;
-	sum = 0;
-	int num_jobs = 500000;
-	for (n = 0; n < num_jobs; n++){
-		thpool_add_work(myPool, increment, NULL);
-	}
-	sleep(1);
-	thpool_pause(myPool);
-	for (n = 0; n < num_jobs; n++){
-		thpool_add_work(myPool, increment, NULL);
-	}
-	thpool_resume(myPool);
-	thpool_wait(myPool);
-	thpool_destroy(myPool);
-	CHECK_EQUAL(1000000, sum);
-	celixThreadMutex_destroy(&mutex);
+    myPool = thpool_init(5);    // pool of 5 threads
+    celixThreadMutex_create(&mutex, NULL);
+    CHECK((myPool != NULL));
+    int n;
+    sum = 0;
+    int num_jobs = 500000;
+    for (n = 0; n < num_jobs; n++){
+        thpool_add_work(myPool, increment, NULL);
+    }
+    sleep(1);
+    thpool_pause(myPool);
+    for (n = 0; n < num_jobs; n++){
+        thpool_add_work(myPool, increment, NULL);
+    }
+    thpool_resume(myPool);
+    thpool_wait(myPool);
+    thpool_destroy(myPool);
+    CHECK_EQUAL(1000000, sum);
+    celixThreadMutex_destroy(&mutex);
 }
diff --git a/libs/utils/private/test/utils_test.cpp b/libs/utils/private/test/utils_test.cpp
index 8f939c0..4801191 100644
--- a/libs/utils/private/test/utils_test.cpp
+++ b/libs/utils/private/test/utils_test.cpp
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * utils_test.cpp
@@ -23,6 +23,7 @@
  *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
  *  \copyright  Apache License, Version 2.0
  */
+
 #include "string.h"
 #include <stdlib.h>
 #include <string.h>
@@ -37,262 +38,262 @@ extern "C"
 }
 
 int main(int argc, char** argv) {
-	return RUN_ALL_TESTS(argc, argv);
+    return RUN_ALL_TESTS(argc, argv);
 }
 
 TEST_GROUP(utils) {
 
-	void setup(void) {
-	}
+    void setup(void) {
+    }
 
-	void teardown() {
-	}
+    void teardown() {
+    }
 };
 
 static char* my_strdup(const char* s){
-	if(s==NULL){
-		return NULL;
-	}
+    if(s==NULL){
+        return NULL;
+    }
 
-	size_t len = strlen(s);
+    size_t len = strlen(s);
 
-	char *d = (char*) calloc (len + 1,sizeof(char));
+    char *d = (char*) calloc (len + 1,sizeof(char));
 
-	if (d == NULL){
-		return NULL;
-	}
+    if (d == NULL){
+        return NULL;
+    }
 
-	strncpy (d,s,len);
-	return d;
+    strncpy (d,s,len);
+    return d;
 }
 
 TEST(utils, stringHash) {
-	char * toHash = my_strdup("abc");
-	unsigned int hash;
-	hash = utils_stringHash((void *) toHash);
-	LONGS_EQUAL(193485963, hash);
-
-	free(toHash);
-	toHash = my_strdup("abc123def456ghi789jkl012mno345pqr678stu901vwx234yz");
-	hash = utils_stringHash((void *) toHash);
-	LONGS_EQUAL(1532304168, hash);
-
-	free(toHash);
-	toHash = my_strdup("abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz");
-	hash = utils_stringHash((void *) toHash);
-	LONGS_EQUAL(3721605959, hash);
-	free(toHash);
+    char * toHash = my_strdup("abc");
+    unsigned int hash;
+    hash = utils_stringHash((void *) toHash);
+    LONGS_EQUAL(193485963, hash);
+
+    free(toHash);
+    toHash = my_strdup("abc123def456ghi789jkl012mno345pqr678stu901vwx234yz");
+    hash = utils_stringHash((void *) toHash);
+    LONGS_EQUAL(1532304168, hash);
+
+    free(toHash);
+    toHash = my_strdup("abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz");
+    hash = utils_stringHash((void *) toHash);
+    LONGS_EQUAL(3721605959, hash);
+    free(toHash);
 }
 
 TEST(utils, stringEquals) {
-	// Compare with equal strings
-	char * org = my_strdup("abc");
-	char * cmp = my_strdup("abc");
-
-	int result = utils_stringEquals((void *) org, (void *) cmp);
-	CHECK(result);
-
-	// Compare with no equal strings
-	free(cmp);
-	cmp = my_strdup("abcd");
-
-	result = utils_stringEquals((void *) org, (void *) cmp);
-	CHECK_FALSE(result);
-
-	// Compare with numeric strings
-	free(org);
-	free(cmp);
-	org = my_strdup("123");
-	cmp = my_strdup("123");
-
-	result = utils_stringEquals((void *) org, (void *) cmp);
-	CHECK(result);
-
-	// Compare with long strings
-	free(org);
-	free(cmp);
-	org = my_strdup("abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz");
-	cmp = my_strdup("abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
-			"abc123def456ghi789jkl012mno345pqr678stu901vwx234yz");
-
-	result = utils_stringEquals((void *) org, (void *) cmp);
-	CHECK(result);
-
-	free(org);
-	free(cmp);
+    // Compare with equal strings
+    char * org = my_strdup("abc");
+    char * cmp = my_strdup("abc");
+
+    int result = utils_stringEquals((void *) org, (void *) cmp);
+    CHECK(result);
+
+    // Compare with no equal strings
+    free(cmp);
+    cmp = my_strdup("abcd");
+
+    result = utils_stringEquals((void *) org, (void *) cmp);
+    CHECK_FALSE(result);
+
+    // Compare with numeric strings
+    free(org);
+    free(cmp);
+    org = my_strdup("123");
+    cmp = my_strdup("123");
+
+    result = utils_stringEquals((void *) org, (void *) cmp);
+    CHECK(result);
+
+    // Compare with long strings
+    free(org);
+    free(cmp);
+    org = my_strdup("abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz");
+    cmp = my_strdup("abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz"
+            "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz");
+
+    result = utils_stringEquals((void *) org, (void *) cmp);
+    CHECK(result);
+
+    free(org);
+    free(cmp);
 }
 
 TEST(utils, string_ndup){
-	// Compare with equal strings
-	const char * org = "abc";
-	char * cmp = NULL;
-
-	cmp = string_ndup(org, 3);
-	STRCMP_EQUAL(org, cmp);
-	free(cmp);
-
-	org = "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz";
-	cmp = string_ndup(org, 50);
-	STRCMP_EQUAL(org, cmp);
-	free(cmp);
-
-	cmp = string_ndup(org, 25);
-	LONGS_EQUAL(25, strlen(cmp));
-	free(cmp);
+    // Compare with equal strings
+    const char * org = "abc";
+    char * cmp = NULL;
+
+    cmp = string_ndup(org, 3);
+    STRCMP_EQUAL(org, cmp);
+    free(cmp);
+
+    org = "abc123def456ghi789jkl012mno345pqr678stu901vwx234yz";
+    cmp = string_ndup(org, 50);
+    STRCMP_EQUAL(org, cmp);
+    free(cmp);
+
+    cmp = string_ndup(org, 25);
+    LONGS_EQUAL(25, strlen(cmp));
+    free(cmp);
 }
 
 TEST(utils, stringTrim) {
-	// Multiple whitespaces, before, after and in between
-	char * toTrim = my_strdup(" a b c ");
-	char * result = utils_stringTrim(toTrim);
+    // Multiple whitespaces, before, after and in between
+    char * toTrim = my_strdup(" a b c ");
+    char * result = utils_stringTrim(toTrim);
 
-	STRCMP_EQUAL("a b c", result);
+    STRCMP_EQUAL("a b c", result);
 
-	// No whitespaces
-	free(toTrim);
-	toTrim = my_strdup("abc");
-	result = utils_stringTrim(toTrim);
+    // No whitespaces
+    free(toTrim);
+    toTrim = my_strdup("abc");
+    result = utils_stringTrim(toTrim);
 
-	STRCMP_EQUAL("abc", result);
+    STRCMP_EQUAL("abc", result);
 
-	// Only whitespace before
-	free(toTrim);
-	toTrim = my_strdup("               abc");
-	result = utils_stringTrim(toTrim);
+    // Only whitespace before
+    free(toTrim);
+    toTrim = my_strdup("               abc");
+    result = utils_stringTrim(toTrim);
 
-	STRCMP_EQUAL("abc", result);
+    STRCMP_EQUAL("abc", result);
 
-	// Only whitespace after
-	free(toTrim);
-	toTrim = my_strdup("abc         ");
-	result = utils_stringTrim(toTrim);
+    // Only whitespace after
+    free(toTrim);
+    toTrim = my_strdup("abc         ");
+    result = utils_stringTrim(toTrim);
 
-	STRCMP_EQUAL("abc", result);
+    STRCMP_EQUAL("abc", result);
 
-	// Whitespace other then space (tab, cr..).
-	free(toTrim);
-	toTrim = my_strdup("\tabc  \n asdf  \n");
-	result = utils_stringTrim(toTrim);
+    // Whitespace other than space (tab, cr..).
+    free(toTrim);
+    toTrim = my_strdup("\tabc  \n asdf  \n");
+    result = utils_stringTrim(toTrim);
 
-	STRCMP_EQUAL("abc  \n asdf", result);
+    STRCMP_EQUAL("abc  \n asdf", result);
 
-	free(toTrim);
+    free(toTrim);
 }
 
 TEST(utils, thread_equalsSelf){
-	celix_thread thread = celixThread_self();
-	bool get;
+    celix_thread thread = celixThread_self();
+    bool get;
 
-	LONGS_EQUAL(CELIX_SUCCESS, thread_equalsSelf(thread, &get));
-	CHECK(get);
+    LONGS_EQUAL(CELIX_SUCCESS, thread_equalsSelf(thread, &get));
+    CHECK(get);
 
-	thread.thread = (pthread_t) 0x42;
-	LONGS_EQUAL(CELIX_SUCCESS, thread_equalsSelf(thread, &get));
-	CHECK_FALSE(get);
+    thread.thread = (pthread_t) 0x42;
+    LONGS_EQUAL(CELIX_SUCCESS, thread_equalsSelf(thread, &get));
+    CHECK_FALSE(get);
 }
 
 TEST(utils, isNumeric) {
-	// Check numeric string
-	char * toCheck = my_strdup("42");
-
-	bool result;
-	celix_status_t status = utils_isNumeric(toCheck, &result);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(result);
-
-	// Check non numeric string
-	free(toCheck);
-	toCheck = my_strdup("42b");
-	status = utils_isNumeric(toCheck, &result);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(!result);
-
-	free(toCheck);
+    // Check numeric string
+    char * toCheck = my_strdup("42");
+
+    bool result;
+    celix_status_t status = utils_isNumeric(toCheck, &result);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(result);
+
+    // Check non numeric string
+    free(toCheck);
+    toCheck = my_strdup("42b");
+    status = utils_isNumeric(toCheck, &result);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(!result);
+
+    free(toCheck);
 }
 
 TEST(utils, compareServiceIdsAndRanking){
-	int ret;
-	//service 1 is higher ranked and has a irrelevant ID
-	ret = utils_compareServiceIdsAndRanking(2,2,1,1);
-	LONGS_EQUAL(1, ret);
-
-	//service 1 is equally ranked and has a lower ID
-	ret = utils_compareServiceIdsAndRanking(1,1,2,1);
-	LONGS_EQUAL(1, ret);
-
-	//service 1 is equally ranked and has a higher ID
-	ret = utils_compareServiceIdsAndRanking(2,1,1,1);
-	LONGS_EQUAL(-1, ret);
-
-	//service 1 is lower ranked and has a irrelevant ID
-	ret = utils_compareServiceIdsAndRanking(1,1,2,2);
-	LONGS_EQUAL(-1, ret);
-
-	//service 1 is equal in ID and irrelevantly ranked
-	ret = utils_compareServiceIdsAndRanking(1,1,1,1);
-	LONGS_EQUAL(0, ret);
+    int ret;
+    //service 1 is higher ranked and has a irrelevant ID
+    ret = utils_compareServiceIdsAndRanking(2,2,1,1);
+    LONGS_EQUAL(1, ret);
+
+    //service 1 is equally ranked and has a lower ID
+    ret = utils_compareServiceIdsAndRanking(1,1,2,1);
+    LONGS_EQUAL(1, ret);
+
+    //service 1 is equally ranked and has a higher ID
+    ret = utils_compareServiceIdsAndRanking(2,1,1,1);
+    LONGS_EQUAL(-1, ret);
+
+    //service 1 is lower ranked and has a irrelevant ID
+    ret = utils_compareServiceIdsAndRanking(1,1,2,2);
+    LONGS_EQUAL(-1, ret);
+
+    //service 1 is equal in ID and irrelevantly ranked
+    ret = utils_compareServiceIdsAndRanking(1,1,1,1);
+    LONGS_EQUAL(0, ret);
 
 
 }
diff --git a/libs/utils/private/test/version_range_test.cpp b/libs/utils/private/test/version_range_test.cpp
index 1e1336c..9ac1d24 100644
--- a/libs/utils/private/test/version_range_test.cpp
+++ b/libs/utils/private/test/version_range_test.cpp
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * version_range_test.cpp
@@ -41,212 +41,212 @@ framework_logger_pt logger = (framework_logger_pt) 0x42;
 }
 
 int main(int argc, char** argv) {
-	return RUN_ALL_TESTS(argc, argv);
+    return RUN_ALL_TESTS(argc, argv);
 }
 
 static char* my_strdup(const char* s) {
-	if (s == NULL) {
-		return NULL;
-	}
+    if (s == NULL) {
+        return NULL;
+    }
 
-	size_t len = strlen(s);
+    size_t len = strlen(s);
 
-	char *d = (char*) calloc(len + 1, sizeof(char));
+    char *d = (char*) calloc(len + 1, sizeof(char));
 
-	if (d == NULL) {
-		return NULL;
-	}
+    if (d == NULL) {
+        return NULL;
+    }
 
-	strncpy(d, s, len);
-	return d;
+    strncpy(d, s, len);
+    return d;
 }
 
 //----------------------TESTGROUP DEFINES----------------------
 
 TEST_GROUP(version_range) {
 
-	void setup(void) {
-	}
+    void setup(void) {
+    }
 
-	void teardown() {
-		mock().checkExpectations();
-		mock().clear();
-	}
+    void teardown() {
+        mock().checkExpectations();
+        mock().clear();
+    }
 };
 
 TEST(version_range, create) {
-	celix_status_t status = CELIX_SUCCESS;
-	version_range_pt range = NULL;
-	version_pt version = (version_pt) malloc(sizeof(*version));
-
-	status = versionRange_createVersionRange(version, false, version, true, &range);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C((range != NULL));
-	LONGS_EQUAL(true, range->isHighInclusive);
-	LONGS_EQUAL(false, range->isLowInclusive);
-	POINTERS_EQUAL(version, range->low);
-	POINTERS_EQUAL(version, range->high);
-
-	mock().expectNCalls(2, "version_destroy")
-			.withParameter("version", version);
-
-	versionRange_destroy(range);
-	free(version);
+    celix_status_t status = CELIX_SUCCESS;
+    version_range_pt range = NULL;
+    version_pt version = (version_pt) malloc(sizeof(*version));
+
+    status = versionRange_createVersionRange(version, false, version, true, &range);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C((range != NULL));
+    LONGS_EQUAL(true, range->isHighInclusive);
+    LONGS_EQUAL(false, range->isLowInclusive);
+    POINTERS_EQUAL(version, range->low);
+    POINTERS_EQUAL(version, range->high);
+
+    mock().expectNCalls(2, "version_destroy")
+            .withParameter("version", version);
+
+    versionRange_destroy(range);
+    free(version);
 }
 
 TEST(version_range, createInfinite) {
-	celix_status_t status = CELIX_SUCCESS;
-	version_range_pt range = NULL;
-	version_pt version = (version_pt) malloc(sizeof(*version));
-	version->major = 1;
-	version->minor = 2;
-	version->micro = 3;
-
-	mock()
-	.expectOneCall("version_createEmptyVersion")
-	.withOutputParameterReturning("version", &version, sizeof("version"));
-	status = versionRange_createInfiniteVersionRange(&range);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(range != NULL);
-	LONGS_EQUAL(true, range->isHighInclusive);
-	LONGS_EQUAL(true, range->isLowInclusive);
-	POINTERS_EQUAL(version, range->low);
-	POINTERS_EQUAL(NULL, range->high);
-
-	mock().expectOneCall("version_destroy")
-			.withParameter("version", version);
-
-	versionRange_destroy(range);
-	free(version);
+    celix_status_t status = CELIX_SUCCESS;
+    version_range_pt range = NULL;
+    version_pt version = (version_pt) malloc(sizeof(*version));
+    version->major = 1;
+    version->minor = 2;
+    version->micro = 3;
+
+    mock()
+    .expectOneCall("version_createEmptyVersion")
+    .withOutputParameterReturning("version", &version, sizeof("version"));
+    status = versionRange_createInfiniteVersionRange(&range);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(range != NULL);
+    LONGS_EQUAL(true, range->isHighInclusive);
+    LONGS_EQUAL(true, range->isLowInclusive);
+    POINTERS_EQUAL(version, range->low);
+    POINTERS_EQUAL(NULL, range->high);
+
+    mock().expectOneCall("version_destroy")
+            .withParameter("version", version);
+
+    versionRange_destroy(range);
+    free(version);
 }
 
 TEST(version_range, isInRange) {
-	bool result;
-	version_range_pt range = NULL;
-	version_pt version = (version_pt) malloc(sizeof(*version));
-	version->major = 1;
-	version->minor = 2;
-	version->micro = 3;
-
-	version_pt low = (version_pt) malloc(sizeof(*low));
-	low->major = 1;
-	low->minor = 2;
-	low->micro = 3;
-
-	version_pt high = (version_pt) malloc(sizeof(*high));
-	high->major = 1;
-	high->minor = 2;
-	high->micro = 3;
-
-	int stat = 1;
-	mock()
-	.expectNCalls(5, "version_compareTo")
-	.withParameter("version", version)
-	.withParameter("compare", low)
-	.withOutputParameterReturning("result", &stat, sizeof(int));
-	int stat2 = -1;
-	mock()
-	.expectNCalls(4, "version_compareTo")
-	.withParameter("version", version)
-	.withParameter("compare", high)
-	.withOutputParameterReturning("result", &stat2, sizeof(int));
-
-	versionRange_createVersionRange(low, true, high, true, &range);
-	LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
-	LONGS_EQUAL(true, result);
-
-	mock().expectOneCall("version_destroy")
-			.withParameter("version", low);
-	mock().expectOneCall("version_destroy")
-			.withParameter("version", high);
-	versionRange_destroy(range);
-
-	versionRange_createVersionRange(low, true, NULL, true, &range);
-	LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
-	LONGS_EQUAL(true, result);
-
-	mock().expectOneCall("version_destroy")
-			.withParameter("version", low);
-	versionRange_destroy(range);
-
-	versionRange_createVersionRange(low, false, high, true, &range);
-	LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
-	LONGS_EQUAL(true, result);
-
-	mock().expectOneCall("version_destroy")
-			.withParameter("version", low);
-	mock().expectOneCall("version_destroy")
-			.withParameter("version", high);
-	versionRange_destroy(range);
-
-	versionRange_createVersionRange(low, true, high, false, &range);
-	LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
-	LONGS_EQUAL(true, result);
-
-	mock().expectOneCall("version_destroy")
-			.withParameter("version", low);
-	mock().expectOneCall("version_destroy")
-			.withParameter("version", high);
-	versionRange_destroy(range);
-
-	versionRange_createVersionRange(low, false, high, false, &range);
-	LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
-	LONGS_EQUAL(true, result);
-
-	mock().expectOneCall("version_destroy")
-			.withParameter("version", low);
-	mock().expectOneCall("version_destroy")
-			.withParameter("version", high);
-	versionRange_destroy(range);
-
-	free(version);
-	free(high);
-	free(low);
+    bool result;
+    version_range_pt range = NULL;
+    version_pt version = (version_pt) malloc(sizeof(*version));
+    version->major = 1;
+    version->minor = 2;
+    version->micro = 3;
+
+    version_pt low = (version_pt) malloc(sizeof(*low));
+    low->major = 1;
+    low->minor = 2;
+    low->micro = 3;
+
+    version_pt high = (version_pt) malloc(sizeof(*high));
+    high->major = 1;
+    high->minor = 2;
+    high->micro = 3;
+
+    int stat = 1;
+    mock()
+    .expectNCalls(5, "version_compareTo")
+    .withParameter("version", version)
+    .withParameter("compare", low)
+    .withOutputParameterReturning("result", &stat, sizeof(int));
+    int stat2 = -1;
+    mock()
+    .expectNCalls(4, "version_compareTo")
+    .withParameter("version", version)
+    .withParameter("compare", high)
+    .withOutputParameterReturning("result", &stat2, sizeof(int));
+
+    versionRange_createVersionRange(low, true, high, true, &range);
+    LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
+    LONGS_EQUAL(true, result);
+
+    mock().expectOneCall("version_destroy")
+            .withParameter("version", low);
+    mock().expectOneCall("version_destroy")
+            .withParameter("version", high);
+    versionRange_destroy(range);
+
+    versionRange_createVersionRange(low, true, NULL, true, &range);
+    LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
+    LONGS_EQUAL(true, result);
+
+    mock().expectOneCall("version_destroy")
+            .withParameter("version", low);
+    versionRange_destroy(range);
+
+    versionRange_createVersionRange(low, false, high, true, &range);
+    LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
+    LONGS_EQUAL(true, result);
+
+    mock().expectOneCall("version_destroy")
+            .withParameter("version", low);
+    mock().expectOneCall("version_destroy")
+            .withParameter("version", high);
+    versionRange_destroy(range);
+
+    versionRange_createVersionRange(low, true, high, false, &range);
+    LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
+    LONGS_EQUAL(true, result);
+
+    mock().expectOneCall("version_destroy")
+            .withParameter("version", low);
+    mock().expectOneCall("version_destroy")
+            .withParameter("version", high);
+    versionRange_destroy(range);
+
+    versionRange_createVersionRange(low, false, high, false, &range);
+    LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
+    LONGS_EQUAL(true, result);
+
+    mock().expectOneCall("version_destroy")
+            .withParameter("version", low);
+    mock().expectOneCall("version_destroy")
+            .withParameter("version", high);
+    versionRange_destroy(range);
+
+    free(version);
+    free(high);
+    free(low);
 }
 
 TEST(version_range, parse) {
-	version_range_pt range = NULL;
-	version_pt low = (version_pt) malloc(sizeof(*low));
-	version_pt high = (version_pt) malloc(sizeof(*high));
-	char * version = my_strdup("[1.2.3,7.8.9]");
-	low->major = 1;
-	low->minor = 2;
-	low->micro = 3;
+    version_range_pt range = NULL;
+    version_pt low = (version_pt) malloc(sizeof(*low));
+    version_pt high = (version_pt) malloc(sizeof(*high));
+    char * version = my_strdup("[1.2.3,7.8.9]");
+    low->major = 1;
+    low->minor = 2;
+    low->micro = 3;
 
-	high->major = 7;
-	high->minor = 8;
-	high->micro = 9;
+    high->major = 7;
+    high->minor = 8;
+    high->micro = 9;
 
-	mock().expectOneCall("version_destroy")
-			.withParameter("version", high);
+    mock().expectOneCall("version_destroy")
+            .withParameter("version", high);
 
-	mock().expectNCalls(2, "version_destroy")
-			.withParameter("version", low);
+    mock().expectNCalls(2, "version_destroy")
+            .withParameter("version", low);
 
-	mock().expectOneCall("version_createVersionFromString")
-		   .withParameter("versionStr", "1.2.3")
-		   .withOutputParameterReturning("version", &low, sizeof(low));
+    mock().expectOneCall("version_createVersionFromString")
+           .withParameter("versionStr", "1.2.3")
+           .withOutputParameterReturning("version", &low, sizeof(low));
 
-	mock().expectOneCall("version_createVersionFromString")
-			.withParameter("versionStr", "7.8.9")
-			.withOutputParameterReturning("version", &high, sizeof(high));
+    mock().expectOneCall("version_createVersionFromString")
+            .withParameter("versionStr", "7.8.9")
+            .withOutputParameterReturning("version", &high, sizeof(high));
 
-	LONGS_EQUAL(CELIX_SUCCESS, versionRange_parse(version, &range));
+    LONGS_EQUAL(CELIX_SUCCESS, versionRange_parse(version, &range));
 
-	versionRange_destroy(range);
-	free(version);
-	version = my_strdup("[1.2.3");
+    versionRange_destroy(range);
+    free(version);
+    version = my_strdup("[1.2.3");
 
-	mock().expectOneCall("version_createVersionFromString")
-			.withParameter("versionStr", "[1.2.3")
-			.withOutputParameterReturning("version", &low, sizeof(low));
+    mock().expectOneCall("version_createVersionFromString")
+            .withParameter("versionStr", "[1.2.3")
+            .withOutputParameterReturning("version", &low, sizeof(low));
 
-	LONGS_EQUAL(CELIX_SUCCESS, versionRange_parse(version, &range));
+    LONGS_EQUAL(CELIX_SUCCESS, versionRange_parse(version, &range));
 
-	versionRange_destroy(range);
-	free(version);
-	free(high);
-	free(low);
+    versionRange_destroy(range);
+    free(version);
+    free(high);
+    free(low);
 }
 
 
diff --git a/libs/utils/private/test/version_test.cpp b/libs/utils/private/test/version_test.cpp
index 5603a33..e65a6b1 100644
--- a/libs/utils/private/test/version_test.cpp
+++ b/libs/utils/private/test/version_test.cpp
@@ -39,317 +39,317 @@ framework_logger_pt logger = (framework_logger_pt) 0x666;
 }
 
 int main(int argc, char** argv) {
-	return RUN_ALL_TESTS(argc, argv);
+    return RUN_ALL_TESTS(argc, argv);
 }
 
 static char* my_strdup(const char* s){
-	if(s==NULL){
-		return NULL;
-	}
+    if (s == NULL) {
+        return NULL;
+    }
 
-	size_t len = strlen(s);
+    size_t len = strlen(s);
 
-	char *d = (char*) calloc (len + 1,sizeof(char));
+    char *d = (char *) calloc(len + 1, sizeof(char));
 
-	if (d == NULL){
-		return NULL;
-	}
+    if (d == NULL) {
+        return NULL;
+    }
 
-	strncpy (d,s,len);
-	return d;
+    strncpy(d,s,len);
+    return d;
 }
 
 TEST_GROUP(version) {
 
-	void setup(void) {
-	}
+    void setup(void) {
+    }
 
-	void teardown() {
-		mock().checkExpectations();
-		mock().clear();
-	}
+    void teardown() {
+        mock().checkExpectations();
+        mock().clear();
+    }
 
 };
 
 
 TEST(version, create) {
-	version_pt version = NULL;
-	char * str;
+    version_pt version = NULL;
+    char * str;
 
-//	str = my_strdup("abc");
-//	status = version_createVersion(1, 2, 3, str, &version);
-//	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status);
+//    str = my_strdup("abc");
+//    status = version_createVersion(1, 2, 3, str, &version);
+//    LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status);
 
-	str = my_strdup("abc");
-	LONGS_EQUAL(CELIX_SUCCESS, version_createVersion(1, 2, 3, str, &version));
-	CHECK_C(version != NULL);
+    str = my_strdup("abc");
+    LONGS_EQUAL(CELIX_SUCCESS, version_createVersion(1, 2, 3, str, &version));
+    CHECK_C(version != NULL);
     LONGS_EQUAL(1, version->major);
-	LONGS_EQUAL(2, version->minor);
-	LONGS_EQUAL(3, version->micro);
-	STRCMP_EQUAL("abc", version->qualifier);
-
-	version_destroy(version);
-	version = NULL;
-	LONGS_EQUAL(CELIX_SUCCESS, version_createVersion(1, 2, 3, NULL, &version));
-	CHECK_C(version != NULL);
-	LONGS_EQUAL(1, version->major);
-	LONGS_EQUAL(2, version->minor);
-	LONGS_EQUAL(3, version->micro);
-	STRCMP_EQUAL("", version->qualifier);
-
-	version_destroy(version);
-	version = NULL;
-	free(str);
-	str = my_strdup("abc");
-	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersion(-1, -2, -3, str, &version));
-
-	version_destroy(version);
-	version = NULL;
-	free(str);
-	str = my_strdup("abc|xyz");
-	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersion(1, 2, 3, str, &version));
-
-	version_destroy(version);
-	free(str);
+    LONGS_EQUAL(2, version->minor);
+    LONGS_EQUAL(3, version->micro);
+    STRCMP_EQUAL("abc", version->qualifier);
+
+    version_destroy(version);
+    version = NULL;
+    LONGS_EQUAL(CELIX_SUCCESS, version_createVersion(1, 2, 3, NULL, &version));
+    CHECK_C(version != NULL);
+    LONGS_EQUAL(1, version->major);
+    LONGS_EQUAL(2, version->minor);
+    LONGS_EQUAL(3, version->micro);
+    STRCMP_EQUAL("", version->qualifier);
+
+    version_destroy(version);
+    version = NULL;
+    free(str);
+    str = my_strdup("abc");
+    LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersion(-1, -2, -3, str, &version));
+
+    version_destroy(version);
+    version = NULL;
+    free(str);
+    str = my_strdup("abc|xyz");
+    LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersion(1, 2, 3, str, &version));
+
+    version_destroy(version);
+    free(str);
 }
 
 TEST(version, clone) {
-	version_pt version = NULL, clone = NULL;
-	char * str;
+    version_pt version = NULL, clone = NULL;
+    char * str;
 
-	str = my_strdup("abc");
-	LONGS_EQUAL(CELIX_SUCCESS, version_createVersion(1, 2, 3, str, &version));
-	LONGS_EQUAL(CELIX_SUCCESS, version_clone(version, &clone));
-	CHECK_C(version != NULL);
+    str = my_strdup("abc");
+    LONGS_EQUAL(CELIX_SUCCESS, version_createVersion(1, 2, 3, str, &version));
+    LONGS_EQUAL(CELIX_SUCCESS, version_clone(version, &clone));
+    CHECK_C(version != NULL);
     LONGS_EQUAL(1, clone->major);
-	LONGS_EQUAL(2, clone->minor);
-	LONGS_EQUAL(3, clone->micro);
-	STRCMP_EQUAL("abc", clone->qualifier);
+    LONGS_EQUAL(2, clone->minor);
+    LONGS_EQUAL(3, clone->micro);
+    STRCMP_EQUAL("abc", clone->qualifier);
 
-	version_destroy(clone);
-	version_destroy(version);
-	free(str);
+    version_destroy(clone);
+    version_destroy(version);
+    free(str);
 }
 
 TEST(version, createFromString) {
-	version_pt version = NULL;
-	celix_status_t status = CELIX_SUCCESS;
-	char * str;
-
-	str = my_strdup("1");
-	LONGS_EQUAL(CELIX_SUCCESS, version_createVersionFromString(str, &version));
-	CHECK_C(version != NULL);
-	LONGS_EQUAL(1, version->major);
-
-	version_destroy(version);
-
-	free(str);
-	str = my_strdup("a");
-	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
-
-	free(str);
-	str = my_strdup("1.a");
-	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
-
-	free(str);
-	str = my_strdup("1.1.a");
-	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
-
-	free(str);
-	str = my_strdup("-1");
-	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
-
-	free(str);
-	str = my_strdup("1.2");
-	version = NULL;
-	LONGS_EQUAL(CELIX_SUCCESS, version_createVersionFromString(str, &version));
-	CHECK_C(version != NULL);
-	LONGS_EQUAL(1, version->major);
-	LONGS_EQUAL(2, version->minor);
-
-	version_destroy(version);
-
-	free(str);
-	str = my_strdup("1.2.3");
-	version = NULL;
-	status = version_createVersionFromString(str, &version);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(version != NULL);
-	LONGS_EQUAL(1, version->major);
-	LONGS_EQUAL(2, version->minor);
-	LONGS_EQUAL(3, version->micro);
-
-	version_destroy(version);
-	free(str);
-	str = my_strdup("1.2.3.abc");
-	version = NULL;
-	status = version_createVersionFromString(str, &version);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(version != NULL);
-    LONGS_EQUAL(1, version->major);
-	LONGS_EQUAL(2, version->minor);
-	LONGS_EQUAL(3, version->micro);
-	STRCMP_EQUAL("abc", version->qualifier);
-
-	version_destroy(version);
-	free(str);
-	str = my_strdup("1.2.3.abc_xyz");
-	version = NULL;
-	status = version_createVersionFromString(str, &version);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(version != NULL);
+    version_pt version = NULL;
+    celix_status_t status = CELIX_SUCCESS;
+    char * str;
+
+    str = my_strdup("1");
+    LONGS_EQUAL(CELIX_SUCCESS, version_createVersionFromString(str, &version));
+    CHECK_C(version != NULL);
     LONGS_EQUAL(1, version->major);
-	LONGS_EQUAL(2, version->minor);
-	LONGS_EQUAL(3, version->micro);
-	STRCMP_EQUAL("abc_xyz", version->qualifier);
-
-	version_destroy(version);
-	free(str);
-	str = my_strdup("1.2.3.abc-xyz");
-	version = NULL;
-	status = version_createVersionFromString(str, &version);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(version != NULL);
+
+    version_destroy(version);
+
+    free(str);
+    str = my_strdup("a");
+    LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
+
+    free(str);
+    str = my_strdup("1.a");
+    LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
+
+    free(str);
+    str = my_strdup("1.1.a");
+    LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
+
+    free(str);
+    str = my_strdup("-1");
+    LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
+
+    free(str);
+    str = my_strdup("1.2");
+    version = NULL;
+    LONGS_EQUAL(CELIX_SUCCESS, version_createVersionFromString(str, &version));
+    CHECK_C(version != NULL);
     LONGS_EQUAL(1, version->major);
-	LONGS_EQUAL(2, version->minor);
-	LONGS_EQUAL(3, version->micro);
-	STRCMP_EQUAL("abc-xyz", version->qualifier);
+    LONGS_EQUAL(2, version->minor);
+
+    version_destroy(version);
 
-	version_destroy(version);
-	free(str);
-	str = my_strdup("1.2.3.abc|xyz");
-	status = version_createVersionFromString(str, &version);
-	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status);
+    free(str);
+    str = my_strdup("1.2.3");
+    version = NULL;
+    status = version_createVersionFromString(str, &version);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(version != NULL);
+    LONGS_EQUAL(1, version->major);
+    LONGS_EQUAL(2, version->minor);
+    LONGS_EQUAL(3, version->micro);
+
+    version_destroy(version);
+    free(str);
+    str = my_strdup("1.2.3.abc");
+    version = NULL;
+    status = version_createVersionFromString(str, &version);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(version != NULL);
+    LONGS_EQUAL(1, version->major);
+    LONGS_EQUAL(2, version->minor);
+    LONGS_EQUAL(3, version->micro);
+    STRCMP_EQUAL("abc", version->qualifier);
+
+    version_destroy(version);
+    free(str);
+    str = my_strdup("1.2.3.abc_xyz");
+    version = NULL;
+    status = version_createVersionFromString(str, &version);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(version != NULL);
+    LONGS_EQUAL(1, version->major);
+    LONGS_EQUAL(2, version->minor);
+    LONGS_EQUAL(3, version->micro);
+    STRCMP_EQUAL("abc_xyz", version->qualifier);
+
+    version_destroy(version);
+    free(str);
+    str = my_strdup("1.2.3.abc-xyz");
+    version = NULL;
+    status = version_createVersionFromString(str, &version);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(version != NULL);
+    LONGS_EQUAL(1, version->major);
+    LONGS_EQUAL(2, version->minor);
+    LONGS_EQUAL(3, version->micro);
+    STRCMP_EQUAL("abc-xyz", version->qualifier);
+
+    version_destroy(version);
+    free(str);
+    str = my_strdup("1.2.3.abc|xyz");
+    status = version_createVersionFromString(str, &version);
+    LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status);
 
-	free(str);
+    free(str);
 }
 
 TEST(version, createEmptyVersion) {
-	version_pt version = NULL;
-	celix_status_t status = CELIX_SUCCESS;
+    version_pt version = NULL;
+    celix_status_t status = CELIX_SUCCESS;
 
-	status = version_createEmptyVersion(&version);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(version != NULL);
+    status = version_createEmptyVersion(&version);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(version != NULL);
     LONGS_EQUAL(0, version->major);
-	LONGS_EQUAL(0, version->minor);
-	LONGS_EQUAL(0, version->micro);
-	STRCMP_EQUAL("", version->qualifier);
+    LONGS_EQUAL(0, version->minor);
+    LONGS_EQUAL(0, version->micro);
+    STRCMP_EQUAL("", version->qualifier);
 
-	version_destroy(version);
+    version_destroy(version);
 }
 
 TEST(version, getters) {
-	version_pt version = NULL;
-	celix_status_t status = CELIX_SUCCESS;
-	char * str;
-	int major, minor, micro;
-	char *qualifier;
-
-	str = my_strdup("abc");
-	status = version_createVersion(1, 2, 3, str, &version);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(version != NULL);
-
-	version_getMajor(version, &major);
+    version_pt version = NULL;
+    celix_status_t status = CELIX_SUCCESS;
+    char * str;
+    int major, minor, micro;
+    char *qualifier;
+
+    str = my_strdup("abc");
+    status = version_createVersion(1, 2, 3, str, &version);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(version != NULL);
+
+    version_getMajor(version, &major);
     LONGS_EQUAL(1, major);
 
     version_getMinor(version, &minor);
-	LONGS_EQUAL(2, minor);
+    LONGS_EQUAL(2, minor);
 
-	version_getMicro(version, &micro);
-	LONGS_EQUAL(3, micro);
+    version_getMicro(version, &micro);
+    LONGS_EQUAL(3, micro);
 
-	version_getQualifier(version, &qualifier);
-	STRCMP_EQUAL("abc", qualifier);
+    version_getQualifier(version, &qualifier);
+    STRCMP_EQUAL("abc", qualifier);
 
-	version_destroy(version);
-	free(str);
+    version_destroy(version);
+    free(str);
 }
 
 TEST(version, compare) {
-	version_pt version = NULL, compare = NULL;
-	celix_status_t status = CELIX_SUCCESS;
-	char * str;
-	int result;
-
-	// Base version to compare
-	str = my_strdup("abc");
-	status = version_createVersion(1, 2, 3, str, &version);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(version != NULL);
-
-	// Compare equality
-	free(str);
-	str = my_strdup("abc");
-	compare = NULL;
-	status = version_createVersion(1, 2, 3, str, &compare);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(version != NULL);
-	status = version_compareTo(version, compare, &result);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	LONGS_EQUAL(0, result);
-
-	// Compare against a higher version
-	free(str);
-	str = my_strdup("bcd");
-	version_destroy(compare);
-	compare = NULL;
-	status = version_createVersion(1, 2, 3, str, &compare);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(version != NULL);
-	status = version_compareTo(version, compare, &result);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK(result < 0);
-
-	// Compare againts a lower version
-	free(str);
-	str = my_strdup("abc");
-	version_destroy(compare);
-	compare = NULL;
-	status = version_createVersion(1, 1, 3, str, &compare);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(version != NULL);
-	status = version_compareTo(version, compare, &result);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK(result > 0);
-
-	version_destroy(compare);
-	version_destroy(version);
-	free(str);
+    version_pt version = NULL, compare = NULL;
+    celix_status_t status = CELIX_SUCCESS;
+    char * str;
+    int result;
+
+    // Base version to compare
+    str = my_strdup("abc");
+    status = version_createVersion(1, 2, 3, str, &version);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(version != NULL);
+
+    // Compare equality
+    free(str);
+    str = my_strdup("abc");
+    compare = NULL;
+    status = version_createVersion(1, 2, 3, str, &compare);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(version != NULL);
+    status = version_compareTo(version, compare, &result);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    LONGS_EQUAL(0, result);
+
+    // Compare against a higher version
+    free(str);
+    str = my_strdup("bcd");
+    version_destroy(compare);
+    compare = NULL;
+    status = version_createVersion(1, 2, 3, str, &compare);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(version != NULL);
+    status = version_compareTo(version, compare, &result);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK(result < 0);
+
+    // Compare againts a lower version
+    free(str);
+    str = my_strdup("abc");
+    version_destroy(compare);
+    compare = NULL;
+    status = version_createVersion(1, 1, 3, str, &compare);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(version != NULL);
+    status = version_compareTo(version, compare, &result);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK(result > 0);
+
+    version_destroy(compare);
+    version_destroy(version);
+    free(str);
 }
 
 TEST(version, toString) {
-	version_pt version = NULL;
-	celix_status_t status = CELIX_SUCCESS;
-	char * str;
-	char *result = NULL;
-
-	str = my_strdup("abc");
-	status = version_createVersion(1, 2, 3, str, &version);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(version != NULL);
-
-	status = version_toString(version, &result);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(result != NULL);
-	STRCMP_EQUAL("1.2.3.abc", result);
-	free(result);
-
-	version_destroy(version);
-	version = NULL;
-	status = version_createVersion(1, 2, 3, NULL, &version);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(version != NULL);
-
-	status = version_toString(version, &result);
-	LONGS_EQUAL(CELIX_SUCCESS, status);
-	CHECK_C(result != NULL);
-	STRCMP_EQUAL("1.2.3", result);
-
-	version_destroy(version);
-	free(result);
-	free(str);
+    version_pt version = NULL;
+    celix_status_t status = CELIX_SUCCESS;
+    char * str;
+    char *result = NULL;
+
+    str = my_strdup("abc");
+    status = version_createVersion(1, 2, 3, str, &version);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(version != NULL);
+
+    status = version_toString(version, &result);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(result != NULL);
+    STRCMP_EQUAL("1.2.3.abc", result);
+    free(result);
+
+    version_destroy(version);
+    version = NULL;
+    status = version_createVersion(1, 2, 3, NULL, &version);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(version != NULL);
+
+    status = version_toString(version, &result);
+    LONGS_EQUAL(CELIX_SUCCESS, status);
+    CHECK_C(result != NULL);
+    STRCMP_EQUAL("1.2.3", result);
+
+    version_destroy(version);
+    free(result);
+    free(str);
 }
 
 TEST(version,semanticCompatibility) {
diff --git a/libs/utils/src/array_list.c b/libs/utils/src/array_list.c
index 20ad5b6..9def496 100644
--- a/libs/utils/src/array_list.c
+++ b/libs/utils/src/array_list.c
@@ -1,28 +1,29 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * array_list.c
  *
  *  \date       Aug 4, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -37,222 +38,222 @@ static bool celix_arrayList_equalsForElement(celix_array_list_t *list, celix_arr
 
 
 celix_status_t arrayList_create(array_list_pt *list) {
-	return arrayList_createWithEquals(arrayList_elementEquals, list);
+    return arrayList_createWithEquals(arrayList_elementEquals, list);
 }
 
 celix_status_t arrayList_createWithEquals(array_list_element_equals_pt equals, array_list_pt *list) {
-	*list = celix_arrayList_create();
-	if (*list != NULL) {
-		(*list)->equalsDeprecated = equals;
+    *list = celix_arrayList_create();
+    if (*list != NULL) {
+        (*list)->equalsDeprecated = equals;
 
-	}
-	return CELIX_SUCCESS;
+    }
+    return CELIX_SUCCESS;
 }
 
 void arrayList_destroy(array_list_pt list) {
-	celix_arrayList_destroy(list);
+    celix_arrayList_destroy(list);
 }
 
 static celix_status_t arrayList_elementEquals(const void *a, const void *b, bool *equals) {
-	*equals = (a == b);
-	return CELIX_SUCCESS;
+    *equals = (a == b);
+    return CELIX_SUCCESS;
 }
 
 static bool celix_arrayList_defaultEquals(celix_array_list_entry_t a, celix_array_list_entry_t b) {
-	return a.longVal == b.longVal; //just compare as long int
+    return a.longVal == b.longVal; //just compare as long int
 }
 
 static bool celix_arrayList_equalsForElement(celix_array_list_t *list, celix_array_list_entry_t a, celix_array_list_entry_t b) {
-	bool equals = false;
-	if (list != NULL) {
-		if (list->equalsDeprecated != NULL) {
-			list->equalsDeprecated(a.voidPtrVal, b.voidPtrVal, &equals);
-		} else if (list->equals != NULL) {
-			equals = list->equals(a, b);
-		}
-	}
-	return equals;
+    bool equals = false;
+    if (list != NULL) {
+        if (list->equalsDeprecated != NULL) {
+            list->equalsDeprecated(a.voidPtrVal, b.voidPtrVal, &equals);
+        } else if (list->equals != NULL) {
+            equals = list->equals(a, b);
+        }
+    }
+    return equals;
 }
 
 void arrayList_trimToSize(array_list_pt list) {
-	list->modCount++;
-	size_t oldCapacity = list->capacity;
-	if (list->size < oldCapacity) {
-		celix_array_list_entry_t * newList = realloc(list->elementData, sizeof(void *) * list->size);
-		list->capacity = list->size;
-		list->elementData = newList;
-	}
+    list->modCount++;
+    size_t oldCapacity = list->capacity;
+    if (list->size < oldCapacity) {
+        celix_array_list_entry_t * newList = realloc(list->elementData, sizeof(void *) * list->size);
+        list->capacity = list->size;
+        list->elementData = newList;
+    }
 }
 
 void arrayList_ensureCapacity(array_list_pt list, int capacity) {
-	celix_array_list_entry_t *newList;
-	list->modCount++;
-	size_t oldCapacity = list->capacity;
-	if (capacity > oldCapacity) {
-		size_t newCapacity = (oldCapacity * 3) / 2 + 1;
-		if (newCapacity < capacity) {
-			newCapacity = capacity;
-		}
-		newList = realloc(list->elementData, sizeof(void *) * newCapacity);
-		list->capacity = newCapacity;
-		list->elementData = newList;
-	}
+    celix_array_list_entry_t *newList;
+    list->modCount++;
+    size_t oldCapacity = list->capacity;
+    if (capacity > oldCapacity) {
+        size_t newCapacity = (oldCapacity * 3) / 2 + 1;
+        if (newCapacity < capacity) {
+            newCapacity = capacity;
+        }
+        newList = realloc(list->elementData, sizeof(void *) * newCapacity);
+        list->capacity = newCapacity;
+        list->elementData = newList;
+    }
 }
 
 unsigned int arrayList_size(array_list_pt list) {
-	return (int)list->size;
+    return (int)list->size;
 }
 
 bool arrayList_isEmpty(array_list_pt list) {
-	return list->size == 0;
+    return list->size == 0;
 }
 
 bool arrayList_contains(array_list_pt list, void * element) {
-	int index = arrayList_indexOf(list, element);
-	return index >= 0;
+    int index = arrayList_indexOf(list, element);
+    return index >= 0;
 }
 
 int arrayList_indexOf(array_list_pt list, void * element) {
-	if (element == NULL) {
-		unsigned int i = 0;
-		for (i = 0; i < list->size; i++) {
-			if (list->elementData[i].voidPtrVal == NULL) {
-				return i;
-			}
-		}
-	} else {
-		unsigned int i = 0;
-		for (i = 0; i < list->size; i++) {
-			celix_array_list_entry_t entry;
-			memset(&entry, 0, sizeof(entry));
-			entry.voidPtrVal = element;
-			bool equals = celix_arrayList_equalsForElement(list, entry, list->elementData[i]);
-			if (equals) {
-				return i;
-			}
-		}
-	}
-	return -1;
+    if (element == NULL) {
+        unsigned int i = 0;
+        for (i = 0; i < list->size; i++) {
+            if (list->elementData[i].voidPtrVal == NULL) {
+                return i;
+            }
+        }
+    } else {
+        unsigned int i = 0;
+        for (i = 0; i < list->size; i++) {
+            celix_array_list_entry_t entry;
+            memset(&entry, 0, sizeof(entry));
+            entry.voidPtrVal = element;
+            bool equals = celix_arrayList_equalsForElement(list, entry, list->elementData[i]);
+            if (equals) {
+                return i;
+            }
+        }
+    }
+    return -1;
 }
 
 int arrayList_lastIndexOf(array_list_pt list, void * element) {
-	if (element == NULL) {
-		int i = 0;
-		int size = (int)list->size;
-		for (i = size - 1; i >= 0; i--) {
-			if (list->elementData[i].voidPtrVal == NULL) {
-				return (int)i;
-			}
-		}
-	} else {
-		int i = 0;
-		int size = (int)list->size;
-		for (i = size - 1; i >= 0; i--) {
-			celix_array_list_entry_t entry;
-			memset(&entry, 0, sizeof(entry));
-			entry.voidPtrVal = element;
-			bool equals = celix_arrayList_equalsForElement(list, entry, list->elementData[i]);
-			if (equals) {
-				return (int)i;
-			}
-		}
-	}
-	return -1;
+    if (element == NULL) {
+        int i = 0;
+        int size = (int)list->size;
+        for (i = size - 1; i >= 0; i--) {
+            if (list->elementData[i].voidPtrVal == NULL) {
+                return (int)i;
+            }
+        }
+    } else {
+        int i = 0;
+        int size = (int)list->size;
+        for (i = size - 1; i >= 0; i--) {
+            celix_array_list_entry_t entry;
+            memset(&entry, 0, sizeof(entry));
+            entry.voidPtrVal = element;
+            bool equals = celix_arrayList_equalsForElement(list, entry, list->elementData[i]);
+            if (equals) {
+                return (int)i;
+            }
+        }
+    }
+    return -1;
 }
 
 void * arrayList_get(array_list_pt list, unsigned int index) {
-	if (index >= list->size) {
-		return NULL;
-	}
+    if (index >= list->size) {
+        return NULL;
+    }
 
-	return list->elementData[index].voidPtrVal;
+    return list->elementData[index].voidPtrVal;
 }
 
 void * arrayList_set(array_list_pt list, unsigned int index, void * element) {
-	void * oldElement;
-	if (index >= list->size) {
-		return NULL;
-	}
+    void * oldElement;
+    if (index >= list->size) {
+        return NULL;
+    }
 
-	oldElement = list->elementData[index].voidPtrVal;
-	memset(&list->elementData[index], 0, sizeof(celix_array_list_entry_t));
-	list->elementData[index].voidPtrVal = element;
-	return oldElement;
+    oldElement = list->elementData[index].voidPtrVal;
+    memset(&list->elementData[index], 0, sizeof(celix_array_list_entry_t));
+    list->elementData[index].voidPtrVal = element;
+    return oldElement;
 }
 
 bool arrayList_add(array_list_pt list, void * element) {
-	arrayList_ensureCapacity(list, (int)list->size + 1);
-	memset(&list->elementData[list->size], 0, sizeof(celix_array_list_entry_t));
-	list->elementData[list->size++].voidPtrVal = element;
-	return true;
+    arrayList_ensureCapacity(list, (int)list->size + 1);
+    memset(&list->elementData[list->size], 0, sizeof(celix_array_list_entry_t));
+    list->elementData[list->size++].voidPtrVal = element;
+    return true;
 }
 
 int arrayList_addIndex(array_list_pt list, unsigned int index, void * element) {
-	size_t numMoved;
-	if (index > list->size) {
-		return -1;
-	}
-	arrayList_ensureCapacity(list, (int)list->size+1);
-	numMoved = list->size - index;
-	memmove(list->elementData+(index+1), list->elementData+index, sizeof(void *) * numMoved);
+    size_t numMoved;
+    if (index > list->size) {
+        return -1;
+    }
+    arrayList_ensureCapacity(list, (int)list->size+1);
+    numMoved = list->size - index;
+    memmove(list->elementData+(index+1), list->elementData+index, sizeof(void *) * numMoved);
 
-	list->elementData[index].voidPtrVal = element;
-	list->size++;
-	return 0;
+    list->elementData[index].voidPtrVal = element;
+    list->size++;
+    return 0;
 }
 
 void * arrayList_remove(array_list_pt list, unsigned int index) {
-	void * oldElement;
-	size_t numMoved;
-	if (index >= list->size) {
-		return NULL;
-	}
+    void * oldElement;
+    size_t numMoved;
+    if (index >= list->size) {
+        return NULL;
+    }
 
-	list->modCount++;
-	oldElement = list->elementData[index].voidPtrVal;
-	numMoved = list->size - index - 1;
-	memmove(list->elementData+index, list->elementData+index+1, sizeof(void *) * numMoved);
-	memset(&list->elementData[--list->size], 0, sizeof(celix_array_list_entry_t));
+    list->modCount++;
+    oldElement = list->elementData[index].voidPtrVal;
+    numMoved = list->size - index - 1;
+    memmove(list->elementData+index, list->elementData+index+1, sizeof(void *) * numMoved);
+    memset(&list->elementData[--list->size], 0, sizeof(celix_array_list_entry_t));
 
-	return oldElement;
+    return oldElement;
 }
 
 void arrayList_fastRemove(array_list_pt list, unsigned int index) {
-	size_t numMoved;
-	list->modCount++;
+    size_t numMoved;
+    list->modCount++;
 
-	numMoved = list->size - index - 1;
-	memmove(list->elementData+index, list->elementData+index+1, sizeof(void *) * numMoved);
-	memset(&list->elementData[--list->size], 0, sizeof(celix_array_list_entry_t));
+    numMoved = list->size - index - 1;
+    memmove(list->elementData+index, list->elementData+index+1, sizeof(void *) * numMoved);
+    memset(&list->elementData[--list->size], 0, sizeof(celix_array_list_entry_t));
 }
 
 bool arrayList_removeElement(array_list_pt list, void * element) {
-	if (element == NULL) {
-		unsigned int i = 0;
-		for (i = 0; i < list->size; i++) {
-			if (list->elementData[i].voidPtrVal == NULL) {
-				arrayList_fastRemove(list, i);
-				return true;
-			}
-		}
-	} else {
-		unsigned int i = 0;
-		for (i = 0; i < list->size; i++) {
-			celix_array_list_entry_t entry;
-			memset(&entry, 0, sizeof(entry));
-			entry.voidPtrVal = element;
-			bool equals = celix_arrayList_equalsForElement(list, entry, list->elementData[i]);
-			if (equals) {
-				arrayList_fastRemove(list, i);
-				return true;
-			}
-		}
-	}
-	return false;
+    if (element == NULL) {
+        unsigned int i = 0;
+        for (i = 0; i < list->size; i++) {
+            if (list->elementData[i].voidPtrVal == NULL) {
+                arrayList_fastRemove(list, i);
+                return true;
+            }
+        }
+    } else {
+        unsigned int i = 0;
+        for (i = 0; i < list->size; i++) {
+            celix_array_list_entry_t entry;
+            memset(&entry, 0, sizeof(entry));
+            entry.voidPtrVal = element;
+            bool equals = celix_arrayList_equalsForElement(list, entry, list->elementData[i]);
+            if (equals) {
+                arrayList_fastRemove(list, i);
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
 void arrayList_clear(array_list_pt list) {
-	celix_arrayList_clear(list);
+    celix_arrayList_clear(list);
 }
 
 bool arrayList_addAll(array_list_pt list, array_list_pt toAdd) {
@@ -268,83 +269,83 @@ bool arrayList_addAll(array_list_pt list, array_list_pt toAdd) {
 }
 
 array_list_pt arrayList_clone(array_list_pt list) {
-	unsigned int i;
-	array_list_pt new = NULL;
-	arrayList_create(&new);
-//	arrayList_ensureCapacity(new, list->size);
-//	memcpy(new->elementData, list->elementData, list->size);
-//	new->size = list->size;
-	
-	for (i = 0; i < arrayList_size(list); i++) {
-		arrayList_add(new, arrayList_get(list, i));
-	}
-	new->modCount = 0;
-	return new;
+    unsigned int i;
+    array_list_pt new = NULL;
+    arrayList_create(&new);
+//    arrayList_ensureCapacity(new, list->size);
+//    memcpy(new->elementData, list->elementData, list->size);
+//    new->size = list->size;
+    
+    for (i = 0; i < arrayList_size(list); i++) {
+        arrayList_add(new, arrayList_get(list, i));
+    }
+    new->modCount = 0;
+    return new;
 }
 
 array_list_iterator_pt arrayListIterator_create(array_list_pt list) {
-	array_list_iterator_pt iterator = (array_list_iterator_pt) malloc(sizeof(*iterator));
+    array_list_iterator_pt iterator = (array_list_iterator_pt) malloc(sizeof(*iterator));
 
-	iterator->lastReturned = -1;
-	iterator->cursor = 0;
-	iterator->list = list;
-	iterator->expectedModificationCount = list->modCount;
+    iterator->lastReturned = -1;
+    iterator->cursor = 0;
+    iterator->list = list;
+    iterator->expectedModificationCount = list->modCount;
 
-	return iterator;
+    return iterator;
 }
 
 void arrayListIterator_destroy(array_list_iterator_pt iterator) {
-	iterator->lastReturned = -1;
-	iterator->cursor = 0;
-	iterator->expectedModificationCount = 0;
-	iterator->list = NULL;
-	free(iterator);
+    iterator->lastReturned = -1;
+    iterator->cursor = 0;
+    iterator->expectedModificationCount = 0;
+    iterator->list = NULL;
+    free(iterator);
 }
 
 bool arrayListIterator_hasNext(array_list_iterator_pt iterator) {
-	return iterator->cursor != iterator->list->size;
+    return iterator->cursor != iterator->list->size;
 }
 
 void * arrayListIterator_next(array_list_iterator_pt iterator) {
-	void * next;
-	if (iterator->expectedModificationCount != iterator->list->modCount) {
-		return NULL;
-	}
-	next = arrayList_get(iterator->list, iterator->cursor);
-	iterator->lastReturned = iterator->cursor++;
-	return next;
+    void * next;
+    if (iterator->expectedModificationCount != iterator->list->modCount) {
+        return NULL;
+    }
+    next = arrayList_get(iterator->list, iterator->cursor);
+    iterator->lastReturned = iterator->cursor++;
+    return next;
 }
 
 bool arrayListIterator_hasPrevious(array_list_iterator_pt iterator) {
-	return iterator->cursor != 0;
+    return iterator->cursor != 0;
 }
 
 void * arrayListIterator_previous(array_list_iterator_pt iterator) {
-	int i;
-	void * previous;
-	if (iterator->expectedModificationCount != iterator->list->modCount) {
-		return NULL;
-	}
-	i = iterator->cursor - 1;
-	previous = arrayList_get(iterator->list, i);
-	iterator->lastReturned = iterator->cursor = i;
-	return previous;
+    int i;
+    void * previous;
+    if (iterator->expectedModificationCount != iterator->list->modCount) {
+        return NULL;
+    }
+    i = iterator->cursor - 1;
+    previous = arrayList_get(iterator->list, i);
+    iterator->lastReturned = iterator->cursor = i;
+    return previous;
 }
 
 void arrayListIterator_remove(array_list_iterator_pt iterator) {
-	if (iterator->lastReturned == -1) {
-		return;
-	}
-	if (iterator->expectedModificationCount != iterator->list->modCount) {
-		return;
-	}
-	if (arrayList_remove(iterator->list, iterator->lastReturned) != NULL) {
-		if (iterator->lastReturned < iterator->cursor) {
-			iterator->cursor--;
-		}
-		iterator->lastReturned = -1;
-		iterator->expectedModificationCount = iterator->list->modCount;
-	}
+    if (iterator->lastReturned == -1) {
+        return;
+    }
+    if (iterator->expectedModificationCount != iterator->list->modCount) {
+        return;
+    }
+    if (arrayList_remove(iterator->list, iterator->lastReturned) != NULL) {
+        if (iterator->lastReturned < iterator->cursor) {
+            iterator->cursor--;
+        }
+        iterator->lastReturned = -1;
+        iterator->expectedModificationCount = iterator->list->modCount;
+    }
 }
 
 
@@ -357,40 +358,40 @@ void arrayListIterator_remove(array_list_iterator_pt iterator) {
  **********************************************************************************************************************/
 
 celix_array_list_t* celix_arrayList_create() {
-	return celix_arrayList_createWithEquals(celix_arrayList_defaultEquals);
+    return celix_arrayList_createWithEquals(celix_arrayList_defaultEquals);
 }
 
 celix_array_list_t* celix_arrayList_createWithEquals(celix_arrayList_equals_fp equals) {
-	array_list_t *list = calloc(1, sizeof(*list));
-	if (list != NULL) {
-		list->capacity = 10;
-		list->elementData = malloc(sizeof(void*) * list->capacity);
-		list->equals = equals;
-	}
-	return list;
+    array_list_t *list = calloc(1, sizeof(*list));
+    if (list != NULL) {
+        list->capacity = 10;
+        list->elementData = malloc(sizeof(void*) * list->capacity);
+        list->equals = equals;
+    }
+    return list;
 }
 
 void celix_arrayList_destroy(celix_array_list_t *list) {
-	list->size = 0;
-	free(list->elementData);
-	free(list);
+    list->size = 0;
+    free(list->elementData);
+    free(list);
 }
 
 int celix_arrayList_size(const celix_array_list_t *list) {
-	return list->size;
+    return list->size;
 }
 
 static celix_array_list_entry_t arrayList_getEntry(const celix_array_list_t *list, int index) {
-	celix_array_list_entry_t entry;
-	memset(&entry, 0, sizeof(entry));
-	if (index < list->size) {
-		entry = list->elementData[index];
-	}
-	return entry;
+    celix_array_list_entry_t entry;
+    memset(&entry, 0, sizeof(entry));
+    if (index < list->size) {
+        entry = list->elementData[index];
+    }
+    return entry;
 }
 
 void* celix_arrayList_get(const celix_array_list_t *list, int index) {
-	return arrayList_getEntry(list, index).voidPtrVal;
+    return arrayList_getEntry(list, index).voidPtrVal;
 }
 
 int celix_arrayList_getInt(const celix_array_list_t *list, int index) { return arrayList_getEntry(list, index).intVal; }
@@ -403,163 +404,163 @@ bool celix_arrayList_getBool(const celix_array_list_t *list, int index) { return
 size_t celix_arrayList_getSize(const celix_array_list_t *list, int index) { return arrayList_getEntry(list, index).sizeVal; }
 
 static void arrayList_addEntry(celix_array_list_t *list, celix_array_list_entry_t entry) {
-	arrayList_ensureCapacity(list, (int)list->size + 1);
-	memset(&list->elementData[list->size], 0, sizeof(entry));
-	list->elementData[list->size++] = entry;
+    arrayList_ensureCapacity(list, (int)list->size + 1);
+    memset(&list->elementData[list->size], 0, sizeof(entry));
+    list->elementData[list->size++] = entry;
 }
 
 void celix_arrayList_add(celix_array_list_t *list, void * element) {
-	celix_array_list_entry_t entry = { .voidPtrVal = element };
-	arrayList_addEntry(list, entry);
+    celix_array_list_entry_t entry = { .voidPtrVal = element };
+    arrayList_addEntry(list, entry);
 }
 
 void celix_arrayList_addInt(celix_array_list_t *list, int val) { 
-	celix_array_list_entry_t entry; 
-	memset(&entry, 0, sizeof(entry)); 
-	entry.intVal = val; 
-	arrayList_addEntry(list, entry);
+    celix_array_list_entry_t entry; 
+    memset(&entry, 0, sizeof(entry)); 
+    entry.intVal = val; 
+    arrayList_addEntry(list, entry);
 }
 void celix_arrayList_addLong(celix_array_list_t *list, long val) { 
-	celix_array_list_entry_t entry; 
-	memset(&entry, 0, sizeof(entry)); 
-	entry.longVal = val; 
-	arrayList_addEntry(list, entry);
+    celix_array_list_entry_t entry; 
+    memset(&entry, 0, sizeof(entry)); 
+    entry.longVal = val; 
+    arrayList_addEntry(list, entry);
 }
 void celix_arrayList_addUInt(celix_array_list_t *list, unsigned int val) { 
-	celix_array_list_entry_t entry; 
-	memset(&entry, 0, sizeof(entry)); 
-	entry.uintVal = val; 
-	arrayList_addEntry(list, entry);
+    celix_array_list_entry_t entry; 
+    memset(&entry, 0, sizeof(entry)); 
+    entry.uintVal = val; 
+    arrayList_addEntry(list, entry);
 }
 void celix_arrayList_addULong(celix_array_list_t *list, unsigned long val) { 
-	celix_array_list_entry_t entry; 
-	memset(&entry, 0, sizeof(entry)); 
-	entry.ulongVal = val; 
-	arrayList_addEntry(list, entry);
+    celix_array_list_entry_t entry; 
+    memset(&entry, 0, sizeof(entry)); 
+    entry.ulongVal = val; 
+    arrayList_addEntry(list, entry);
 }
 void celix_arrayList_addDouble(celix_array_list_t *list, double val) { 
-	celix_array_list_entry_t entry; 
-	memset(&entry, 0, sizeof(entry)); 
-	entry.doubleVal = val; 
-	arrayList_addEntry(list, entry);
+    celix_array_list_entry_t entry; 
+    memset(&entry, 0, sizeof(entry)); 
+    entry.doubleVal = val; 
+    arrayList_addEntry(list, entry);
 }
 void celix_arrayList_addFloat(celix_array_list_t *list, float val) { 
-	celix_array_list_entry_t entry; 
-	memset(&entry, 0, sizeof(entry)); 
-	entry.floatVal = val; 
-	arrayList_addEntry(list, entry);
+    celix_array_list_entry_t entry; 
+    memset(&entry, 0, sizeof(entry)); 
+    entry.floatVal = val; 
+    arrayList_addEntry(list, entry);
 }
 void celix_arrayList_addBool(celix_array_list_t *list, bool val) { 
-	celix_array_list_entry_t entry; 
-	memset(&entry, 0, sizeof(entry)); 
-	entry.boolVal = val; 
-	arrayList_addEntry(list, entry);
+    celix_array_list_entry_t entry; 
+    memset(&entry, 0, sizeof(entry)); 
+    entry.boolVal = val; 
+    arrayList_addEntry(list, entry);
 }
 void celix_arrayList_addSize(celix_array_list_t *list, size_t val) { 
-	celix_array_list_entry_t entry; 
-	memset(&entry, 0, sizeof(entry)); 
-	entry.sizeVal = val; 
-	arrayList_addEntry(list, entry);
+    celix_array_list_entry_t entry; 
+    memset(&entry, 0, sizeof(entry)); 
+    entry.sizeVal = val; 
+    arrayList_addEntry(list, entry);
 }
 
 int celix_arrayList_indexOf(celix_array_list_t *list, celix_array_list_entry_t entry) {
-	size_t size = celix_arrayList_size(list);
-	int i;
-	int index = -1;
-	for (i = 0 ; i < size ; ++i) {
-		bool eq = celix_arrayList_equalsForElement(list, entry, list->elementData[i]);
-		if (eq) {
-			index = i;
-			break;
-		}
-	}
-	return index;
+    size_t size = celix_arrayList_size(list);
+    int i;
+    int index = -1;
+    for (i = 0 ; i < size ; ++i) {
+        bool eq = celix_arrayList_equalsForElement(list, entry, list->elementData[i]);
+        if (eq) {
+            index = i;
+            break;
+        }
+    }
+    return index;
 }
 void celix_arrayList_removeAt(celix_array_list_t *list, int index) {
-	if (index >= 0 && index < list->size) {
-		list->modCount++;
-		size_t numMoved = list->size - index - 1;
-		memmove(list->elementData+index, list->elementData+index+1, sizeof(void *) * numMoved);
-		memset(&list->elementData[--list->size], 0, sizeof(celix_array_list_entry_t));
-	}
+    if (index >= 0 && index < list->size) {
+        list->modCount++;
+        size_t numMoved = list->size - index - 1;
+        memmove(list->elementData+index, list->elementData+index+1, sizeof(void *) * numMoved);
+        memset(&list->elementData[--list->size], 0, sizeof(celix_array_list_entry_t));
+    }
 }
 
 void celix_arrayList_removeEntry(celix_array_list_t *list, celix_array_list_entry_t entry) {
-	int index = celix_arrayList_indexOf(list, entry);
-	celix_arrayList_removeAt(list, index);
+    int index = celix_arrayList_indexOf(list, entry);
+    celix_arrayList_removeAt(list, index);
 }
 
 
 void celix_arrayList_remove(celix_array_list_t *list, void *ptr) {
-	celix_array_list_entry_t entry;
+    celix_array_list_entry_t entry;
         memset(&entry, 0, sizeof(entry));
-	entry.voidPtrVal = ptr;
-	celix_arrayList_removeEntry(list, entry);
+    entry.voidPtrVal = ptr;
+    celix_arrayList_removeEntry(list, entry);
 }
 
 void celix_arrayList_removeInt(celix_array_list_t *list, int val) {
-	celix_array_list_entry_t entry;
+    celix_array_list_entry_t entry;
         memset(&entry, 0, sizeof(entry));
-	entry.intVal = val;
-	celix_arrayList_removeEntry(list, entry);
+    entry.intVal = val;
+    celix_arrayList_removeEntry(list, entry);
 }
 
 void celix_arrayList_removeLong(celix_array_list_t *list, long val) {
-	celix_array_list_entry_t entry;
+    celix_array_list_entry_t entry;
         memset(&entry, 0, sizeof(entry));
-	entry.longVal = val;
-	celix_arrayList_removeEntry(list, entry);
+    entry.longVal = val;
+    celix_arrayList_removeEntry(list, entry);
 }
 
 void celix_arrayList_removeUInt(celix_array_list_t *list, unsigned int val) {
-	celix_array_list_entry_t entry;
+    celix_array_list_entry_t entry;
         memset(&entry, 0, sizeof(entry));
-	entry.uintVal = val;
-	celix_arrayList_removeEntry(list, entry);
+    entry.uintVal = val;
+    celix_arrayList_removeEntry(list, entry);
 }
 
 void celix_arrayList_removeULong(celix_array_list_t *list, unsigned long val) {
-	celix_array_list_entry_t entry;
+    celix_array_list_entry_t entry;
         memset(&entry, 0, sizeof(entry));
-	entry.ulongVal = val;
-	celix_arrayList_removeEntry(list, entry);
+    entry.ulongVal = val;
+    celix_arrayList_removeEntry(list, entry);
 }
 
 void celix_arrayList_removeFloat(celix_array_list_t *list, float val) {
-	celix_array_list_entry_t entry;
+    celix_array_list_entry_t entry;
         memset(&entry, 0, sizeof(entry));
-	entry.floatVal = val;
-	celix_arrayList_removeEntry(list, entry);
+    entry.floatVal = val;
+    celix_arrayList_removeEntry(list, entry);
 }
 
 void celix_arrayList_removeDouble(celix_array_list_t *list, double val) {
-	celix_array_list_entry_t entry;
+    celix_array_list_entry_t entry;
         memset(&entry, 0, sizeof(entry));
-	entry.doubleVal = val;
-	celix_arrayList_removeEntry(list, entry);
+    entry.doubleVal = val;
+    celix_arrayList_removeEntry(list, entry);
 }
 
 void celix_arrayList_removeBool(celix_array_list_t *list, bool val) {
-	celix_array_list_entry_t entry;
+    celix_array_list_entry_t entry;
         memset(&entry, 0, sizeof(entry));
-	entry.boolVal = val;
-	celix_arrayList_removeEntry(list, entry);
+    entry.boolVal = val;
+    celix_arrayList_removeEntry(list, entry);
 }
 
 void celix_arrayList_removeSize(celix_array_list_t *list, size_t val) {
-	celix_array_list_entry_t entry;
+    celix_array_list_entry_t entry;
         memset(&entry, 0, sizeof(entry));
-	entry.sizeVal = val;
-	celix_arrayList_removeEntry(list, entry);
+    entry.sizeVal = val;
+    celix_arrayList_removeEntry(list, entry);
 }
 
 void celix_arrayList_clear(celix_array_list_t *list) {
-	unsigned int i;
-	list->modCount++;
-
-	for (i = 0; i < list->size; i++) {
-		// free(list->elementData[i]);
-		memset(&list->elementData[i], 0, sizeof(celix_array_list_entry_t));
-	}
-	list->size = 0;
+    unsigned int i;
+    list->modCount++;
+
+    for (i = 0; i < list->size; i++) {
+        // free(list->elementData[i]);
+        memset(&list->elementData[i], 0, sizeof(celix_array_list_entry_t));
+    }
+    list->size = 0;
 }
diff --git a/libs/utils/src/array_list_private.h b/libs/utils/src/array_list_private.h
index df37354..89d1d74 100644
--- a/libs/utils/src/array_list_private.h
+++ b/libs/utils/src/array_list_private.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * array_list_private.h
  *
  *  \date       Aug 4, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef array_list_t_PRIVATE_H_
@@ -30,21 +30,21 @@
 #include "array_list.h"
 
 struct celix_array_list {
-	celix_array_list_entry_t* elementData;
-	size_t size;
-	size_t capacity;
+    celix_array_list_entry_t* elementData;
+    size_t size;
+    size_t capacity;
 
-	unsigned int modCount;
+    unsigned int modCount;
 
-	array_list_element_equals_pt equalsDeprecated;
-	celix_arrayList_equals_fp  equals;
+    array_list_element_equals_pt equalsDeprecated;
+    celix_arrayList_equals_fp  equals;
 };
 
 struct celix_array_list_iterator {
-	array_list_pt list;
-	unsigned int cursor;
-	int lastReturned;
-	unsigned int expectedModificationCount;
+    array_list_pt list;
+    unsigned int cursor;
+    int lastReturned;
+    unsigned int expectedModificationCount;
 };
 
 void * arrayList_remove(array_list_pt list, unsigned int index);
diff --git a/libs/utils/src/celix_threads.c b/libs/utils/src/celix_threads.c
index f01d258..58a8528 100644
--- a/libs/utils/src/celix_threads.c
+++ b/libs/utils/src/celix_threads.c
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * celix_threads.c
@@ -33,23 +33,23 @@
 celix_status_t celixThread_create(celix_thread_t *new_thread, celix_thread_attr_t *attr, celix_thread_start_t func, void *data) {
     celix_status_t status = CELIX_SUCCESS;
 
-	if (pthread_create(&(*new_thread).thread, attr, func, data) != 0) {
-		status = CELIX_BUNDLE_EXCEPTION;
-	}
-	else {
-		(*new_thread).threadInitialized = true;
-	}
+    if (pthread_create(&(*new_thread).thread, attr, func, data) != 0) {
+        status = CELIX_BUNDLE_EXCEPTION;
+    }
+    else {
+        (*new_thread).threadInitialized = true;
+    }
 
-	return status;
+    return status;
 }
 
 #if defined(_GNU_SOURCE) && defined(__linux__)
 void celixThread_setName(celix_thread_t *thread, const char *threadName) {
-	pthread_setname_np(thread->thread, threadName);
+    pthread_setname_np(thread->thread, threadName);
 }
 #else
 void celixThread_setName(celix_thread_t *thread __attribute__((unused)), const char *threadName  __attribute__((unused))) {
-	//nop
+    //nop
 }
 #endif
 
@@ -63,14 +63,14 @@ celix_status_t celixThread_detach(celix_thread_t thread) {
 }
 
 celix_status_t celixThread_join(celix_thread_t thread, void **retVal) {
-	celix_status_t status = CELIX_SUCCESS;
+    celix_status_t status = CELIX_SUCCESS;
 
-	if (pthread_join(thread.thread, retVal) != 0) {
-		status = CELIX_BUNDLE_EXCEPTION;
-	}
+    if (pthread_join(thread.thread, retVal) != 0) {
+        status = CELIX_BUNDLE_EXCEPTION;
+    }
 
     // #TODO make thread a pointer? Now this statement has no effect
-	// thread.threadInitialized = false;
+    // thread.threadInitialized = false;
 
     return status;
 }
@@ -80,12 +80,12 @@ celix_status_t celixThread_kill(celix_thread_t thread, int sig) {
 }
 
 celix_thread_t celixThread_self() {
-	celix_thread_t thread;
+    celix_thread_t thread;
 
-	thread.thread = pthread_self();
-	thread.threadInitialized = true;
+    thread.thread = pthread_self();
+    thread.threadInitialized = true;
 
-	return thread;
+    return thread;
 }
 
 int celixThread_equals(celix_thread_t thread1, celix_thread_t thread2) {
@@ -114,33 +114,33 @@ celix_status_t celixThreadMutex_unlock(celix_thread_mutex_t *mutex) {
 }
 
 celix_status_t celixThreadMutexAttr_create(celix_thread_mutexattr_t *attr) {
-	return pthread_mutexattr_init(attr);
+    return pthread_mutexattr_init(attr);
 }
 
 celix_status_t celixThreadMutexAttr_destroy(celix_thread_mutexattr_t *attr) {
-	return pthread_mutexattr_destroy(attr);
+    return pthread_mutexattr_destroy(attr);
 }
 
 celix_status_t celixThreadMutexAttr_settype(celix_thread_mutexattr_t *attr, int type) {
-	celix_status_t status;
-	switch(type) {
-		case CELIX_THREAD_MUTEX_NORMAL :
... 4917 lines suppressed ...


[celix] 02/03: Updated celix-examples to use celix_properties_t* over properties_pt

Posted by rl...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

rlenferink pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/celix.git

commit 9c1b9a26077896ec39ca7967ccf64b881e06f986
Author: Roy Lenferink <le...@gmail.com>
AuthorDate: Wed Jul 17 18:53:53 2019 +0200

    Updated celix-examples to use celix_properties_t* over properties_pt
    
    Updated formatting as well
---
 .../bundle_with_private_lib/src/activator.c        | 44 +++++------
 .../bundle_with_private_lib/tlib/include/test.h    | 28 +++----
 .../bundle_with_private_lib/tlib/src/test.c        | 28 +++----
 .../celix-examples/civetweb/resources/index.html   | 29 ++++---
 .../celix-examples/civetweb/resources/script.js    | 30 +++----
 .../celix-examples/civetweb/src/bundle_activator.c | 32 ++++----
 .../celix-examples/dm_example/api/include/phase1.h | 36 ++++-----
 .../celix-examples/dm_example/api/include/phase2.h | 36 ++++-----
 .../dm_example/phase1/src/phase1_activator.c       | 82 +++++++++----------
 .../dm_example/phase1/src/phase1_cmp.c             | 61 +++++++-------
 .../dm_example/phase1/src/phase1_cmp.h             | 32 ++++----
 .../dm_example/phase2a/src/phase2a_activator.c     | 80 +++++++++----------
 .../dm_example/phase2a/src/phase2a_cmp.c           | 55 ++++++-------
 .../dm_example/phase2a/src/phase2a_cmp.h           | 32 ++++----
 .../dm_example/phase2b/src/phase2b_activator.c     | 92 +++++++++++-----------
 .../dm_example/phase2b/src/phase2b_cmp.c           | 55 ++++++-------
 .../dm_example/phase2b/src/phase2b_cmp.h           | 32 ++++----
 .../dm_example/phase3/src/phase3_activator.c       | 88 ++++++++++-----------
 .../dm_example/phase3/src/phase3_cmp.c             | 55 ++++++-------
 .../dm_example/phase3/src/phase3_cmp.h             | 32 ++++----
 examples/celix-examples/embedding/src/main.c       | 58 +++++++-------
 .../celix-examples/export_import/CMakeLists.txt    | 81 ++++++++++---------
 .../celix-examples/export_import/include/test.h    | 28 +++----
 .../celix-examples/export_import/include/test2.h   | 28 +++----
 .../celix-examples/export_import/src/activator.c   | 63 +++++++--------
 examples/celix-examples/export_import/src/test.c   | 28 +++----
 examples/celix-examples/export_import/src/test2.c  | 28 +++----
 .../hello_world_c/src/bundle_activator.c           | 29 ++++---
 .../hello_world_cxx/src/BundleActivator.cc         | 28 +++----
 .../log_service_example/src/activator.c            | 70 ++++++++--------
 .../services_example_c/api/example_calc.h          | 28 +++----
 .../src/dynamic_consumer_example.c                 | 28 +++----
 .../src/dynamic_provider_example.c                 | 34 ++++----
 .../src/simple_consumer_example.c                  | 28 +++----
 .../src/simple_provider_example.c                  | 28 +++----
 .../services_example_cxx/api/example.h             | 38 ++++-----
 .../track_tracker_example/src/activator.c          | 29 +++----
 37 files changed, 805 insertions(+), 808 deletions(-)

diff --git a/examples/celix-examples/bundle_with_private_lib/src/activator.c b/examples/celix-examples/bundle_with_private_lib/src/activator.c
index a98346c..e8a1182 100644
--- a/examples/celix-examples/bundle_with_private_lib/src/activator.c
+++ b/examples/celix-examples/bundle_with_private_lib/src/activator.c
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #include <stdlib.h>
@@ -25,20 +25,20 @@
 
 
 struct userData {
-	const char * word;
+    const char * word;
 };
 
 static celix_status_t activator_start(struct userData *data, celix_bundle_context_t *ctx) {
-	data->word = "Import";
-	const char *bndName = celix_bundle_getSymbolicName(celix_bundleContext_getBundle(ctx));
-	printf("Hello %s\n", data->word);
-	doo(bndName);
-	return CELIX_SUCCESS;
+    data->word = "Import";
+    const char *bndName = celix_bundle_getSymbolicName(celix_bundleContext_getBundle(ctx));
+    printf("Hello %s\n", data->word);
+    doo(bndName);
+    return CELIX_SUCCESS;
 }
 
 static celix_status_t activator_stop(struct userData *data, celix_bundle_context_t *ctx __attribute__((unused))) {
-	printf("Goodbye %s\n", data->word);
-	return CELIX_SUCCESS;
+    printf("Goodbye %s\n", data->word);
+    return CELIX_SUCCESS;
 }
 
 
diff --git a/examples/celix-examples/bundle_with_private_lib/tlib/include/test.h b/examples/celix-examples/bundle_with_private_lib/tlib/include/test.h
index c037c00..34615d0 100644
--- a/examples/celix-examples/bundle_with_private_lib/tlib/include/test.h
+++ b/examples/celix-examples/bundle_with_private_lib/tlib/include/test.h
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #ifndef TEST_H_
diff --git a/examples/celix-examples/bundle_with_private_lib/tlib/src/test.c b/examples/celix-examples/bundle_with_private_lib/tlib/src/test.c
index 296b8c1..5021cd6 100644
--- a/examples/celix-examples/bundle_with_private_lib/tlib/src/test.c
+++ b/examples/celix-examples/bundle_with_private_lib/tlib/src/test.c
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #include <stdio.h>
diff --git a/examples/celix-examples/civetweb/resources/index.html b/examples/celix-examples/civetweb/resources/index.html
index cf497cd..dac5c4c 100644
--- a/examples/celix-examples/civetweb/resources/index.html
+++ b/examples/celix-examples/civetweb/resources/index.html
@@ -1,20 +1,20 @@
 <!--
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
 -->
 <!DOCTYPE html>
 <html lang="en">
@@ -32,4 +32,3 @@
     <script>docReady();</script>
 </body>
 </html>
-
diff --git a/examples/celix-examples/civetweb/resources/script.js b/examples/celix-examples/civetweb/resources/script.js
index 10292cb..5cabf42 100644
--- a/examples/celix-examples/civetweb/resources/script.js
+++ b/examples/celix-examples/civetweb/resources/script.js
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 function docReady() {
@@ -30,7 +30,7 @@ function docReady() {
 
     document.getElementById("command_button").onclick = function() {
         input = document.getElementById("command_input").value;
-	document.getElementById("command_input").value = "";
+    document.getElementById("command_input").value = "";
         shellSocket.send(input);
     };
 
diff --git a/examples/celix-examples/civetweb/src/bundle_activator.c b/examples/celix-examples/civetweb/src/bundle_activator.c
index 1f338f6..86ec8c2 100644
--- a/examples/celix-examples/civetweb/src/bundle_activator.c
+++ b/examples/celix-examples/civetweb/src/bundle_activator.c
@@ -1,35 +1,31 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
-
-
 #include <string.h>
 #include <stdio.h>
 
-
 #include <celix_api.h>
 #include <shell.h>
 #include <civetweb.h>
 
 #include "http_admin/api.h"
 
-
 typedef struct activator_data {
     celix_bundle_context_t *ctx;
 
diff --git a/examples/celix-examples/dm_example/api/include/phase1.h b/examples/celix-examples/dm_example/api/include/phase1.h
index 04e9da7..73977fb 100644
--- a/examples/celix-examples/dm_example/api/include/phase1.h
+++ b/examples/celix-examples/dm_example/api/include/phase1.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * publisher.h
  *
  *  \date       Aug 23, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef PHASE1_H_
@@ -35,8 +35,8 @@
 
 
 struct phase1_struct {
-	void *handle;
-	int (*getData)(void *handle, unsigned int *data);
+    void *handle;
+    int (*getData)(void *handle, unsigned int *data);
 };
 
 typedef struct phase1_struct phase1_t;
diff --git a/examples/celix-examples/dm_example/api/include/phase2.h b/examples/celix-examples/dm_example/api/include/phase2.h
index 2f4df86..a1df911 100644
--- a/examples/celix-examples/dm_example/api/include/phase2.h
+++ b/examples/celix-examples/dm_example/api/include/phase2.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * publisher.h
  *
  *  \date       Aug 23, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef PHASE2_H
@@ -31,8 +31,8 @@
 #define PHASE2_VERSION  "1.0.0.0"
 
 struct phase2_struct {
-	void *handle;
-	void (*getData)(void *handle, double *data);
+    void *handle;
+    void (*getData)(void *handle, double *data);
 };
 
 typedef struct phase2_struct phase2_t;
diff --git a/examples/celix-examples/dm_example/phase1/src/phase1_activator.c b/examples/celix-examples/dm_example/phase1/src/phase1_activator.c
index 542e1ab..f351c52 100644
--- a/examples/celix-examples/dm_example/phase1/src/phase1_activator.c
+++ b/examples/celix-examples/dm_example/phase1/src/phase1_activator.c
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #include <stdlib.h>
@@ -26,44 +26,44 @@
 
 struct phase1_activator_struct {
     phase1_cmp_t *phase1Cmp;
-	phase1_t phase1Serv;
+    phase1_t phase1Serv;
 };
 
 static celix_status_t activator_start(struct phase1_activator_struct *act, celix_bundle_context_t *ctx) {
-	celix_status_t status = CELIX_SUCCESS;
-	printf("PHASE1: start\n");
-	act->phase1Cmp = phase1_create();
-	if (act->phase1Cmp != NULL) {
+    celix_status_t status = CELIX_SUCCESS;
+    printf("PHASE1: start\n");
+    act->phase1Cmp = phase1_create();
+    if (act->phase1Cmp != NULL) {
 
-		act->phase1Serv.handle = act->phase1Cmp;
-		act->phase1Serv.getData = (void *)phase1_getData;
+        act->phase1Serv.handle = act->phase1Cmp;
+        act->phase1Serv.getData = (void *)phase1_getData;
 
-		celix_properties_t *props = properties_create();
-		properties_set(props, "id", "phase1");
+        celix_properties_t *props = celix_properties_create();
+        celix_properties_set(props, "id", "phase1");
 
-		celix_dm_component_t *cmp= celix_dmComponent_create(ctx, "PHASE1_PROCESSING_COMPONENT");
-		celix_dmComponent_setImplementation(cmp, act->phase1Cmp);
-		CELIX_DMCOMPONENT_SETCALLBACKS(cmp, phase1_cmp_t *, phase1_init, phase1_start, phase1_stop, phase1_deinit);
-		phase1_setComp(act->phase1Cmp, cmp);
-		celix_dmComponent_addInterface(cmp, PHASE1_NAME, PHASE1_VERSION, &act->phase1Serv, props);
+        celix_dm_component_t *cmp= celix_dmComponent_create(ctx, "PHASE1_PROCESSING_COMPONENT");
+        celix_dmComponent_setImplementation(cmp, act->phase1Cmp);
+        CELIX_DMCOMPONENT_SETCALLBACKS(cmp, phase1_cmp_t *, phase1_init, phase1_start, phase1_stop, phase1_deinit);
+        phase1_setComp(act->phase1Cmp, cmp);
+        celix_dmComponent_addInterface(cmp, PHASE1_NAME, PHASE1_VERSION, &act->phase1Serv, props);
 
-		celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);
-		celix_dependencyManager_add(mng, cmp);
-	} else {
-		status = CELIX_ENOMEM;
-	}
-	return status;
+        celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);
+        celix_dependencyManager_add(mng, cmp);
+    } else {
+        status = CELIX_ENOMEM;
+    }
+    return status;
 }
 
 static celix_status_t activator_stop(struct phase1_activator_struct *act, celix_bundle_context_t *ctx) {
-	printf("PHASE1: stop\n");
-	celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);
-	celix_dependencyManager_removeAllComponents(mng);
-	if (act->phase1Cmp != NULL) {
-		phase1_destroy(act->phase1Cmp);
-	}
+    printf("PHASE1: stop\n");
+    celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);
+    celix_dependencyManager_removeAllComponents(mng);
+    if (act->phase1Cmp != NULL) {
+        phase1_destroy(act->phase1Cmp);
+    }
 
-	return CELIX_SUCCESS;
+    return CELIX_SUCCESS;
 }
 
 CELIX_GEN_BUNDLE_ACTIVATOR(struct phase1_activator_struct, activator_start, activator_stop);
\ No newline at end of file
diff --git a/examples/celix-examples/dm_example/phase1/src/phase1_cmp.c b/examples/celix-examples/dm_example/phase1/src/phase1_cmp.c
index e27dcb7..558bf0e 100644
--- a/examples/celix-examples/dm_example/phase1/src/phase1_cmp.c
+++ b/examples/celix-examples/dm_example/phase1/src/phase1_cmp.c
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * publisher.c
  *
  *  \date       Oct 29, 2015
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 #include <stdio.h>
 #include <stdlib.h>
@@ -36,42 +36,41 @@
 #define SLEEPTIME 1000
 
 struct phase1_cmp_struct {
-	celix_thread_t thread;
+    celix_thread_t thread;
     bool running;
-	unsigned int counter;
-	celix_dm_component_t *component;
-
+    unsigned int counter;
+    celix_dm_component_t *component;
 };
 
 static void *phase1_thread(void *data);
 
 phase1_cmp_t *phase1_create(void) {
-	phase1_cmp_t *cmp = calloc(1, sizeof(*cmp));
-	if (cmp != NULL) {
-		cmp->counter = 0;
+    phase1_cmp_t *cmp = calloc(1, sizeof(*cmp));
+    if (cmp != NULL) {
+        cmp->counter = 0;
         cmp->running = false;
-	}
-	return cmp;
+    }
+    return cmp;
 }
 
 void phase1_setComp(phase1_cmp_t *cmp, celix_dm_component_t *dmCmp) {
-	cmp->component = dmCmp;
+    cmp->component = dmCmp;
 }
 
 int phase1_init(phase1_cmp_t *cmp) {
-	printf("init phase1\n");
+    printf("init phase1\n");
     return 0;
 }
 
 int phase1_start(phase1_cmp_t *cmp) {
-	printf("start phase1\n");
+    printf("start phase1\n");
     cmp->running = true;
     celixThread_create(&cmp->thread, NULL, phase1_thread, cmp);
     return 0;
 }
 
 int phase1_stop(phase1_cmp_t *cmp) {
-	printf("stop phase1\n");
+    printf("stop phase1\n");
     cmp->running = false;
     celixThread_kill(cmp->thread, SIGUSR1);
     celixThread_join(cmp->thread, NULL);
@@ -85,7 +84,7 @@ int phase1_deinit(phase1_cmp_t *cmp) {
 
 void phase1_destroy(phase1_cmp_t *cmp) {
     free(cmp);
-	printf("destroy phase1\n");
+    printf("destroy phase1\n");
 }
 
 static void *phase1_thread(void *data) {
@@ -94,7 +93,7 @@ static void *phase1_thread(void *data) {
     while (cmp->running) {
         cmp->counter += 1;
         if (cmp->counter == 2) {
-        	static char *runtime_interface = "DUMMY INTERFACE: DO NOT USE\n";
+            static char *runtime_interface = "DUMMY INTERFACE: DO NOT USE\n";
             celix_dmComponent_addInterface(cmp->component, "RUNTIME_ADDED_INTERFACE", "1.0.0", runtime_interface, NULL);
         }
         usleep(SLEEPTIME);
diff --git a/examples/celix-examples/dm_example/phase1/src/phase1_cmp.h b/examples/celix-examples/dm_example/phase1/src/phase1_cmp.h
index 002ece8..3f8c10b 100644
--- a/examples/celix-examples/dm_example/phase1/src/phase1_cmp.h
+++ b/examples/celix-examples/dm_example/phase1/src/phase1_cmp.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * publisher.h
  *
  *  \date       Oct 29, 2015
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef PHASE1_CMP_H
diff --git a/examples/celix-examples/dm_example/phase2a/src/phase2a_activator.c b/examples/celix-examples/dm_example/phase2a/src/phase2a_activator.c
index 9cfad7d..6a51893 100644
--- a/examples/celix-examples/dm_example/phase2a/src/phase2a_activator.c
+++ b/examples/celix-examples/dm_example/phase2a/src/phase2a_activator.c
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #include <stdlib.h>
@@ -28,51 +28,51 @@
 
 struct phase2a_activator_struct {
     phase2a_cmp_t *phase2aCmp;
-	phase2_t phase2Serv;
+    phase2_t phase2Serv;
 };
 
 static celix_status_t activator_start(struct phase2a_activator_struct *act, celix_bundle_context_t *ctx) {
-	printf("phase2a: start\n");
-	celix_status_t status = CELIX_SUCCESS;
-	act->phase2aCmp = phase2a_create();
-	if (act->phase2aCmp != NULL) {
+    printf("phase2a: start\n");
+    celix_status_t status = CELIX_SUCCESS;
+    act->phase2aCmp = phase2a_create();
+    if (act->phase2aCmp != NULL) {
 
-		act->phase2Serv.handle = act->phase2aCmp;
-		act->phase2Serv.getData = (void *)phase2a_getData;
+        act->phase2Serv.handle = act->phase2aCmp;
+        act->phase2Serv.getData = (void *)phase2a_getData;
 
-		celix_properties_t *props = properties_create();
-		properties_set(props, "id", "phase2a");
+        celix_properties_t *props = celix_properties_create();
+        celix_properties_set(props, "id", "phase2a");
 
-		celix_dm_component_t *cmp = celix_dmComponent_create(ctx, "PHASE2A_PROCESSING_COMPONENT");
-		celix_dmComponent_setImplementation(cmp, act->phase2aCmp);
-		CELIX_DMCOMPONENT_SETCALLBACKS(cmp, phase2a_cmp_t *, phase2a_init, phase2a_start, phase2a_stop, phase2a_deinit);
-		celix_dmComponent_addInterface(cmp, PHASE2_NAME, PHASE2_VERSION, &act->phase2Serv, props);
+        celix_dm_component_t *cmp = celix_dmComponent_create(ctx, "PHASE2A_PROCESSING_COMPONENT");
+        celix_dmComponent_setImplementation(cmp, act->phase2aCmp);
+        CELIX_DMCOMPONENT_SETCALLBACKS(cmp, phase2a_cmp_t *, phase2a_init, phase2a_start, phase2a_stop, phase2a_deinit);
+        celix_dmComponent_addInterface(cmp, PHASE2_NAME, PHASE2_VERSION, &act->phase2Serv, props);
 
 
-		celix_dm_service_dependency_t *dep = celix_dmServiceDependency_create();
+        celix_dm_service_dependency_t *dep = celix_dmServiceDependency_create();
         celix_dmServiceDependency_setService(dep, PHASE1_NAME, PHASE1_RANGE_ALL, NULL);
         celix_dmServiceDependency_setCallback(dep, (void*)phase2a_setPhase1);
         celix_dmServiceDependency_setStrategy(dep, DM_SERVICE_DEPENDENCY_STRATEGY_LOCKING);
         celix_dmServiceDependency_setRequired(dep, true);
-		celix_dmComponent_addServiceDependency(cmp, dep);
+        celix_dmComponent_addServiceDependency(cmp, dep);
 
-		celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);
-		celix_dependencyManager_add(mng, cmp);
-	} else {
-		status = CELIX_ENOMEM;
-	}
+        celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);
+        celix_dependencyManager_add(mng, cmp);
+    } else {
+        status = CELIX_ENOMEM;
+    }
 
-	return status;
+    return status;
 }
 
 static celix_status_t activator_stop(struct phase2a_activator_struct *act, celix_bundle_context_t *ctx) {
-	printf("phase2a: stop\n");
+    printf("phase2a: stop\n");
     celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);
     celix_dependencyManager_removeAllComponents(mng);
-	if (act->phase2aCmp != NULL) {
-		phase2a_destroy(act->phase2aCmp);
-	}
-	return CELIX_SUCCESS;
+    if (act->phase2aCmp != NULL) {
+        phase2a_destroy(act->phase2aCmp);
+    }
+    return CELIX_SUCCESS;
 }
 
 CELIX_GEN_BUNDLE_ACTIVATOR(struct phase2a_activator_struct, activator_start, activator_stop)
diff --git a/examples/celix-examples/dm_example/phase2a/src/phase2a_cmp.c b/examples/celix-examples/dm_example/phase2a/src/phase2a_cmp.c
index d115b69..b3149e5 100644
--- a/examples/celix-examples/dm_example/phase2a/src/phase2a_cmp.c
+++ b/examples/celix-examples/dm_example/phase2a/src/phase2a_cmp.c
@@ -1,28 +1,29 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * publisher.c
  *
  *  \date       Oct 29, 2015
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -34,9 +35,9 @@
 #define SLEEPTIME 2000000
 
 struct phase2a_cmp_struct {
-	celix_thread_t thread;
+    celix_thread_t thread;
     bool running;
-	double currentValue;
+    double currentValue;
     celix_thread_mutex_t mutex;
     const phase1_t* phase1Serv;
 };
@@ -44,29 +45,29 @@ struct phase2a_cmp_struct {
 static void *phase2a_thread(void *data);
 
 phase2a_cmp_t *phase2a_create(void) {
-	phase2a_cmp_t *cmp = calloc(1, sizeof(*cmp));
-	if (cmp != NULL) {
-		cmp->currentValue = 0.0;
+    phase2a_cmp_t *cmp = calloc(1, sizeof(*cmp));
+    if (cmp != NULL) {
+        cmp->currentValue = 0.0;
         cmp->running = false;
         celixThreadMutex_create(&cmp->mutex, NULL);
-	}
-	return cmp;
+    }
+    return cmp;
 }
 
 int phase2a_init(phase2a_cmp_t *cmp) {
-	printf("init phase2a\n");
+    printf("init phase2a\n");
     return 0;
 }
 
 int phase2a_start(phase2a_cmp_t *cmp) {
-	printf("start phase2a\n");
+    printf("start phase2a\n");
     cmp->running = true;
     celixThread_create(&cmp->thread, NULL, phase2a_thread, cmp);
     return 0;
 }
 
 int phase2a_stop(phase2a_cmp_t *cmp) {
-	printf("stop phase2a\n");
+    printf("stop phase2a\n");
     cmp->running = false;
     celixThread_kill(cmp->thread, SIGUSR1);
     celixThread_join(cmp->thread, NULL);
@@ -81,7 +82,7 @@ int phase2a_deinit(phase2a_cmp_t *cmp) {
 void phase2a_destroy(phase2a_cmp_t *cmp) {
     celixThreadMutex_destroy(&cmp->mutex);
     free(cmp);
-	printf("destroy phase2a\n");
+    printf("destroy phase2a\n");
 }
 
 int phase2a_setPhase1(phase2a_cmp_t *cmp, const phase1_t* phase1) {
diff --git a/examples/celix-examples/dm_example/phase2a/src/phase2a_cmp.h b/examples/celix-examples/dm_example/phase2a/src/phase2a_cmp.h
index 060b23d..c04fd57 100644
--- a/examples/celix-examples/dm_example/phase2a/src/phase2a_cmp.h
+++ b/examples/celix-examples/dm_example/phase2a/src/phase2a_cmp.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * publisher.h
  *
  *  \date       Oct 29, 2015
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef PHASE2A_CMP_H
diff --git a/examples/celix-examples/dm_example/phase2b/src/phase2b_activator.c b/examples/celix-examples/dm_example/phase2b/src/phase2b_activator.c
index 12fdb81..47df4f9 100644
--- a/examples/celix-examples/dm_example/phase2b/src/phase2b_activator.c
+++ b/examples/celix-examples/dm_example/phase2b/src/phase2b_activator.c
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #include <stdlib.h>
@@ -28,51 +28,51 @@
 
 struct phase2b_activator_struct {
     phase2b_cmp_t *phase2bCmp;
-	phase2_t phase2Serv;
+    phase2_t phase2Serv;
 };
 
 static celix_status_t activator_start(struct phase2b_activator_struct *act, celix_bundle_context_t *ctx) {
-	printf("phase2b: start\n");
-	celix_status_t status = CELIX_SUCCESS;
-	act->phase2bCmp = phase2b_create();
-	if (act->phase2bCmp != NULL) {
+    printf("phase2b: start\n");
+    celix_status_t status = CELIX_SUCCESS;
+    act->phase2bCmp = phase2b_create();
+    if (act->phase2bCmp != NULL) {
 
-		act->phase2Serv.handle = act->phase2bCmp;
-		act->phase2Serv.getData = (void *)phase2b_getData;
+        act->phase2Serv.handle = act->phase2bCmp;
+        act->phase2Serv.getData = (void *)phase2b_getData;
 
-		celix_properties_t *props = properties_create();
-		properties_set(props, "id", "phase2b");
+        celix_properties_t *props = celix_properties_create();
+        celix_properties_set(props, "id", "phase2b");
 
-		celix_dm_component_t *cmp = celix_dmComponent_create(ctx, "PHASE2B_PROCESSING_COMPONENT");
-		celix_dmComponent_setImplementation(cmp, act->phase2bCmp);
-		CELIX_DMCOMPONENT_SETCALLBACKS(cmp, phase2b_cmp_t *, phase2b_init, phase2b_start, phase2b_stop, phase2b_deinit);
-		celix_dmComponent_addInterface(cmp, PHASE2_NAME, PHASE2_VERSION, &act->phase2Serv, props);
+        celix_dm_component_t *cmp = celix_dmComponent_create(ctx, "PHASE2B_PROCESSING_COMPONENT");
+        celix_dmComponent_setImplementation(cmp, act->phase2bCmp);
+        CELIX_DMCOMPONENT_SETCALLBACKS(cmp, phase2b_cmp_t *, phase2b_init, phase2b_start, phase2b_stop, phase2b_deinit);
+        celix_dmComponent_addInterface(cmp, PHASE2_NAME, PHASE2_VERSION, &act->phase2Serv, props);
 
 
-		celix_dm_service_dependency_t *dep = celix_dmServiceDependency_create();
-		celix_dmServiceDependency_setService(dep, PHASE1_NAME, PHASE1_RANGE_EXACT, NULL);
-		celix_dmServiceDependency_setCallback(dep, (void*)phase2b_setPhase1);
-		celix_dmServiceDependency_setRequired(dep, true);
-		celix_dmServiceDependency_setStrategy(dep, DM_SERVICE_DEPENDENCY_STRATEGY_LOCKING);
-		celix_dmComponent_addServiceDependency(cmp, dep);
+        celix_dm_service_dependency_t *dep = celix_dmServiceDependency_create();
+        celix_dmServiceDependency_setService(dep, PHASE1_NAME, PHASE1_RANGE_EXACT, NULL);
+        celix_dmServiceDependency_setCallback(dep, (void*)phase2b_setPhase1);
+        celix_dmServiceDependency_setRequired(dep, true);
+        celix_dmServiceDependency_setStrategy(dep, DM_SERVICE_DEPENDENCY_STRATEGY_LOCKING);
+        celix_dmComponent_addServiceDependency(cmp, dep);
 
-		celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);
-		celix_dependencyManager_add(mng, cmp);
-	} else {
-		status = CELIX_ENOMEM;
-	}
+        celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);
+        celix_dependencyManager_add(mng, cmp);
+    } else {
+        status = CELIX_ENOMEM;
+    }
 
-	return status;
+    return status;
 }
 
 static celix_status_t activator_stop(struct phase2b_activator_struct *act, celix_bundle_context_t *ctx) {
-	printf("phase2b: stop\n");
-	celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);
-	celix_dependencyManager_removeAllComponents(mng);
-	if (act->phase2bCmp != NULL) {
-		phase2b_destroy(act->phase2bCmp);
-	}
-	return CELIX_SUCCESS;
+    printf("phase2b: stop\n");
+    celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);
+    celix_dependencyManager_removeAllComponents(mng);
+    if (act->phase2bCmp != NULL) {
+        phase2b_destroy(act->phase2bCmp);
+    }
+    return CELIX_SUCCESS;
 }
 
 
diff --git a/examples/celix-examples/dm_example/phase2b/src/phase2b_cmp.c b/examples/celix-examples/dm_example/phase2b/src/phase2b_cmp.c
index a74dcfa..9617a00 100644
--- a/examples/celix-examples/dm_example/phase2b/src/phase2b_cmp.c
+++ b/examples/celix-examples/dm_example/phase2b/src/phase2b_cmp.c
@@ -1,28 +1,29 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * publisher.c
  *
  *  \date       Oct 29, 2015
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -34,9 +35,9 @@
 #define SLEEPTIME 2000000
 
 struct phase2b_cmp_struct {
-	celix_thread_t thread;
+    celix_thread_t thread;
     bool running;
-	double currentValue;
+    double currentValue;
     celix_thread_mutex_t mutex;
     const phase1_t* phase1Serv;
 };
@@ -44,29 +45,29 @@ struct phase2b_cmp_struct {
 static void *phase2b_thread(void *data);
 
 phase2b_cmp_t *phase2b_create(void) {
-	phase2b_cmp_t *cmp = calloc(1, sizeof(*cmp));
-	if (cmp != NULL) {
-		cmp->currentValue = 0.0;
+    phase2b_cmp_t *cmp = calloc(1, sizeof(*cmp));
+    if (cmp != NULL) {
+        cmp->currentValue = 0.0;
         cmp->running = false;
         celixThreadMutex_create(&cmp->mutex, NULL);
-	}
-	return cmp;
+    }
+    return cmp;
 }
 
 int phase2b_init(phase2b_cmp_t *cmp) {
-	printf("init phase2b\n");
+    printf("init phase2b\n");
     return 0;
 }
 
 int phase2b_start(phase2b_cmp_t *cmp) {
-	printf("start phase2b\n");
+    printf("start phase2b\n");
     cmp->running = true;
     celixThread_create(&cmp->thread, NULL, phase2b_thread, cmp);
     return 0;
 }
 
 int phase2b_stop(phase2b_cmp_t *cmp) {
-	printf("stop phase2b\n");
+    printf("stop phase2b\n");
     cmp->running = false;
     celixThread_kill(cmp->thread, SIGUSR1);
     celixThread_join(cmp->thread, NULL);
@@ -81,7 +82,7 @@ int phase2b_deinit(phase2b_cmp_t *cmp) {
 void phase2b_destroy(phase2b_cmp_t *cmp) {
     celixThreadMutex_destroy(&cmp->mutex);
     free(cmp);
-	printf("destroy phase2b\n");
+    printf("destroy phase2b\n");
 }
 
 int phase2b_setPhase1(phase2b_cmp_t *cmp, const phase1_t* phase1) {
diff --git a/examples/celix-examples/dm_example/phase2b/src/phase2b_cmp.h b/examples/celix-examples/dm_example/phase2b/src/phase2b_cmp.h
index 7ae0358..21c1f27 100644
--- a/examples/celix-examples/dm_example/phase2b/src/phase2b_cmp.h
+++ b/examples/celix-examples/dm_example/phase2b/src/phase2b_cmp.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * publisher.h
  *
  *  \date       Oct 29, 2015
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef PHASE2B_CMP_H
diff --git a/examples/celix-examples/dm_example/phase3/src/phase3_activator.c b/examples/celix-examples/dm_example/phase3/src/phase3_activator.c
index 2fb38ca..3448939 100644
--- a/examples/celix-examples/dm_example/phase3/src/phase3_activator.c
+++ b/examples/celix-examples/dm_example/phase3/src/phase3_activator.c
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #include <stdlib.h>
@@ -29,43 +29,43 @@ struct phase3_activator_struct {
 };
 
 static celix_status_t activator_start(struct phase3_activator_struct *act, celix_bundle_context_t *ctx) {
-	celix_status_t status = CELIX_SUCCESS;
-	printf("phase3: start\n");
-	act->phase3Cmp = phase3_create();
-	if (act->phase3Cmp != NULL) {
+    celix_status_t status = CELIX_SUCCESS;
+    printf("phase3: start\n");
+    act->phase3Cmp = phase3_create();
+    if (act->phase3Cmp != NULL) {
 
-		celix_dm_component_t *cmp = celix_dmComponent_create(ctx, "PHASE3_PROCESSING_COMPONENT");
-		celix_dmComponent_setImplementation(cmp, act->phase3Cmp);
-		CELIX_DMCOMPONENT_SETCALLBACKS(cmp, phase3_cmp_t *, phase3_init, phase3_start, phase3_stop, phase3_deinit);
+        celix_dm_component_t *cmp = celix_dmComponent_create(ctx, "PHASE3_PROCESSING_COMPONENT");
+        celix_dmComponent_setImplementation(cmp, act->phase3Cmp);
+        CELIX_DMCOMPONENT_SETCALLBACKS(cmp, phase3_cmp_t *, phase3_init, phase3_start, phase3_stop, phase3_deinit);
 
-		celix_dm_service_dependency_t *dep = celix_dmServiceDependency_create();
-		celix_dmServiceDependency_setService(dep, PHASE2_NAME, NULL, NULL);
-		celix_dmServiceDependency_setStrategy(dep, DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND); //SUSPEND Strategy is default
-		celix_dm_service_dependency_callback_options_t opts = CELIX_EMPTY_DM_SERVICE_DEPENDENCY_CALLBACK_OPTIONS;
-		opts.add = (void*)phase3_addPhase2;
-		opts.remove = (void*)phase3_removePhase2;
-		celix_dmServiceDependency_setCallbacksWithOptions(dep, &opts);
-		celix_dmServiceDependency_setRequired(dep, true);
-		celix_dmComponent_addServiceDependency(cmp, dep);
+        celix_dm_service_dependency_t *dep = celix_dmServiceDependency_create();
+        celix_dmServiceDependency_setService(dep, PHASE2_NAME, NULL, NULL);
+        celix_dmServiceDependency_setStrategy(dep, DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND); //SUSPEND Strategy is default
+        celix_dm_service_dependency_callback_options_t opts = CELIX_EMPTY_DM_SERVICE_DEPENDENCY_CALLBACK_OPTIONS;
+        opts.add = (void*)phase3_addPhase2;
+        opts.remove = (void*)phase3_removePhase2;
+        celix_dmServiceDependency_setCallbacksWithOptions(dep, &opts);
+        celix_dmServiceDependency_setRequired(dep, true);
+        celix_dmComponent_addServiceDependency(cmp, dep);
 
-		celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);
-		celix_dependencyManager_add(mng, cmp);
-	} else {
-		status = CELIX_ENOMEM;
-	}
-	return status;
+        celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);
+        celix_dependencyManager_add(mng, cmp);
+    } else {
+        status = CELIX_ENOMEM;
+    }
+    return status;
 
 }
 
 static celix_status_t activator_stop(struct phase3_activator_struct *act, celix_bundle_context_t *ctx) {
-	celix_status_t status = CELIX_SUCCESS;
-	printf("phase3: stop\n");
-	celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);
-	celix_dependencyManager_removeAllComponents(mng);
-	if (act->phase3Cmp != NULL) {
-		phase3_destroy(act->phase3Cmp);
-	}
-	return status;
+    celix_status_t status = CELIX_SUCCESS;
+    printf("phase3: stop\n");
+    celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);
+    celix_dependencyManager_removeAllComponents(mng);
+    if (act->phase3Cmp != NULL) {
+        phase3_destroy(act->phase3Cmp);
+    }
+    return status;
 }
 
 
diff --git a/examples/celix-examples/dm_example/phase3/src/phase3_cmp.c b/examples/celix-examples/dm_example/phase3/src/phase3_cmp.c
index e4e6902..55811e3 100644
--- a/examples/celix-examples/dm_example/phase3/src/phase3_cmp.c
+++ b/examples/celix-examples/dm_example/phase3/src/phase3_cmp.c
@@ -1,28 +1,29 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * publisher.c
  *
  *  \date       Oct 29, 2015
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -35,38 +36,38 @@
 #define SLEEPTIME 2000000
 
 struct phase3_cmp_struct {
-	celix_thread_t thread;
+    celix_thread_t thread;
     bool running;
-	double currentValue;
+    double currentValue;
     celix_array_list_t *phase2Services; //phase2_t *
 };
 
 static void *phase3_thread(void *data);
 
 phase3_cmp_t *phase3_create() {
-	phase3_cmp_t *cmp = calloc(1, sizeof(*cmp));
-	if (cmp != NULL) {
-		cmp->currentValue = 0.0;
+    phase3_cmp_t *cmp = calloc(1, sizeof(*cmp));
+    if (cmp != NULL) {
+        cmp->currentValue = 0.0;
         cmp->running = false;
         arrayList_create(&cmp->phase2Services);
-	}
-	return cmp;
+    }
+    return cmp;
 }
 
 int phase3_init(phase3_cmp_t *cmp) {
-	printf("init phase3\n");
+    printf("init phase3\n");
     return 0;
 }
 
 int phase3_start(phase3_cmp_t *cmp) {
-	printf("start phase3\n");
+    printf("start phase3\n");
     cmp->running = true;
     celixThread_create(&cmp->thread, NULL, phase3_thread, cmp);
     return 0;
 }
 
 int phase3_stop(phase3_cmp_t *cmp) {
-	printf("stop phase3\n");
+    printf("stop phase3\n");
     cmp->running = false;
     celixThread_kill(cmp->thread, SIGUSR1);
     celixThread_join(cmp->thread, NULL);
@@ -81,7 +82,7 @@ int phase3_deinit(phase3_cmp_t *cmp) {
 void phase3_destroy(phase3_cmp_t *cmp) {
     arrayList_destroy(cmp->phase2Services);
     free(cmp);
-	printf("destroy phase3\n");
+    printf("destroy phase3\n");
 }
 
 int phase3_addPhase2(phase3_cmp_t *cmp, const phase2_t* phase2) {
diff --git a/examples/celix-examples/dm_example/phase3/src/phase3_cmp.h b/examples/celix-examples/dm_example/phase3/src/phase3_cmp.h
index 9c63845..457eaa8 100644
--- a/examples/celix-examples/dm_example/phase3/src/phase3_cmp.h
+++ b/examples/celix-examples/dm_example/phase3/src/phase3_cmp.h
@@ -1,27 +1,27 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * publisher.h
  *
  *  \date       Oct 29, 2015
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
 
 #ifndef PHASE3_CMP_H
diff --git a/examples/celix-examples/embedding/src/main.c b/examples/celix-examples/embedding/src/main.c
index 933469c..99d1dc4 100644
--- a/examples/celix-examples/embedding/src/main.c
+++ b/examples/celix-examples/embedding/src/main.c
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #include <stdlib.h>
@@ -27,8 +27,8 @@ typedef struct foo {
 
 #define FOO_SERVICE_NAME "foo_service"
 typedef struct foo_service {
-	void *handle;
-	void (*foo)(void *handle);
+    void *handle;
+    void (*foo)(void *handle);
 } foo_service_t;
 
 static void embedded_foo(void *handle) {
@@ -43,30 +43,30 @@ static void use_foo_service(void *callbackHandle __attribute__((unused)), void *
 
 int main(void) {
 
-	celix_framework_t *framework = NULL;
-	celix_properties_t *config = properties_create();
-	int rc = celixLauncher_launchWithProperties(config, &framework);
+    celix_framework_t *framework = NULL;
+    celix_properties_t *config = celix_properties_create();
+    int rc = celixLauncher_launchWithProperties(config, &framework);
 
-	if (rc == 0) {
-		celix_bundle_context_t *ctx = celix_framework_getFrameworkContext(framework);
+    if (rc == 0) {
+        celix_bundle_context_t *ctx = celix_framework_getFrameworkContext(framework);
 
         foo_t *foo = calloc(1, sizeof(*foo));
         foo->val = 42;
-		foo_service_t *svc = calloc(1, sizeof(*svc));
+        foo_service_t *svc = calloc(1, sizeof(*svc));
 
-		svc->handle = foo;
-		svc->foo = embedded_foo;
+        svc->handle = foo;
+        svc->foo = embedded_foo;
 
-		long svcId = celix_bundleContext_registerService(ctx, svc, FOO_SERVICE_NAME, NULL);
-		celix_bundleContext_useService(ctx, FOO_SERVICE_NAME, NULL, use_foo_service);
+        long svcId = celix_bundleContext_registerService(ctx, svc, FOO_SERVICE_NAME, NULL);
+        celix_bundleContext_useService(ctx, FOO_SERVICE_NAME, NULL, use_foo_service);
 
         celix_bundleContext_unregisterService(ctx, svcId);
         free(svc);
         free(foo);
 
-		celixLauncher_destroy(framework);
-	}
+        celixLauncher_destroy(framework);
+    }
 
-	return rc;
+    return rc;
 }
 
diff --git a/examples/celix-examples/export_import/CMakeLists.txt b/examples/celix-examples/export_import/CMakeLists.txt
index 2b95c98..0d2420c 100644
--- a/examples/celix-examples/export_import/CMakeLists.txt
+++ b/examples/celix-examples/export_import/CMakeLists.txt
@@ -16,45 +16,44 @@
 # under the License.
 
 if(NOT APPLE)
-#Importing and exporting libraries not (yet) work under OSX.
-
-add_library(hello_testlib SHARED
-    private/src/test
-)
-set_library_version(hello_testlib "4.3.2") # sets target propery VERSION to 4.3.2 and SOVERSION to 4
-
-
-add_library(hello_test2lib SHARED
-        private/src/test2
-)
-set_library_version(hello_test2lib "3.3.3")
-
-add_celix_bundle(hello_bundle
-    VERSION "1.2"
-    SOURCES
-        private/src/activator.c
-    IMPORT_LIBRARIES hello_test2lib
-)
-
-add_celix_bundle(hello_export
-    VERSION "1.0"
-    NO_ACTIVATOR
-    EXPORT_LIBRARIES hello_test2lib
-)
-
-celix_bundle_private_libs(hello_bundle
-    hello_testlib
-)
-
-add_celix_container(helloworld_byref
-    GROUP hello
-    BUNDLES hello_export hello_bundle ${CELIX_SHELL_BUNDLE} ${CELIX_SHELL_TUI_BUNDLE}
-)
-
-add_celix_container(helloworld_withcopy
-    GROUP hello
-    COPY #Ensures that bundles are copied in the deploy location
-    BUNDLES hello_export hello_bundle ${SHELL_BUNDLE} ${SHELL_TUI_BUNDLE}
-)
-
+    #Importing and exporting libraries not (yet) work under OSX.
+
+    add_library(hello_testlib SHARED
+        private/src/test
+    )
+    set_library_version(hello_testlib "4.3.2") # sets target propery VERSION to 4.3.2 and SOVERSION to 4
+
+
+    add_library(hello_test2lib SHARED
+            private/src/test2
+    )
+    set_library_version(hello_test2lib "3.3.3")
+
+    add_celix_bundle(hello_bundle
+        VERSION "1.2"
+        SOURCES
+            private/src/activator.c
+        IMPORT_LIBRARIES hello_test2lib
+    )
+
+    add_celix_bundle(hello_export
+        VERSION "1.0"
+        NO_ACTIVATOR
+        EXPORT_LIBRARIES hello_test2lib
+    )
+
+    celix_bundle_private_libs(hello_bundle
+        hello_testlib
+    )
+
+    add_celix_container(helloworld_byref
+        GROUP hello
+        BUNDLES hello_export hello_bundle ${CELIX_SHELL_BUNDLE} ${CELIX_SHELL_TUI_BUNDLE}
+    )
+
+    add_celix_container(helloworld_withcopy
+        GROUP hello
+        COPY #Ensures that bundles are copied in the deploy location
+        BUNDLES hello_export hello_bundle ${SHELL_BUNDLE} ${SHELL_TUI_BUNDLE}
+    )
 endif()
diff --git a/examples/celix-examples/export_import/include/test.h b/examples/celix-examples/export_import/include/test.h
index cdbd05d..55011d9 100644
--- a/examples/celix-examples/export_import/include/test.h
+++ b/examples/celix-examples/export_import/include/test.h
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * test.h
diff --git a/examples/celix-examples/export_import/include/test2.h b/examples/celix-examples/export_import/include/test2.h
index bff9048..ea231d3 100644
--- a/examples/celix-examples/export_import/include/test2.h
+++ b/examples/celix-examples/export_import/include/test2.h
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * test.h
diff --git a/examples/celix-examples/export_import/src/activator.c b/examples/celix-examples/export_import/src/activator.c
index f19118b..1b523c6 100644
--- a/examples/celix-examples/export_import/src/activator.c
+++ b/examples/celix-examples/export_import/src/activator.c
@@ -1,28 +1,29 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * activator.c
  *
  *  \date       Aug 20, 2010
- *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- *  \copyright	Apache License, Version 2.0
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
  */
+
 #include <stdlib.h>
 #include <stdio.h>
 
@@ -32,37 +33,37 @@
 #include "test2.h"
 
 struct userData {
-	char * word;
+    char * word;
 };
 
 celix_status_t bundleActivator_create(celix_bundle_context_t *context, void **userData) {
-	celix_status_t status = CELIX_SUCCESS;
+    celix_status_t status = CELIX_SUCCESS;
     *userData = malloc(sizeof(struct userData));
     if (*userData != NULL) {
-		((struct userData *)(*userData))->word = "World";
-	} else {
-		status = CELIX_START_ERROR;
-	}
-	return status;
+        ((struct userData *)(*userData))->word = "World";
+    } else {
+        status = CELIX_START_ERROR;
+    }
+    return status;
 }
 
 celix_status_t bundleActivator_start(void * userData, celix_bundle_context_t *context) {
-	struct userData * data = (struct userData *) userData;
-	printf("Hello %s\n", data->word);
+    struct userData * data = (struct userData *) userData;
+    printf("Hello %s\n", data->word);
 
-	doo();
+    doo();
     bar();
 
-	return CELIX_SUCCESS;
+    return CELIX_SUCCESS;
 }
 
 celix_status_t bundleActivator_stop(void * userData, celix_bundle_context_t *context) {
-	struct userData * data = (struct userData *) userData;
-	printf("Goodbye %s\n", data->word);
-	return CELIX_SUCCESS;
+    struct userData * data = (struct userData *) userData;
+    printf("Goodbye %s\n", data->word);
+    return CELIX_SUCCESS;
 }
 
 celix_status_t bundleActivator_destroy(void * userData, celix_bundle_context_t *context) {
     free(userData);
-	return CELIX_SUCCESS;
+    return CELIX_SUCCESS;
 }
diff --git a/examples/celix-examples/export_import/src/test.c b/examples/celix-examples/export_import/src/test.c
index 280fc61..9dff6bb 100644
--- a/examples/celix-examples/export_import/src/test.c
+++ b/examples/celix-examples/export_import/src/test.c
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * test.c
diff --git a/examples/celix-examples/export_import/src/test2.c b/examples/celix-examples/export_import/src/test2.c
index 9beb1bc..ec0631b 100644
--- a/examples/celix-examples/export_import/src/test2.c
+++ b/examples/celix-examples/export_import/src/test2.c
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 /*
  * test.c
diff --git a/examples/celix-examples/hello_world_c/src/bundle_activator.c b/examples/celix-examples/hello_world_c/src/bundle_activator.c
index 8202a75..e1d06db 100644
--- a/examples/celix-examples/hello_world_c/src/bundle_activator.c
+++ b/examples/celix-examples/hello_world_c/src/bundle_activator.c
@@ -1,23 +1,22 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
-
 #include <celix_api.h>
 
 typedef struct activator_data {
diff --git a/examples/celix-examples/hello_world_cxx/src/BundleActivator.cc b/examples/celix-examples/hello_world_cxx/src/BundleActivator.cc
index 2d83bdc..e1035b3 100644
--- a/examples/celix-examples/hello_world_cxx/src/BundleActivator.cc
+++ b/examples/celix-examples/hello_world_cxx/src/BundleActivator.cc
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #include <memory>
diff --git a/examples/celix-examples/log_service_example/src/activator.c b/examples/celix-examples/log_service_example/src/activator.c
index b684a5f..d111cfb 100644
--- a/examples/celix-examples/log_service_example/src/activator.c
+++ b/examples/celix-examples/log_service_example/src/activator.c
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #include <stdlib.h>
@@ -25,23 +25,23 @@
 #include "log_helper.h"
 
 typedef struct user_data {
-	pthread_t logger_thread;
-	pthread_mutex_t lock;
-	bool running;
-	log_helper_pt log_helper;
+    pthread_t logger_thread;
+    pthread_mutex_t lock;
+    bool running;
+    log_helper_pt log_helper;
 } user_data_t;
 
 static void *loggerThread(void *userData);
 
 celix_status_t activator_start(user_data_t *data, celix_bundle_context_t *ctx) {
-	celix_status_t status = logHelper_create(ctx, &data->log_helper);
-	if (status == CELIX_SUCCESS) {
-		logHelper_start(data->log_helper);
-		data->running = true;
-		pthread_mutex_init(&data->lock, NULL);
-		pthread_create(&data->logger_thread, NULL, loggerThread, data);
-	}
-	return status;
+    celix_status_t status = logHelper_create(ctx, &data->log_helper);
+    if (status == CELIX_SUCCESS) {
+        logHelper_start(data->log_helper);
+        data->running = true;
+        pthread_mutex_init(&data->lock, NULL);
+        pthread_create(&data->logger_thread, NULL, loggerThread, data);
+    }
+    return status;
 }
 
 celix_status_t activator_stop(user_data_t *data, celix_bundle_context_t *ctx __attribute__((unused))) {
@@ -49,24 +49,24 @@ celix_status_t activator_stop(user_data_t *data, celix_bundle_context_t *ctx __a
     data->running = false;
     pthread_mutex_unlock(&data->lock);
     pthread_join(data->logger_thread, NULL);
-	logHelper_stop(data->log_helper);
-	logHelper_destroy(&data->log_helper);
-	return CELIX_SUCCESS;
+    logHelper_stop(data->log_helper);
+    logHelper_destroy(&data->log_helper);
+    return CELIX_SUCCESS;
 }
 
 
 static void *loggerThread(void *userData) {
-	user_data_t *data = userData;
+    user_data_t *data = userData;
 
     bool running = true;
-	while (running) {
-		logHelper_log(data->log_helper, OSGI_LOGSERVICE_INFO, "My log message");
-		sleep(1);
+    while (running) {
+        logHelper_log(data->log_helper, OSGI_LOGSERVICE_INFO, "My log message");
+        sleep(1);
         pthread_mutex_lock(&data->lock);
         running = data->running;
         pthread_mutex_unlock(&data->lock);
-	}
-	return NULL;
+    }
+    return NULL;
 }
 
 CELIX_GEN_BUNDLE_ACTIVATOR(user_data_t, activator_start, activator_stop)
diff --git a/examples/celix-examples/services_example_c/api/example_calc.h b/examples/celix-examples/services_example_c/api/example_calc.h
index 8afe6c3..c251c40 100644
--- a/examples/celix-examples/services_example_c/api/example_calc.h
+++ b/examples/celix-examples/services_example_c/api/example_calc.h
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #ifndef CELIX_EXAMPLE_CALC_H
diff --git a/examples/celix-examples/services_example_c/src/dynamic_consumer_example.c b/examples/celix-examples/services_example_c/src/dynamic_consumer_example.c
index a666928..5173efc 100644
--- a/examples/celix-examples/services_example_c/src/dynamic_consumer_example.c
+++ b/examples/celix-examples/services_example_c/src/dynamic_consumer_example.c
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #include <unistd.h>
diff --git a/examples/celix-examples/services_example_c/src/dynamic_provider_example.c b/examples/celix-examples/services_example_c/src/dynamic_provider_example.c
index 3f0a2a5..9e05646 100644
--- a/examples/celix-examples/services_example_c/src/dynamic_provider_example.c
+++ b/examples/celix-examples/services_example_c/src/dynamic_provider_example.c
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #include <unistd.h>
@@ -63,7 +63,7 @@ void * run(void *handle) {
     bool up = true;
     while (isRunning(data)) {
         if (up) {
-            celix_properties_t *props = properties_create();
+            celix_properties_t *props = celix_properties_create();
             celix_properties_setLong(props, OSGI_FRAMEWORK_SERVICE_RANKING, rand());
             data->svcIds[i++] = celix_bundleContext_registerService(data->ctx, &data->svc, EXAMPLE_CALC_NAME, props);
         } else { //down
@@ -101,14 +101,14 @@ static celix_status_t activator_start(activator_data_t *data, celix_bundle_conte
     }
 
     pthread_create(&data->thread, NULL, run ,data);
-	return CELIX_SUCCESS;
+    return CELIX_SUCCESS;
 }
 
 static celix_status_t activator_stop(activator_data_t *data, celix_bundle_context_t *ctx __attribute__((unused))) {
     setRunning(data, false);
     pthread_join(data->thread, NULL);
     pthread_mutex_destroy(&data->mutex);
-	return CELIX_SUCCESS;
+    return CELIX_SUCCESS;
 }
 
 CELIX_GEN_BUNDLE_ACTIVATOR(activator_data_t, activator_start, activator_stop)
\ No newline at end of file
diff --git a/examples/celix-examples/services_example_c/src/simple_consumer_example.c b/examples/celix-examples/services_example_c/src/simple_consumer_example.c
index e078f56..49e2e07 100644
--- a/examples/celix-examples/services_example_c/src/simple_consumer_example.c
+++ b/examples/celix-examples/services_example_c/src/simple_consumer_example.c
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #include <unistd.h>
diff --git a/examples/celix-examples/services_example_c/src/simple_provider_example.c b/examples/celix-examples/services_example_c/src/simple_provider_example.c
index 769867f..f22ec17 100644
--- a/examples/celix-examples/services_example_c/src/simple_provider_example.c
+++ b/examples/celix-examples/services_example_c/src/simple_provider_example.c
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #include <stdio.h>
diff --git a/examples/celix-examples/services_example_cxx/api/example.h b/examples/celix-examples/services_example_cxx/api/example.h
index 68ce0e3..28b3d41 100644
--- a/examples/celix-examples/services_example_cxx/api/example.h
+++ b/examples/celix-examples/services_example_cxx/api/example.h
@@ -1,20 +1,20 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
 
 #ifndef EXAMPLE_H_
@@ -24,14 +24,14 @@
 extern "C" {
 #endif
 
-#define EXAMPLE_NAME 			"org.example"
-#define EXAMPLE_VERSION 		"1.0.0"
-#define EXAMPLE_CONSUMER_RANGE   "[1.0.0,2.0.0)"
+#define EXAMPLE_NAME      		"org.example"
+#define EXAMPLE_VERSION         "1.0.0"
+#define EXAMPLE_CONSUMER_RANGE  "[1.0.0,2.0.0)"
 
 
 struct example_struct {
-	void *handle;
-	int (*method)(void *handle, int arg1, double arg2, double *result);
+    void *handle;
+    int (*method)(void *handle, int arg1, double arg2, double *result);
 } ;
 
 typedef struct example_struct example_t;
diff --git a/examples/celix-examples/track_tracker_example/src/activator.c b/examples/celix-examples/track_tracker_example/src/activator.c
index 0eba4dc..fc91719 100644
--- a/examples/celix-examples/track_tracker_example/src/activator.c
+++ b/examples/celix-examples/track_tracker_example/src/activator.c
@@ -1,21 +1,22 @@
 /**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements.  See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership.  The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License.  You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
  *
- *  http://www.apache.org/licenses/LICENSE-2.0
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- *specific language governing permissions and limitations
- *under the License.
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
  */
+
 #include <stdlib.h>
 #include <unistd.h>
 #include <stdio.h>