diff --git a/src/test_utils.cc b/src/test_utils.cc
index 85afad9..6a4a63e 100644
--- a/src/test_utils.cc
+++ b/src/test_utils.cc
@@ -14,91 +14,91 @@ namespace pEp {
         namespace Utils {
 
             //Ident
-            pEpIdent wrap(::pEp_identity *const ident)
+            pEpIdent wrap(::pEp_identity *ident)
             {
                 assert(ident);
-                auto ret = pEpIdent(ident, [](::pEp_identity *) {});
+                auto ret = pEpIdent{ ident, [](::pEp_identity *) {} };
                 return ret;
             }
 
-            pEpIdent appropriate(::pEp_identity *const ident)
+            pEpIdent appropriate(::pEp_identity *ident)
             {
                 assert(ident);
-                auto ret = pEpIdent(ident, ::free_identity);
+                auto ret = pEpIdent{ ident, ::free_identity };
                 return ret;
             }
 
-            pEpIdent dup(const ::pEp_identity *const ident)
+            pEpIdent dup(const ::pEp_identity *ident)
             {
                 assert(ident);
-                auto ret = pEpIdent(::identity_dup(ident), ::free_identity);
+                auto ret = pEpIdent{ ::identity_dup(ident), ::free_identity };
                 return ret;
             }
 
-            pEpIdent kill(::pEp_identity *const ident)
+            pEpIdent kill(::pEp_identity *ident)
             {
                 assert(ident);
-                auto ret = pEpIdent(::identity_dup(ident), ::free_identity);
+                auto ret = pEpIdent{ ::identity_dup(ident), ::free_identity };
                 ::free_identity(ident);
                 return ret;
             }
 
             //IdentityList
-            pEpIdentList wrap(::identity_list *const ident)
+            pEpIdentList wrap(::identity_list *ident)
             {
                 assert(ident);
-                auto ret = pEpIdentList(ident, [](::identity_list *) {});
+                auto ret = pEpIdentList{ ident, [](::identity_list *) {} };
                 return ret;
             }
 
-            pEpIdentList appropriate(::identity_list *const ident)
+            pEpIdentList appropriate(::identity_list *ident)
             {
                 assert(ident);
-                auto ret = pEpIdentList(ident, ::free_identity_list);
+                auto ret = pEpIdentList{ ident, ::free_identity_list };
                 return ret;
             }
 
-            pEpIdentList dup(const ::identity_list *const ident)
+            pEpIdentList dup(const ::identity_list *ident)
             {
                 assert(ident);
-                auto ret = pEpIdentList(::identity_list_dup(ident), ::free_identity_list);
+                auto ret = pEpIdentList{ ::identity_list_dup(ident), ::free_identity_list };
                 return ret;
             }
 
-            pEpIdentList kill(::identity_list *const ident)
+            pEpIdentList kill(::identity_list *ident)
             {
                 assert(ident);
-                auto ret = pEpIdentList(::identity_list_dup(ident), ::free_identity_list);
+                auto ret = pEpIdentList{ ::identity_list_dup(ident), ::free_identity_list };
                 ::free_identity_list(ident);
                 return ret;
             }
 
             //Message
-            pEpMessage wrap(::message *const msg)
+            pEpMessage wrap(::message *msg)
             {
                 assert(msg);
-                auto ret = pEpMessage(msg, [](::message *) {});
+                auto ret = pEpMessage{ msg, [](::message *) {} };
                 return ret;
             }
 
-            pEpMessage appropriate(::message *const msg)
+            pEpMessage appropriate(::message *msg)
             {
                 assert(msg);
-                auto ret = pEpMessage(msg, ::free_message);
+                auto ret = pEpMessage{ msg, ::free_message };
                 return ret;
             }
 
-            pEpMessage dup(const ::message *const msg)
+            pEpMessage dup(const ::message *msg)
             {
                 assert(msg);
-                auto ret = pEpMessage(::message_dup(msg), ::free_message);
+                auto ret = pEpMessage{ ::message_dup(msg), ::free_message };
                 return ret;
             }
 
-            pEpMessage kill(::message *const msg)
+            pEpMessage kill(::message *msg)
             {
                 assert(msg);
-                auto ret = pEpMessage(::message_dup(msg), ::free_message);
+                auto ret = pEpMessage{ ::message_dup(msg), ::free_message };
                 ::free_message(msg);
                 return ret;
             }
@@ -122,11 +122,7 @@ namespace pEp {
             {
                 std::string name;
                 ::pEp_identity *ident = nullptr;
-                ident = ::new_identity(
-                    strdup(address.c_str()),
-                    "",
-                    "",
-                    ("partner " + address).c_str());
+                ident = ::new_identity(strdup(address.c_str()), "", "", ("partner " + address).c_str());
                 ident->me = false;
 
                 return appropriate(ident);
@@ -170,7 +166,7 @@ namespace pEp {
                 return createMessage(from, to_ident, longmsg);
             }
 
-            std::string mimeEncode(const pEpMessage msg)
+            std::string mimeEncode(pEpMessage msg)
             {
                 char *mimetext;
                 PEP_STATUS status = ::mime_encode_message(msg.get(), false, &mimetext, false);
@@ -193,7 +189,7 @@ namespace pEp {
                 return pEpMessage(msg, ::free_message);
             }
 
-            EncryptResult encryptMessage(const pEpMessage msg)
+            EncryptResult encryptMessage(pEpMessage msg)
             {
                 pEpMessage msg_out;
                 bool could_encrypt = false;
@@ -218,7 +214,7 @@ namespace pEp {
             }
 
 
-            DecryptResult decryptMessage(const pEpMessage msg, ::PEP_decrypt_flags_t *flags)
+            DecryptResult decryptMessage(pEpMessage msg, ::PEP_decrypt_flags_t *flags)
             {
                 pEpMessage msg_out;
                 bool was_encrypted = false;
@@ -244,13 +240,13 @@ namespace pEp {
                 return DecryptResult(msg_out, rating, kl, flags, was_encrypted);
             }
 
-            DecryptResult decryptMessage(const pEpMessage msg)
+            DecryptResult decryptMessage(pEpMessage msg)
             {
                 ::PEP_decrypt_flags_t dummy{ 0 };
                 return decryptMessage(msg, &dummy);
             }
 
-            EncryptResult encryptAndEncode(const pEpMessage msg)
+            EncryptResult encryptAndEncode(pEpMessage msg)
             {
                 EncryptResult ret = encryptMessage(msg);
                 std::string mime_text = mimeEncode(std::get<0>(ret));
diff --git a/src/test_utils.hh b/src/test_utils.hh
index a40aa9f..89af446 100644
--- a/src/test_utils.hh
+++ b/src/test_utils.hh
@@ -89,22 +89,22 @@ namespace pEp {
 
             // Datatypes
             //Ident
-            pEpIdent wrap(::pEp_identity *const ident);
-            pEpIdent appropriate(::pEp_identity *const ident);
-            pEpIdent dup(const ::pEp_identity *const ident);
-            pEpIdent kill(::pEp_identity *const ident);
+            pEpIdent wrap(::pEp_identity *ident);
+            pEpIdent appropriate(::pEp_identity *ident);
+            pEpIdent dup(const ::pEp_identity *ident);
+            pEpIdent kill(::pEp_identity *ident);
 
             //IdentityList
-            pEpIdentList wrap(::identity_list *const ident);
-            pEpIdentList appropriate(::identity_list *const ident);
-            pEpIdentList dup(const ::identity_list *const ident);
-            pEpIdentList kill(::identity_list *const ident);
+            pEpIdentList wrap(::identity_list *ident);
+            pEpIdentList appropriate(::identity_list *ident);
+            pEpIdentList dup(const ::identity_list *ident);
+            pEpIdentList kill(::identity_list *ident);
 
             //Message
-            pEpMessage wrap(::message *const msg);
-            pEpMessage appropriate(::message *const msg);
-            pEpMessage dup(const ::message *const msg);
-            pEpMessage kill(::message *const msg);
+            pEpMessage wrap(::message *msg);
+            pEpMessage appropriate(::message *msg);
+            pEpMessage dup(const ::message *msg);
+            pEpMessage kill(::message *msg);
 
             // helpers
             pEpIdent createOwnIdent(const std::string &address);
@@ -115,14 +115,14 @@ namespace pEp {
             pEpMessage createMessage(pEpIdent from, const std::string &to_addr, const std::string &longmsg);
 
 
-            std::string mimeEncode(const pEpMessage msg);
+            std::string mimeEncode(pEpMessage msg);
             pEpMessage mimeDecode(const std::string &mime_text);
 
-            EncryptResult encryptMessage(const pEpMessage msg);
-            DecryptResult decryptMessage(const pEpMessage msg, ::PEP_decrypt_flags_t *flags);
-            DecryptResult decryptMessage(const pEpMessage msg);
+            EncryptResult encryptMessage(pEpMessage msg);
+            DecryptResult decryptMessage(pEpMessage msg, ::PEP_decrypt_flags_t *flags);
+            DecryptResult decryptMessage(pEpMessage msg);
 
-            EncryptResult encryptAndEncode(const pEpMessage msg);
+            EncryptResult encryptAndEncode(pEpMessage msg);
             DecryptResult decryptAndDecode(const std::string &mime_data);
 
         } // namespace Utils