Fixed some compile warnings

Change-Id: I2a35fc2adc0c3e2484a1be260da20d0a4ab92ed6

46 files changed, 180 insertions, 180 deletions

diff --git a/src/CommonAPI/DBus/DBusConfiguration.cpp b/src/CommonAPI/DBus/DBusConfiguration.cpp
index 743fdaa..1fa9ae7 100644
--- a/src/CommonAPI/DBus/DBusConfiguration.cpp
+++ b/src/CommonAPI/DBus/DBusConfiguration.cpp
@@ -213,6 +213,8 @@ void DBusConfiguration::readConfigFile(std::ifstream& addressConfigFile) {
                     }
                     newFactoryFound = false;
                     break;
+                case FileParsingState::UNDEFINED:
+                    break;
             }
         }
 
@@ -241,6 +243,8 @@ void DBusConfiguration::readConfigFile(std::ifstream& addressConfigFile) {
                     case FileParsingState::PARSING_ADDRESS:
                         readValue(readLine, serviceDetails);
                         break;
+                    case FileParsingState::UNDEFINED:
+                        break;
                 }
                 break;
         }
diff --git a/src/CommonAPI/DBus/DBusConnection.cpp b/src/CommonAPI/DBus/DBusConnection.cpp
index 8f0bd86..61b31d7 100644
--- a/src/CommonAPI/DBus/DBusConnection.cpp
+++ b/src/CommonAPI/DBus/DBusConnection.cpp
@@ -79,37 +79,38 @@ void DBusConnection::resumeDispatching() const {
 }
 
 DBusConnection::DBusConnection(BusType busType) :
-                busType_(busType),
-                libdbusConnection_(NULL),
-                dbusConnectionStatusEvent_(this),
+                dispatchThread_(NULL),
                 stopDispatching_(false),
+                mainLoopContext_(std::shared_ptr<MainLoopContext>(NULL)),
+                dispatchSource_(),
+                watchContext_(NULL),
                 pauseDispatching_(false),
-                dispatchThread_(NULL),
+                libdbusConnection_(NULL),
+                busType_(busType),
+                dbusConnectionStatusEvent_(this),
+                libdbusSignalMatchRulesCount_(0),
                 dbusObjectMessageHandler_(),
-                watchContext_(NULL),
                 connectionNameCount_(),
-                dispatchSource_(),
-                mainLoopContext_(std::shared_ptr<MainLoopContext>(NULL)),
-                enforcerThread_(NULL),
-                libdbusSignalMatchRulesCount_(0) {
+                enforcerThread_(NULL)
+                 {
 
     dbus_threads_init_default();
 }
 
 DBusConnection::DBusConnection(::DBusConnection* libDbusConnection) :
-                busType_(WRAPPED),
-                libdbusConnection_(libDbusConnection),
-                dbusConnectionStatusEvent_(this),
+                dispatchThread_(NULL),
                 stopDispatching_(false),
+                mainLoopContext_(std::shared_ptr<MainLoopContext>(NULL)),
+                dispatchSource_(),
+                watchContext_(NULL),
                 pauseDispatching_(false),
-                dispatchThread_(NULL),
+                libdbusConnection_(libDbusConnection),
+                busType_(WRAPPED),
+                dbusConnectionStatusEvent_(this),
+                libdbusSignalMatchRulesCount_(0),
                 dbusObjectMessageHandler_(),
-                watchContext_(NULL),
                 connectionNameCount_(),
-                dispatchSource_(),
-                mainLoopContext_(std::shared_ptr<MainLoopContext>(NULL)),
-                enforcerThread_(NULL),
-                libdbusSignalMatchRulesCount_(0) {
+                enforcerThread_(NULL) {
     dbus_threads_init_default();
 }
 
@@ -454,29 +455,29 @@ bool DBusConnection::sendDBusMessage(const DBusMessage& dbusMessage, uint32_t* a
 }
 
 void DBusConnection::onLibdbusPendingCallNotifyThunk(::DBusPendingCall* libdbusPendingCall, void *userData) {
-	assert(userData);
-	assert(libdbusPendingCall);
+    assert(userData);
+    assert(libdbusPendingCall);
 
-	auto dbusMessageReplyAsyncHandler = reinterpret_cast<DBusMessageReplyAsyncHandler*>(userData);
+    auto dbusMessageReplyAsyncHandler = reinterpret_cast<DBusMessageReplyAsyncHandler*>(userData);
 
-	::DBusMessage* libdbusMessage = dbus_pending_call_steal_reply(libdbusPendingCall);
-	const bool increaseLibdbusMessageReferenceCount = false;
-	DBusMessage dbusMessage(libdbusMessage, increaseLibdbusMessageReferenceCount);
-	CallStatus callStatus = CallStatus::SUCCESS;
+    ::DBusMessage* libdbusMessage = dbus_pending_call_steal_reply(libdbusPendingCall);
+    const bool increaseLibdbusMessageReferenceCount = false;
+    DBusMessage dbusMessage(libdbusMessage, increaseLibdbusMessageReferenceCount);
+    CallStatus callStatus = CallStatus::SUCCESS;
 
-	if (!dbusMessage.isMethodReturnType()) {
-		callStatus = CallStatus::REMOTE_ERROR;
-	}
+    if (!dbusMessage.isMethodReturnType()) {
+        callStatus = CallStatus::REMOTE_ERROR;
+    }
 
-	dbusMessageReplyAsyncHandler->onDBusMessageReply(callStatus, dbusMessage);
+    dbusMessageReplyAsyncHandler->onDBusMessageReply(callStatus, dbusMessage);
 
-	// libdbus calls the Cleanup method below
-	dbus_pending_call_unref(libdbusPendingCall);
+    // libdbus calls the Cleanup method below
+    dbus_pending_call_unref(libdbusPendingCall);
 }
 
 void DBusConnection::onLibdbusDataCleanup(void* userData) {
-	auto dbusMessageReplyAsyncHandler = reinterpret_cast<DBusMessageReplyAsyncHandler*>(userData);
-	delete dbusMessageReplyAsyncHandler;
+    auto dbusMessageReplyAsyncHandler = reinterpret_cast<DBusMessageReplyAsyncHandler*>(userData);
+    delete dbusMessageReplyAsyncHandler;
 }
 
 
diff --git a/src/CommonAPI/DBus/DBusDaemonProxy.cpp b/src/CommonAPI/DBus/DBusDaemonProxy.cpp
index 24d4d16..99ca10d 100644
--- a/src/CommonAPI/DBus/DBusDaemonProxy.cpp
+++ b/src/CommonAPI/DBus/DBusDaemonProxy.cpp
@@ -38,8 +38,8 @@ static const std::string commonApiParticipantId_ = "org.freedesktop.DBus-/org/fr
 
 DBusDaemonProxy::DBusDaemonProxy(const std::shared_ptr<DBusProxyConnection>& dbusConnection):
                 DBusProxyBase(dbusConnection),
-                interfaceVersionAttribute_(1, 0),
-                nameOwnerChangedEvent_(*this, "NameOwnerChanged", "sss") {
+                nameOwnerChangedEvent_(*this, "NameOwnerChanged", "sss"),
+                interfaceVersionAttribute_(1, 0) {
 }
 
 void DBusDaemonProxy::init() {
diff --git a/src/CommonAPI/DBus/DBusInputStream.cpp b/src/CommonAPI/DBus/DBusInputStream.cpp
index 2d3b1df..53ae32d 100644
--- a/src/CommonAPI/DBus/DBusInputStream.cpp
+++ b/src/CommonAPI/DBus/DBusInputStream.cpp
@@ -10,11 +10,11 @@ namespace CommonAPI {
 namespace DBus {
 
 DBusInputStream::DBusInputStream(const CommonAPI::DBus::DBusMessage& message) :
-                message_(message),
                 dataBegin_(message.getBodyData()),
                 currentDataPosition_(0),
                 dataLength_(message.getBodyLength()),
-                exception_(nullptr) {
+                exception_(nullptr),
+                message_(message) {
 }
 
 DBusInputStream::~DBusInputStream() {}
diff --git a/src/CommonAPI/DBus/DBusMainLoopContext.cpp b/src/CommonAPI/DBus/DBusMainLoopContext.cpp
index c1a581f..c093a67 100644
--- a/src/CommonAPI/DBus/DBusMainLoopContext.cpp
+++ b/src/CommonAPI/DBus/DBusMainLoopContext.cpp
@@ -96,9 +96,9 @@ void DBusWatch::addDependentDispatchSource(DispatchSource* dispatchSource) {
 
 
 DBusTimeout::DBusTimeout(::DBusTimeout* libdbusTimeout, std::weak_ptr<MainLoopContext>& mainLoopContext) :
+                dueTimeInMs_(TIMEOUT_INFINITE),
                 libdbusTimeout_(libdbusTimeout),
-                mainLoopContext_(mainLoopContext),
-                dueTimeInMs_(TIMEOUT_INFINITE) {
+                mainLoopContext_(mainLoopContext) {
 }
 
 bool DBusTimeout::isReadyToBeMonitored() {
diff --git a/src/CommonAPI/DBus/DBusObjectManager.cpp b/src/CommonAPI/DBus/DBusObjectManager.cpp
index 3525585..bea40a1 100644
--- a/src/CommonAPI/DBus/DBusObjectManager.cpp
+++ b/src/CommonAPI/DBus/DBusObjectManager.cpp
@@ -23,8 +23,8 @@ namespace CommonAPI {
 namespace DBus {
 
 DBusObjectManager::DBusObjectManager(const std::shared_ptr<DBusProxyConnection>& dbusConnection):
-        dbusConnection_(dbusConnection),
-        rootDBusObjectManagerStub_(new DBusObjectManagerStub("/", dbusConnection)) {
+                rootDBusObjectManagerStub_(new DBusObjectManagerStub("/", dbusConnection)),
+                dbusConnection_(dbusConnection){
 
     if (!dbusConnection->isObjectPathMessageHandlerSet()) {
         dbusConnection->setObjectPathMessageHandler(
@@ -267,9 +267,9 @@ bool DBusObjectManager::onIntrospectableInterfaceDBusMessage(const DBusMessage&
                     foundRegisteredObjects = true;
                 }
             } else {
-                for (int i = 1; i < elems.size() - 1; i++) {
+                for (unsigned int i = 1; i < elems.size() - 1; i++) {
                     std::string build;
-                    for (int j = 1; j <= i; j++) {
+                    for (unsigned int j = 1; j <= i; j++) {
                         build = build + "/" + elems[j];
                         if (dbusMessage.hasObjectPath(build)) {
                             if (nodeSet.find(elems[j + 1]) == nodeSet.end()) {
diff --git a/src/CommonAPI/DBus/DBusObjectManagerStub.cpp b/src/CommonAPI/DBus/DBusObjectManagerStub.cpp
index 5d0f721..6d08f8d 100644
--- a/src/CommonAPI/DBus/DBusObjectManagerStub.cpp
+++ b/src/CommonAPI/DBus/DBusObjectManagerStub.cpp
@@ -17,8 +17,8 @@ namespace DBus {
 
 DBusObjectManagerStub::DBusObjectManagerStub(const std::string& dbusObjectPath,
                                              const std::shared_ptr<DBusProxyConnection>& dbusConnection) :
-                dbusConnection_(dbusConnection),
-                dbusObjectPath_(dbusObjectPath) {
+                        dbusObjectPath_(dbusObjectPath),
+                        dbusConnection_(dbusConnection) {
     assert(!dbusObjectPath.empty());
     assert(dbusObjectPath[0] == '/');
     assert(dbusConnection);
diff --git a/src/CommonAPI/DBus/DBusOutputStream.cpp b/src/CommonAPI/DBus/DBusOutputStream.cpp
index b94c4d5..4dfc9fa 100644
--- a/src/CommonAPI/DBus/DBusOutputStream.cpp
+++ b/src/CommonAPI/DBus/DBusOutputStream.cpp
@@ -289,7 +289,7 @@ bool DBusOutputStream::hasError() const {
  */
 void DBusOutputStream::flush() {
     const int toWrite = payload_.size();
-    const bool success = dbusMessage_.setBodyLength(toWrite);
+    dbusMessage_.setBodyLength(toWrite);
     char* destinationDataPtr = dbusMessage_.getBodyData();
 
     memcpy(destinationDataPtr, payload_.c_str(), toWrite);
diff --git a/src/CommonAPI/DBus/DBusProxy.cpp b/src/CommonAPI/DBus/DBusProxy.cpp
index 24e39a1..73fc54a 100644
--- a/src/CommonAPI/DBus/DBusProxy.cpp
+++ b/src/CommonAPI/DBus/DBusProxy.cpp
@@ -36,16 +36,16 @@ DBusProxy::DBusProxy(const std::shared_ptr<DBusFactory>& factory,
                      const std::string& dbusObjectPath,
                      const std::shared_ptr<DBusProxyConnection>& dbusConnection):
                 DBusProxyBase(dbusConnection),
-                factory_(factory),
+                dbusProxyStatusEvent_(this),
+                availabilityStatus_(AvailabilityStatus::UNKNOWN),
+                interfaceVersionAttribute_(*this, "uu", "getInterfaceVersion"),
+                dbusServiceRegistry_(dbusConnection->getDBusServiceRegistry()),
                 commonApiServiceId_(split(commonApiAddress, ':')[1]),
                 commonApiParticipantId_(split(commonApiAddress, ':')[2]),
                 dbusBusName_(dbusBusName),
                 dbusObjectPath_(dbusObjectPath),
                 dbusInterfaceName_(dbusInterfaceName),
-                dbusProxyStatusEvent_(this),
-                availabilityStatus_(AvailabilityStatus::UNKNOWN),
-                interfaceVersionAttribute_(*this, "uu", "getInterfaceVersion"),
-                dbusServiceRegistry_(dbusConnection->getDBusServiceRegistry()) {
+                factory_(factory) {
 }
 
 void DBusProxy::init() {
diff --git a/src/CommonAPI/DBus/DBusProxyAsyncCallbackHandler.h b/src/CommonAPI/DBus/DBusProxyAsyncCallbackHandler.h
index 74bb244..37c3ba6 100644
--- a/src/CommonAPI/DBus/DBusProxyAsyncCallbackHandler.h
+++ b/src/CommonAPI/DBus/DBusProxyAsyncCallbackHandler.h
@@ -28,31 +28,31 @@ namespace DBus {
 template <typename ... _ArgTypes>
 class DBusProxyAsyncCallbackHandler: public DBusProxyConnection::DBusMessageReplyAsyncHandler {
  public:
-	typedef std::function<void(CallStatus, _ArgTypes...)> FunctionType;
+    typedef std::function<void(CallStatus, _ArgTypes...)> FunctionType;
 
-	static inline std::unique_ptr<DBusProxyConnection::DBusMessageReplyAsyncHandler> create(FunctionType&& callback) {
-		return std::unique_ptr<DBusProxyConnection::DBusMessageReplyAsyncHandler>(
-				new DBusProxyAsyncCallbackHandler(std::move(callback)));
-	}
+    static inline std::unique_ptr<DBusProxyConnection::DBusMessageReplyAsyncHandler> create(FunctionType&& callback) {
+        return std::unique_ptr<DBusProxyConnection::DBusMessageReplyAsyncHandler>(
+                new DBusProxyAsyncCallbackHandler(std::move(callback)));
+    }
 
-	DBusProxyAsyncCallbackHandler() = delete;
-	DBusProxyAsyncCallbackHandler(FunctionType&& callback):
-		callback_(std::move(callback)) {
-	}
+    DBusProxyAsyncCallbackHandler() = delete;
+    DBusProxyAsyncCallbackHandler(FunctionType&& callback):
+        callback_(std::move(callback)) {
+    }
 
-	virtual std::future<CallStatus> getFuture() {
-		return promise_.get_future();
-	}
+    virtual std::future<CallStatus> getFuture() {
+        return promise_.get_future();
+    }
 
-	virtual void onDBusMessageReply(const CallStatus& dbusMessageCallStatus, const DBusMessage& dbusMessage) {
-		promise_.set_value(handleDBusMessageReply(dbusMessageCallStatus, dbusMessage, typename make_sequence<sizeof...(_ArgTypes)>::type()));
-	}
+    virtual void onDBusMessageReply(const CallStatus& dbusMessageCallStatus, const DBusMessage& dbusMessage) {
+        std::tuple<_ArgTypes...> argTuple;
+        promise_.set_value(handleDBusMessageReply(dbusMessageCallStatus, dbusMessage, typename make_sequence<sizeof...(_ArgTypes)>::type(), argTuple));
+    }
 
  private:
-	template <int... _ArgIndices>
-	inline CallStatus handleDBusMessageReply(const CallStatus dbusMessageCallStatus, const DBusMessage& dbusMessage, index_sequence<_ArgIndices...>) const {
-		CallStatus callStatus = dbusMessageCallStatus;
-		std::tuple<_ArgTypes...> argTuple;
+    template <int... _ArgIndices>
+    inline CallStatus handleDBusMessageReply(const CallStatus dbusMessageCallStatus, const DBusMessage& dbusMessage, index_sequence<_ArgIndices...>, std::tuple<_ArgTypes...> argTuple) const {
+        CallStatus callStatus = dbusMessageCallStatus;
 
         if (dbusMessageCallStatus == CallStatus::SUCCESS) {
             if (!dbusMessage.isErrorType()) {
@@ -65,12 +65,12 @@ class DBusProxyAsyncCallbackHandler: public DBusProxyConnection::DBusMessageRepl
             }
         }
 
-		callback_(callStatus, std::move(std::get<_ArgIndices>(argTuple))...);
-		return callStatus;
-	}
+        callback_(callStatus, std::move(std::get<_ArgIndices>(argTuple))...);
+        return callStatus;
+    }
 
-	std::promise<CallStatus> promise_;
-	const FunctionType callback_;
+    std::promise<CallStatus> promise_;
+    const FunctionType callback_;
 };
 
 } // namespace DBus
diff --git a/src/CommonAPI/DBus/DBusProxyBase.cpp b/src/CommonAPI/DBus/DBusProxyBase.cpp
index e80224e..5e83875 100644
--- a/src/CommonAPI/DBus/DBusProxyBase.cpp
+++ b/src/CommonAPI/DBus/DBusProxyBase.cpp
@@ -11,8 +11,8 @@ namespace CommonAPI {
 namespace DBus {
 
 DBusProxyBase::DBusProxyBase(const std::shared_ptr<DBusProxyConnection>& dbusConnection) :
-                dbusConnection_(dbusConnection),
-                commonApiDomain_("local") {
+                        commonApiDomain_("local"),
+                        dbusConnection_(dbusConnection){
 }
 
 DBusMessage DBusProxyBase::createMethodCall(const char* methodName,
diff --git a/src/CommonAPI/DBus/DBusProxyHelper.h b/src/CommonAPI/DBus/DBusProxyHelper.h
index 0a316be..336810d 100644
--- a/src/CommonAPI/DBus/DBusProxyHelper.h
+++ b/src/CommonAPI/DBus/DBusProxyHelper.h
@@ -182,7 +182,8 @@ template<
 
             CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 
-            callCallbackOnNotAvailable(asyncCallback, typename make_sequence<sizeof...(_OutArgs)>::type());
+            std::tuple<_OutArgs...> argTuple;
+            callCallbackOnNotAvailable(asyncCallback, typename make_sequence<sizeof...(_OutArgs)>::type(), argTuple);
 
             std::promise<CallStatus> promise;
             promise.set_value(callStatus);
@@ -233,7 +234,8 @@ template<
 
             CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 
-            callCallbackOnNotAvailable(asyncCallback, typename make_sequence<sizeof...(_OutArgs)>::type());
+            std::tuple<_OutArgs...> argTuple;
+            callCallbackOnNotAvailable(asyncCallback, typename make_sequence<sizeof...(_OutArgs)>::type(),argTuple);
 
             std::promise<CallStatus> promise;
             promise.set_value(callStatus);
@@ -268,9 +270,8 @@ template<
 
     template <int... _ArgIndices>
     static void callCallbackOnNotAvailable(std::function<void(CallStatus, _OutArgs...)> callback,
-                                           index_sequence<_ArgIndices...>) {
+                                           index_sequence<_ArgIndices...>, std::tuple<_OutArgs...> argTuple) {
 
-        std::tuple<_OutArgs...> argTuple;
         const CallStatus callstatus = CallStatus::NOT_AVAILABLE;
         callback(callstatus, std::move(std::get<_ArgIndices>(argTuple))...);
     }
diff --git a/src/CommonAPI/DBus/DBusProxyManager.cpp b/src/CommonAPI/DBus/DBusProxyManager.cpp
index b8ba87e..abbc491 100644
--- a/src/CommonAPI/DBus/DBusProxyManager.cpp
+++ b/src/CommonAPI/DBus/DBusProxyManager.cpp
@@ -18,8 +18,8 @@ DBusProxyManager::DBusProxyManager(DBusProxy& dbusProxy,
                 dbusProxy_(dbusProxy),
                 dbusInstanceAvailabilityStatusEvent_(dbusProxy, interfaceId),
                 factory_(factory),
-                interfaceId_(interfaceId),
-                registry_(dbusProxy.getDBusConnection()->getDBusServiceRegistry())
+                registry_(dbusProxy.getDBusConnection()->getDBusServiceRegistry()),
+                interfaceId_(interfaceId)
 
 { }
 
diff --git a/src/CommonAPI/DBus/DBusServiceRegistry.cpp b/src/CommonAPI/DBus/DBusServiceRegistry.cpp
index e5952de..2041e40 100644
--- a/src/CommonAPI/DBus/DBusServiceRegistry.cpp
+++ b/src/CommonAPI/DBus/DBusServiceRegistry.cpp
@@ -293,7 +293,6 @@ bool DBusServiceRegistry::isServiceInstanceAlive(const std::string& dbusInterfac
         dbusServicesMutex_.lock();
         //std::unordered_map<std::string, DBusObjectPathCache>::value_type value(dbusObjectPath, std::move(newDbusObjectPathCache));
         //auto dbusObjectPathCacheInserted = dbusObjectPathsCache->insert(std::move({dbusObjectPath, std::move(newDbusObjectPathCache)}));
-        auto dbusObjectPathCacheInserted =
                         dbusObjectPathsCache->insert(std::make_pair(dbusObjectPath, std::move(newDbusObjectPathCache)));
 
         dbusObjectPathCacheIterator = dbusObjectPathsCache->find(dbusObjectPath);
@@ -476,10 +475,7 @@ SubscriptionStatus DBusServiceRegistry::onSignalDBusMessage(const DBusMessage& d
 
     dbusInputStream >> dbusObjectPath;
 
-    bool added = false;
-
     if (dbusMessage.hasMemberName("InterfacesAdded")) {
-        added = true;
         dbusInterfaceNameState = DBusRecordState::AVAILABLE;
 
         typedef std::unordered_map<std::string, bool> DBusPropertiesChangedDict;
diff --git a/src/CommonAPI/DBus/DBusServiceRegistry.h b/src/CommonAPI/DBus/DBusServiceRegistry.h
index 9d59cf1..09f020a 100644
--- a/src/CommonAPI/DBus/DBusServiceRegistry.h
+++ b/src/CommonAPI/DBus/DBusServiceRegistry.h
@@ -132,8 +132,8 @@ class DBusServiceRegistry: public std::enable_shared_from_this<DBusServiceRegist
         }
 
         DBusServiceListenersRecord(DBusServiceListenersRecord&& other):
-            uniqueBusName(std::move(other.uniqueBusName)),
             uniqueBusNameState(other.uniqueBusNameState),
+            uniqueBusName(std::move(other.uniqueBusName)),
             promiseOnResolve(std::move(other.promiseOnResolve)),
             futureOnResolve(std::move(other.futureOnResolve)),
             mutexOnResolve(std::move(other.mutexOnResolve)),
diff --git a/src/CommonAPI/DBus/DBusStubAdapter.cpp b/src/CommonAPI/DBus/DBusStubAdapter.cpp
index 7456d9f..f532fed 100644
--- a/src/CommonAPI/DBus/DBusStubAdapter.cpp
+++ b/src/CommonAPI/DBus/DBusStubAdapter.cpp
@@ -25,14 +25,14 @@ DBusStubAdapter::DBusStubAdapter(const std::shared_ptr<DBusFactory>& factory,
                                  const std::string& dbusObjectPath,
                                  const std::shared_ptr<DBusProxyConnection>& dbusConnection,
                                  const bool isManagingInterface) :
-                factory_(factory),
                 commonApiDomain_(split(commonApiAddress, ':')[0]),
                 commonApiServiceId_(split(commonApiAddress, ':')[1]),
                 commonApiParticipantId_(split(commonApiAddress, ':')[2]),
-                dbusInterfaceName_(dbusInterfaceName),
                 dbusBusName_(dbusBusName),
                 dbusObjectPath_(dbusObjectPath),
+                dbusInterfaceName_(dbusInterfaceName),
                 dbusConnection_(dbusConnection),
+                factory_(factory),
                 isManagingInterface_(isManagingInterface) {
 
     assert(!dbusBusName_.empty());
diff --git a/src/CommonAPI/DBus/DBusStubAdapterHelper.h b/src/CommonAPI/DBus/DBusStubAdapterHelper.h
index d4c9f5e..a617b15 100644
--- a/src/CommonAPI/DBus/DBusStubAdapterHelper.h
+++ b/src/CommonAPI/DBus/DBusStubAdapterHelper.h
@@ -234,12 +234,13 @@ class DBusMethodWithReplyStubDispatcher<_StubClass, _In<_InArgs...>, _Out<_OutAr
     }
 
     bool dispatchDBusMessage(const DBusMessage& dbusMessage, const std::shared_ptr<_StubClass>& stub, DBusStubAdapterHelperType& dbusStubAdapterHelper) {
+        std::tuple<_InArgs..., _OutArgs...> argTuple;
         return handleDBusMessage(
                         dbusMessage,
                         stub,
                         dbusStubAdapterHelper,
                         typename make_sequence_range<sizeof...(_InArgs), 0>::type(),
-                        typename make_sequence_range<sizeof...(_OutArgs), sizeof...(_InArgs)>::type());
+                        typename make_sequence_range<sizeof...(_OutArgs), sizeof...(_InArgs)>::type(),argTuple);
     }
  private:
     template <int... _InArgIndices, int... _OutArgIndices>
@@ -247,8 +248,8 @@ class DBusMethodWithReplyStubDispatcher<_StubClass, _In<_InArgs...>, _Out<_OutAr
                                   const std::shared_ptr<_StubClass>& stub,
                                   DBusStubAdapterHelperType& dbusStubAdapterHelper,
                                   index_sequence<_InArgIndices...>,
-                                  index_sequence<_OutArgIndices...>) const {
-        std::tuple<_InArgs..., _OutArgs...> argTuple;
+                                  index_sequence<_OutArgIndices...>,
+                                  std::tuple<_InArgs..., _OutArgs...> argTuple) const {
 
         if (sizeof...(_InArgs) > 0) {
             DBusInputStream dbusInputStream(dbusMessage);
@@ -300,12 +301,13 @@ class DBusMethodWithReplyAdapterDispatcher<_StubClass, _StubAdapterClass, _In<_I
     }
 
     bool dispatchDBusMessage(const DBusMessage& dbusMessage, const std::shared_ptr<_StubClass>& stub, DBusStubAdapterHelperType& dbusStubAdapterHelper) {
+        std::tuple<_InArgs..., _OutArgs...> argTuple;
         return handleDBusMessage(
                         dbusMessage,
                         stub,
                         dbusStubAdapterHelper,
                         typename make_sequence_range<sizeof...(_InArgs), 0>::type(),
-                        typename make_sequence_range<sizeof...(_OutArgs), sizeof...(_InArgs)>::type());
+                        typename make_sequence_range<sizeof...(_OutArgs), sizeof...(_InArgs)>::type(),argTuple);
     }
 
  private:
@@ -314,8 +316,8 @@ class DBusMethodWithReplyAdapterDispatcher<_StubClass, _StubAdapterClass, _In<_I
                                   const std::shared_ptr<_StubClass>& stub,
                                   DBusStubAdapterHelperType& dbusStubAdapterHelper,
                                   index_sequence<_InArgIndices...>,
-                                  index_sequence<_OutArgIndices...>) const {
-        std::tuple<_InArgs..., _OutArgs...> argTuple;
+                                  index_sequence<_OutArgIndices...>,
+                                  std::tuple<_InArgs..., _OutArgs...> argTuple) const {
 
         if (sizeof...(_InArgs) > 0) {
             DBusInputStream dbusInputStream(dbusMessage);
diff --git a/src/test/DBusAddressTranslatorTest.cpp b/src/test/DBusAddressTranslatorTest.cpp
index 218cd5c..d953ec2 100644
--- a/src/test/DBusAddressTranslatorTest.cpp
+++ b/src/test/DBusAddressTranslatorTest.cpp
@@ -144,7 +144,7 @@ protected:
 };
 
 TEST_F(AddressTranslatorTest, InstanceCanBeRetrieved) {
-    CommonAPI::DBus::DBusAddressTranslator& translator = CommonAPI::DBus::DBusAddressTranslator::getInstance();
+    CommonAPI::DBus::DBusAddressTranslator::getInstance();
 }
 
 TEST_F(AddressTranslatorTest, ParsesDBusAddresses) {
diff --git a/src/test/DBusClientIdTest.cpp b/src/test/DBusClientIdTest.cpp
index eeb52b0..b21aeb9 100644
--- a/src/test/DBusClientIdTest.cpp
+++ b/src/test/DBusClientIdTest.cpp
@@ -7,8 +7,6 @@
 
 #include <gtest/gtest.h>
 
-#define COMMONAPI_INTERNAL_COMPILATION
-
 #include "CommonAPI/DBus/DBusClientId.h"
 #include "CommonAPI/types.h"
 
diff --git a/src/test/DBusCommunicationTest.cpp b/src/test/DBusCommunicationTest.cpp
index 3a06910..a693ceb 100644
--- a/src/test/DBusCommunicationTest.cpp
+++ b/src/test/DBusCommunicationTest.cpp
@@ -413,9 +413,9 @@ class DBusLowLevelCommunicationTest: public ::testing::Test {
         std::shared_ptr<CommonAPI::DBus::DBusObjectManagerStub> rootDBusObjectManagerStub = dbusConnection->getDBusObjectManager()->getRootDBusObjectManagerStub();
 
         const auto dbusObjectManager = dbusConnection->getDBusObjectManager();
-        const bool isDBusObjectRegistrationSuccessful = dbusObjectManager->registerDBusStubAdapter(dbusStubAdapter);
+        dbusObjectManager->registerDBusStubAdapter(dbusStubAdapter);
 
-        const bool isServiceExportSuccessful = rootDBusObjectManagerStub->exportManagedDBusStubAdapter(dbusStubAdapter);
+        rootDBusObjectManagerStub->exportManagedDBusStubAdapter(dbusStubAdapter);
 
         return dbusStubAdapter;
     }
diff --git a/src/test/DBusConnectionTest.cpp b/src/test/DBusConnectionTest.cpp
index ce1c893..8477e38 100644
--- a/src/test/DBusConnectionTest.cpp
+++ b/src/test/DBusConnectionTest.cpp
@@ -287,7 +287,6 @@ TEST_F(DBusConnectionTest, LibdbusConnectionsMayCommitSuicide) {
     dbus_message_set_signature(libdbusMessageCall, "");
 
     DBusPendingCall* libdbusPendingCall;
-    dbus_bool_t libdbusSuccess;
 
     dbus_connection_send_with_reply(
                     libdbusConnection,
@@ -341,10 +340,8 @@ TEST_F(DBusConnectionTest, DISABLED_TimeoutForNonexistingServices) {
 
     dbus_message_set_signature(libdbusMessageCall, "");
 
-    bool hasHappened = false;
 
     DBusPendingCall* libdbusPendingCall;
-    dbus_bool_t libdbusSuccess;
 
     dbus_connection_send_with_reply(
                     libdbusConnection,
diff --git a/src/test/DBusLoadTest.cpp b/src/test/DBusLoadTest.cpp
index c75590c..94090d3 100644
--- a/src/test/DBusLoadTest.cpp
+++ b/src/test/DBusLoadTest.cpp
@@ -114,7 +114,7 @@ const uint32_t DBusLoadTest::numProxies_ = 100;
 TEST_F(DBusLoadTest, SingleClientMultipleProxiesSingleStubCallsSucceed) {
     std::array<std::shared_ptr<commonapi::tests::TestInterfaceProxyBase>, numProxies_> testProxies;
 
-    for (auto i = 0; i < numProxies_; i++) {
+    for (unsigned int i = 0; i < numProxies_; i++) {
         testProxies[i] = proxyFactory_->buildProxy < commonapi::tests::TestInterfaceProxy > (serviceAddress_);
         ASSERT_TRUE((bool )testProxies[i]);
     }
@@ -128,9 +128,9 @@ TEST_F(DBusLoadTest, SingleClientMultipleProxiesSingleStubCallsSucceed) {
     ASSERT_TRUE(serviceRegistered);
 
     bool allProxiesAvailable = false;
-    for (auto i = 0; !allProxiesAvailable && i < 100; ++i) {
+    for (unsigned int i = 0; !allProxiesAvailable && i < 100; ++i) {
         allProxiesAvailable = true;
-        for (auto j = 0; j < numProxies_; ++j) {
+        for (unsigned int j = 0; j < numProxies_; ++j) {
             allProxiesAvailable = allProxiesAvailable && testProxies[j]->isAvailable();
         }
         if (!allProxiesAvailable)
@@ -139,8 +139,8 @@ TEST_F(DBusLoadTest, SingleClientMultipleProxiesSingleStubCallsSucceed) {
     ASSERT_TRUE(allProxiesAvailable);
 
     uint32_t callId = 0;
-    for (auto i = 0; i < numCallsPerProxy_; i++) {
-        for (auto j = 0; j < numProxies_; j++) {
+    for (unsigned int i = 0; i < numCallsPerProxy_; i++) {
+        for (unsigned int j = 0; j < numProxies_; j++) {
             uint32_t in1 = i;
             std::string in2 = "string" + std::to_string(i) + "_" + std::to_string(j);
             testProxies[j]->testPredefinedTypeMethodAsync(
@@ -159,7 +159,7 @@ TEST_F(DBusLoadTest, SingleClientMultipleProxiesSingleStubCallsSucceed) {
     }
 
     bool allCallsSucceeded = false;
-    for (auto i = 0; !allCallsSucceeded && i < 100; ++i) {
+    for (unsigned int i = 0; !allCallsSucceeded && i < 100; ++i) {
         allCallsSucceeded = std::all_of(callSucceeded_.cbegin(), callSucceeded_.cend(), [](int b){ return b; });
         if (!allCallsSucceeded)
             usleep(100000);
@@ -174,7 +174,7 @@ TEST_F(DBusLoadTest, MultipleClientsSingleStubCallsSucceed) {
     std::array<std::shared_ptr<CommonAPI::Factory>, numProxies_> testProxyFactories;
     std::array<std::shared_ptr<commonapi::tests::TestInterfaceProxyBase>, numProxies_> testProxies;
 
-    for (auto i = 0; i < numProxies_; i++) {
+    for (unsigned int i = 0; i < numProxies_; i++) {
         testProxyFactories[i] = runtime_->createFactory();
         ASSERT_TRUE((bool )testProxyFactories[i]);
         testProxies[i] = testProxyFactories[i]->buildProxy < commonapi::tests::TestInterfaceProxy > (serviceAddress_);
@@ -191,9 +191,9 @@ TEST_F(DBusLoadTest, MultipleClientsSingleStubCallsSucceed) {
     ASSERT_TRUE(serviceRegistered);
 
     bool allProxiesAvailable = false;
-    for (auto i = 0; !allProxiesAvailable && i < 100; ++i) {
+    for (unsigned int i = 0; !allProxiesAvailable && i < 100; ++i) {
         allProxiesAvailable = true;
-        for (auto j = 0; j < numProxies_; ++j) {
+        for (unsigned int j = 0; j < numProxies_; ++j) {
             allProxiesAvailable = allProxiesAvailable && testProxies[j]->isAvailable();
         }
         if (!allProxiesAvailable)
@@ -202,8 +202,8 @@ TEST_F(DBusLoadTest, MultipleClientsSingleStubCallsSucceed) {
     ASSERT_TRUE(allProxiesAvailable);
 
     uint32_t callId = 0;
-    for (auto i = 0; i < numCallsPerProxy_; i++) {
-        for (auto j = 0; j < numProxies_; j++) {
+    for (unsigned int i = 0; i < numCallsPerProxy_; i++) {
+        for (unsigned int j = 0; j < numProxies_; j++) {
             uint32_t in1 = i;
             std::string in2 = "string" + std::to_string(i) + "_" + std::to_string(j);
             testProxies[j]->testPredefinedTypeMethodAsync(
@@ -222,7 +222,7 @@ TEST_F(DBusLoadTest, MultipleClientsSingleStubCallsSucceed) {
     }
 
     bool allCallsSucceeded = false;
-    for (auto i = 0; !allCallsSucceeded && i < 100; ++i) {
+    for (unsigned int i = 0; !allCallsSucceeded && i < 100; ++i) {
         allCallsSucceeded = std::all_of(callSucceeded_.cbegin(), callSucceeded_.cend(), [](int b){ return b; });
         if (!allCallsSucceeded)
             usleep(100000);
@@ -239,14 +239,14 @@ TEST_F(DBusLoadTest, MultipleClientsMultipleServersCallsSucceed) {
     std::array<std::shared_ptr<commonapi::tests::TestInterfaceProxyBase>, numProxies_> testProxies;
     std::array<std::shared_ptr<commonapi::tests::TestInterfaceStub>, numProxies_> testStubs;
 
-    for (auto i = 0; i < numProxies_; i++) {
+    for (unsigned int i = 0; i < numProxies_; i++) {
         testProxyFactories[i] = runtime_->createFactory();
         ASSERT_TRUE((bool )testProxyFactories[i]);
         testProxies[i] = testProxyFactories[i]->buildProxy < commonapi::tests::TestInterfaceProxy > (serviceAddress_+std::to_string(i));
         ASSERT_TRUE((bool )testProxies[i]);
     }
 
-    for (auto i = 0; i < numProxies_; i++) {
+    for (unsigned int i = 0; i < numProxies_; i++) {
         testStubFactories[i] = runtime_->createFactory();
         ASSERT_TRUE((bool )testStubFactories[i]);
         testStubs[i] = std::make_shared<TestInterfaceStubFinal>();
@@ -261,9 +261,9 @@ TEST_F(DBusLoadTest, MultipleClientsMultipleServersCallsSucceed) {
     }
 
     bool allProxiesAvailable = false;
-    for (auto i = 0; !allProxiesAvailable && i < 100; ++i) {
+    for (unsigned int i = 0; !allProxiesAvailable && i < 100; ++i) {
         allProxiesAvailable = true;
-        for (auto j = 0; j < numProxies_; ++j) {
+        for (unsigned int j = 0; j < numProxies_; ++j) {
             allProxiesAvailable = allProxiesAvailable && testProxies[j]->isAvailable();
         }
         if (!allProxiesAvailable)
@@ -272,8 +272,8 @@ TEST_F(DBusLoadTest, MultipleClientsMultipleServersCallsSucceed) {
     ASSERT_TRUE(allProxiesAvailable);
 
     uint32_t callId = 0;
-    for (auto i = 0; i < numCallsPerProxy_; i++) {
-        for (auto j = 0; j < numProxies_; j++) {
+    for (unsigned int i = 0; i < numCallsPerProxy_; i++) {
+        for (unsigned int j = 0; j < numProxies_; j++) {
             uint32_t in1 = i;
             std::string in2 = "string" + std::to_string(i) + "_" + std::to_string(j);
             testProxies[j]->testPredefinedTypeMethodAsync(
@@ -299,7 +299,7 @@ TEST_F(DBusLoadTest, MultipleClientsMultipleServersCallsSucceed) {
     }
     ASSERT_TRUE(allCallsSucceeded);
 
-    for (auto i = 0; i < numProxies_; i++) {
+    for (unsigned int i = 0; i < numProxies_; i++) {
         servicePublisher_->unregisterService(serviceAddress_+std::to_string(i));
     }
 }
diff --git a/src/test/DBusMainLoopIntegrationTest.cpp b/src/test/DBusMainLoopIntegrationTest.cpp
index f3bc0ae..34cccce 100644
--- a/src/test/DBusMainLoopIntegrationTest.cpp
+++ b/src/test/DBusMainLoopIntegrationTest.cpp
@@ -263,7 +263,6 @@ TEST_F(DBusMainLoopTest, ProxyAndServiceInSameDemoMainloopCanCommunicate) {
 
     uint32_t uint32Value = 42;
     std::string stringValue = "Hai :)";
-    bool running = true;
 
     std::future<CommonAPI::CallStatus> futureStatus = proxy->testVoidPredefinedTypeMethodAsync(
                     uint32Value,
@@ -440,7 +439,7 @@ class DBusInGLibMainLoopTest: public ::testing::Test {
         for (auto dependentSourceIterator = dependentSources.begin();
                 dependentSourceIterator != dependentSources.end();
                 dependentSourceIterator++) {
-            GSource* gDispatchSource = g_source_new(&standardGLibSourceCallbackFuncs, sizeof(GDispatchWrapper));
+            g_source_new(&standardGLibSourceCallbackFuncs, sizeof(GDispatchWrapper));
             GSource* gSource = gSourceMappings.find(*dependentSourceIterator)->second;
             g_source_destroy(gSource);
             g_source_unref(gSource);
@@ -582,4 +581,4 @@ int main(int argc, char** argv) {
     ::testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/src/test/DBusObjectManagerStubTest.cpp b/src/test/DBusObjectManagerStubTest.cpp
index 1c94a9b..b7d1294 100644
--- a/src/test/DBusObjectManagerStubTest.cpp
+++ b/src/test/DBusObjectManagerStubTest.cpp
@@ -140,10 +140,10 @@ struct TestDBusObjectManagerSignalHandler: public CommonAPI::DBus::DBusConnectio
 private:
     TestDBusObjectManagerSignalHandler(const std::string& dbusObjectPath,
                                        const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection) :
-                    dbusObjectPath_(dbusObjectPath),
-                    dbusConnection_(dbusConnection),
                     totalAddedCount(0),
-                    totalRemovedCount(0) {
+                    totalRemovedCount(0),
+                    dbusObjectPath_(dbusObjectPath),
+                    dbusConnection_(dbusConnection) {
     }
 
     void init() {
diff --git a/src/test/DBusProxyTest.cpp b/src/test/DBusProxyTest.cpp
index 5668abb..1893a70 100644
--- a/src/test/DBusProxyTest.cpp
+++ b/src/test/DBusProxyTest.cpp
@@ -277,8 +277,8 @@ TEST_F(ProxyTest, IsAvailableBlocking) {
 }
 
 TEST_F(ProxyTest, HasNecessaryAttributesAndEvents) {
-    CommonAPI::InterfaceVersionAttribute& versionAttribute = (proxy_->getInterfaceVersionAttribute());
-    CommonAPI::ProxyStatusEvent& statusEvent = (proxy_->getProxyStatusEvent());
+    (proxy_->getInterfaceVersionAttribute());
+    (proxy_->getProxyStatusEvent());
 }
 
 TEST_F(ProxyTest, TestInterfaceVersionAttribute) {
@@ -432,7 +432,6 @@ TEST_F(ProxyTest, ProxyCanFetchVersionAttributeFromInheritedInterfaceStub) {
     CommonAPI::InterfaceVersionAttribute& versionAttribute = extendedProxy->getInterfaceVersionAttribute();
 
     CommonAPI::Version version;
-    CommonAPI::CallStatus status;
     bool wasCalled = false;
 
     std::future<CommonAPI::CallStatus> futureVersion = versionAttribute.getValueAsync([&](const CommonAPI::CallStatus& callStatus, CommonAPI::Version version) {
diff --git a/src/test/DBusSelectiveBroadcastTest.cpp b/src/test/DBusSelectiveBroadcastTest.cpp
index 870568c..271ea72 100644
--- a/src/test/DBusSelectiveBroadcastTest.cpp
+++ b/src/test/DBusSelectiveBroadcastTest.cpp
@@ -196,7 +196,7 @@ TEST_F(DBusSelectiveBroadcastTest, ProxysCanSubscribe)
     EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory1, 2);
     EXPECT_EQ(selectiveBroadcastArrivedAtProxyFromSameFactory2, 1);
 
-    auto subscriptionResult3 = proxyFromOtherFactory->getTestSelectiveBroadcastSelectiveEvent().subscribe(std::bind(&DBusSelectiveBroadcastTest::selectiveBroadcastCallbackForProxyFromOtherFactory, this));
+    proxyFromOtherFactory->getTestSelectiveBroadcastSelectiveEvent().subscribe(std::bind(&DBusSelectiveBroadcastTest::selectiveBroadcastCallbackForProxyFromOtherFactory, this));
     ASSERT_EQ(stub->getNumberOfSubscribedClients(), 2); // should still be two because proxyFromSameFactory1_ is still subscribed
 
     proxyFromSameFactory2->getTestSelectiveBroadcastSelectiveEvent().unsubscribe(subscriptionResult2);
@@ -242,7 +242,7 @@ TEST_F(DBusSelectiveBroadcastTest, ProxysCanBeRejected) {
 
     bool subbed = false;
 
-    auto subscriptionResult1 = proxyFromSameFactory1->getTestSelectiveBroadcastSelectiveEvent().subscribe(
+    proxyFromSameFactory1->getTestSelectiveBroadcastSelectiveEvent().subscribe(
                     std::bind(&DBusSelectiveBroadcastTest::selectiveBroadcastCallbackForProxyFromSameFactory1, this),
                     subbed);
     ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1);
@@ -250,7 +250,7 @@ TEST_F(DBusSelectiveBroadcastTest, ProxysCanBeRejected) {
 
     stub->acceptSubs = false;
 
-    auto subscriptionResult2 = proxyFromOtherFactory->getTestSelectiveBroadcastSelectiveEvent().subscribe(
+    proxyFromOtherFactory->getTestSelectiveBroadcastSelectiveEvent().subscribe(
                     std::bind(&DBusSelectiveBroadcastTest::selectiveBroadcastCallbackForProxyFromOtherFactory, this),
                     subbed);
     ASSERT_EQ(stub->getNumberOfSubscribedClients(), 1);
@@ -268,4 +268,4 @@ int main(int argc, char** argv) {
     ::testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/src/test/DBusServiceRegistryTest.cpp b/src/test/DBusServiceRegistryTest.cpp
index 9135ff5..34a40f5 100644
--- a/src/test/DBusServiceRegistryTest.cpp
+++ b/src/test/DBusServiceRegistryTest.cpp
@@ -90,10 +90,10 @@ struct TestDBusServiceListener {
 
     TestDBusServiceListener(const std::string& commonApiAddress,
                             const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection):
-                                commonApiAddress_(commonApiAddress),
-                                dbusServiceRegistry_(dbusConnection->getDBusServiceRegistry()),
+                                availabilityStatusCount(0),
                                 isSubscribed(false),
-                                availabilityStatusCount(0) {
+                                commonApiAddress_(commonApiAddress),
+                                dbusServiceRegistry_(dbusConnection->getDBusServiceRegistry()) {
     }
 
     ~TestDBusServiceListener() {
diff --git a/src/test/DBusTestUtils.h b/src/test/DBusTestUtils.h
index 912d368..0ed4938 100644
--- a/src/test/DBusTestUtils.h
+++ b/src/test/DBusTestUtils.h
@@ -17,13 +17,13 @@ inline char eliminateZeroes(char val) {
 }
 
 inline void printLibdbusMessageBody(char* data, uint32_t fromByteIndex, uint32_t toByteIndex) {
-	for(int i = fromByteIndex; i < toByteIndex; i++) {
-		std::cout << eliminateZeroes(data[i]);
-		if(i%8 == 7) {
-			std::cout << std::endl;
-		}
-	}
-	std::cout << std::endl;
+    for (unsigned int i = fromByteIndex; i < toByteIndex; i++) {
+        std::cout << eliminateZeroes(data[i]);
+        if (i % 8 == 7) {
+            std::cout << std::endl;
+        }
+    }
+    std::cout << std::endl;
 }
 
 inline void printLibdbusMessage(DBusMessage* libdbusMessage, uint32_t fromByteIndex, uint32_t toByteIndex) {
@@ -53,6 +53,7 @@ inline std::string toString(CommonAPI::DBus::DBusServiceRegistry::DBusRecordStat
         case CommonAPI::DBus::DBusServiceRegistry::DBusRecordState::UNKNOWN:
             return "UNKNOWN";
     }
+    return "";
 }
 
 inline std::string toString(CommonAPI::AvailabilityStatus state) {
@@ -64,6 +65,7 @@ inline std::string toString(CommonAPI::AvailabilityStatus state) {
         case CommonAPI::AvailabilityStatus::UNKNOWN:
             return "UNKNOWN";
     }
+    return "";
 }
 
 inline std::string toString(CommonAPI::CallStatus state) {
@@ -79,5 +81,6 @@ inline std::string toString(CommonAPI::CallStatus state) {
         case CommonAPI::CallStatus::SUCCESS:
             return "SUCCESS";
     }
+    return "";
 }
 #endif //__DBUS_TEST_UTILS__
diff --git a/src/test/DBusVariantOutputStreamTest.cpp b/src/test/DBusVariantOutputStreamTest.cpp
index ad02d66..f8534e3 100644
--- a/src/test/DBusVariantOutputStreamTest.cpp
+++ b/src/test/DBusVariantOutputStreamTest.cpp
@@ -162,7 +162,7 @@ TEST_F(VariantOutputStreamTest, CanWriteVariantInArray) {
     std::vector<InnerVar> inVector;
     std::vector<InnerVar> outVector;
 
-    for (int i = 0; i < numOfElements; i++) {
+    for (unsigned int i = 0; i < numOfElements; i++) {
         inVector.push_back(InnerVar(fromInt));
     }
 
@@ -188,7 +188,7 @@ TEST_F(VariantOutputStreamTest, CanWriteArrayInVariant) {
 
     std::vector<int> inVector;
     int fromInt = 14132;
-    for (int i = 0; i < numOfElements; i++) {
+    for (unsigned int i = 0; i < numOfElements; i++) {
         inVector.push_back(fromInt);
     }
 
@@ -271,7 +271,7 @@ TEST_F(VariantOutputStreamTest, CanWriteVariantInArrayInVariant) {
 
     VarVector inVector;
     int fromInt = 14132;
-    for (int i = 0; i < numOfElements; i++) {
+    for (unsigned int i = 0; i < numOfElements; i++) {
         inVector.push_back(InnerVar(fromInt));
     }
 
@@ -297,4 +297,4 @@ int main(int argc, char** argv) {
     ::testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/src/test/DemoMainLoop.h b/src/test/DemoMainLoop.h
index 41b51eb..0de634f 100644
--- a/src/test/DemoMainLoop.h
+++ b/src/test/DemoMainLoop.h
@@ -48,7 +48,10 @@ class MainLoop {
     MainLoop& operator=(MainLoop&&) = delete;
 
     explicit MainLoop(std::shared_ptr<MainLoopContext> context) :
-            context_(context), currentMinimalTimeoutInterval_(TIMEOUT_INFINITE), running_(false), breakLoop_(false) {
+                      context_(context),
+                      currentMinimalTimeoutInterval_(TIMEOUT_INFINITE),
+                      breakLoop_(false),
+                      running_(false) {
 
 #ifdef WIN32
         WSAEVENT wsaEvent = WSACreateEvent();
diff --git a/src/test/commonapi/tests/DerivedTypeCollection.h b/src/test/commonapi/tests/DerivedTypeCollection.h
index 9e43d78..e0cacd1 100644
--- a/src/test/commonapi/tests/DerivedTypeCollection.h
+++ b/src/test/commonapi/tests/DerivedTypeCollection.h
@@ -350,6 +350,9 @@ static inline const char* getTypeCollectionName() {
     return typeCollectionName;
 }
 
+inline CommonAPI::Version getTypeCollectionVersion() {
+    return CommonAPI::Version(1, 0);
+}
 
 } // namespace DerivedTypeCollection
 
diff --git a/src/test/commonapi/tests/ExtendedInterfaceDBusProxy.cpp b/src/test/commonapi/tests/ExtendedInterfaceDBusProxy.cpp
index d46c5e1..8306c51 100644
--- a/src/test/commonapi/tests/ExtendedInterfaceDBusProxy.cpp
+++ b/src/test/commonapi/tests/ExtendedInterfaceDBusProxy.cpp
@@ -34,14 +34,14 @@ ExtendedInterfaceDBusProxy::ExtendedInterfaceDBusProxy(
                     const std::string& busName,
                     const std::string& objectPath,
                     const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyconnection):
-        TestInterfaceDBusProxy(
+        CommonAPI::DBus::DBusProxy(factory, commonApiAddress, interfaceName, busName, objectPath, dbusProxyconnection)
+        , TestInterfaceDBusProxy(
                     factory,
                     commonApiAddress,
                     interfaceName,
                     busName,
                     objectPath,
-                    dbusProxyconnection),
-        CommonAPI::DBus::DBusProxy(factory, commonApiAddress, interfaceName, busName, objectPath, dbusProxyconnection)
+                    dbusProxyconnection)
     {
     }
 
diff --git a/src/test/commonapi/tests/ExtendedInterfaceProxy.h b/src/test/commonapi/tests/ExtendedInterfaceProxy.h
index 18bae29..de00deb 100644
--- a/src/test/commonapi/tests/ExtendedInterfaceProxy.h
+++ b/src/test/commonapi/tests/ExtendedInterfaceProxy.h
@@ -121,8 +121,8 @@ public:
 template <typename ... _AttributeExtensions>
 ExtendedInterfaceProxy<_AttributeExtensions...>::ExtendedInterfaceProxy(std::shared_ptr<CommonAPI::Proxy> delegate):
         TestInterfaceProxy<_AttributeExtensions...>(delegate),
-        delegate_(std::dynamic_pointer_cast<ExtendedInterfaceProxyBase>(delegate)),
-        _AttributeExtensions(*(std::dynamic_pointer_cast<ExtendedInterfaceProxyBase>(delegate)))... {
+        _AttributeExtensions(*(std::dynamic_pointer_cast<ExtendedInterfaceProxyBase>(delegate)))...,
+        delegate_(std::dynamic_pointer_cast<ExtendedInterfaceProxyBase>(delegate)) {
 }
 
 template <typename ... _AttributeExtensions>
diff --git a/src/test/commonapi/tests/PredefinedTypeCollection.h b/src/test/commonapi/tests/PredefinedTypeCollection.h
index 7ccf60d..653a4f1 100644
--- a/src/test/commonapi/tests/PredefinedTypeCollection.h
+++ b/src/test/commonapi/tests/PredefinedTypeCollection.h
@@ -48,6 +48,9 @@ static inline const char* getTypeCollectionName() {
     return typeCollectionName;
 }
 
+inline CommonAPI::Version getTypeCollectionVersion() {
+    return CommonAPI::Version(1, 0);
+}
 
 } // namespace PredefinedTypeCollection
 
diff --git a/src/test/commonapi/tests/TestInterfaceProxy.h b/src/test/commonapi/tests/TestInterfaceProxy.h
index 52491e2..60b5691 100644
--- a/src/test/commonapi/tests/TestInterfaceProxy.h
+++ b/src/test/commonapi/tests/TestInterfaceProxy.h
@@ -382,8 +382,8 @@ namespace TestInterfaceExtensions {
 //
 template <typename ... _AttributeExtensions>
 TestInterfaceProxy<_AttributeExtensions...>::TestInterfaceProxy(std::shared_ptr<CommonAPI::Proxy> delegate):
-        delegate_(std::dynamic_pointer_cast<TestInterfaceProxyBase>(delegate)),
-        _AttributeExtensions(*(std::dynamic_pointer_cast<TestInterfaceProxyBase>(delegate)))... {
+        _AttributeExtensions(*(std::dynamic_pointer_cast<TestInterfaceProxyBase>(delegate)))...,
+        delegate_(std::dynamic_pointer_cast<TestInterfaceProxyBase>(delegate)) {
 }
 
 template <typename ... _AttributeExtensions>
diff --git a/src/test/commonapi/tests/managed/BranchInterfaceProxy.h b/src/test/commonapi/tests/managed/BranchInterfaceProxy.h
index c543d36..d91a5e8 100644
--- a/src/test/commonapi/tests/managed/BranchInterfaceProxy.h
+++ b/src/test/commonapi/tests/managed/BranchInterfaceProxy.h
@@ -117,8 +117,8 @@ public:
 //
 template <typename ... _AttributeExtensions>
 BranchInterfaceProxy<_AttributeExtensions...>::BranchInterfaceProxy(std::shared_ptr<CommonAPI::Proxy> delegate):
-        delegate_(std::dynamic_pointer_cast<BranchInterfaceProxyBase>(delegate)),
-        _AttributeExtensions(*(std::dynamic_pointer_cast<BranchInterfaceProxyBase>(delegate)))... {
+        _AttributeExtensions(*(std::dynamic_pointer_cast<BranchInterfaceProxyBase>(delegate)))...,
+        delegate_(std::dynamic_pointer_cast<BranchInterfaceProxyBase>(delegate)) {
 }
 
 template <typename ... _AttributeExtensions>
diff --git a/src/test/commonapi/tests/managed/LeafInterfaceProxy.h b/src/test/commonapi/tests/managed/LeafInterfaceProxy.h
index 289e3c3..4aa88a5 100644
--- a/src/test/commonapi/tests/managed/LeafInterfaceProxy.h
+++ b/src/test/commonapi/tests/managed/LeafInterfaceProxy.h
@@ -117,8 +117,8 @@ public:
 //
 template <typename ... _AttributeExtensions>
 LeafInterfaceProxy<_AttributeExtensions...>::LeafInterfaceProxy(std::shared_ptr<CommonAPI::Proxy> delegate):
-        delegate_(std::dynamic_pointer_cast<LeafInterfaceProxyBase>(delegate)),
-        _AttributeExtensions(*(std::dynamic_pointer_cast<LeafInterfaceProxyBase>(delegate)))... {
+        _AttributeExtensions(*(std::dynamic_pointer_cast<LeafInterfaceProxyBase>(delegate)))...,
+        delegate_(std::dynamic_pointer_cast<LeafInterfaceProxyBase>(delegate)) {
 }
 
 template <typename ... _AttributeExtensions>
diff --git a/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp b/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp
index 7fa1c1b..a56a381 100644
--- a/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp
+++ b/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp
@@ -129,9 +129,7 @@ bool RootInterfaceDBusStubAdapterInternal::registerManagedStubLeafInterface(std:
                     registeredLeafInterfaceInstances.insert(instance);
                     return true;
                 } else {
-                    const bool isManagedDeregistrationSuccessful =
-                        CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterManagedService(
-                                        commonApiAddress);
+                    CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterManagedService(commonApiAddress);
                 }
             }
         }
@@ -183,9 +181,7 @@ bool RootInterfaceDBusStubAdapterInternal::registerManagedStubBranchInterface(st
                     registeredBranchInterfaceInstances.insert(instance);
                     return true;
                 } else {
-                    const bool isManagedDeregistrationSuccessful =
-                        CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterManagedService(
-                                        commonApiAddress);
+                    CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterManagedService(commonApiAddress);
                 }
             }
         }
diff --git a/src/test/commonapi/tests/managed/RootInterfaceProxy.h b/src/test/commonapi/tests/managed/RootInterfaceProxy.h
index e128995..7f01728 100644
--- a/src/test/commonapi/tests/managed/RootInterfaceProxy.h
+++ b/src/test/commonapi/tests/managed/RootInterfaceProxy.h
@@ -119,8 +119,8 @@ public:
 //
 template <typename ... _AttributeExtensions>
 RootInterfaceProxy<_AttributeExtensions...>::RootInterfaceProxy(std::shared_ptr<CommonAPI::Proxy> delegate):
-        delegate_(std::dynamic_pointer_cast<RootInterfaceProxyBase>(delegate)),
-        _AttributeExtensions(*(std::dynamic_pointer_cast<RootInterfaceProxyBase>(delegate)))... {
+        _AttributeExtensions(*(std::dynamic_pointer_cast<RootInterfaceProxyBase>(delegate)))...,
+        delegate_(std::dynamic_pointer_cast<RootInterfaceProxyBase>(delegate)) {
 }
 
 template <typename ... _AttributeExtensions>
diff --git a/src/test/commonapi/tests/managed/RootInterfaceStubDefault.cpp b/src/test/commonapi/tests/managed/RootInterfaceStubDefault.cpp
index 7f9d526..8866718 100644
--- a/src/test/commonapi/tests/managed/RootInterfaceStubDefault.cpp
+++ b/src/test/commonapi/tests/managed/RootInterfaceStubDefault.cpp
@@ -14,8 +14,8 @@ namespace tests {
 namespace managed {
 
 RootInterfaceStubDefault::RootInterfaceStubDefault():
-        autoInstanceCounter_(0),
         remoteEventHandler_(this),
+        autoInstanceCounter_(0),
         interfaceVersion_(RootInterface::getInterfaceVersion()) {
 }
 
diff --git a/src/test/commonapi/tests/managed/SecondRootDBusStubAdapter.cpp b/src/test/commonapi/tests/managed/SecondRootDBusStubAdapter.cpp
index 20ccd2b..4ddba05 100644
--- a/src/test/commonapi/tests/managed/SecondRootDBusStubAdapter.cpp
+++ b/src/test/commonapi/tests/managed/SecondRootDBusStubAdapter.cpp
@@ -107,9 +107,7 @@ bool SecondRootDBusStubAdapterInternal::registerManagedStubLeafInterface(std::sh
                     registeredLeafInterfaceInstances.insert(instance);
                     return true;
                 } else {
-                    const bool isManagedDeregistrationSuccessful =
-                        CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterManagedService(
-                                        commonApiAddress);
+                    CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterManagedService(commonApiAddress);
                 }
             }
         }
diff --git a/src/test/commonapi/tests/managed/SecondRootProxy.h b/src/test/commonapi/tests/managed/SecondRootProxy.h
index 0ce5699..27eb126 100644
--- a/src/test/commonapi/tests/managed/SecondRootProxy.h
+++ b/src/test/commonapi/tests/managed/SecondRootProxy.h
@@ -97,8 +97,8 @@ public:
 //
 template <typename ... _AttributeExtensions>
 SecondRootProxy<_AttributeExtensions...>::SecondRootProxy(std::shared_ptr<CommonAPI::Proxy> delegate):
-        delegate_(std::dynamic_pointer_cast<SecondRootProxyBase>(delegate)),
-        _AttributeExtensions(*(std::dynamic_pointer_cast<SecondRootProxyBase>(delegate)))... {
+        _AttributeExtensions(*(std::dynamic_pointer_cast<SecondRootProxyBase>(delegate)))...,
+        delegate_(std::dynamic_pointer_cast<SecondRootProxyBase>(delegate)) {
 }
 
 template <typename ... _AttributeExtensions>
diff --git a/src/test/commonapi/tests/managed/SecondRootStubDefault.cpp b/src/test/commonapi/tests/managed/SecondRootStubDefault.cpp
index 37500a5..5199fdb 100644
--- a/src/test/commonapi/tests/managed/SecondRootStubDefault.cpp
+++ b/src/test/commonapi/tests/managed/SecondRootStubDefault.cpp
@@ -14,8 +14,8 @@ namespace tests {
 namespace managed {
 
 SecondRootStubDefault::SecondRootStubDefault():
-        autoInstanceCounter_(0),
         remoteEventHandler_(this),
+        autoInstanceCounter_(0),
         interfaceVersion_(SecondRoot::getInterfaceVersion()) {
 }
 
diff --git a/src/test/dbusDynamicLoadingTests/DBusDynamicLoadingBasicTest.cpp b/src/test/dbusDynamicLoadingTests/DBusDynamicLoadingBasicTest.cpp
index fb91f5f..a21a99c 100644
--- a/src/test/dbusDynamicLoadingTests/DBusDynamicLoadingBasicTest.cpp
+++ b/src/test/dbusDynamicLoadingTests/DBusDynamicLoadingBasicTest.cpp
@@ -196,7 +196,6 @@ TEST_F(DBusDynamicLoadingBasicTest, CreatedProxiesAndServicesCanCommunicate) {
 
     servicePublisher->registerService(myStub, testServiceAddress, serviceFactory);
 
-    uint32_t i = 0;
     for (uint32_t i = 0; i < 300 && !defaultTestProxy->isAvailable(); ++i) {
         usleep(1000);
     }
diff --git a/src/test/dbusDynamicLoadingTests/DBusDynamicLoadingMixedValidityTest.cpp b/src/test/dbusDynamicLoadingTests/DBusDynamicLoadingMixedValidityTest.cpp
index 5e34932..b1d6263 100644
--- a/src/test/dbusDynamicLoadingTests/DBusDynamicLoadingMixedValidityTest.cpp
+++ b/src/test/dbusDynamicLoadingTests/DBusDynamicLoadingMixedValidityTest.cpp
@@ -168,7 +168,6 @@ TEST_F(DBusDynamicLoadingPartiallyInvalidConfigTest, CreatedProxiesAndServicesCa
 
     servicePublisher->registerService(myStub, testServiceAddress, serviceFactory);
 
-    uint32_t i = 0;
     for (uint32_t i = 0; i < 300 && !defaultTestProxy->isAvailable(); ++i) {
         usleep(1000);
     }
diff --git a/src/test/dbusDynamicLoadingTests/DBusDynamicLoadingMultipleDefinitionTest.cpp b/src/test/dbusDynamicLoadingTests/DBusDynamicLoadingMultipleDefinitionTest.cpp
index e30a8c5..2e402c3 100644
--- a/src/test/dbusDynamicLoadingTests/DBusDynamicLoadingMultipleDefinitionTest.cpp
+++ b/src/test/dbusDynamicLoadingTests/DBusDynamicLoadingMultipleDefinitionTest.cpp
@@ -160,7 +160,6 @@ TEST_F(DBusDynamicLoadingMultipleDefinitionTest, CreatedProxiesAndServicesCanCom
 
     servicePublisher->registerService(myStub, testServiceAddress, serviceFactory);
 
-    uint32_t i = 0;
     for (uint32_t i = 0; i < 300 && !defaultTestProxy->isAvailable(); ++i) {
         usleep(1000);
     }