diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5631380..467b052 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -14,9 +14,27 @@ ProcessorCount(PROCESSORS_NUM)
 
 set(CMAKE_ECLIPSE_MAKE_ARGUMENTS ${CMAKE_ECLIPSE_MAKE_ARGUMENTS} "--no-print-directory -j${PROCESSORS_NUM} -r -s" CACHE STRING "Make parameters")
 
-# Check if the build run from Jenkins or locally 
 project(${PROJECT_NAME} LANGUAGES C)
 
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+option(OPTION_ASAN "Enable AddressSanitizer" OFF)
+
+set(PROJECT_COMPILE_OPTIONS "")
+
+if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
+    list(APPEND PROJECT_COMPILE_OPTIONS -Wall -Wextra -Werror)
+
+    if(OPTION_ASAN)
+        message(STATUS "AddressSanitizer enabled")
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fno-omit-frame-pointer -g3")
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
+        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
+    endif()
+elseif(OPTION_ASAN)
+    message(WARNING "AddressSanitizer is only supported with GCC and Clang compilers.")
+endif()
+
 # TODO: Change STATIC to SHARED when libeebus is a part of SDK
 add_library(${PROJECT_NAME} STATIC)
 
@@ -161,6 +179,12 @@ target_include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}
 )
 
+target_compile_options(
+  ${PROJECT_NAME}
+  PRIVATE
+    ${PROJECT_COMPILE_OPTIONS}
+)
+
 # Warn if there are unresolved symbols in libeebus.
 # There should not be any unresolved symbols, and we don't want to
 # wait until the executable is linked to find out.
diff --git a/examples/heat_pump/CMakeLists.txt b/examples/heat_pump/CMakeLists.txt
index 81adc13..277be55 100644
--- a/examples/heat_pump/CMakeLists.txt
+++ b/examples/heat_pump/CMakeLists.txt
@@ -34,6 +34,11 @@ target_include_directories(${PROJECT_NAME}
     ${PROJECT_SOURCE_DIR}
 )
 
+target_compile_options(${PROJECT_NAME}
+    PRIVATE
+    ${PROJECT_COMPILE_OPTIONS}
+)
+
 target_link_libraries(${PROJECT_NAME}
     PRIVATE
     ${MATH_LIBRARY}
diff --git a/examples/heat_pump/hpsrv.c b/examples/heat_pump/hpsrv.c
index 68bc472..f53baf0 100644
--- a/examples/heat_pump/hpsrv.c
+++ b/examples/heat_pump/hpsrv.c
@@ -115,6 +115,8 @@ EebusError HpsrvConstruct(Hpsrv* self) {
 }
 
 EebusError AddLpc(Hpsrv* self, DeviceLocalObject* device_local, EntityLocalObject* entity_local) {
+  UNUSED(device_local);
+
   self->cs_lpc_listener = CsLpcListenerCreate();
   if (self->cs_lpc_listener == NULL) {
     return kEebusErrorMemoryAllocate;
@@ -132,6 +134,8 @@ EebusError AddLpc(Hpsrv* self, DeviceLocalObject* device_local, EntityLocalObjec
 }
 
 EebusError AddLpp(Hpsrv* self, DeviceLocalObject* device_local, EntityLocalObject* entity_local) {
+  UNUSED(device_local);
+
   self->cs_lpp_listener = CsLppListenerCreate();
   if (self->cs_lpp_listener == NULL) {
     return kEebusErrorMemoryAllocate;
@@ -149,6 +153,8 @@ EebusError AddLpp(Hpsrv* self, DeviceLocalObject* device_local, EntityLocalObjec
 }
 
 EebusError AddMpc(Hpsrv* self, DeviceLocalObject* device_local, EntityLocalObject* entity_local) {
+  UNUSED(device_local);
+
   static const MuMpcMeasurementConfig measurement_default_cfg = {
       .value_source = kMeasurementValueSourceTypeMeasuredValue,
   };
@@ -363,12 +369,16 @@ void OnRemoteSkiDisconnected(ServiceReaderObject* self, EebusServiceObject* serv
 
 void OnRemoteServicesUpdate(ServiceReaderObject* self, EebusServiceObject* service, const Vector* entries) {
   UNUSED(self);
+  UNUSED(service);
+  UNUSED(entries);
 
   // Optional: print the remote services
 }
 
 void OnShipIdUpdate(ServiceReaderObject* self, const char* ski, const char* shipd_id) {
   UNUSED(self);
+  UNUSED(ski);
+  UNUSED(shipd_id);
 }
 
 void OnShipStateUpdate(ServiceReaderObject* self, const char* ski, SmeState state) {
@@ -379,6 +389,7 @@ void OnShipStateUpdate(ServiceReaderObject* self, const char* ski, SmeState stat
 
 bool IsWaitingForTrustAllowed(const ServiceReaderObject* self, const char* ski) {
   UNUSED(self);
+  UNUSED(ski);
 
   return true;
 }
diff --git a/examples/hems/CMakeLists.txt b/examples/hems/CMakeLists.txt
index c2c3738..484ea17 100644
--- a/examples/hems/CMakeLists.txt
+++ b/examples/hems/CMakeLists.txt
@@ -35,6 +35,11 @@ target_include_directories(${PROJECT_NAME}
     ${PROJECT_SOURCE_DIR}
 )
 
+target_compile_options(${PROJECT_NAME}
+    PRIVATE
+    ${PROJECT_COMPILE_OPTIONS}
+)
+
 target_link_libraries(${PROJECT_NAME}
     PRIVATE
     ${MATH_LIBRARY}
diff --git a/examples/hems/eg_lpc_listener.c b/examples/hems/eg_lpc_listener.c
index aace786..8b5c9cd 100644
--- a/examples/hems/eg_lpc_listener.c
+++ b/examples/hems/eg_lpc_listener.c
@@ -91,6 +91,7 @@ EgLpListenerObject* EgLpcListenerCreate(HemsObject* hems) {
 }
 
 void Destruct(EgLpListenerObject* self) {
+  UNUSED(self);
   // Nothing to be deallocated yet
 }
 
@@ -101,6 +102,8 @@ void OnRemoteEntityConnect(EgLpListenerObject* self, const EntityAddressType* en
 }
 
 void OnRemoteEntityDisconnect(EgLpListenerObject* self, const EntityAddressType* entity_addr) {
+  UNUSED(entity_addr);
+
   EgLpcListener* const lpc_listener = EG_LP_LISTENER(self);
 
   // Currently only single remote entity is supported,
diff --git a/examples/hems/eg_lpp_listener.c b/examples/hems/eg_lpp_listener.c
index a2ab755..ff0ebd8 100644
--- a/examples/hems/eg_lpp_listener.c
+++ b/examples/hems/eg_lpp_listener.c
@@ -91,6 +91,7 @@ EgLpListenerObject* EgLppListenerCreate(HemsObject* hems) {
 }
 
 void Destruct(EgLpListenerObject* self) {
+  UNUSED(self);
   // Nothing to be deallocated yet
 }
 
@@ -101,6 +102,8 @@ void OnRemoteEntityConnect(EgLpListenerObject* self, const EntityAddressType* en
 }
 
 void OnRemoteEntityDisconnect(EgLpListenerObject* self, const EntityAddressType* entity_addr) {
+  UNUSED(entity_addr);
+
   EgLppListener* const lpp_listener = EG_LP_LISTENER(self);
 
   // Currently only single remote entity is supported,
diff --git a/examples/hems/hems.c b/examples/hems/hems.c
index 9a18763..0ce498c 100644
--- a/examples/hems/hems.c
+++ b/examples/hems/hems.c
@@ -105,6 +105,8 @@ EebusError HemsConstruct(Hems* self) {
 }
 
 EebusError AddEgLpc(Hems* self, DeviceLocalObject* device_local, EntityLocalObject* entity_local) {
+  UNUSED(device_local);
+
   self->eg_lpc_listener = EgLpcListenerCreate(HEMS_OBJECT(self));
   if (self->eg_lpc_listener == NULL) {
     return kEebusErrorMemoryAllocate;
@@ -121,6 +123,8 @@ EebusError AddEgLpc(Hems* self, DeviceLocalObject* device_local, EntityLocalObje
 }
 
 EebusError AddEgLpp(Hems* self, DeviceLocalObject* device_local, EntityLocalObject* entity_local) {
+  UNUSED(device_local);
+
   self->eg_lpp_listener = EgLppListenerCreate(HEMS_OBJECT(self));
   if (self->eg_lpp_listener == NULL) {
     return kEebusErrorMemoryAllocate;
@@ -137,6 +141,8 @@ EebusError AddEgLpp(Hems* self, DeviceLocalObject* device_local, EntityLocalObje
 }
 
 EebusError AddMaMpc(Hems* self, DeviceLocalObject* device_local, EntityLocalObject* entity_local) {
+  UNUSED(device_local);
+
   self->ma_mpc_listener = MaMpcListenerCreate(HEMS_OBJECT(self));
   if (self->ma_mpc_listener == NULL) {
     return kEebusErrorMemoryAllocate;
@@ -301,6 +307,7 @@ void OnShipStateUpdate(ServiceReaderObject* self, const char* ski, SmeState stat
 
 bool IsWaitingForTrustAllowed(const ServiceReaderObject* self, const char* ski) {
   UNUSED(self);
+  UNUSED(ski);
 
   return true;
 }
diff --git a/examples/hems/ma_mpc_listener.c b/examples/hems/ma_mpc_listener.c
index 4daa0d8..eeb8c8a 100644
--- a/examples/hems/ma_mpc_listener.c
+++ b/examples/hems/ma_mpc_listener.c
@@ -59,7 +59,6 @@ static const MaMpcListenerInterface ma_mpc_listener_methods = {
 };
 
 static EebusError MaMpcListenerConstruct(MaMpcListener* self, HemsObject* hems);
-static float GetValue(const ScaledValue* value);
 
 EebusError MaMpcListenerConstruct(MaMpcListener* self, HemsObject* hems) {
   // Override "virtual functions table"
diff --git a/src/cli/eebus_cli_cs_lp.c b/src/cli/eebus_cli_cs_lp.c
index 7ce934d..cf9bcb0 100644
--- a/src/cli/eebus_cli_cs_lp.c
+++ b/src/cli/eebus_cli_cs_lp.c
@@ -22,6 +22,7 @@
 #include <string.h>
 
 #include "src/cli/eebus_cli_cs_lp.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_bool/eebus_bool.h"
 #include "src/common/eebus_date_time/eebus_date_time.h"
 #include "src/use_case/model/scaled_value.h"
@@ -101,6 +102,7 @@ EebusCliHandlerObject* CsLpCliCreate(EnergyDirectionType energy_direction, CsLpU
 }
 
 void Destruct(EebusCliHandlerObject* self) {
+  UNUSED(self);
   // Nothing to be deallocated yet
 }
 
@@ -110,6 +112,9 @@ void Destruct(EebusCliHandlerObject* self) {
 //
 //-------------------------------------------------------------------------------------------//
 void HandleCmdGetPowerLimit(const CsLpCli* self, const char* const* tokens, size_t num_tokens) {
+  UNUSED(tokens);
+  UNUSED(num_tokens);
+
   LoadLimit limit = {0};
   if (CsLpGetActivePowerLimit(self->cs_lp, &limit) != kEebusErrorOk) {
     printf("%s getting Active Power Limit failed\n", self->cmd_name_caps);
@@ -123,6 +128,9 @@ void HandleCmdGetPowerLimit(const CsLpCli* self, const char* const* tokens, size
 }
 
 void HandleCmdGetFailsafeLimit(const CsLpCli* self, const char* const* tokens, size_t num_tokens) {
+  UNUSED(tokens);
+  UNUSED(num_tokens);
+
   ScaledValue power_limit = {0};
   bool is_changeable      = false;
   if (CsLpGetFailsafeActivePowerLimit(self->cs_lp, &power_limit, &is_changeable) != kEebusErrorOk) {
@@ -136,6 +144,9 @@ void HandleCmdGetFailsafeLimit(const CsLpCli* self, const char* const* tokens, s
 }
 
 void HandleCmdGetFailsafeDuration(const CsLpCli* self, const char* const* tokens, size_t num_tokens) {
+  UNUSED(tokens);
+  UNUSED(num_tokens);
+
   DurationType duration = {0};
   bool is_changeable    = false;
   if (CsLpGetFailsafeDurationMinimum(self->cs_lp, &duration, &is_changeable) != kEebusErrorOk) {
diff --git a/src/cli/eebus_cli_eg_lp.c b/src/cli/eebus_cli_eg_lp.c
index 9042bce..dd467eb 100644
--- a/src/cli/eebus_cli_eg_lp.c
+++ b/src/cli/eebus_cli_eg_lp.c
@@ -22,6 +22,7 @@
 #include <string.h>
 
 #include "src/cli/eebus_cli_eg_lp.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_bool/eebus_bool.h"
 #include "src/common/eebus_date_time/eebus_date_time.h"
 #include "src/use_case/model/scaled_value.h"
@@ -132,6 +133,9 @@ void Destruct(EebusCliHandlerObject* self) {
 //
 //-------------------------------------------------------------------------------------------//
 void HandleCmdGetPowerLimit(const EgLpCli* self, const char* const* tokens, size_t num_tokens) {
+  UNUSED(tokens);
+  UNUSED(num_tokens);
+
   LoadLimit limit = {0};
   if (EgLpGetActivePowerLimit(self->eg_lp, self->entity_addr, &limit) != kEebusErrorOk) {
     printf("%s getting power limit failed\n", self->cmd_name_caps);
@@ -145,6 +149,9 @@ void HandleCmdGetPowerLimit(const EgLpCli* self, const char* const* tokens, size
 }
 
 void HandleCmdGetFailsafeLimit(const EgLpCli* self, const char* const* tokens, size_t num_tokens) {
+  UNUSED(tokens);
+  UNUSED(num_tokens);
+
   ScaledValue power_limit = {0};
   if (EgLpGetFailsafeActivePowerLimit(self->eg_lp, self->entity_addr, &power_limit) != kEebusErrorOk) {
     printf("%s getting failsafe limit failed\n", self->cmd_name_caps);
@@ -156,6 +163,9 @@ void HandleCmdGetFailsafeLimit(const EgLpCli* self, const char* const* tokens, s
 }
 
 void HandleCmdGetFailsafeDuration(const EgLpCli* self, const char* const* tokens, size_t num_tokens) {
+  UNUSED(tokens);
+  UNUSED(num_tokens);
+
   DurationType duration = {0};
   if (EgLpGetFailsafeDurationMinimum(self->eg_lp, self->entity_addr, &duration) != kEebusErrorOk) {
     printf("%s getting failsafe duration failed\n", self->cmd_name_caps);
diff --git a/src/cli/eebus_cli_mu_mpc.c b/src/cli/eebus_cli_mu_mpc.c
index 7b64e9b..3bd2b36 100644
--- a/src/cli/eebus_cli_mu_mpc.c
+++ b/src/cli/eebus_cli_mu_mpc.c
@@ -22,6 +22,7 @@
 #include <string.h>
 
 #include "src/cli/eebus_cli_mu_mpc.h"
+#include "src/common/eebus_arguments.h"
 #include "src/use_case/actor/mu/mpc/mu_mpc.h"
 
 typedef struct MuMpcCli MuMpcCli;
@@ -76,6 +77,7 @@ EebusCliHandlerObject* MuMpcCliCreate(MuMpcUseCaseObject* mu_mpc) {
 }
 
 void Destruct(EebusCliHandlerObject* self) {
+  UNUSED(self);
   // Nothing to be deallocated yet
 }
 
diff --git a/src/common/eebus_data/eebus_data_base.c b/src/common/eebus_data/eebus_data_base.c
index 5b9dd5f..12a010f 100644
--- a/src/common/eebus_data/eebus_data_base.c
+++ b/src/common/eebus_data/eebus_data_base.c
@@ -23,6 +23,7 @@
 #include <string.h>
 
 #include "src/common/api/eebus_data_interface.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_assert.h"
 #include "src/common/eebus_errors.h"
 #include "src/common/eebus_malloc.h"
@@ -118,6 +119,7 @@ EebusError EebusDataBaseCopyMatching(
     void* dst_base_addr,
     const void* data_to_match_base_addr
 ) {
+  UNUSED(data_to_match_base_addr);
   // No matching check is done by default
   return EEBUS_DATA_WRITE(cfg, dst_base_addr, base_addr);
 }
@@ -139,6 +141,10 @@ bool EebusDataBaseHasIdentifiers(const EebusDataCfg* cfg, const void* base_addr)
 
 bool EebusDataBaseSelectorsMatch(const EebusDataCfg* cfg, const void* base_addr, const EebusDataCfg* selectors_cfg,
     const void* selectors_base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(selectors_cfg);
+  UNUSED(selectors_base_addr);
   // SelectorsMatch() currently is not supported by default
   EEBUS_ASSERT_ALWAYS();
   return false;
@@ -167,11 +173,19 @@ EebusError EebusDataBaseWriteElements(const EebusDataCfg* cfg, void* base_addr,
 
 EebusError EebusDataBaseWritePartial(const EebusDataCfg* cfg, void* base_addr, void* src_base_addr,
     const EebusDataCfg* selectors_cfg, const void* selectors_base_addr, SelectorsMatcher selectors_matcher) {
+  UNUSED(selectors_cfg);
+  UNUSED(selectors_base_addr);
+  UNUSED(selectors_matcher);
+
   return EEBUS_DATA_WRITE_ELEMENTS(cfg, base_addr, src_base_addr);
 }
 
 void EebusDataBaseDeletePartial(const EebusDataCfg* cfg, void* base_addr, const EebusDataCfg* selectors_cfg,
     const void* selectors_base_addr, SelectorsMatcher selectors_matcher, const EebusDataCfg* elements_cfg,
     const void* elements_base_addr) {
+  UNUSED(selectors_cfg);
+  UNUSED(selectors_base_addr);
+  UNUSED(selectors_matcher);
+
   EEBUS_DATA_DELETE_ELEMENTS(cfg, base_addr, elements_cfg, elements_base_addr);
 }
diff --git a/src/common/eebus_data/eebus_data_choice.c b/src/common/eebus_data/eebus_data_choice.c
index 47f467e..16e72f7 100644
--- a/src/common/eebus_data/eebus_data_choice.c
+++ b/src/common/eebus_data/eebus_data_choice.c
@@ -21,6 +21,7 @@
 #include <stdbool.h>
 
 #include "src/common/api/eebus_data_interface.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_assert.h"
 #include "src/common/eebus_data/eebus_data_base.h"
 #include "src/common/eebus_data/eebus_data_util.h"
@@ -72,11 +73,18 @@ const EebusDataInterface eebus_data_choice_methods = {
 };
 
 void* CreateEmpty(const EebusDataCfg* cfg, void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+
   EEBUS_ASSERT_ALWAYS();
   return NULL;
 }
 
 EebusError FromJsonObjectItem(const EebusDataCfg* cfg, void* base_addr, const JsonObject* json_item) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(json_item);
+
   EEBUS_ASSERT_ALWAYS();
   return kEebusErrorOther;
 }
@@ -99,6 +107,10 @@ EebusError FromJsonObject(const EebusDataCfg* cfg, void* base_addr, const JsonOb
 }
 
 EebusError ToJsonObjectItem(const EebusDataCfg* cfg, const void* base_addr, JsonObject** json_item) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(json_item);
+
   EEBUS_ASSERT_ALWAYS();
   return kEebusErrorOther;
 }
@@ -111,7 +123,7 @@ static EebusError ToJsonObject(const EebusDataCfg* cfg, const void* base_addr, J
 
   const int32_t* const type_id         = (const int32_t*)((const uint8_t*)base_addr + cfg->type_id_offset);
   const EebusDataCfg* const choice_cfg = (const EebusDataCfg*)cfg->metadata;
-  if (*type_id >= EebusDataGetCfgSize(choice_cfg)) {
+  if (*type_id >= (int32_t)EebusDataGetCfgSize(choice_cfg)) {
     return kEebusErrorInputArgumentOutOfRange;
   }
 
@@ -129,7 +141,8 @@ bool Compare(const EebusDataCfg* a_cfg, const void* a_base_addr, const EebusData
   const int32_t* const a_type_id = (const int32_t*)((const uint8_t*)a_base_addr + a_cfg->type_id_offset);
   const int32_t* const b_type_id = (const int32_t*)((const uint8_t*)b_base_addr + b_cfg->type_id_offset);
 
-  if ((*a_type_id >= EebusDataGetCfgSize(a_choice_cfg)) || (*b_type_id >= EebusDataGetCfgSize(b_choice_cfg))) {
+  if ((*a_type_id >= (int32_t)EebusDataGetCfgSize(a_choice_cfg))
+      || (*b_type_id >= (int32_t)EebusDataGetCfgSize(b_choice_cfg))) {
     EEBUS_ASSERT_ALWAYS();
     return false;
   }
@@ -144,9 +157,9 @@ bool IsNull(const EebusDataCfg* cfg, const void* base_addr) {
 
   const int32_t* const type_id = (const int32_t*)((const uint8_t*)base_addr + cfg->type_id_offset);
 
-  if (*type_id >= EebusDataGetCfgSize(choice_cfg)) {
+  if (*type_id >= (int32_t)EebusDataGetCfgSize(choice_cfg)) {
     EEBUS_ASSERT_ALWAYS();
-    return kEebusErrorInputArgument;
+    return false;
   }
 
   return EEBUS_DATA_IS_NULL(&choice_cfg[*type_id], (const uint8_t*)base_addr + cfg->offset);
@@ -157,32 +170,50 @@ bool IsEmpty(const EebusDataCfg* cfg, const void* base_addr) {
 
   const int32_t* const type_id = (const int32_t*)((const uint8_t*)base_addr + cfg->type_id_offset);
 
-  if (*type_id >= EebusDataGetCfgSize(choice_cfg)) {
+  if (*type_id >= (int32_t)EebusDataGetCfgSize(choice_cfg)) {
     EEBUS_ASSERT_ALWAYS();
-    return kEebusErrorInputArgument;
+    return false;
   }
 
   return EEBUS_DATA_IS_EMPTY(&choice_cfg[*type_id], (const uint8_t*)base_addr + cfg->offset);
 }
 
 bool HasIdentifiers(const EebusDataCfg* cfg, const void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+
   EEBUS_ASSERT_ALWAYS();
   return false;
 }
 
 bool SelectorsMatch(const EebusDataCfg* cfg, const void* base_addr, const EebusDataCfg* selectors_cfg,
     const void* selectors_base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(selectors_cfg);
+  UNUSED(selectors_base_addr);
+
   EEBUS_ASSERT_ALWAYS();
   return false;
 }
 
 bool IdentifiersMatch(const EebusDataCfg* cfg, const void* base_addr, const void* src_base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(src_base_addr);
+
   EEBUS_ASSERT_ALWAYS();
   return false;
 }
 
 EebusError ReadElements(const EebusDataCfg* cfg, const void* base_addr, void* dst_base_addr,
     const EebusDataCfg* elements_cfg, const void* elements_base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(dst_base_addr);
+  UNUSED(elements_cfg);
+  UNUSED(elements_base_addr);
+
   EEBUS_ASSERT_ALWAYS();
   return kEebusErrorOther;
 }
@@ -193,7 +224,7 @@ EebusError Write(const EebusDataCfg* cfg, void* base_addr, const void* src_base_
   const int32_t* const src_type_id = (const int32_t*)((const uint8_t*)src_base_addr + cfg->type_id_offset);
   int32_t* const type_id           = (int32_t*)((uint8_t*)base_addr + cfg->type_id_offset);
 
-  if (*src_type_id >= EebusDataGetCfgSize(choice_cfg)) {
+  if (*src_type_id >= (int32_t)EebusDataGetCfgSize(choice_cfg)) {
     EEBUS_ASSERT_ALWAYS();
     return kEebusErrorInputArgument;
   }
@@ -209,6 +240,11 @@ EebusError Write(const EebusDataCfg* cfg, void* base_addr, const void* src_base_
 
 void DeleteElements(
     const EebusDataCfg* cfg, void* base_addr, const EebusDataCfg* elements_cfg, const void* elements_base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(elements_cfg);
+  UNUSED(elements_base_addr);
+
   EEBUS_ASSERT_ALWAYS();
 }
 
@@ -216,7 +252,7 @@ void Delete(const EebusDataCfg* cfg, void* base_addr) {
   const EebusDataCfg* const choice_cfg = (const EebusDataCfg*)cfg->metadata;
   const int32_t* const choice_type_id  = (const int32_t*)((const uint8_t*)base_addr + cfg->type_id_offset);
 
-  if (*choice_type_id >= EebusDataGetCfgSize(choice_cfg)) {
+  if (*choice_type_id >= (int32_t)EebusDataGetCfgSize(choice_cfg)) {
     EEBUS_ASSERT_ALWAYS();
     return;
   }
diff --git a/src/common/eebus_data/eebus_data_choice_root.c b/src/common/eebus_data/eebus_data_choice_root.c
index e0070ec..9d67922 100644
--- a/src/common/eebus_data/eebus_data_choice_root.c
+++ b/src/common/eebus_data/eebus_data_choice_root.c
@@ -23,6 +23,7 @@
 #include <string.h>
 
 #include "src/common/api/eebus_data_interface.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_assert.h"
 #include "src/common/eebus_data/eebus_data_base.h"
 #include "src/common/eebus_malloc.h"
@@ -126,58 +127,105 @@ char* PrintUnformatted(const EebusDataCfg* cfg, const void* base_addr) {
 }
 
 EebusError FromJsonObjectItem(const EebusDataCfg* cfg, void* base_addr, const JsonObject* json_obj) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(json_obj);
+
   EEBUS_ASSERT_ALWAYS();
   return kEebusErrorOther;
 }
 
 EebusError ToJsonObject(const EebusDataCfg* cfg, const void* base_addr, JsonObject* json_obj, bool is_root) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(json_obj);
+  UNUSED(is_root);
+
   EEBUS_ASSERT_ALWAYS();
   return kEebusErrorOther;
 }
 
 EebusError ToJsonObjectItem(const EebusDataCfg* cfg, const void* base_addr, JsonObject** json_obj) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(json_obj);
+
   EEBUS_ASSERT_ALWAYS();
   return kEebusErrorOther;
 }
 
 EebusError FromJsonObject(const EebusDataCfg* cfg, void* base_addr, const JsonObject* json_obj, bool is_root) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(json_obj);
+  UNUSED(is_root);
+
   EEBUS_ASSERT_ALWAYS();
   return kEebusErrorOther;
 }
 
 bool Compare(const EebusDataCfg* a_cfg, const void* a_base_addr, const EebusDataCfg* b_cfg, const void* b_base_addr) {
+  UNUSED(a_cfg);
+  UNUSED(a_base_addr);
+  UNUSED(b_cfg);
+  UNUSED(b_base_addr);
+
   EEBUS_ASSERT_ALWAYS();
   return false;
 }
 
 bool IsNull(const EebusDataCfg* cfg, const void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+
   EEBUS_ASSERT_ALWAYS();
   return false;
 }
 
 bool IsEmpty(const EebusDataCfg* cfg, const void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+
   EEBUS_ASSERT_ALWAYS();
   return false;
 }
 
 bool HasIdentifiers(const EebusDataCfg* cfg, const void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+
   EEBUS_ASSERT_ALWAYS();
   return false;
 }
 
 bool SelectorsMatch(const EebusDataCfg* cfg, const void* base_addr, const EebusDataCfg* selectors_cfg,
     const void* selectors_base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(selectors_cfg);
+  UNUSED(selectors_base_addr);
+
   EEBUS_ASSERT_ALWAYS();
   return false;
 }
 
 bool IdentifiersMatch(const EebusDataCfg* cfg, const void* base_addr, const void* src_base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(src_base_addr);
+
   EEBUS_ASSERT_ALWAYS();
   return false;
 }
 
 EebusError ReadElements(const EebusDataCfg* cfg, const void* base_addr, void* dst_base_addr,
     const EebusDataCfg* elements_cfg, const void* elements_base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(dst_base_addr);
+  UNUSED(elements_cfg);
+  UNUSED(elements_base_addr);
+
   EEBUS_ASSERT_ALWAYS();
   return kEebusErrorOther;
 }
@@ -208,18 +256,38 @@ EebusError Write(const EebusDataCfg* cfg, void* base_addr, const void* src_base_
 
 EebusError WritePartial(const EebusDataCfg* cfg, void* base_addr, const void* src_base_addr,
     const EebusDataCfg* selectors_cfg, const void* selectors_base_addr, SelectorsMatcher selectors_matcher) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(src_base_addr);
+  UNUSED(selectors_cfg);
+  UNUSED(selectors_base_addr);
+  UNUSED(selectors_matcher);
+
   EEBUS_ASSERT_ALWAYS();
   return kEebusErrorOther;
 }
 
 void DeleteElements(
     const EebusDataCfg* cfg, void* base_addr, const EebusDataCfg* elements_cfg, const void* elements_base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(elements_cfg);
+  UNUSED(elements_base_addr);
+
   EEBUS_ASSERT_ALWAYS();
 }
 
 void DeletePartial(const EebusDataCfg* cfg, void* base_addr, const EebusDataCfg* selectors_cfg,
     const void* selectors_base_addr, SelectorsMatcher selectors_matcher, const EebusDataCfg* elements_cfg,
     const void* elements_base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(selectors_cfg);
+  UNUSED(selectors_base_addr);
+  UNUSED(selectors_matcher);
+  UNUSED(elements_cfg);
+  UNUSED(elements_base_addr);
+
   EEBUS_ASSERT_ALWAYS();
 }
 
diff --git a/src/common/eebus_data/eebus_data_container.c b/src/common/eebus_data/eebus_data_container.c
index b6c533c..a56c254 100644
--- a/src/common/eebus_data/eebus_data_container.c
+++ b/src/common/eebus_data/eebus_data_container.c
@@ -19,6 +19,7 @@
  */
 
 #include "src/common/api/eebus_data_interface.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_assert.h"
 #include "src/common/eebus_data/eebus_data_base.h"
 #include "src/common/eebus_data/eebus_data_list.h"
@@ -90,6 +91,10 @@ CopyMatching(const EebusDataCfg* cfg, const void* base_addr, void* dst_base_addr
 
 bool SelectorsMatch(const EebusDataCfg* cfg, const void* base_addr, const EebusDataCfg* selectors_cfg,
     const void* selectors_base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(selectors_cfg);
+  UNUSED(selectors_base_addr);
   EEBUS_ASSERT_ALWAYS();
   return false;
 }
diff --git a/src/common/eebus_data/eebus_data_enum.h b/src/common/eebus_data/eebus_data_enum.h
index 524a4e8..383bac6 100644
--- a/src/common/eebus_data/eebus_data_enum.h
+++ b/src/common/eebus_data/eebus_data_enum.h
@@ -21,6 +21,7 @@
 #ifndef SRC_COMMON_EEBUS_DATA_EEBUS_DATA_ENUM_H_
 #define SRC_COMMON_EEBUS_DATA_EEBUS_DATA_ENUM_H_
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include "src/common/api/eebus_data_interface.h"
@@ -50,6 +51,12 @@ struct EnumMapping {
   int32_t value;
 };
 
+#define EEBUS_ENUM_MAPPING_END \
+  {                            \
+      .name  = NULL,           \
+      .value = 0,              \
+  }
+
 extern const EebusDataInterface eebus_data_enum_methods;
 
 /**
diff --git a/src/common/eebus_data/eebus_data_list.c b/src/common/eebus_data/eebus_data_list.c
index 06ebc21..164008c 100644
--- a/src/common/eebus_data/eebus_data_list.c
+++ b/src/common/eebus_data/eebus_data_list.c
@@ -136,6 +136,9 @@ const EebusDataInterface eebus_data_list_simple_methods = {
 };
 
 void* CreateEmpty(const EebusDataCfg* cfg, void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+
   EEBUS_ASSERT_ALWAYS();
   return NULL;
 }
@@ -312,10 +315,15 @@ bool IsNull(const EebusDataCfg* cfg, const void* base_addr) {
 }
 
 bool IsEmpty(const EebusDataCfg* cfg, const void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+
   return false;
 }
 
 bool HasIdentifiers(const EebusDataCfg* cfg, const void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
   // Return false is required to handle differnet nested lists partial write separately
   return false;
 }
@@ -395,6 +403,8 @@ EebusError CopyToSelectedData(
     const void* selectors_base_addr,
     SelectorsMatcher selectors_matcher
 ) {
+  UNUSED(selectors_matcher);
+
   if (EEBUS_DATA_IS_NULL(cfg, src_base_addr)) {
     return kEebusErrorOk;
   }
@@ -545,6 +555,8 @@ void DeleteListItems(
     const void* selectors_base_addr,
     SelectorsMatcher selectors_matcher
 ) {
+  UNUSED(selectors_matcher);
+
   void*** const ar      = (void***)((uint8_t*)base_addr + cfg->offset);
   size_t* const ar_size = (size_t*)((uint8_t*)base_addr + cfg->size_offset);
 
@@ -595,6 +607,8 @@ void DeleteListItemsElements(
     const EebusDataCfg* elements_cfg,
     const void* elements_base_addr
 ) {
+  UNUSED(selectors_matcher);
+
   void*** const ar      = (void***)((uint8_t*)base_addr + cfg->offset);
   size_t* const ar_size = (size_t*)((uint8_t*)base_addr + cfg->size_offset);
 
diff --git a/src/common/eebus_data/eebus_data_numeric.c b/src/common/eebus_data/eebus_data_numeric.c
index b0e938b..4c274d1 100644
--- a/src/common/eebus_data/eebus_data_numeric.c
+++ b/src/common/eebus_data/eebus_data_numeric.c
@@ -49,7 +49,7 @@
   const JsonNumConvInterface name = {                                                  \
       .json_to_num = JsonToNum##type,                                                  \
       .num_to_json = NumToJson##type,                                                  \
-  };
+  }
 
 JSON_NUM_CONV_DECL(json_num_conv_uint8, uint8_t);
 JSON_NUM_CONV_DECL(json_num_conv_uint16, uint16_t);
diff --git a/src/common/eebus_data/eebus_data_sequence.c b/src/common/eebus_data/eebus_data_sequence.c
index 9d507fd..ff6c0d2 100644
--- a/src/common/eebus_data/eebus_data_sequence.c
+++ b/src/common/eebus_data/eebus_data_sequence.c
@@ -24,6 +24,7 @@
 #include <string.h>
 
 #include "src/common/api/eebus_data_interface.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_data/eebus_data_base.h"
 #include "src/common/eebus_data/eebus_data_util.h"
 #include "src/common/eebus_malloc.h"
@@ -362,6 +363,10 @@ EebusError EebusDataSequenceWritePartial(
     const void* selectors_base_addr,
     SelectorsMatcher selectors_matcher
 ) {
+  UNUSED(selectors_cfg);
+  UNUSED(selectors_base_addr);
+  UNUSED(selectors_matcher);
+
   const void** const src_buf = (const void**)((const uint8_t*)src_base_addr + cfg->offset);
   if (*src_buf == NULL) {
     // Nothing to be copied — ok
diff --git a/src/common/eebus_data/eebus_data_simple.c b/src/common/eebus_data/eebus_data_simple.c
index a618aee..7858818 100644
--- a/src/common/eebus_data/eebus_data_simple.c
+++ b/src/common/eebus_data/eebus_data_simple.c
@@ -22,6 +22,7 @@
 #include <string.h>
 
 #include "src/common/api/eebus_data_interface.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_assert.h"
 #include "src/common/eebus_errors.h"
 #include "src/common/eebus_malloc.h"
@@ -49,6 +50,8 @@ bool EebusDataSimpleIsNull(const EebusDataCfg* cfg, const void* base_addr) {
 }
 
 bool EebusDataSimpleIsEmpty(const EebusDataCfg* cfg, const void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
   // There is no specific value for simple data to be trated as "empty"
   return false;
 }
diff --git a/src/common/eebus_data/eebus_data_string.c b/src/common/eebus_data/eebus_data_string.c
index efbc59f..12e1b51 100644
--- a/src/common/eebus_data/eebus_data_string.c
+++ b/src/common/eebus_data/eebus_data_string.c
@@ -21,6 +21,7 @@
 #include <stdbool.h>
 
 #include "src/common/api/eebus_data_interface.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_assert.h"
 #include "src/common/eebus_data/eebus_data_simple.h"
 #include "src/common/eebus_errors.h"
@@ -60,6 +61,9 @@ const EebusDataInterface eebus_data_string_methods = {
 };
 
 void* CreateEmpty(const EebusDataCfg* cfg, void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+
   EEBUS_ASSERT_ALWAYS();
   return NULL;
 }
diff --git a/src/common/eebus_data/eebus_data_stub.c b/src/common/eebus_data/eebus_data_stub.c
index 26d079c..e7ccda7 100644
--- a/src/common/eebus_data/eebus_data_stub.c
+++ b/src/common/eebus_data/eebus_data_stub.c
@@ -22,6 +22,7 @@
 #include <string.h>
 
 #include "src/common/api/eebus_data_interface.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_assert.h"
 #include "src/common/eebus_data/eebus_data_base.h"
 #include "src/common/eebus_malloc.h"
@@ -78,69 +79,179 @@ const EebusDataInterface eebus_data_stub_methods = {
     .delete_               = Delete,
 };
 
-void* CreateEmpty(const EebusDataCfg* cfg, void* base_addr) { return NULL; }
+void* CreateEmpty(const EebusDataCfg* cfg, void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
 
-void* Parse(const EebusDataCfg* cfg, const char* s) { return NULL; }
+  return NULL;
+}
+
+void* Parse(const EebusDataCfg* cfg, const char* s) {
+  UNUSED(cfg);
+  UNUSED(s);
+
+  return NULL;
+}
 
-char* PrintUnformatted(const EebusDataCfg* cfg, const void* base_addr) { return NULL; }
+char* PrintUnformatted(const EebusDataCfg* cfg, const void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+
+  return NULL;
+}
 
 EebusError FromJsonObjectItem(const EebusDataCfg* cfg, void* base_addr, const JsonObject* json_obj) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(json_obj);
+
   return kEebusErrorOk;
 }
 
 EebusError FromJsonObject(const EebusDataCfg* cfg, void* base_addr, const JsonObject* json_obj, bool is_root) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(json_obj);
+  UNUSED(is_root);
+
   return kEebusErrorOk;
 }
 
 EebusError ToJsonObjectItem(const EebusDataCfg* cfg, const void* base_addr, JsonObject** json_obj) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+
   *json_obj = NULL;
   return kEebusErrorOk;
 }
 
 EebusError ToJsonObject(const EebusDataCfg* cfg, const void* base_addr, JsonObject* json_obj, bool is_root) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(json_obj);
+  UNUSED(is_root);
+
   return kEebusErrorOk;
 }
 
 bool Compare(const EebusDataCfg* a_cfg, const void* a_base_addr, const EebusDataCfg* b_cfg, const void* b_base_addr) {
+  UNUSED(a_cfg);
+  UNUSED(a_base_addr);
+  UNUSED(b_cfg);
+  UNUSED(b_base_addr);
+
+  return true;
+}
+
+bool IsNull(const EebusDataCfg* cfg, const void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+
   return true;
 }
 
-bool IsNull(const EebusDataCfg* cfg, const void* base_addr) { return true; }
+bool IsEmpty(const EebusDataCfg* cfg, const void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
 
-bool IsEmpty(const EebusDataCfg* cfg, const void* base_addr) { return false; }
+  return false;
+}
 
 bool HasIdentifiers(const EebusDataCfg* cfg, const void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+
   return false;
 }
 
 bool SelectorsMatch(const EebusDataCfg* cfg, const void* base_addr, const EebusDataCfg* selectors_cfg,
     const void* selectors_base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(selectors_cfg);
+  UNUSED(selectors_base_addr);
+
   return false;
 }
 
 bool IdentifiersMatch(const EebusDataCfg* cfg, const void* base_addr, const void* src_base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(src_base_addr);
+
   return false;
 }
 
 EebusError ReadElements(const EebusDataCfg* cfg, const void* base_addr, void* dst_base_addr,
     const EebusDataCfg* elements_cfg, const void* elements_base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(dst_base_addr);
+  UNUSED(elements_cfg);
+  UNUSED(elements_base_addr);
+
+  return kEebusErrorOk;
+}
+
+EebusError Write(const EebusDataCfg* cfg, void* base_addr, const void* src_base) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(src_base);
+
   return kEebusErrorOk;
 }
 
-EebusError Write(const EebusDataCfg* cfg, void* base_addr, const void* src_base) { return kEebusErrorOk; }
+EebusError WriteElements(const EebusDataCfg* cfg, void* base_addr, const void* src_base) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(src_base);
 
-EebusError WriteElements(const EebusDataCfg* cfg, void* base_addr, const void* src_base) { return kEebusErrorOk; }
+  return kEebusErrorOk;
+}
 
 EebusError WritePartial(const EebusDataCfg* cfg, void* base_addr, const void* src_base_addr,
     const EebusDataCfg* selectors_cfg, const void* selectors_base_addr, SelectorsMatcher selectors_matcher) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(src_base_addr);
+  UNUSED(selectors_cfg);
+  UNUSED(selectors_base_addr);
+  UNUSED(selectors_matcher);
+
   return kEebusErrorOk;
 }
 
 void DeleteElements(
-    const EebusDataCfg* cfg, void* base_addr, const EebusDataCfg* elements_cfg, const void* elements_base_addr) {}
+    const EebusDataCfg* cfg,
+    void* base_addr,
+    const EebusDataCfg* elements_cfg,
+    const void* elements_base_addr
+) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(elements_cfg);
+  UNUSED(elements_base_addr);
+}
 
-void DeletePartial(const EebusDataCfg* cfg, void* base_addr, const EebusDataCfg* selectors_cfg,
-    const void* selectors_base_addr, SelectorsMatcher selectors_matcher, const EebusDataCfg* elements_cfg,
-    const void* elements_base_addr) {}
+void DeletePartial(
+    const EebusDataCfg* cfg,
+    void* base_addr,
+    const EebusDataCfg* selectors_cfg,
+    const void* selectors_base_addr,
+    SelectorsMatcher selectors_matcher,
+    const EebusDataCfg* elements_cfg,
+    const void* elements_base_addr
+) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+  UNUSED(selectors_cfg);
+  UNUSED(selectors_base_addr);
+  UNUSED(selectors_matcher);
+  UNUSED(elements_cfg);
+  UNUSED(elements_base_addr);
+}
 
-void Delete(const EebusDataCfg* cfg, void* base_addr) {}
+void Delete(const EebusDataCfg* cfg, void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+}
diff --git a/src/common/eebus_data/eebus_data_tag.c b/src/common/eebus_data/eebus_data_tag.c
index bcb9480..f5752e2 100644
--- a/src/common/eebus_data/eebus_data_tag.c
+++ b/src/common/eebus_data/eebus_data_tag.c
@@ -23,6 +23,7 @@
 #include <stdbool.h>
 
 #include "src/common/api/eebus_data_interface.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_assert.h"
 #include "src/common/eebus_data/eebus_data_base.h"
 #include "src/common/eebus_errors.h"
@@ -112,7 +113,12 @@ bool IsNull(const EebusDataCfg* cfg, const void* base_addr) {
   return *buf == EEBUS_TAG_RESET;
 }
 
-bool IsEmpty(const EebusDataCfg* cfg, const void* base_addr) { return false; }
+bool IsEmpty(const EebusDataCfg* cfg, const void* base_addr) {
+  UNUSED(cfg);
+  UNUSED(base_addr);
+
+  return false;
+}
 
 EebusError ReadElements(const EebusDataCfg* cfg, const void* base_addr, void* dst_base_addr,
     const EebusDataCfg* elements_cfg, const void* elements_base_addr) {
diff --git a/src/common/eebus_date_time/eebus_date.c b/src/common/eebus_date_time/eebus_date.c
index e40a5ea..3e4e305 100644
--- a/src/common/eebus_date_time/eebus_date.c
+++ b/src/common/eebus_date_time/eebus_date.c
@@ -18,6 +18,7 @@
  * @brief EEBUS Date utility implementation
  */
 
+#include <inttypes.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -118,7 +119,7 @@ char* EebusDateToString(const EebusDate* self) {
   }
 
   // Format the date into the string
-  snprintf(buffer, buffer_size, "%04d-%02d-%02d", (int)self->year, (int)self->month, (int)self->day);
+  snprintf(buffer, buffer_size, "%04" PRId32 "-%02" PRId32 "-%02" PRId32, self->year, self->month, self->day);
 
   return buffer;
 }
diff --git a/src/common/json_impl_cjson.c b/src/common/json_impl_cjson.c
index af440a4..e75845b 100644
--- a/src/common/json_impl_cjson.c
+++ b/src/common/json_impl_cjson.c
@@ -33,7 +33,7 @@ const JsonObject* JsonGetItem(const JsonObject* json_obj, const char* name, bool
     return (const JsonObject*)cJSON_GetObjectItem((const cJSON*)json_obj, name);
   } else {
     // Search for named item within sequence
-    for (size_t j = 0; j < cJSON_GetArraySize((const cJSON*)json_obj); ++j) {
+    for (size_t j = 0; j < (size_t)cJSON_GetArraySize((const cJSON*)json_obj); ++j) {
       const cJSON* const json_el   = cJSON_GetArrayItem((const cJSON*)json_obj, (int)j);
       const cJSON* const json_item = cJSON_GetObjectItem(json_el, name);
       if (json_item != NULL) {
@@ -47,7 +47,7 @@ const JsonObject* JsonGetItem(const JsonObject* json_obj, const char* name, bool
 
 JsonObject* JsonAddObjectToArray(JsonObject* json_ar) {
   if (json_ar == NULL) {
-    return false;
+    return NULL;
   }
 
   JsonObject* const json_obj = JsonCreateObject();
@@ -61,7 +61,7 @@ JsonObject* JsonAddObjectToArray(JsonObject* json_ar) {
 
 JsonObject* JsonAddStringToArray(JsonObject* json_ar, const char* s) {
   if ((json_ar == NULL) || (s == NULL)) {
-    return false;
+    return NULL;
   }
 
   JsonObject* const json_str = JsonCreateString(s);
@@ -75,7 +75,7 @@ JsonObject* JsonAddStringToArray(JsonObject* json_ar, const char* s) {
 
 JsonObject* JsonAddNumberToArray(JsonObject* json_obj, double num) {
   if (json_obj == NULL) {
-    return false;
+    return NULL;
   }
 
   JsonObject* const json_num = JsonCreateNumber(num);
diff --git a/src/common/string_lut.c b/src/common/string_lut.c
index 3b82a04..a392429 100644
--- a/src/common/string_lut.c
+++ b/src/common/string_lut.c
@@ -35,12 +35,16 @@ static void StringLutRecordRelease(StringLutRecord* record);
 static void StringLutRecordDelete(StringLutRecord* record);
 
 EebusError StringLutRecordInit(StringLutRecord* record, const char* key, void* value, StringLutValueDeleter deleter) {
-  if ((record == NULL) || (key == NULL) || (value == NULL)) {
+  if (record == NULL) {
     return kEebusErrorInputArgumentNull;
   }
 
   memset(record, 0, sizeof(*record));
 
+  if ((key == NULL) || (value == NULL)) {
+    return kEebusErrorInputArgumentNull;
+  }
+
   record->key = StringCopy(key);
   if (record->key == NULL) {
     return kEebusErrorMemoryAllocate;
diff --git a/src/common/uint64_lut.c b/src/common/uint64_lut.c
index e89d07d..4bc47ad 100644
--- a/src/common/uint64_lut.c
+++ b/src/common/uint64_lut.c
@@ -36,12 +36,16 @@ static void Uint64LutRecordRelease(Uint64LutRecord* record);
 static void Uint64LutRecordDelete(Uint64LutRecord* record);
 
 EebusError Uint64LutRecordInit(Uint64LutRecord* record, uint64_t key, void* value, Uint64LutValueDeleter deleter) {
-  if ((record == NULL) || (value == NULL)) {
+  if (record == NULL) {
     return kEebusErrorInputArgumentNull;
   }
 
   memset(record, 0, sizeof(*record));
 
+  if (value == NULL) {
+    return kEebusErrorInputArgumentNull;
+  }
+
   record->key     = key;
   record->value   = value;
   record->deleter = deleter;
diff --git a/src/service/service/eebus_service.c b/src/service/service/eebus_service.c
index 784951f..78fec6b 100644
--- a/src/service/service/eebus_service.c
+++ b/src/service/service/eebus_service.c
@@ -20,6 +20,7 @@
 
 #include <string.h>
 
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_malloc.h"
 #include "src/service/api/service_reader_interface.h"
 #include "src/service/service/eebus_service.h"
@@ -246,6 +247,8 @@ void OnHandleShipStateUpdate(ShipNodeReaderObject* self, const char* ski, SmeSta
 }
 
 bool IsWaitingForTrustAllowed(ShipNodeReaderObject* self, const char* ski) {
+  UNUSED(ski);
+
   return EEBUS_SERVICE(self)->is_pairing_possible;
 }
 
@@ -270,11 +273,15 @@ DeviceLocalObject* GetLocalDevice(const EebusServiceObject* self) {
 }
 
 const ConnectionState* GetConnectionStateWithSki(const EebusServiceObject* self, const char* ski) {
+  UNUSED(self);
+  UNUSED(ski);
   // TODO: Implement method
   return NULL;
 }
 
 const ServiceDetails* GetRemoteServiceDetailsWithSki(const EebusServiceObject* self, const char* ski) {
+  UNUSED(self);
+  UNUSED(ski);
   // TODO: Implement method
   return NULL;
 }
diff --git a/src/ship/mdns/ship_mdns_bonjour.c b/src/ship/mdns/ship_mdns_bonjour.c
index 3f8d11f..492c710 100644
--- a/src/ship/mdns/ship_mdns_bonjour.c
+++ b/src/ship/mdns/ship_mdns_bonjour.c
@@ -481,6 +481,7 @@ static void MdnsResolveServiceCallback(
 ) {
   UNUSED(service_ref);
   UNUSED(iface);
+  UNUSED(name);
 
   ActiveResolveEntry* const resolve = (ActiveResolveEntry*)ctx;
   if ((resolve == NULL) || (resolve->owner == NULL)) {
@@ -780,6 +781,13 @@ static void MdnsRegisterServiceCallback(
     const char* domain,
     void* ctx
 ) {
+  UNUSED(ref);
+  UNUSED(flags);
+  UNUSED(name);
+  UNUSED(type);
+  UNUSED(domain);
+  UNUSED(ctx);
+
   if (error == kDNSServiceErr_NoError) {
     MDNS_DEBUG_PRINTF("Service registered: %s.%s.%s\n", name, type, domain);
   } else {
diff --git a/src/ship/ship_connection/ship_connection.c b/src/ship/ship_connection/ship_connection.c
index 2fe4b3e..97a3aad 100644
--- a/src/ship/ship_connection/ship_connection.c
+++ b/src/ship/ship_connection/ship_connection.c
@@ -21,6 +21,7 @@
 
 #include "src/common/array_util.h"
 #include "src/common/debug.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_errors.h"
 #include "src/common/eebus_malloc.h"
 #include "src/common/eebus_queue/eebus_queue.h"
@@ -344,6 +345,7 @@ void WriteMessage(DataWriterObject* self, const uint8_t* msg, size_t msg_size) {
 }
 
 void ReportConnectionError(ShipConnection* self, EebusError err) {
+  UNUSED(err);
   // if the handshake is aborted, a closed connection is no error
   const SmeState state = self->sme_state;
 
@@ -823,7 +825,10 @@ EebusError SmePinStateCommonPinRequirementSendProcedure(
   return ret;
 }
 
-void SmePinStateCommonConnectionDataExchangeEnableProcedure(ShipConnection* self, PinStateType node_pin_state) {}
+void SmePinStateCommonConnectionDataExchangeEnableProcedure(ShipConnection* self, PinStateType node_pin_state) {
+  UNUSED(self);
+  UNUSED(node_pin_state);
+}
 
 void SmePinStateHandlePermissionType(ShipConnection* self, const PinInputPermissionType* node_pin_requirement) {
   if (node_pin_requirement == NULL) {
diff --git a/src/ship/ship_connection/ship_connection_debug.c b/src/ship/ship_connection/ship_connection_debug.c
index a1f642c..697ead5 100644
--- a/src/ship/ship_connection/ship_connection_debug.c
+++ b/src/ship/ship_connection/ship_connection_debug.c
@@ -87,6 +87,12 @@ const char* SmeStateToString(SmeState state) {
 
 #else
 
-const char* SmeStateToString(SmeState state) { return ""; }
+#include "src/common/eebus_arguments.h"
+
+const char* SmeStateToString(SmeState state) {
+  UNUSED(state);
+
+  return "";
+}
 
 #endif  // #if SHIP_CONNECTION_DEBUG
diff --git a/src/ship/ship_connection/ship_message_serialize.c b/src/ship/ship_connection/ship_message_serialize.c
index 6126804..341b42a 100644
--- a/src/ship/ship_connection/ship_message_serialize.c
+++ b/src/ship/ship_connection/ship_message_serialize.c
@@ -28,6 +28,7 @@
 #include <string.h>
 
 #include "src/common/array_util.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_errors.h"
 #include "src/common/eebus_malloc.h"
 #include "src/common/json.h"
@@ -458,6 +459,7 @@ EebusError DataSerialize(const Data* data, cJSON* data_obj) {
 
 EebusError SmeConnectionAccessMethodsRequestSerialize(
     const AccessMethodsRequest* sme_access_metods_req, cJSON* access_metods_req_obj) {
+  UNUSED(sme_access_metods_req);
   cJSON* const access_methods_req_ar = cJSON_AddArrayToObject(access_metods_req_obj, "accessMethodsRequest");
 
   return (access_methods_req_ar != NULL) ? kEebusErrorOk : kEebusErrorMemory;
diff --git a/src/ship/ship_node/ship_node.c b/src/ship/ship_node/ship_node.c
index 777fd69..61d0916 100644
--- a/src/ship/ship_node/ship_node.c
+++ b/src/ship/ship_node/ship_node.c
@@ -20,6 +20,7 @@
 #include <string.h>
 
 #include "ship_node_internal.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_device_info.h"
 #include "src/common/eebus_mutex/eebus_mutex.h"
 #include "src/common/eebus_queue/eebus_queue.h"
@@ -284,11 +285,15 @@ void ShipNodeOnMdnsEntriesFoundCallback(Vector* found_entries, void* ctx) {
 }
 
 bool IsRemoteServiceForSkiPaired(InfoProviderObject* self, const char* ski) {
+  UNUSED(self);
+  UNUSED(ski);
   // TODO: Implement method
   return false;
 }
 
 void CloseShipConnection(ShipNode* self, ShipConnectionObject* sc, bool had_error) {
+  UNUSED(had_error);
+
   if ((sc == NULL) || (sc != self->ship_connection)) {
     SHIP_NODE_DEBUG_PRINTF("%s(), invalid Ship Connection instance\n", __func__);
     return;
@@ -317,15 +322,21 @@ void HandleConnectionClosed(InfoProviderObject* self, ShipConnectionObject* sc,
 }
 
 void ReportServiceShipId(InfoProviderObject* self, const char* service_id, const char* ship_id) {
+  UNUSED(self);
+  UNUSED(service_id);
+  UNUSED(ship_id);
   // TODO: Implement method
 }
 
 bool IsWaitingForTrustAllowed(InfoProviderObject* self, const char* ski) {
+  UNUSED(self);
+  UNUSED(ski);
   // TODO: Implement method
   return false;
 }
 
 void HandleShipStateUpdate(InfoProviderObject* self, const char* ski, SmeState state, const char* err) {
+  UNUSED(err);
   const ShipNode* const sn = SHIP_NODE(self);
 
   SHIP_NODE_READER_ON_SHIP_STATE_UPDATE(sn->ship_node_reader, ski, state);
@@ -535,6 +546,7 @@ void Stop(ShipNodeObject* self) {
 }
 
 void ShipNodeRegisterSki(ShipNodeObject* self, const char* ski, bool is_trusted) {
+  UNUSED(is_trusted);
   ShipNode* const sn = SHIP_NODE(self);
 
   EEBUS_MUTEX_LOCK(sn->mutex);
@@ -544,6 +556,7 @@ void ShipNodeRegisterSki(ShipNodeObject* self, const char* ski, bool is_trusted)
 }
 
 void RegisterRemoteSki(ShipNodeObject* self, const char* ski, bool is_trusted) {
+  UNUSED(is_trusted);
   ShipNode* const sn = SHIP_NODE(self);
 
   ShipNodeQueueMessage queue_msg = {
@@ -557,6 +570,7 @@ void RegisterRemoteSki(ShipNodeObject* self, const char* ski, bool is_trusted) {
 }
 
 void ShipNodeUnregisterSki(ShipNodeObject* self, const char* ski) {
+  UNUSED(ski);
   ShipNode* const sn = SHIP_NODE(self);
 
   EEBUS_MUTEX_LOCK(sn->mutex);
@@ -590,5 +604,7 @@ void UnregisterRemoteSki(ShipNodeObject* self, const char* ski) {
 }
 
 void CancelPairingWithSki(ShipNodeObject* self, const char* ski) {
+  UNUSED(self);
+  UNUSED(ski);
   // TODO: Implement method
 }
diff --git a/src/ship/tls_certificate/tls_certificate.c b/src/ship/tls_certificate/tls_certificate.c
index d8ebcc8..529f54a 100644
--- a/src/ship/tls_certificate/tls_certificate.c
+++ b/src/ship/tls_certificate/tls_certificate.c
@@ -25,6 +25,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_errors.h"
 #include "src/common/eebus_malloc.h"
 #include "src/common/string_util.h"
@@ -247,6 +248,11 @@ TlsCertificateObject* TlsCertificateLoadX509KeyPair(const char* cert_file, const
 
 TlsCertificateObject*
 TlsCertificateParseX509KeyPair(const char* cert_buf, size_t cert_buf_size, const char* key_buf, size_t key_buf_size) {
+  UNUSED(cert_buf);
+  UNUSED(cert_buf_size);
+  UNUSED(key_buf);
+  UNUSED(key_buf_size);
+
   return NULL;  // Not implemented
 }
 
diff --git a/src/ship/websocket/http_server.c b/src/ship/websocket/http_server.c
index afc4dc6..b0d6fa8 100644
--- a/src/ship/websocket/http_server.c
+++ b/src/ship/websocket/http_server.c
@@ -24,6 +24,7 @@
 #include <libwebsockets.h>
 
 #include "src/common/debug.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_malloc.h"
 #include "src/common/eebus_mutex/eebus_mutex.h"
 #include "src/common/eebus_thread/eebus_thread.h"
@@ -135,8 +136,8 @@ void HttpServerConstruct(
   self->conn_establish_cb  = conn_establish_cb;
   self->conn_establish_ctx = conn_establish_ctx;
 
-  self->port = port;
-  self->ws   = NULL;
+  self->port         = port;
+  self->ws           = NULL;
   self->ws_is_active = false;
 
   self->lws_ctx = NULL;
@@ -327,6 +328,8 @@ int HttpServerOnClientConnect(HttpServer* self, struct lws* wsi) {
 }
 
 int HttpServerOnReceive(HttpServer* self, struct lws* wsi, void* in, size_t len) {
+  UNUSED(self);
+
   WebsocketObject* ws = (WebsocketObject*)lws_wsi_user(wsi);
   if (ws == NULL) {
     HTTP_SERVER_DEBUG_PRINTF("%s(), websocket object is NULL\n", __func__);
@@ -342,6 +345,7 @@ int HttpServerOnReceive(HttpServer* self, struct lws* wsi, void* in, size_t len)
 }
 
 int HttpServerOnWriteable(HttpServer* self, struct lws* wsi) {
+  UNUSED(self);
   WebsocketObject* ws = (WebsocketObject*)lws_wsi_user(wsi);
   if (ws == NULL) {
     HTTP_SERVER_DEBUG_PRINTF("%s(), websocket object is NULL\n", __func__);
@@ -371,6 +375,8 @@ int HttpServerOnConnectionClose(HttpServer* self, struct lws* wsi) {
 }
 
 int HttpServerServiceCallback(struct lws* wsi, enum lws_callback_reasons reason, void* user, void* in, size_t len) {
+  UNUSED(user);
+
   HTTP_SERVER_DEBUG_PRINTF("%s(), reason = %s\n", __func__, WebsocketLwsReasonToString(reason));
   HttpServer* const srv = lws_context_user(lws_get_context(wsi));
   int ret               = 0;
diff --git a/src/ship/websocket/websocket.c b/src/ship/websocket/websocket.c
index ea47389..611eb22 100644
--- a/src/ship/websocket/websocket.c
+++ b/src/ship/websocket/websocket.c
@@ -29,6 +29,7 @@
 #include <libwebsockets.h>
 
 #include "src/common/debug.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_errors.h"
 #include "src/common/eebus_malloc.h"
 #include "src/common/eebus_queue/eebus_queue.h"
@@ -158,6 +159,7 @@ int32_t WebsocketWrite(WebsocketObject* self, const uint8_t* msg, size_t msg_siz
 }
 
 void WebsocketClose(WebsocketObject* self, int32_t close_code, const char* reason) {
+  UNUSED(reason);
   Websocket* const ws = WEBSOCKET(self);
 
   EEBUS_MUTEX_LOCK(ws->wr_mutex);
@@ -214,7 +216,7 @@ int WebsocketOnWritable(WebsocketObject* self) {
   const int n = lws_write(ws->wsi, &wr_msg.data[LWS_PRE], sz, LWS_WRITE_BINARY);
 
   EEBUS_FREE(wr_msg.data);
-  if (n < sz) {
+  if ((n < 0) || ((size_t)n != sz)) {
     WEBSOCKET_DEBUG_PRINTF("sending message failed: %d < %d\n", n, sz);
     return -1;
   }
diff --git a/src/ship/websocket/websocket_client.c b/src/ship/websocket/websocket_client.c
index 2834166..41f5622 100644
--- a/src/ship/websocket/websocket_client.c
+++ b/src/ship/websocket/websocket_client.c
@@ -18,6 +18,8 @@
  * @brief Websocket Uri implementation
  */
 
+#include "src/common/eebus_arguments.h"
+#include "src/common/eebus_malloc.h"
 #include "src/common/eebus_thread/eebus_thread.h"
 #include "src/common/string_util.h"
 #include "src/ship/websocket/websocket.h"
@@ -67,7 +69,7 @@ static EebusError WebsocketClientConstruct(
 static void* WebsocketClientLoop(void* parameters);
 static struct lws_client_connect_info* WebsocketClientConnectInfoCreate(WebsocketClient* self);
 static struct lws_context* WebsocketClientLwsContextCreate(WebsocketClient* self);
-static EebusError WebsocketClientParse(WebsocketClient* self, char* uri);
+static EebusError WebsocketClientParse(WebsocketClient* self);
 static EebusError WebsocketClientTryStart(WebsocketClient* self);
 static int WebsocketClientOnClientEstablished(WebsocketClient* self);
 static int WebsocketClientOnClientConnectionError(WebsocketClient* self, const char* in, size_t len);
@@ -198,7 +200,7 @@ struct lws_context* WebsocketClientLwsContextCreate(WebsocketClient* self) {
   return lws_create_context(&lws_ctx_creation_info);
 }
 
-EebusError WebsocketClientParse(WebsocketClient* self, char* uri) {
+EebusError WebsocketClientParse(WebsocketClient* self) {
   const char* path     = NULL;
   const char* protocol = NULL;
 
@@ -225,7 +227,7 @@ EebusError WebsocketClientParse(WebsocketClient* self, char* uri) {
 EebusError WebsocketClientTryStart(WebsocketClient* self) {
   Websocket* const ws = WEBSOCKET(self);
 
-  if (WebsocketClientParse(self, self->uri) != kEebusErrorOk) {
+  if (WebsocketClientParse(self) != kEebusErrorOk) {
     WEBSOCKET_DEBUG_PRINTF("%s(), error parsing uri\n", __func__);
     return kEebusErrorParse;
   }
@@ -363,6 +365,7 @@ int WebsocketClientServiceCallback(
     void* in,
     size_t len
 ) {
+  UNUSED(user);
   WebsocketClient* const ws = lws_context_user(lws_get_context(wsi));
 
   WEBSOCKET_DEBUG_PRINTF("%s(), reason = %s\n", __func__, WebsocketLwsReasonToString(reason));
diff --git a/src/ship/websocket/websocket_server_creator.c b/src/ship/websocket/websocket_server_creator.c
index 5018ab4..0d38218 100644
--- a/src/ship/websocket/websocket_server_creator.c
+++ b/src/ship/websocket/websocket_server_creator.c
@@ -20,6 +20,7 @@
 
 #include <libwebsockets.h>
 
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_malloc.h"
 #include "src/ship/api/http_server_interface.h"
 #include "src/ship/api/websocket_creator_interface.h"
@@ -63,6 +64,7 @@ WebsocketCreatorObject* WebsocketServerCreatorCreate(HttpServerObject* srv, stru
 }
 
 void Destruct(WebsocketCreatorObject* self) {
+  UNUSED(self);
   // WSI release is handled by the WebsocketServer, since it provides the WSI
 }
 
diff --git a/src/spine/device/data_reader.c b/src/spine/device/data_reader.c
index cdfd3c6..9d0401a 100644
--- a/src/spine/device/data_reader.c
+++ b/src/spine/device/data_reader.c
@@ -18,6 +18,7 @@
  * @brief Data Reader implementation
  */
 
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_malloc.h"
 #include "src/common/message_buffer.h"
 #include "src/ship/api/data_reader_interface.h"
@@ -60,6 +61,7 @@ DataReaderObject* DataReaderCreate(DeviceRemoteObject* device_remote) {
 }
 
 void Destruct(DataReaderObject* self) {
+  UNUSED(self);
   // Nothing to be deallocated here
 }
 
diff --git a/src/spine/device/sender.c b/src/spine/device/sender.c
index cb71e84..b91b5e1 100644
--- a/src/spine/device/sender.c
+++ b/src/spine/device/sender.c
@@ -22,6 +22,7 @@
 
 #include "src/common/array_util.h"
 #include "src/common/debug.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_malloc.h"
 #include "src/common/json.h"
 #include "src/ship/api/data_writer_interface.h"
@@ -158,6 +159,7 @@ SenderObject* SenderCreate(DataWriterObject* writer) {
 }
 
 void Destruct(SenderObject* self) {
+  UNUSED(self);
   // Nothing to be deallocated yet
 }
 
diff --git a/src/spine/feature/feature_local.c b/src/spine/feature/feature_local.c
index c9b8e53..8df26c1 100644
--- a/src/spine/feature/feature_local.c
+++ b/src/spine/feature/feature_local.c
@@ -19,6 +19,8 @@
  */
 
 #include <string.h>
+
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_malloc.h"
 #include "src/common/uint64_lut.h"
 #include "src/spine/api/device_local_interface.h"
@@ -521,6 +523,9 @@ EebusError FeatureLocalRequestRemoteDataBySenderAddress(
     const FeatureAddressType* dest_addr,
     uint32_t max_delay
 ) {
+  UNUSED(dest_ski);
+  UNUSED(max_delay);
+
   return SEND_READ(sender, FEATURE_GET_ADDRESS(FEATURE_OBJECT(self)), dest_addr, cmd);
 }
 
diff --git a/src/spine/function/function.c b/src/spine/function/function.c
index b7cbaf0..9f1731c 100644
--- a/src/spine/function/function.c
+++ b/src/spine/function/function.c
@@ -20,6 +20,7 @@
 
 #include <string.h>
 
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_malloc.h"
 #include "src/common/num_ptr.h"
 #include "src/spine/api/function_interface.h"
@@ -220,6 +221,7 @@ CmdType* CreateNotifyCmd(
 }
 
 EebusError AddDataToWriteCmd(const Function* self, CmdType* cmd, const void* data, const FilterType* filter_partial) {
+  UNUSED(filter_partial);
   const EebusDataCfg* const cfg = ModelGetDataCfg(self->type);
 
   cmd->data_choice_type_id = self->type;
@@ -322,6 +324,7 @@ void* DataCopy(const FunctionObject* self) {
 
 EebusError UpdateData(FunctionObject* self, const void* new_data, const FilterType* filter_partial,
     const FilterType* filter_delete, bool wr_remote, bool persist) {
+  UNUSED(wr_remote);
   Function* const function = FUNCTION(self);
 
   const EebusDataCfg* const cfg = ModelGetDataCfg(function->type);
diff --git a/src/spine/model/actuator_level_types.inc b/src/spine/model/actuator_level_types.inc
index b6d4a53..02cd4c5 100644
--- a/src/spine/model/actuator_level_types.inc
+++ b/src/spine/model/actuator_level_types.inc
@@ -21,7 +21,7 @@ static const EnumMapping actuator_level_fct_lut[] = {
     {"percentageRelative", kActuatorLevelFctTypePercentageRelative},
     {"absolut", kActuatorLevelFctTypeAbsolut},
     {"relative", kActuatorLevelFctTypeRelative},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg actuator_level_data_cfg[] = {
diff --git a/src/spine/model/actuator_switch_types.inc b/src/spine/model/actuator_switch_types.inc
index f5f56a4..3ff5d75 100644
--- a/src/spine/model/actuator_switch_types.inc
+++ b/src/spine/model/actuator_switch_types.inc
@@ -16,7 +16,7 @@ static const EnumMapping actuator_switch_fct_lut[] = {
     {"on", kActuatorSwitchFctTypeOn},
     {"off", kActuatorSwitchFctTypeOff},
     {"toggle", kActuatorSwitchFctTypeToggle},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg actuator_switch_data_cfg[] = {
diff --git a/src/spine/model/alarm_types.inc b/src/spine/model/alarm_types.inc
index a89ab22..45bd191 100644
--- a/src/spine/model/alarm_types.inc
+++ b/src/spine/model/alarm_types.inc
@@ -17,7 +17,7 @@ static const EnumMapping alarm_type_lut[] = {
     {"alarmCancelled", kAlarmTypeTypeAlarmCancelled},
     {"underThreshold", kAlarmTypeTypeUnderThreshold},
     {"overThreshold", kAlarmTypeTypeOverThreshold},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg alarm_data_cfg[] = {
diff --git a/src/spine/model/bill_types.inc b/src/spine/model/bill_types.inc
index 6f34ea9..c364567 100644
--- a/src/spine/model/bill_types.inc
+++ b/src/spine/model/bill_types.inc
@@ -14,13 +14,13 @@
 
 static const EnumMapping bill_type_lut[] = {
     {"chargingSummary", kBillTypeTypeChargingSummary},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping bill_position_type_lut[] = {
     {"gridElectricEnergy", kBillPositionTypeTypeGridElectricEnergy},
     {"selfProducedElectricEnergy", kBillPositionTypeTypeSelfProducedElectricEnergy},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping bill_cost_type_lut[] = {
@@ -29,7 +29,7 @@ static const EnumMapping bill_cost_type_lut[] = {
     {"co2Emission", kBillCostTypeTypeCo2Emission},
     {"renewableEnergy", kBillCostTypeTypeRenewableEnergy},
     {"radioactiveWaste", kBillCostTypeTypeRadioactiveWaste},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg bill_value_cfg[] = {
diff --git a/src/spine/model/command_frame_types.inc b/src/spine/model/command_frame_types.inc
index 7cd1c7f..a5e11fc 100644
--- a/src/spine/model/command_frame_types.inc
+++ b/src/spine/model/command_frame_types.inc
@@ -57,7 +57,7 @@ static const EnumMapping command_classifier_lut[] = {
     {"write", kCommandClassifierTypeWrite},
     {"call", kCommandClassifierTypeCall},
     {"result", kCommandClassifierTypeResult},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg cmd_control_cfg[] = {
diff --git a/src/spine/model/common_data_types.inc b/src/spine/model/common_data_types.inc
index 5ac2360..504c221 100644
--- a/src/spine/model/common_data_types.inc
+++ b/src/spine/model/common_data_types.inc
@@ -37,7 +37,7 @@ static const EnumMapping recurring_interval_lut[] = {
     {"hourly", kRecurringIntervalTypeHourly},
     {"everyMinute", kRecurringIntervalTypeEveryminute},
     {"everySecond", kRecurringIntervalTypeEverysecond},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping month_lut[] = {
@@ -53,7 +53,7 @@ static const EnumMapping month_lut[] = {
     {"october", kMonthTypeOctober},
     {"november", kMonthTypeNovember},
     {"december", kMonthTypeDecember},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping day_of_week_lut[] = {
@@ -64,7 +64,7 @@ static const EnumMapping day_of_week_lut[] = {
     {"friday", kDayOfWeekTypeFriday},
     {"saturday", kDayOfWeekTypeSaturday},
     {"sunday", kDayOfWeekTypeSunday},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg days_of_week_cfg[] = {
@@ -84,7 +84,7 @@ static const EnumMapping occurrence_lut[] = {
     {"third", kOccurrenceTypeThird},
     {"fourth", kOccurrenceTypeFourth},
     {"last", kOccurrenceTypeLast},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg absolute_or_recurring_time_cfg[] = {
@@ -183,13 +183,13 @@ static const EnumMapping commodity_type_lut[] = {
     {"heat", kCommodityTypeTypeHeat},
     {"coolingLoad", kCommodityTypeTypeCoolingLoad},
     {"air", kCommodityTypeTypeAir},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping energy_direction_lut[] = {
     {"consume", kEnergyDirectionTypeConsume},
     {"produce", kEnergyDirectionTypeProduce},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping energy_mode_lut[] = {
@@ -197,7 +197,7 @@ static const EnumMapping energy_mode_lut[] = {
     {"produce", kEnergyModeTypeProduce},
     {"idle", kEnergyModeTypeIdle},
     {"auto", kEnergyModeTypeAuto},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping unit_of_measurement_lut[] = {
@@ -295,7 +295,7 @@ static const EnumMapping unit_of_measurement_lut[] = {
     {"Btu/h", kUnitOfMeasurementTypeBtuh},
     {"Ah", kUnitOfMeasurementTypeAh},
     {"kg/Wh", kUnitOfMeasurementTypekgWh},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping currency_lut[] = {
@@ -477,7 +477,7 @@ static const EnumMapping currency_lut[] = {
     {"ZAR", kCurrencyTypeZar},
     {"ZMW", kCurrencyTypeZmw},
     {"ZWL", kCurrencyTypeZwl},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping scope_type_lut[] = {
@@ -567,7 +567,7 @@ static const EnumMapping scope_type_lut[] = {
     {"incentiveTableEnConsWithTF", kScopeTypeTypeIncentiveTableEnConsWithTF},
     {"incentiveTableEnProdWithTF", kScopeTypeTypeIncentiveTableEnProdWithTF},
     {"activePowerForecast", kScopeTypeTypeActivePowerForecast},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 #endif  // SRC_SPINE_MODEL_COMMON_DATA_TYPES_INC_
diff --git a/src/spine/model/datagram.c b/src/spine/model/datagram.c
index c32f7fa..82d0974 100644
--- a/src/spine/model/datagram.c
+++ b/src/spine/model/datagram.c
@@ -20,6 +20,7 @@
 
 #include "src/spine/model/datagram.h"
 
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_data/eebus_data.h"
 #include "src/spine/model/feature_types.h"
 #include "src/spine/model/model.h"
@@ -45,6 +46,7 @@ bool DatagramHeaderIsValid(const HeaderType* header) {
 }
 
 bool DatagramPayloadIsValid(const PayloadType* payload) {
+  UNUSED(payload);
   // TODO: Implement function
   return true;
 }
diff --git a/src/spine/model/datagram.inc b/src/spine/model/datagram.inc
index db4335f..6b4398e 100644
--- a/src/spine/model/datagram.inc
+++ b/src/spine/model/datagram.inc
@@ -17,7 +17,7 @@ static const EnumMapping cmd_classifiers[] = {
     {"write", kCommandClassifierTypeWrite},
     {"call", kCommandClassifierTypeCall},
     {"result", kCommandClassifierTypeResult},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg datagram_header_data_cfg[] = {
diff --git a/src/spine/model/device_classification_types.inc b/src/spine/model/device_classification_types.inc
index 3946fce..89cd6b5 100644
--- a/src/spine/model/device_classification_types.inc
+++ b/src/spine/model/device_classification_types.inc
@@ -18,7 +18,7 @@ static const EnumMapping power_source_lut[] = {
     {"mains3Phase", kPowerSourceTypeMains3Phase},
     {"battery", kPowerSourceTypeBattery},
     {"dc", kPowerSourceTypeDc},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg device_classification_manufacturer_data_cfg[] = {
diff --git a/src/spine/model/device_configuration_types.inc b/src/spine/model/device_configuration_types.inc
index ad68d24..2f68ca6 100644
--- a/src/spine/model/device_configuration_types.inc
+++ b/src/spine/model/device_configuration_types.inc
@@ -16,7 +16,7 @@ static const EnumMapping device_configuration_key_value_string_lut[] = {
     {"iso15118-2ed1", kDeviceConfigurationKeyValueStringTypeISO151182ED1},
     {"iso15118-2ed2", kDeviceConfigurationKeyValueStringTypeISO151182ED2},
     {"iec61851", kDeviceConfigurationKeyValueStringTypeIEC61851},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping device_configuration_key_name_lut[] = {
@@ -58,7 +58,7 @@ static const EnumMapping device_configuration_key_name_lut[] = {
     {"incentivesSimulationConcurrent", kDeviceConfigurationKeyNameTypeIncentivesSimulationConcurrent},
     {"incentivesTimeoutIncentiveRequest", kDeviceConfigurationKeyNameTypeIncentivesTimeoutIncentiveRequest},
     {"incentivesWaitIncentiveWriteable", kDeviceConfigurationKeyNameTypeIncentivesWaitIncentiveWriteable},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping device_configuration_key_value_type_lut[] = {
@@ -70,7 +70,7 @@ static const EnumMapping device_configuration_key_value_type_lut[] = {
     {"time", kDeviceConfigurationKeyValueTypeTypeTime},
     {"scaledNumber", kDeviceConfigurationKeyValueTypeTypeScaledNumber},
     {"integer", kDeviceConfigurationKeyValueTypeTypeInteger},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg device_configuration_key_value_value_cfg[] = {
diff --git a/src/spine/model/device_diagnosis_types.inc b/src/spine/model/device_diagnosis_types.inc
index 78f2689..38c6979 100644
--- a/src/spine/model/device_diagnosis_types.inc
+++ b/src/spine/model/device_diagnosis_types.inc
@@ -23,7 +23,7 @@ static const EnumMapping device_diagnosis_operating_state_lut[] = {
     {"finished", kDeviceDiagnosisOperatingStateTypeFinished},
     {"temporarilyNotReady", kDeviceDiagnosisOperatingStateTypeTemporarilyNotReady},
     {"off", kDeviceDiagnosisOperatingStateTypeOff},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping power_supply_condition_lut[] = {
@@ -32,7 +32,7 @@ static const EnumMapping power_supply_condition_lut[] = {
     {"critical", kPowerSupplyConditionTypeCritical},
     {"unknown", kPowerSupplyConditionTypeUnknown},
     {"error", kPowerSupplyConditionTypeError},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg device_diagnosis_state_data_cfg[] = {
diff --git a/src/spine/model/device_types.inc b/src/spine/model/device_types.inc
index 76d7b80..bfcda0c 100644
--- a/src/spine/model/device_types.inc
+++ b/src/spine/model/device_types.inc
@@ -31,7 +31,7 @@ static const EnumMapping device_type_lut[] = {
     {"EnergyManagementSystem", kDeviceTypeTypeEnergyManagementSystem},
     {"Inverter", kDeviceTypeTypeInverter},
     {"ChargingStation", kDeviceTypeTypeChargingStation},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 #endif  // SRC_SPINE_MODEL_DEVICE_TYPES_INC_
diff --git a/src/spine/model/electrical_connection_types.inc b/src/spine/model/electrical_connection_types.inc
index e83b02c..c8b7027 100644
--- a/src/spine/model/electrical_connection_types.inc
+++ b/src/spine/model/electrical_connection_types.inc
@@ -19,13 +19,13 @@ static const EnumMapping electrical_connection_measurand_variant_lut[] = {
     {"instantaneous", kElectricalConnectionMeasurandVariantTypeInstantaneous},
     {"angle", kElectricalConnectionMeasurandVariantTypeAngle},
     {"cosPhi", kElectricalConnectionMeasurandVariantTypeCosphi},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping electrical_connection_voltage_type_lut[] = {
     {"ac", kElectricalConnectionVoltageTypeTypeAc},
     {"dc", kElectricalConnectionVoltageTypeTypeDc},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping electrical_connection_ac_measurement_type_lut[] = {
@@ -33,7 +33,7 @@ static const EnumMapping electrical_connection_ac_measurement_type_lut[] = {
     {"reactive", kElectricalConnectionAcMeasurementTypeTypeReactive},
     {"apparent", kElectricalConnectionAcMeasurementTypeTypeApparent},
     {"phase", kElectricalConnectionAcMeasurementTypeTypePhase},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping electrical_connection_phase_name_lut[] = {
@@ -47,7 +47,7 @@ static const EnumMapping electrical_connection_phase_name_lut[] = {
     {"neutral", kElectricalConnectionPhaseNameTypeNeutral},
     {"ground", kElectricalConnectionPhaseNameTypeGround},
     {"none", kElectricalConnectionPhaseNameTypeNone},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping electrical_connection_connection_point_lut[] = {
@@ -56,7 +56,7 @@ static const EnumMapping electrical_connection_connection_point_lut[] = {
     {"pv", kElectricalConnectionConnectionPointTypePv},
     {"sd", kElectricalConnectionConnectionPointTypeSd},
     {"other", kElectricalConnectionConnectionPointTypeOther},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping electrical_connection_characteristic_context_lut[] = {
@@ -65,7 +65,7 @@ static const EnumMapping electrical_connection_characteristic_context_lut[] = {
     {"inverter", kElectricalConnectionCharacteristicContextTypeInverter},
     {"pvString", kElectricalConnectionCharacteristicContextTypePvString},
     {"battery", kElectricalConnectionCharacteristicContextTypeBattery},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping electrical_connection_characteristic_type_lut[] = {
@@ -83,7 +83,7 @@ static const EnumMapping electrical_connection_characteristic_type_lut[] = {
     {"apparentPowerProductionNominalMax", kElectricalConnectionCharacteristicTypeTypeApparentPowerProductionNominalMax},
     {"apparentPowerConsumptionNominalMax",
      kElectricalConnectionCharacteristicTypeTypeApparentPowerConsumptionNominalMax},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg electrical_connection_parameter_description_data_cfg[] = {
diff --git a/src/spine/model/entity_types.inc b/src/spine/model/entity_types.inc
index 8387f85..cdf7c71 100644
--- a/src/spine/model/entity_types.inc
+++ b/src/spine/model/entity_types.inc
@@ -67,7 +67,7 @@ static const EnumMapping entity_type_lut[] = {
     {"PVString", kEntityTypeTypePVString},
     {"GridGuard", kEntityTypeTypeGridGuard},
     {"ControllableSystem", kEntityTypeTypeControllableSystem},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 #endif  // SRC_SPINE_MODEL_ENTITY_TYPES_INC_
diff --git a/src/spine/model/feature_types.inc b/src/spine/model/feature_types.inc
index bd574be..4f65805 100644
--- a/src/spine/model/feature_types.inc
+++ b/src/spine/model/feature_types.inc
@@ -33,7 +33,7 @@ static const EnumMapping role_lut[] = {
     {"client", kRoleTypeClient},
     {"server", kRoleTypeServer},
     {"special", kRoleTypeSpecial},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping feature_type_lut[] = {
@@ -69,7 +69,7 @@ static const EnumMapping feature_type_lut[] = {
     {"Bill", kFeatureTypeTypeBill},
     {"Identification", kFeatureTypeTypeIdentification},
     {"StateInformation", kFeatureTypeTypeStateInformation},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping feature_specific_usage_lut[] = {
@@ -87,7 +87,7 @@ static const EnumMapping feature_specific_usage_lut[] = {
     {"FlexibleChosenForecast", FeatureSpecificUsageTypeFlexibleChosenForecast},
     {"FlexibleOptionalForecast", FeatureSpecificUsageTypeFlexibleOptionalForecast},
     {"OptionalSequenceBasedImmediateControl", FeatureSpecificUsageTypeOptionalSequenceBasedImmediateControl},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 #endif  // SRC_SPINE_MODEL_FEATURE_TYPES_INC_
diff --git a/src/spine/model/function_types.inc b/src/spine/model/function_types.inc
index 384eb23..54a9731 100644
--- a/src/spine/model/function_types.inc
+++ b/src/spine/model/function_types.inc
@@ -158,7 +158,7 @@ static const EnumMapping function_lut[] = {
     {"timeTableDescriptionListData", kFunctionTypeTimeTableDescriptionListData},
     {"timeTableListData", kFunctionTypeTimeTableListData},
     {"useCaseInformationListData", kFunctionTypeUseCaseInformationListData},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg function_property_cfg[] = {
diff --git a/src/spine/model/hvac_types.inc b/src/spine/model/hvac_types.inc
index 129d4d1..14c4721 100644
--- a/src/spine/model/hvac_types.inc
+++ b/src/spine/model/hvac_types.inc
@@ -20,7 +20,7 @@ static const EnumMapping hvac_system_function_type_lut[] = {
     {"cooling", kHvacSystemFunctionTypeTypeCooling},
     {"ventilation", kHvacSystemFunctionTypeTypeVentilation},
     {"dhw", kHvacSystemFunctionTypeTypeDhw},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping hvac_operation_mode_type_lut[] = {
@@ -28,7 +28,7 @@ static const EnumMapping hvac_operation_mode_type_lut[] = {
     {"on", kHvacOperationModeTypeTypeOn},
     {"off", kHvacOperationModeTypeTypeOff},
     {"eco", kHvacOperationModeTypeTypeEco},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping hvac_overrun_type_lut[] = {
@@ -42,7 +42,7 @@ static const EnumMapping hvac_overrun_type_lut[] = {
     {"oneTimeVentilation", kHvacOverrunTypeTypeOneTimeVentilation},
     {"hvacSystemOff", kHvacOverrunTypeTypeHvacSystemOff},
     {"valveKick", kHvacOverrunTypeTypeValveKick},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping hvac_overrun_status_lut[] = {
@@ -50,7 +50,7 @@ static const EnumMapping hvac_overrun_status_lut[] = {
     {"running", kHvacOverrunStatusTypeRunning},
     {"finished", kHvacOverrunStatusTypeFinished},
     {"inactive", kHvacOverrunStatusTypeInactive},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg hvac_system_function_data_cfg[] = {
diff --git a/src/spine/model/identification_types.inc b/src/spine/model/identification_types.inc
index a7e5e1b..9d2cead 100644
--- a/src/spine/model/identification_types.inc
+++ b/src/spine/model/identification_types.inc
@@ -17,7 +17,7 @@ static const EnumMapping identification_type_lut[] = {
     {"eui48", kIdentificationTypeTypeEui48},
     {"eui64", kIdentificationTypeTypeEui64},
     {"userRfidTag", kIdentificationTypeTypeUserrfidtag},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg identification_data_cfg[] = {
diff --git a/src/spine/model/loadcontrol_types.inc b/src/spine/model/loadcontrol_types.inc
index 91a60de..bf62868 100644
--- a/src/spine/model/loadcontrol_types.inc
+++ b/src/spine/model/loadcontrol_types.inc
@@ -20,7 +20,7 @@ static const EnumMapping load_control_event_action_lut[] = {
     {"increase", kLoadControlEventActionTypeIncrease},
     {"emergency", kLoadControlEventActionTypeEmergency},
     {"normal", kLoadControlEventActionTypeNormal},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping load_control_event_state_lut[] = {
@@ -30,21 +30,21 @@ static const EnumMapping load_control_event_state_lut[] = {
     {"eventRejected", kLoadControlEventStateTypeEventRejected},
     {"eventCancelled", kLoadControlEventStateTypeEventCancelled},
     {"eventError", kLoadControlEventStateTypeEventError},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping load_control_limit_type_lut[] = {
     {"minValueLimit", kLoadControlLimitTypeTypeMinValueLimit},
     {"maxValueLimit", kLoadControlLimitTypeTypeMaxValueLimit},
     {"signDependentAbsValueLimit", kLoadControlLimitTypeTypeSignDependentAbsValueLimit},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping load_control_category_lut[] = {
     {"obligation", kLoadControlCategoryTypeObligation},
     {"recommendation", kLoadControlCategoryTypeRecommendation},
     {"optimization", kLoadControlCategoryTypeOptimization},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg load_control_node_data_cfg[] = {
diff --git a/src/spine/model/measurement_types.inc b/src/spine/model/measurement_types.inc
index ce2d122..f0c3564 100644
--- a/src/spine/model/measurement_types.inc
+++ b/src/spine/model/measurement_types.inc
@@ -56,7 +56,7 @@ static const EnumMapping measurement_type_lut[] = {
     {"voltage", kMeasurementTypeTypeVoltage},
     {"volume", kMeasurementTypeTypeVolume},
     {"volumetricFlow", kMeasurementTypeTypeVolumetricFlow},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping measurement_value_type_lut[] = {
@@ -65,28 +65,28 @@ static const EnumMapping measurement_value_type_lut[] = {
     {"minValue", kMeasurementValueTypeTypeMinValue},
     {"maxValue", kMeasurementValueTypeTypeMaxValue},
     {"standardDeviation", kMeasurementValueTypeTypeStandardDeviation},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping measurement_value_source_lut[] = {
     {"measuredValue", kMeasurementValueSourceTypeMeasuredValue},
     {"calculatedValue", kMeasurementValueSourceTypeCalculatedValue},
     {"empiricalValue", kMeasurementValueSourceTypeEmpiricalValue},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping measurement_value_tendency_lut[] = {
     {"rising", kMeasurementValueTendencyTypeRising},
     {"stable", kMeasurementValueTendencyTypeStable},
     {"falling", kMeasurementValueTendencyTypeFalling},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping measurement_value_state_lut[] = {
     {"normal", kMeasurementValueStateTypeNormal},
     {"outOfRange", kMeasurementValueStateTypeOutofrange},
     {"error", kMeasurementValueStateTypeError},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg measurement_data_cfg[] = {
diff --git a/src/spine/model/messaging_types.inc b/src/spine/model/messaging_types.inc
index d4bc9fd..f4e5c6c 100644
--- a/src/spine/model/messaging_types.inc
+++ b/src/spine/model/messaging_types.inc
@@ -19,7 +19,7 @@ static const EnumMapping messaging_type_lut[] = {
     {"alarm", kMessagingTypeTypeAlarm},
     {"emergency", kMessagingTypeTypeEmergency},
     {"obsolete", kMessagingTypeTypeObsolete},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg messaging_data_cfg[] = {
diff --git a/src/spine/model/network_management_types.inc b/src/spine/model/network_management_types.inc
index 7f7c04b..0a4b541 100644
--- a/src/spine/model/network_management_types.inc
+++ b/src/spine/model/network_management_types.inc
@@ -21,21 +21,21 @@ static const EnumMapping network_management_feature_set_lut[] = {
     {"router", kNetworkManagementFeatureSetTypeRouter},
     {"smart", kNetworkManagementFeatureSetTypeSmart},
     {"simple", kNetworkManagementFeatureSetTypeSimple},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping network_management_process_state_state_lut[] = {
     {"succeeded", kNetworkManagementProcessStateStateTypeSucceeded},
     {"failed", kNetworkManagementProcessStateStateTypeFailed},
     {"aborted", kNetworkManagementProcessStateStateTypeAborted},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping network_management_state_change_lut[] = {
     {"added", kNetworkManagementStateChangeTypeAdded},
     {"removed", kNetworkManagementStateChangeTypeRemoved},
     {"modified", kNetworkManagementStateChangeTypeModified},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg network_management_add_node_call_cfg[] = {
diff --git a/src/spine/model/power_sequences_types.inc b/src/spine/model/power_sequences_types.inc
index 4e20e0a..3e4ca46 100644
--- a/src/spine/model/power_sequences_types.inc
+++ b/src/spine/model/power_sequences_types.inc
@@ -26,14 +26,14 @@ static const EnumMapping power_time_slot_value_type_lut[] = {
     {"energyExpectedValue", kPowerTimeSlotValueTypeTypeEnergyExpectedValue},
     {"energyStandardDeviation", kPowerTimeSlotValueTypeTypeEnergyStandardDeviation},
     {"energySkewness", kPowerTimeSlotValueTypeTypeEnergySkewness},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping power_sequence_scope_lut[] = {
     {"forecast", kPowerSequenceScopeTypeForecast},
     {"measurement", kPowerSequenceScopeTypeMeasurement},
     {"recommendation", kPowerSequenceScopeTypeRecommendation},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping power_sequence_state_lut[] = {
@@ -45,7 +45,7 @@ static const EnumMapping power_sequence_state_lut[] = {
     {"inactive", kPowerSequenceStateTypeInactive},
     {"completed", kPowerSequenceStateTypeCompleted},
     {"invalid", kPowerSequenceStateTypeInvalid},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg power_time_slot_schedule_data_cfg[] = {
diff --git a/src/spine/model/sensing_types.inc b/src/spine/model/sensing_types.inc
index 7edcd9c..edfdeaf 100644
--- a/src/spine/model/sensing_types.inc
+++ b/src/spine/model/sensing_types.inc
@@ -49,7 +49,7 @@ static const EnumMapping sensing_state_lut[] = {
     {"notDetected", kSensingStateTypeNotDetected},
     {"alarmed", kSensingStateTypeAlarmed},
     {"notAlarmed", kSensingStateTypeNotAlarmed},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping sensing_type_lut[] = {
@@ -69,7 +69,7 @@ static const EnumMapping sensing_type_lut[] = {
     {"alarmSensor", kSensingTypeTypeAlarmSensor},
     {"powerAlarmSensor", kSensingTypeTypePowerAlarmSensor},
     {"dayNightIndicator", kSensingTypeTypeDayNightIndicator},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg sensing_data_cfg[] = {
diff --git a/src/spine/model/setpoint_types.inc b/src/spine/model/setpoint_types.inc
index 2e2b715..82cd7be 100644
--- a/src/spine/model/setpoint_types.inc
+++ b/src/spine/model/setpoint_types.inc
@@ -15,7 +15,7 @@
 static const EnumMapping setpoint_type_lut[] = {
     {"valueAbsolute", kSetpointTypeTypeValueAbsolute},
     {"valueRelative", kSetpointTypeTypeValueRelative},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg setpoint_data_cfg[] = {
diff --git a/src/spine/model/state_information_types.inc b/src/spine/model/state_information_types.inc
index 93f920f..ca84ba9 100644
--- a/src/spine/model/state_information_types.inc
+++ b/src/spine/model/state_information_types.inc
@@ -44,7 +44,7 @@ static const EnumMapping state_information_lut[] = {
     {"dcVoltageBelowLimit", kStateInformationTypeDcVoltageBelowLimit},
     {"hardwareTestFailure", kStateInformationTypeHardwareTestFailure},
     {"genericInternalError", kStateInformationTypeGenericInternalError},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping state_information_functionality_lut[] = {
@@ -61,7 +61,7 @@ static const EnumMapping state_information_functionality_lut[] = {
     {"throttled", kStateInformationFunctionalityTypeThrottled},
     {"shuttingDown", kStateInformationFunctionalityTypeShuttingDown},
     {"manualShutdown", kStateInformationFunctionalityTypeManualShutdown},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping state_information_failure_lut[] = {
@@ -83,13 +83,13 @@ static const EnumMapping state_information_failure_lut[] = {
     {"dcVoltageBelowLimit", kStateInformationFailureTypeDcVoltageBelowLimit},
     {"hardwareTestFailure", kStateInformationFailureTypeHardwareTestFailure},
     {"genericInternalError", kStateInformationFailureTypeGenericInternalError},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping state_information_category_lut[] = {
     {"functionality", kStateInformationCategoryTypeFunctionality},
     {"failure", kStateInformationCategoryTypeFailure},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg state_information_data_cfg[] = {
diff --git a/src/spine/model/supply_conditions_types.inc b/src/spine/model/supply_conditions_types.inc
index 76ced4d..4340088 100644
--- a/src/spine/model/supply_conditions_types.inc
+++ b/src/spine/model/supply_conditions_types.inc
@@ -21,7 +21,7 @@ static const EnumMapping supply_condition_event_type_lut[] = {
     {"releaseOfLimitations", kSupplyConditionEventTypeTypeReleaseOfLimitations},
     {"otherProblem", kSupplyConditionEventTypeTypeOtherProblem},
     {"gridConditionUpdate", kSupplyConditionEventTypeTypeGridConditionUpdate},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping supply_condition_originator_lut[] = {
@@ -30,7 +30,7 @@ static const EnumMapping supply_condition_originator_lut[] = {
     {"internalLimit", kSupplyConditionOriginatorTypeInternalLimit},
     {"internalService", kSupplyConditionOriginatorTypeInternalService},
     {"internalUser", kSupplyConditionOriginatorTypeInternalUser},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping grid_condition_lut[] = {
@@ -39,7 +39,7 @@ static const EnumMapping grid_condition_lut[] = {
     {"good", kGridConditionTypeGood},
     {"productionRed", kGridConditionTypeProductionRed},
     {"productionYellow", kGridConditionTypeProductionYellow},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg supply_condition_data_cfg[] = {
diff --git a/src/spine/model/tariff_information_types.inc b/src/spine/model/tariff_information_types.inc
index d477a0d..fa4c062 100644
--- a/src/spine/model/tariff_information_types.inc
+++ b/src/spine/model/tariff_information_types.inc
@@ -18,13 +18,13 @@ static const EnumMapping tier_boundary_type_lut[] = {
     {"powerBoundary", kTierBoundaryTypeTypePowerBoundary},
     {"energyBoundary", kTierBoundaryTypeTypeEnergyBoundary},
     {"countBoundary", kTierBoundaryTypeTypeCountBoundary},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping tier_type_lut[] = {
     {"fixedCost", kTierTypeTypeFixedCost},
     {"dynamicCost", kTierTypeTypeDynamicCost},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping incentive_type_lut[] = {
@@ -32,7 +32,7 @@ static const EnumMapping incentive_type_lut[] = {
     {"relativeCost", kIncentiveTypeTypeRelativeCost},
     {"renewableEnergyPercentage", kIncentiveTypeTypeRenewableEnergyPercentage},
     {"co2Emission", kIncentiveTypeTypeCo2Emission},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping incentive_value_type_lut[] = {
@@ -40,7 +40,7 @@ static const EnumMapping incentive_value_type_lut[] = {
     {"averageValue", kIncentiveValueTypeTypeAverageValue},
     {"minValue", kIncentiveValueTypeTypeMinvalue},
     {"maxValue", kIncentiveValueTypeTypeMaxvalue},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg tariff_overall_constraints_data_cfg[] = {
diff --git a/src/spine/model/task_management_types.inc b/src/spine/model/task_management_types.inc
index 9c5a77f..c560a32 100644
--- a/src/spine/model/task_management_types.inc
+++ b/src/spine/model/task_management_types.inc
@@ -32,14 +32,14 @@ static const EnumMapping task_management_job_state_lut[] = {
     {"pending", kTaskManagementJobStateTypePending},
     {"completed", kTaskManagementJobStateTypeCompleted},
     {"invalid", kTaskManagementJobStateTypeInvalid},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping task_management_job_source_lut[] = {
     {"InternalMechanism", kTaskManagementJobSourceTypeInternalMechanism},
     {"UserInteraction", kTaskManagementJobSourceTypeUserInteraction},
     {"ExternalConfiguration", kTaskManagementJobSourceTypeExternalConfiguration},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg task_management_hvac_related_cfg[] = {
diff --git a/src/spine/model/threshold_types.inc b/src/spine/model/threshold_types.inc
index 06d3369..f47366b 100644
--- a/src/spine/model/threshold_types.inc
+++ b/src/spine/model/threshold_types.inc
@@ -23,7 +23,7 @@ static const EnumMapping threshold_type_lut[] = {
     {"maxValueThresholdExtreme", kThresholdTypeTypeMaxValueThresholdExtreme},
     {"sagThreshold", kThresholdTypeTypeSagThreshold},
     {"swellThreshold", kThresholdTypeTypeSwellThreshold},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg threshold_data_cfg[] = {
diff --git a/src/spine/model/time_series_types.inc b/src/spine/model/time_series_types.inc
index b3582c0..a1c0441 100644
--- a/src/spine/model/time_series_types.inc
+++ b/src/spine/model/time_series_types.inc
@@ -21,7 +21,7 @@ static const EnumMapping time_series_type_lut[] = {
     {"dischargingEnergyRequest", kTimeSeriesTypeTypeDischargingEnergyRequest},
     {"consumptionLimitCurve", kTimeSeriesTypeTypeConsumptionLimitCurve},
     {"productionLimitCurve", kTimeSeriesTypeTypeProductionLimitCurve},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg time_series_slot_cfg[] = {
diff --git a/src/spine/model/timetable_types.inc b/src/spine/model/timetable_types.inc
index f3c19f3..42fcb4d 100644
--- a/src/spine/model/timetable_types.inc
+++ b/src/spine/model/timetable_types.inc
@@ -16,7 +16,7 @@ static const EnumMapping time_slot_time_mode_lut[] = {
     {"absolute", kTimeSlotTimeModeTypeAbsolute},
     {"recurring", kTimeSlotTimeModeTypeRecurring},
     {"both", kTimeSlotTimeModeTypeBoth},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg time_table_data_cfg[] = {
diff --git a/src/spine/model/usecase_information_types.inc b/src/spine/model/usecase_information_types.inc
index 8af8b16..86ff8ba 100644
--- a/src/spine/model/usecase_information_types.inc
+++ b/src/spine/model/usecase_information_types.inc
@@ -39,7 +39,7 @@ static const EnumMapping use_case_actor_lut[] = {
     {"PVSystem", kUseCaseActorTypePVSystem},
     {"SmartAppliance", kUseCaseActorTypeSmartAppliance},
     {"VisualizationAppliance", kUseCaseActorTypeVisualizationAppliance},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EnumMapping use_case_name_lut[] = {
@@ -81,7 +81,7 @@ static const EnumMapping use_case_name_lut[] = {
     {"visualizationOfAggregatedBatteryData", kUseCaseNameTypeVisualizationOfAggregatedBatteryData},
     {"visualizationOfAggregatedPhotovoltaicData", kUseCaseNameTypeVisualizationOfAggregatedPhotovoltaicData},
     {"visualizationOfHeatingAreaName", kUseCaseNameTypeVisualizationOfHeatingAreaName},
-    {NULL},
+    EEBUS_ENUM_MAPPING_END,
 };
 
 static const EebusDataCfg scenario_support_element_data_cfg
diff --git a/src/spine/node_management/node_management_destination_list.c b/src/spine/node_management/node_management_destination_list.c
index 5bfaac7..bc7f9fb 100644
--- a/src/spine/node_management/node_management_destination_list.c
+++ b/src/spine/node_management/node_management_destination_list.c
@@ -19,11 +19,15 @@
  */
 
 #include "src/common/array_util.h"
+#include "src/common/eebus_arguments.h"
 #include "src/spine/api/device_local_interface.h"
 #include "src/spine/api/message.h"
 #include "src/spine/node_management/node_management_internal.h"
 
 EebusError RequestDestinationListData(NodeManagement* self, const char* remote_device_addr, SenderObject* sender) {
+  UNUSED(self);
+  UNUSED(remote_device_addr);
+  UNUSED(sender);
   return kEebusErrorNotImplemented;
 }
 
@@ -45,6 +49,8 @@ EebusError ProcessReadDestinationListData(NodeManagement* self, const Message* m
 }
 
 EebusError ProcessReplyDestinationListData(NodeManagement* self, const Message* msg) {
+  UNUSED(self);
+  UNUSED(msg);
   return kEebusErrorNotImplemented;
 }
 
diff --git a/src/spine/node_management/node_management_detailed_discovery.c b/src/spine/node_management/node_management_detailed_discovery.c
index 18ccda1..621e6ca 100644
--- a/src/spine/node_management/node_management_detailed_discovery.c
+++ b/src/spine/node_management/node_management_detailed_discovery.c
@@ -19,6 +19,7 @@
  */
 
 #include "src/common/array_util.h"
+#include "src/common/eebus_arguments.h"
 #include "src/spine/api/device_local_interface.h"
 #include "src/spine/entity/entity.h"
 #include "src/spine/events/events.h"
@@ -186,6 +187,7 @@ EebusError ProcessReadDetailedDiscoveryData(NodeManagement* self, const Message*
 }
 
 EebusError ProcessReplyDetailedDiscoveryData(NodeManagement* self, const Message* msg) {
+  UNUSED(self);
   DeviceRemoteObject* const dr = msg->device_remote;
 
   const NodeManagementDetailedDiscoveryDataType* const discovery_data
@@ -255,6 +257,8 @@ EebusError ProcessReplyDetailedDiscoveryData(NodeManagement* self, const Message
 }
 
 EebusError ProcessNotifyDetailedDiscoveryData(NodeManagement* self, const Message* msg) {
+  UNUSED(self);
+  UNUSED(msg);
   // TODO: Implement method
   return kEebusErrorNotImplemented;
 }
diff --git a/src/spine/node_management/node_management_usecase.c b/src/spine/node_management/node_management_usecase.c
index 361dd6a..7aeb55f 100644
--- a/src/spine/node_management/node_management_usecase.c
+++ b/src/spine/node_management/node_management_usecase.c
@@ -19,6 +19,7 @@
  */
 
 #include "src/common/array_util.h"
+#include "src/common/eebus_arguments.h"
 #include "src/spine/api/message.h"
 #include "src/spine/events/events.h"
 #include "src/spine/model/cmd.h"
@@ -70,6 +71,8 @@ EebusError ProcessReadUseCaseData(NodeManagement* self, const Message* msg) {
 }
 
 EebusError ProcessReplyUseCaseData(NodeManagement* self, const Message* msg) {
+  UNUSED(self);
+
   const NodeManagementUseCaseDataType* const usecase_data = (const NodeManagementUseCaseDataType*)msg->cmd->data_choice;
 
   FeatureRemoteObject* const fr = msg->feature_remote;
diff --git a/src/spine/subscription/subscription_manager.c b/src/spine/subscription/subscription_manager.c
index 2337037..8b32a30 100644
--- a/src/spine/subscription/subscription_manager.c
+++ b/src/spine/subscription/subscription_manager.c
@@ -18,6 +18,7 @@
  * @brief Subscription Manager implementation
  */
 
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_malloc.h"
 #include "src/spine/api/device_local_interface.h"
 #include "src/spine/api/feature_link.h"
@@ -244,6 +245,8 @@ void RemoveEntitySubscriptions(SubscriptionManagerObject* self, EntityRemoteObje
 }
 
 Vector* GetFeatureSubscriptions(const SubscriptionManagerObject* self, FeatureAddressType feature_addr) {
+  UNUSED(self);
+  UNUSED(feature_addr);
   // TODO: Implement method
   return NULL;
 }
diff --git a/src/use_case/actor/common/load_control.c b/src/use_case/actor/common/load_control.c
index ee4a6d4..5d70001 100644
--- a/src/use_case/actor/common/load_control.c
+++ b/src/use_case/actor/common/load_control.c
@@ -67,9 +67,14 @@ EebusError LoadControlWriteLimit(
       .limit_id = limit_data->limit_id,
   };
 
+  // clang-format off
   const LoadControlLimitDataElementsType* delete_elements = &(LoadControlLimitDataElementsType){
-      .time_period = &(TimePeriodElementsType){EEBUS_TAG_RESET},
+      .time_period = &(TimePeriodElementsType){
+          .start_time = EEBUS_TAG_RESET,
+          .end_time   = EEBUS_TAG_RESET,
+      },
   };
+  // clang-format on
 
   // If timer period should not be deleted, reset delete_selectors and delete_elements
   if (!limit->delete_duration) {
diff --git a/src/use_case/actor/cs/cs_lp.c b/src/use_case/actor/cs/cs_lp.c
index c9823a9..dca8cd8 100644
--- a/src/use_case/actor/cs/cs_lp.c
+++ b/src/use_case/actor/cs/cs_lp.c
@@ -23,6 +23,7 @@
 #include <stddef.h>
 
 #include "src/common/array_util.h"
+#include "src/common/eebus_arguments.h"
 #include "src/spine/entity/entity_local.h"
 #include "src/spine/feature/feature_local.h"
 #include "src/spine/model/loadcontrol_types.h"
@@ -357,6 +358,7 @@ EebusError AddDeviceConfigurationFeature(CsLpUseCase* self, EntityLocalObject* e
 }
 
 EebusError AddDeviceDiagnosisFeature(CsLpUseCase* self, EntityLocalObject* entity) {
+  UNUSED(self);
   FeatureLocalObject* const fl
       = ENTITY_LOCAL_ADD_FEATURE_WITH_TYPE_AND_ROLE(entity, kFeatureTypeTypeDeviceDiagnosis, kRoleTypeServer);
   FEATURE_LOCAL_SET_FUNCTION_OPERATIONS(fl, kFunctionTypeDeviceDiagnosisHeartbeatData, true, false);
diff --git a/src/use_case/actor/ma/mpc/ma_mpc.c b/src/use_case/actor/ma/mpc/ma_mpc.c
index 452b0a3..8eadce0 100644
--- a/src/use_case/actor/ma/mpc/ma_mpc.c
+++ b/src/use_case/actor/ma/mpc/ma_mpc.c
@@ -23,6 +23,7 @@
 #include <stddef.h>
 
 #include "src/common/array_util.h"
+#include "src/common/eebus_arguments.h"
 #include "src/spine/entity/entity_local.h"
 #include "src/spine/feature/feature_local.h"
 #include "src/spine/model/usecase_information_types.h"
@@ -105,6 +106,7 @@ static EebusError
 MaMpcUseCaseConstruct(MaMpcUseCase* self, EntityLocalObject* local_entity, MaMpcListenerObject* ma_mpc_listener);
 
 EebusError AddFeatures(UseCaseObject* self, EntityLocalObject* entity) {
+  UNUSED(self);
   // client features
   const FeatureTypeType client_features[] = {
       kFeatureTypeTypeElectricalConnection,
diff --git a/src/use_case/actor/ma/mpc/ma_mpc_measurement.c b/src/use_case/actor/ma/mpc/ma_mpc_measurement.c
index 6695f19..71143dd 100644
--- a/src/use_case/actor/ma/mpc/ma_mpc_measurement.c
+++ b/src/use_case/actor/ma/mpc/ma_mpc_measurement.c
@@ -19,6 +19,7 @@
  */
 
 #include "src/common/array_util.h"
+#include "src/common/eebus_arguments.h"
 #include "src/use_case/api/ma_mpc_measurement_interface.h"
 #include "src/use_case/model/mpc_types.h"
 #include "src/use_case/specialization/electrical_connection/electrical_connection_client.h"
@@ -311,6 +312,8 @@ bool CheckPhaseSpecificData(
     const EnergyDirectionType* energy_direction,
     const MeasurementDataType* item
 ) {
+  UNUSED(mcl);
+
   if ((item->value == NULL) || (item->value->number == NULL) || (item->measurement_id == NULL)) {
     return false;
   }
@@ -420,6 +423,8 @@ EebusError GetEnergyStrategy(
     ElectricalConnectionClient* eccl,
     ScaledValue* value
 ) {
+  UNUSED(eccl);
+
   const MeasurementDescriptionDataType filter = {
       .measurement_type = &measurement->measurement_type,
       .commodity_type   = &(CommodityTypeType){kCommodityTypeTypeElectricity},
@@ -457,6 +462,9 @@ EebusError GetFrequencyStrategy(
     ElectricalConnectionClient* eccl,
     ScaledValue* value
 ) {
+  UNUSED(measurement);
+  UNUSED(eccl);
+
   const MeasurementDescriptionDataType filter = {
       .measurement_type = &(MeasurementTypeType){kMeasurementTypeTypeFrequency},
       .commodity_type   = &(CommodityTypeType){kCommodityTypeTypeElectricity},
diff --git a/src/use_case/actor/mu/mpc/mu_mpc.c b/src/use_case/actor/mu/mpc/mu_mpc.c
index fa60452..8755c00 100644
--- a/src/use_case/actor/mu/mpc/mu_mpc.c
+++ b/src/use_case/actor/mu/mpc/mu_mpc.c
@@ -17,6 +17,7 @@
 #include "src/use_case/actor/mu/mpc/mu_mpc.h"
 
 #include "src/common/array_util.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_mutex/eebus_mutex.h"
 #include "src/use_case/actor/mu/mpc/mu_mpc_internal.h"
 #include "src/use_case/actor/mu/mpc/mu_mpc_measurement.h"
@@ -341,5 +342,7 @@ void Destruct(UseCaseObject* self) {
 }
 
 bool IsEntityCompatible(const UseCaseObject* self, const EntityRemoteObject* remote_entity) {
+  UNUSED(self);
+  UNUSED(remote_entity);
   return true;  // For now, all entities are compatible with this use case
 }
diff --git a/src/use_case/specialization/measurement/measurement_server.c b/src/use_case/specialization/measurement/measurement_server.c
index ff091a1..e001fb4 100644
--- a/src/use_case/specialization/measurement/measurement_server.c
+++ b/src/use_case/specialization/measurement/measurement_server.c
@@ -20,6 +20,7 @@
 
 #include "src/use_case/specialization/measurement/measurement_server.h"
 #include "src/common/array_util.h"
+#include "src/common/eebus_arguments.h"
 #include "src/spine/model/filter.h"
 #include "src/spine/model/measurement_types.h"
 
@@ -120,6 +121,7 @@ EebusError MeasurementServerUpdateMeasurementWithFilter(
     const MeasurementListDataSelectorsType* delete_selectors,
     const MeasurementDataElementsType* delete_elements
 ) {
+  UNUSED(filter);
   const MeasurementDataType* measurement_data[]   = {measurement};
   const MeasurementListDataType measurements_list = {measurement_data, ARRAY_SIZE(measurement_data)};
 
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 9433d92..a57e9d8 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -76,14 +76,14 @@ else()
   add_library(cjson ALIAS PkgConfig::CJSON)
 endif()
 
-if(CMAKE_CXX_COMPILER_ID MATCHES GNU OR CMAKE_C_COMPILER_ID MATCHES "Clang")
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
 endif()
-if(CMAKE_C_COMPILER_ID MATCHES GNU OR CMAKE_C_COMPILER_ID MATCHES "Clang")
+if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage")
 endif()
 
-if(CMAKE_CXX_COMPILER_ID MATCHES GNU OR CMAKE_C_COMPILER_ID MATCHES "Clang")
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang" OR CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
 endif()
 
@@ -101,10 +101,13 @@ set(GTEST_SOURCES
   ${GTestFiles}
 )
 
-if(CMAKE_CXX_COMPILER_ID MATCHES GNU OR CMAKE_C_COMPILER_ID MATCHES "Clang")
+if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
   set(PROJECT_COMPILE_OPTIONS
     -Wno-psabi
-    -Werror=return-type
+    -Wall
+    -Wextra
+    -Wno-missing-field-initializers
+    -Werror
     --coverage
     -fprofile-arcs
   )
@@ -132,7 +135,7 @@ if (NOT APPLE)
   set(GCOV "-lgcov")
 endif()
 
-if(CMAKE_CXX_COMPILER_ID MATCHES GNU OR CMAKE_C_COMPILER_ID MATCHES "Clang")
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang" OR CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
   set(PROJECT_LINK_OPTIONS
     --coverage
     ${GCOV}
diff --git a/tests/src/common/eebus_queue/eebus_queue_test.cpp b/tests/src/common/eebus_queue/eebus_queue_test.cpp
index bb8b709..c842429 100644
--- a/tests/src/common/eebus_queue/eebus_queue_test.cpp
+++ b/tests/src/common/eebus_queue/eebus_queue_test.cpp
@@ -33,7 +33,7 @@ TEST(EebusQueueTest, EebusQueueTestGeneric) {
   ASSERT_FALSE(EEBUS_QUEUE_IS_FULL(queue.get()));
 
   int32_t msg_wr = 1;
-  for (int i = 0; i < kQueueMaxSize; ++i) {
+  for (size_t i = 0; i < kQueueMaxSize; ++i) {
     EXPECT_FALSE(EEBUS_QUEUE_IS_FULL(queue.get()));
     EXPECT_EQ(EEBUS_QUEUE_SEND(queue.get(), &msg_wr, 0), kEebusErrorOk);
     ++msg_wr;
@@ -43,7 +43,7 @@ TEST(EebusQueueTest, EebusQueueTestGeneric) {
 
   msg_wr         = 1;
   int32_t msg_rd = 0;
-  for (int i = 0; i < kQueueMaxSize; ++i) {
+  for (size_t i = 0; i < kQueueMaxSize; ++i) {
     EXPECT_FALSE(EEBUS_QUEUE_IS_EMPTY(queue.get()));
     EXPECT_EQ(EEBUS_QUEUE_RECEIVE(queue.get(), &msg_rd, 0), kEebusErrorOk);
     EXPECT_EQ(msg_rd, msg_wr);
@@ -60,7 +60,7 @@ TEST(EebusQueueTest, EebusQueueTestGeneric) {
   msg_rd = 0;
 
   msg_wr = 6;
-  for (int i = 0; i < kQueueMaxSize; ++i) {
+  for (size_t i = 0; i < kQueueMaxSize; ++i) {
     EXPECT_EQ(EEBUS_QUEUE_SEND(queue.get(), &msg_wr, 0), kEebusErrorOk);
     ++msg_wr;
   }
@@ -70,7 +70,7 @@ TEST(EebusQueueTest, EebusQueueTestGeneric) {
 
   msg_wr = 6;
   msg_rd = 0;
-  for (int i = 0; i < kQueueMaxSize; ++i) {
+  for (size_t i = 0; i < kQueueMaxSize; ++i) {
     EXPECT_FALSE(EEBUS_QUEUE_IS_EMPTY(queue.get()));
     EXPECT_EQ(EEBUS_QUEUE_RECEIVE(queue.get(), &msg_rd, 0), kEebusErrorOk);
     EXPECT_EQ(msg_rd, msg_wr);
diff --git a/tests/src/common/eebus_timer/eebus_timer_test.cpp b/tests/src/common/eebus_timer/eebus_timer_test.cpp
index cecc91e..674dc24 100644
--- a/tests/src/common/eebus_timer/eebus_timer_test.cpp
+++ b/tests/src/common/eebus_timer/eebus_timer_test.cpp
@@ -25,9 +25,11 @@
 
 #include <string_view>
 
+#include "src/common/eebus_arguments.h"
 #include "tests/src/memory_leak.inc"
 
 static void EebusTimerTimeoutCallbackStub(void* eebus_timer) {
+  UNUSED(eebus_timer);
   return;
 }
 
diff --git a/tests/src/mocks/common/eebus_timer/eebus_timer_mock.cpp b/tests/src/mocks/common/eebus_timer/eebus_timer_mock.cpp
index a319970..6761c1b 100644
--- a/tests/src/mocks/common/eebus_timer/eebus_timer_mock.cpp
+++ b/tests/src/mocks/common/eebus_timer/eebus_timer_mock.cpp
@@ -23,6 +23,7 @@
 #include <gmock/gmock.h>
 
 #include "src/common/api/eebus_timer_interface.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_errors.h"
 #include "src/common/eebus_timer/eebus_timer.h"
 
@@ -69,6 +70,8 @@ EebusTimerMock* EebusTimerMockCreate(void) {
 }
 
 EebusTimerObject* EebusTimerCreate(EebusTimerTimeoutCallback cb, void* ctx) {
+  UNUSED(cb);
+  UNUSED(ctx);
   return EEBUS_TIMER_OBJECT(EebusTimerMockCreate());
 }
 
diff --git a/tests/src/mocks/ship/websocket/websocket_creator_mock.cpp b/tests/src/mocks/ship/websocket/websocket_creator_mock.cpp
index 903c4a9..cf52456 100644
--- a/tests/src/mocks/ship/websocket/websocket_creator_mock.cpp
+++ b/tests/src/mocks/ship/websocket/websocket_creator_mock.cpp
@@ -22,6 +22,7 @@
 
 #include <gmock/gmock.h>
 
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_errors.h"
 #include "src/ship/api/websocket_creator_interface.h"
 #include "websocket_mock.h"
@@ -69,6 +70,8 @@ void Destruct(WebsocketCreatorObject* self) {
 }
 
 WebsocketObject* CreateWebsocket(WebsocketCreatorObject* self, WebsocketCallback cb, void* ctx) {
-  WebsocketCreatorMock* const mock = WEBSOCKET_CREATOR_MOCK(self);
+  UNUSED(self);
+  UNUSED(cb);
+  UNUSED(ctx);
   return WEBSOCKET_OBJECT(WebsocketMockCreate());
 }
diff --git a/tests/src/mocks/use_case/api/eg_lp_listener_mock.cpp b/tests/src/mocks/use_case/api/eg_lp_listener_mock.cpp
index 531e8ae..db1879e 100644
--- a/tests/src/mocks/use_case/api/eg_lp_listener_mock.cpp
+++ b/tests/src/mocks/use_case/api/eg_lp_listener_mock.cpp
@@ -7,6 +7,7 @@
 
 #include <gmock/gmock.h>
 
+#include "src/common/eebus_arguments.h"
 #include "src/use_case/api/eg_lp_listener_interface.h"
 
 static void Destruct(EgLpListenerObject* self);
@@ -90,6 +91,7 @@ void OnPowerLimitReceive(
     const DurationType* duration,
     bool is_active
 ) {
+  UNUSED(entity_addr);
   EgLpListenerMock* const mock = EG_LP_LISTENER_MOCK(self);
   mock->gmock->OnPowerLimitReceive(self, power_limit, duration, is_active);
 }
@@ -99,6 +101,7 @@ void OnFailsafePowerLimitReceive(
     const EntityAddressType* entity_addr,
     const ScaledValue* power_limit
 ) {
+  UNUSED(entity_addr);
   EgLpListenerMock* const mock = EG_LP_LISTENER_MOCK(self);
   mock->gmock->OnFailsafePowerLimitReceive(self, power_limit);
 }
@@ -108,11 +111,13 @@ void OnFailsafeDurationReceive(
     const EntityAddressType* entity_addr,
     const DurationType* duration
 ) {
+  UNUSED(entity_addr);
   EgLpListenerMock* const mock = EG_LP_LISTENER_MOCK(self);
   mock->gmock->OnFailsafeDurationReceive(self, duration);
 }
 
 void OnHeartbeatReceive(EgLpListenerObject* self, const EntityAddressType* entity_addr, uint64_t heartbeat_counter) {
+  UNUSED(entity_addr);
   EgLpListenerMock* const mock = EG_LP_LISTENER_MOCK(self);
   mock->gmock->OnHeartbeatReceive(self, heartbeat_counter);
 }
diff --git a/tests/src/service/service/eebus_service/eebus_service_test.cpp b/tests/src/service/service/eebus_service/eebus_service_test.cpp
index 4ef2816..f80a7f2 100644
--- a/tests/src/service/service/eebus_service/eebus_service_test.cpp
+++ b/tests/src/service/service/eebus_service/eebus_service_test.cpp
@@ -21,6 +21,7 @@
 #include "mocks/ship/ship_node/ship_node_mock.h"
 #include "mocks/ship/tls_certificate/tls_certificate_mock.h"
 #include "mocks/spine/device/device_local_mock.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_device_info.h"
 #include "src/common/eebus_malloc.h"
 #include "src/common/vector.h"
@@ -50,6 +51,8 @@ static DeviceLocalMock* device_local_mock;
 
 DeviceLocalObject*
 DeviceLocalCreate(const EebusDeviceInfo* device_info, const NetworkManagementFeatureSetType* feature_set) {
+  UNUSED(device_info);
+  UNUSED(feature_set);
   return DEVICE_LOCAL_OBJECT(device_local_mock);
 }
 
@@ -65,12 +68,18 @@ ShipNodeObject* ShipNodeCreate(
     ShipNodeReaderObject* ship_node_reader,
     ServiceDetails* local_service_details
 ) {
+  UNUSED(ski);
+  UNUSED(role);
+  UNUSED(device_info);
+  UNUSED(service_name);
+  UNUSED(port);
+  UNUSED(ssl_cert);
+  UNUSED(ship_node_reader);
+  UNUSED(local_service_details);
   return SHIP_NODE_OBJECT(ship_node_mock);
 }
 
 void EebusServiceTestSuite::SetUp() {
-  static constexpr EntityTypeType entity_types[] = {kEntityTypeTypeCEM};
-
   configuration_ = EebusServiceConfigCreate("vendor", "brand", "model", "serial", "EnergyManagementSystem", 4729);
 
   tls_certificate_mock_ = TlsCertificateMockCreate();
@@ -107,10 +116,6 @@ void EebusServiceTestSuite::TearDown() {
 TEST_F(EebusServiceTestSuite, eebus_service_service_reader) {
   static constexpr char test_ski[] = "test";
 
-  RemoteServiceInfo entry = {
-      .ski = test_ski,
-  };
-
   const Vector* entries = VectorCreate();
 
   ServiceReaderObject* const sr = SERVICE_READER_OBJECT(service_reader_mock_);
diff --git a/tests/src/service/service/eebus_service_config/eebus_service_config_test.cpp b/tests/src/service/service/eebus_service_config/eebus_service_config_test.cpp
index df71f4b..1ea56a6 100644
--- a/tests/src/service/service/eebus_service_config/eebus_service_config_test.cpp
+++ b/tests/src/service/service/eebus_service_config/eebus_service_config_test.cpp
@@ -50,9 +50,6 @@ TEST_P(EebusServiceConfigCreateTests, eebus_service_config_create_tests) {
 
   const char* device_type = GetParam().device_type;
 
-  const EntityTypeType* entity_types = GetParam().entity_types;
-  const size_t entity_types_size     = GetParam().entity_types_size;
-
   const int32_t port = GetParam().port;
 
   // Act: Initialise Configuration
diff --git a/tests/src/ship/ship_connection/ship_connection/client/cmi/cmi_client_wait_test.cpp b/tests/src/ship/ship_connection/ship_connection/client/cmi/cmi_client_wait_test.cpp
index 6695151..c299677 100644
--- a/tests/src/ship/ship_connection/ship_connection/client/cmi/cmi_client_wait_test.cpp
+++ b/tests/src/ship/ship_connection/ship_connection/client/cmi/cmi_client_wait_test.cpp
@@ -39,7 +39,7 @@ std::ostream& operator<<(std::ostream& os, const ShipCmiClientWaitStateTestInput
 TEST_P(ShipConnectionCmiWaitStateTests, CmiClientWaitReplyReceivedTest) {
   // Arrange:
   // Create message and add it to the queue
-  ShipConnectionQueueMessage queue_msg = {GetParam().msg_type, NULL};
+  ShipConnectionQueueMessage queue_msg{GetParam().msg_type, {NULL}};
   EEBUS_QUEUE_SEND(sc.msg_queue, &queue_msg, sizeof(queue_msg));
 
   // Expect timer function calls
diff --git a/tests/src/ship/ship_connection/ship_connection/server/cmi/cmi_server_wait_test.cpp b/tests/src/ship/ship_connection/ship_connection/server/cmi/cmi_server_wait_test.cpp
index 0ad8ba9..29385f9 100644
--- a/tests/src/ship/ship_connection/ship_connection/server/cmi/cmi_server_wait_test.cpp
+++ b/tests/src/ship/ship_connection/ship_connection/server/cmi/cmi_server_wait_test.cpp
@@ -38,7 +38,7 @@ std::ostream& operator<<(std::ostream& os, const ShipCmiServerWaitStateTestInput
 
 TEST_P(ShipConnectionServerCmiWaitStateTests, CmiServerWaitReceivedReplyTest) {
   // Arrange: Create message queue and add message to it
-  ShipConnectionQueueMessage queue_msg = {GetParam().msg_type, NULL};
+  ShipConnectionQueueMessage queue_msg = {GetParam().msg_type, {NULL}};
   EEBUS_QUEUE_SEND(sc.msg_queue, &queue_msg, sizeof(queue_msg));
 
   // Expect timer function calls
diff --git a/tests/src/ship/ship_connection/ship_connection/sme_hello/sme_hello_ready_listen_test.cpp b/tests/src/ship/ship_connection/ship_connection/sme_hello/sme_hello_ready_listen_test.cpp
index 80a9582..e166b45 100644
--- a/tests/src/ship/ship_connection/ship_connection/sme_hello/sme_hello_ready_listen_test.cpp
+++ b/tests/src/ship/ship_connection/ship_connection/sme_hello/sme_hello_ready_listen_test.cpp
@@ -117,8 +117,6 @@ TEST_P(
   EXPECT_CALL(*prr_timer_mock->gmock, Stop(sc.prolongation_request_reply_timer));
 
   // Calculate message size
-  const size_t msg_size      = msg_buf.data_size - 1;
-  const size_t ret_num_bytes = GetParam().msg_send_successful ? msg_size : 0;
   EXPECT_CALL(
       *ifp_mock->gmock,
       HandleShipStateUpdate(
diff --git a/tests/src/ship/ship_connection/ship_message_deserialize/sme_hello_deserialize_test.cpp b/tests/src/ship/ship_connection/ship_message_deserialize/sme_hello_deserialize_test.cpp
index 00ef849..ede41dc 100644
--- a/tests/src/ship/ship_connection/ship_message_deserialize/sme_hello_deserialize_test.cpp
+++ b/tests/src/ship/ship_connection/ship_message_deserialize/sme_hello_deserialize_test.cpp
@@ -45,7 +45,7 @@ MATCHER_P3(SmeHelloEq, phase, waiting, prolongation_request, "") {
     match = match && (waiting == nullptr);
   } else {
     match = match && (waiting != nullptr);
-    match = match && (*arg->waiting == *waiting);
+    match = match && (*arg->waiting == static_cast<uint32_t>(*waiting));
   }
 
   if (arg->prolongation_request == nullptr) {
diff --git a/tests/src/ship/ship_connection/ship_message_serialize/sme_connection_access_methods_request_serialize_test.cpp b/tests/src/ship/ship_connection/ship_message_serialize/sme_connection_access_methods_request_serialize_test.cpp
index 6a63cea..907cf96 100644
--- a/tests/src/ship/ship_connection/ship_message_serialize/sme_connection_access_methods_request_serialize_test.cpp
+++ b/tests/src/ship/ship_connection/ship_message_serialize/sme_connection_access_methods_request_serialize_test.cpp
@@ -32,7 +32,7 @@ TEST(SmeConnectionAccessMethodsRequestSerializeTests, SmeConnectionAccessMethods
   EXPECT_EQ(SHIP_MESSAGE_SERIALIZE_GET_BUFFER(serialize), nullptr);
   ShipMessageSerializeDelete(serialize);
 
-  AccessMethodsRequest sme_access_methods_req;
+  AccessMethodsRequest sme_access_methods_req{};
   serialize = ShipMessageSerializeCreate(&sme_access_methods_req, kValueUndefined);
   EXPECT_EQ(SHIP_MESSAGE_SERIALIZE_GET_BUFFER(serialize), nullptr);
   ShipMessageSerializeDelete(serialize);
@@ -52,7 +52,7 @@ class SmeConnectionAccessMethodsRequestSerializeTests
 
 TEST_P(SmeConnectionAccessMethodsRequestSerializeTests, SmeConnectionAccessMethodsRequestSerializeTests) {
   // Arrange: Initialize the AccessMethodsRequest from test input
-  AccessMethodsRequest sme_access_methods_req;
+  AccessMethodsRequest sme_access_methods_req = {};
 
   // Act: Run the AccessMethodsRequest serialization procedure
   auto serialize = ShipMessageSerializeCreate(&sme_access_methods_req, kSmeConnectionAccessMethodsRequest);
diff --git a/tests/src/ship/ship_node/ship_node_test.cpp b/tests/src/ship/ship_node/ship_node_test.cpp
index ab2f7e2..1ee0af7 100644
--- a/tests/src/ship/ship_node/ship_node_test.cpp
+++ b/tests/src/ship/ship_node/ship_node_test.cpp
@@ -18,6 +18,7 @@
 #include <iostream>
 #include <memory>
 
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_device_info.h"
 #include "src/common/eebus_thread/eebus_thread.h"
 #include "src/ship/ship_connection/ship_connection.h"
@@ -32,11 +33,16 @@ ShipConnectionObject* ShipConnectionCreate(
     const char* remote_ski,
     const char* remote_ship_id
 ) {
+  UNUSED(info_provider);
+  UNUSED(role);
+  UNUSED(local_ship_id);
+  UNUSED(remote_ski);
+  UNUSED(remote_ship_id);
   // Connection will not be started within test
   return nullptr;
 }
 
-int main(int argc, char** argv) {
+int main() {
   std::cout << "ShipNode start-stop test\n";
 
   // Create the ship node
diff --git a/tests/src/spine/feature/write_approve_test_suite.cpp b/tests/src/spine/feature/write_approve_test_suite.cpp
index e2da485..9255812 100644
--- a/tests/src/spine/feature/write_approve_test_suite.cpp
+++ b/tests/src/spine/feature/write_approve_test_suite.cpp
@@ -16,6 +16,7 @@
 
 #include "tests/src/spine/feature/write_approve_test_suite.h"
 #include "src/common/api/eebus_timer_interface.h"
+#include "src/common/eebus_arguments.h"
 #include "src/spine/model/result_types.h"
 #include "tests/src/memory_leak.inc"
 
@@ -87,10 +88,10 @@ void WriteApproveTestSuite::TearDown() {
 
 Message WriteApproveTestSuite::CreateTestMessage(FunctionType data_type_id, uint64_t msg_counter) {
   // Create spine data with deleter
-  spine_data_ = std::unique_ptr<void, std::function<void(void*)>>{
+  spine_data_ = std::unique_ptr<void, std::function<void(void*)>>(
       ModelFunctionDataCreateEmpty(data_type_id),
       [data_type_id](void* p) -> void { ModelFunctionDataDelete(data_type_id, p); }
-  };
+  );
 
   // Create mock command with spine data
   cmd_mock_ = std::make_unique<CmdType>(CmdType{
@@ -145,7 +146,7 @@ void TryApproveWriteRequestBeforeTimeoutCallback(const Message* msg, void* ctx)
   EXPECT_EQ(VectorGetSize(&feature_local->pending_write_requests), 1);
 
   // Check remaining time for all pending write requests
-  for (int i = 0; i < VectorGetSize(&feature_local->pending_write_requests); ++i) {
+  for (size_t i = 0; i < VectorGetSize(&feature_local->pending_write_requests); ++i) {
     PendingWriteRequestObject* pwr
         = (PendingWriteRequestObject*)VectorGetElement(&feature_local->pending_write_requests, i);
     EXPECT_EQ(PENDING_WRITE_REQUEST_GET_REMAINING_TIME(pwr), 1);
@@ -166,7 +167,7 @@ void TryApproveWriteRequestAfterTimeoutCallback(const Message* msg, void* ctx) {
   MsgCounterType msg_cnt = *msg->request_header->msg_cnt;
 
   // Check that all pending write requests are not expired yet
-  for (int i = 0; i < VectorGetSize(&feature_local->pending_write_requests); ++i) {
+  for (size_t i = 0; i < VectorGetSize(&feature_local->pending_write_requests); ++i) {
     PendingWriteRequestObject* pwr
         = (PendingWriteRequestObject*)VectorGetElement(&feature_local->pending_write_requests, i);
     EXPECT_EQ(PENDING_WRITE_REQUEST_HAS_EXPIRED(pwr), false);
@@ -208,8 +209,6 @@ void DenyWriteRequestCallback(const Message* msg, void* ctx) {
 }
 
 void TryApproveShouldPass(const Message* msg, void* ctx) {
-  FeatureLocal* feature_local = FEATURE_LOCAL(ctx);
-
   const char* ski = DEVICE_REMOTE_GET_SKI(msg->device_remote);
 
   MsgCounterType msg_cnt = *msg->request_header->msg_cnt;
@@ -219,8 +218,6 @@ void TryApproveShouldPass(const Message* msg, void* ctx) {
 }
 
 void TryApproveShouldFail(const Message* msg, void* ctx) {
-  FeatureLocal* feature_local = FEATURE_LOCAL(ctx);
-
   const char* ski = DEVICE_REMOTE_GET_SKI(msg->device_remote);
 
   MsgCounterType msg_cnt = *msg->request_header->msg_cnt;
@@ -230,8 +227,6 @@ void TryApproveShouldFail(const Message* msg, void* ctx) {
 }
 
 void DenyShouldPass(const Message* msg, void* ctx) {
-  FeatureLocal* feature_local = FEATURE_LOCAL(ctx);
-
   const char* ski = DEVICE_REMOTE_GET_SKI(msg->device_remote);
 
   MsgCounterType msg_cnt = *msg->request_header->msg_cnt;
@@ -245,8 +240,6 @@ void DenyShouldPass(const Message* msg, void* ctx) {
 }
 
 void DenyShouldFail(const Message* msg, void* ctx) {
-  FeatureLocal* feature_local = FEATURE_LOCAL(ctx);
-
   const char* ski = DEVICE_REMOTE_GET_SKI(msg->device_remote);
 
   MsgCounterType msg_cnt = *msg->request_header->msg_cnt;
diff --git a/tests/src/spine/function/filter_test_data.cpp b/tests/src/spine/function/filter_test_data.cpp
index 931a86d..ba42dec 100644
--- a/tests/src/spine/function/filter_test_data.cpp
+++ b/tests/src/spine/function/filter_test_data.cpp
@@ -47,5 +47,5 @@ std::unique_ptr<FilterType, decltype(&FilterDelete)> FilterTestDataParse(const s
   }
 
   std::unique_ptr<FilterType, decltype(&FilterDelete)> filter{FilterParse(s_filter_delete.get()), FilterDelete};
-  return std::move(filter);
+  return filter;
 }
diff --git a/tests/src/spine/function/function_data_test_data.cpp b/tests/src/spine/function/function_data_test_data.cpp
index ca9572d..82203ac 100644
--- a/tests/src/spine/function/function_data_test_data.cpp
+++ b/tests/src/spine/function/function_data_test_data.cpp
@@ -58,10 +58,10 @@ std::unique_ptr<FunctionData, decltype(&FunctionDataDelete)> FunctionDataTestDat
   }
 
   FunctionDataParse(fd.get(), s_unformatted.get());
-  return std::move(fd);
+  return fd;
 }
 
 std::unique_ptr<char[], decltype(&JsonFree)> FunctionDataTestDataPrint(const FunctionData* fd) {
   std::unique_ptr<char[], decltype(&JsonFree)> s{FunctionDataPrintUnformatted(fd), JsonFree};
-  return std::move(s);
+  return s;
 }
diff --git a/tests/src/use_case/actor/cs/lpc/cs_lpc_test.cpp b/tests/src/use_case/actor/cs/lpc/cs_lpc_test.cpp
index 6d1777b..3ac8bd0 100644
--- a/tests/src/use_case/actor/cs/lpc/cs_lpc_test.cpp
+++ b/tests/src/use_case/actor/cs/lpc/cs_lpc_test.cpp
@@ -237,7 +237,7 @@ class CsLpcTestFixture : public UseCaseTestFixture {
 
     HandleMessage(receive::limits_write);
 
-    LoadLimit limit{0};
+    LoadLimit limit{{0}};
     EXPECT_EQ(CsLpcGetActiveConsumptionPowerLimit(use_case_.get(), &limit), kEebusErrorOk);
     EXPECT_THAT(&limit.value, ScaledValueEq(100, 0));
   }
@@ -246,7 +246,7 @@ class CsLpcTestFixture : public UseCaseTestFixture {
     ExpectSendMessage(send::result_data_msg_cnt_ref_21);
     HandleMessage(receive::negative_limits_write);
 
-    LoadLimit limit{0};
+    LoadLimit limit{{0}};
     EXPECT_EQ(CsLpcGetActiveConsumptionPowerLimit(use_case_.get(), &limit), kEebusErrorOk);
     EXPECT_THAT(&limit.value, ScaledValueEq(100, 0));
   }
diff --git a/tests/src/use_case/actor/cs/lpp/cs_lpp_test.cpp b/tests/src/use_case/actor/cs/lpp/cs_lpp_test.cpp
index 0970e84..b299ae8 100644
--- a/tests/src/use_case/actor/cs/lpp/cs_lpp_test.cpp
+++ b/tests/src/use_case/actor/cs/lpp/cs_lpp_test.cpp
@@ -237,7 +237,7 @@ class CsLppTestFixture : public UseCaseTestFixture {
 
     HandleMessage(receive::limits_write);
 
-    LoadLimit limit{0};
+    LoadLimit limit{{0}};
     EXPECT_EQ(CsLppGetActiveProductionPowerLimit(use_case_.get(), &limit), kEebusErrorOk);
     EXPECT_THAT(&limit.value, ScaledValueEq(100, 0));
   }
@@ -246,7 +246,7 @@ class CsLppTestFixture : public UseCaseTestFixture {
     ExpectSendMessage(send::result_data_msg_cnt_ref_21);
     HandleMessage(receive::negative_limits_write);
 
-    LoadLimit limit{0};
+    LoadLimit limit{{0}};
     EXPECT_EQ(CsLppGetActiveProductionPowerLimit(use_case_.get(), &limit), kEebusErrorOk);
     EXPECT_THAT(&limit.value, ScaledValueEq(100, 0));
   }
diff --git a/tests/src/use_case/actor/eg/lpc/eg_lpc_test.cpp b/tests/src/use_case/actor/eg/lpc/eg_lpc_test.cpp
index e96585b..3f29408 100644
--- a/tests/src/use_case/actor/eg/lpc/eg_lpc_test.cpp
+++ b/tests/src/use_case/actor/eg/lpc/eg_lpc_test.cpp
@@ -29,6 +29,7 @@
 #include "mocks/ship/ship_connection/data_writer_mock.h"
 #include "mocks/use_case/api/eg_lp_listener_mock.h"
 #include "src/common/array_util.h"
+#include "src/common/eebus_arguments.h"
 #include "src/common/eebus_malloc.h"
 #include "src/common/eebus_timer/eebus_timer.h"
 #include "src/common/message_buffer.h"
diff --git a/tests/src/use_case/use_case_test_fixture.cpp b/tests/src/use_case/use_case_test_fixture.cpp
index 75209e9..02dea44 100644
--- a/tests/src/use_case/use_case_test_fixture.cpp
+++ b/tests/src/use_case/use_case_test_fixture.cpp
@@ -19,6 +19,7 @@
 #include <iomanip>
 
 #include "src/common/array_util.h"
+#include "src/common/eebus_arguments.h"
 #include "src/spine/device/device_local.h"
 #include "src/spine/device/device_local_internal.h"
 #include "src/spine/entity/entity_local.h"
@@ -38,6 +39,7 @@ UseCaseTestFixture::UseCaseTestFixture(const char* type, const char* vendor, con
 }
 
 void LogMessage(const char* direction, const uint8_t* msg, size_t msg_size) {
+  UNUSED(msg_size);
   auto now  = std::chrono::system_clock::now();
   auto time = std::chrono::system_clock::to_time_t(now);
   auto ms   = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) % 1000;