diff --git a/.clang-tidy b/.clang-tidy
index cf282ab5..b136b173 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -9,21 +9,28 @@ Checks:        "*,\
 -fuchsia-default-arguments,\
 -google-readability-todo,\
 -google-runtime-int,\
+-cppcoreguidelines-avoid-goto,\
 -cppcoreguidelines-pro-type-member-init,\
 -cppcoreguidelines-pro-type-static-cast-downcast,\
 # not applicable\
+-fuchsia-default-argument-calls,\
 -fuchsia-overloaded-operator,\
+-fuchsia-statically-constructed-objects,\
 # not currently a coding convention, C++11-specific, but conceivable,\
 -modernize-use-nullptr,\
 -modernize-use-equals-default,\
 -modernize-deprecated-headers,\
 # not currently a coding convention, C++11-specific and hard to implement,\
 -hicpp-no-malloc,\
+-hicpp-avoid-c-arrays,\
+-modernize-avoid-c-arrays,\
 -modernize-pass-by-value,\
 -modernize-loop-convert,\
 -modernize-use-auto,\
+-modernize-use-trailing-return-type,\
 -modernize-use-using,\
 -modernize-return-braced-init-list,\
+-cppcoreguidelines-avoid-c-arrays,\
 -cppcoreguidelines-no-malloc,\
 -cppcoreguidelines-owning-memory,\
 -cppcoreguidelines-pro-type-union-access,\
@@ -37,6 +44,7 @@ Checks:        "*,\
 # duplicates,\
 -google-readability-braces-around-statements,\
 -cppcoreguidelines-pro-type-cstyle-cast,\
+-cppcoreguidelines-avoid-magic-numbers,\
 -hicpp-braces-around-statements,\
 -hicpp-use-equals-default,\
 -hicpp-deprecated-headers,\
diff --git a/.travis.yml b/.travis.yml
index 1247fa0d..b33020e1 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -29,18 +29,18 @@ env:
 matrix:
   include:
   - if: type = cron OR (branch =~ analyze$ AND type = push)
-    env: BUILD_TYPE=cmake CLANG_TIDY=/usr/bin/clang-tidy-6.0 CC=clang-6.0 CXX=clang++-6.0
+    env: BUILD_TYPE=cmake CLANG_TIDY=/usr/bin/clang-tidy-8 CC=clang-8 CXX=clang++-8
     os: linux
     compiler: clang
     addons:
       apt:
         sources:
           - ubuntu-toolchain-r-test
-          - llvm-toolchain-trusty-6.0
+          - llvm-toolchain-trusty-8
         packages:
-          - clang-6.0
-          - clang-tools-6.0
-          - clang-tidy-6.0
+          - clang-8
+          - clang-tools-8
+          - clang-tidy-8
   - env: BUILD_TYPE=default CURVE=tweetnacl IPv6=ON
     os: linux
     dist: precise
@@ -107,15 +107,15 @@ matrix:
   - env: BUILD_TYPE=android CURVE=tweetnacl
     os: linux
     dist: trusty
-  - env: BUILD_TYPE=cmake DO_CLANG_FORMAT_CHECK=1 CLANG_FORMAT=/usr/lib/llvm-7/bin/clang-format
+  - env: BUILD_TYPE=cmake DO_CLANG_FORMAT_CHECK=1 CLANG_FORMAT=/usr/lib/llvm-8/bin/clang-format
     os: linux
     addons:
       apt:
         sources:
-        - llvm-toolchain-trusty-7
+        - llvm-toolchain-trusty-8
         - ubuntu-toolchain-r-test
         packages:
-        - clang-format-7
+        - clang-format-8
   - env: BUILD_TYPE=default POLLER=poll
     os: linux
   - env: BUILD_TYPE=default POLLER=select
diff --git a/builds/cmake/ci_build.sh b/builds/cmake/ci_build.sh
index c99e0ac6..009202ee 100755
--- a/builds/cmake/ci_build.sh
+++ b/builds/cmake/ci_build.sh
@@ -60,8 +60,8 @@ if [ -n "$CLANG_TIDY" ] ; then
         MAKE_PREFIXES+=("${TRAVIS_BUILD_DIR}/bw-output")
         
     fi
-    CMAKE_PREFIXES+=("scan-build-6.0")
-    MAKE_PREFIXES+=("scan-build-6.0")
+    CMAKE_PREFIXES+=("scan-build-8")
+    MAKE_PREFIXES+=("scan-build-8")
     MAKE_PREFIXES+=("-plist-html")
     SCAN_BUILD_OUTPUT="$(pwd)/scan-build-report"
     MAKE_PREFIXES+=("-o ${SCAN_BUILD_OUTPUT}")
diff --git a/src/ctx.cpp b/src/ctx.cpp
index 83627dbf..bd5f7f16 100644
--- a/src/ctx.cpp
+++ b/src/ctx.cpp
@@ -385,11 +385,11 @@ int zmq::ctx_t::get (int option_, void *optval_, size_t *optvallen_)
 
 int zmq::ctx_t::get (int option_)
 {
-    int optval_ = 0;
-    size_t optvallen_ = sizeof (int);
+    int optval = 0;
+    size_t optvallen = sizeof (int);
 
-    if (get (option_, &optval_, &optvallen_) == 0)
-        return optval_;
+    if (get (option_, &optval, &optvallen) == 0)
+        return optval;
 
     errno = EINVAL;
     return -1;
@@ -616,7 +616,9 @@ int zmq::thread_ctx_t::set (int option_, const void *optval_, size_t optvallen_)
     return -1;
 }
 
-int zmq::thread_ctx_t::get (int option_, void *optval_, size_t *optvallen_)
+int zmq::thread_ctx_t::get (int option_,
+                            void *optval_,
+                            const size_t *optvallen_)
 {
     const bool is_int = (*optvallen_ == sizeof (int));
     int *value = static_cast<int *> (optval_);
diff --git a/src/ctx.hpp b/src/ctx.hpp
index 9aef8434..bdc358b2 100644
--- a/src/ctx.hpp
+++ b/src/ctx.hpp
@@ -73,7 +73,7 @@ class thread_ctx_t
                        const char *name_ = NULL) const;
 
     int set (int option_, const void *optval_, size_t optvallen_);
-    int get (int option_, void *optval_, size_t *optvallen_);
+    int get (int option_, void *optval_, const size_t *optvallen_);
 
   protected:
     //  Synchronisation of access to context options.
diff --git a/src/curve_client.cpp b/src/curve_client.cpp
index 3d801b5e..1e5cf42d 100644
--- a/src/curve_client.cpp
+++ b/src/curve_client.cpp
@@ -128,8 +128,8 @@ zmq::mechanism_t::status_t zmq::curve_client_t::status () const
         return mechanism_t::ready;
     if (_state == error_received)
         return mechanism_t::error;
-    else
-        return mechanism_t::handshaking;
+
+    return mechanism_t::handshaking;
 }
 
 int zmq::curve_client_t::produce_hello (msg_t *msg_)
diff --git a/src/curve_client.hpp b/src/curve_client.hpp
index 2ad515f2..c786e764 100644
--- a/src/curve_client.hpp
+++ b/src/curve_client.hpp
@@ -72,10 +72,10 @@ class curve_client_t : public curve_mechanism_base_t
     curve_client_tools_t _tools;
 
     int produce_hello (msg_t *msg_);
-    int process_welcome (const uint8_t *cmd_data_, size_t data_size_);
+    int process_welcome (const uint8_t *msg_data_, size_t msg_size_);
     int produce_initiate (msg_t *msg_);
-    int process_ready (const uint8_t *cmd_data_, size_t data_size_);
-    int process_error (const uint8_t *cmd_data_, size_t data_size_);
+    int process_ready (const uint8_t *msg_data_, size_t msg_size_);
+    int process_error (const uint8_t *msg_data_, size_t msg_size_);
 };
 }
 
diff --git a/src/decoder_allocators.hpp b/src/decoder_allocators.hpp
index c9e51281..81ab1fab 100644
--- a/src/decoder_allocators.hpp
+++ b/src/decoder_allocators.hpp
@@ -103,7 +103,7 @@ class shared_message_memory_allocator
 
     void inc_ref ();
 
-    static void call_dec_ref (void *, void *buffer_);
+    static void call_dec_ref (void *, void *hint_);
 
     std::size_t size () const;
 
diff --git a/src/ip.cpp b/src/ip.cpp
index fe8912f2..4cefb9a9 100644
--- a/src/ip.cpp
+++ b/src/ip.cpp
@@ -255,9 +255,9 @@ int zmq::bind_to_device (fd_t s_, const std::string &bound_device_)
     if (rc != 0) {
         assert_success_or_recoverable (s_, rc);
         return -1;
-    } else {
-        return 0;
     }
+    return 0;
+
 #else
     LIBZMQ_UNUSED (s_);
     LIBZMQ_UNUSED (bound_device_);
@@ -550,10 +550,10 @@ int zmq::make_fdpair (fd_t *r_, fd_t *w_)
         errno_assert (errno == ENFILE || errno == EMFILE);
         *w_ = *r_ = -1;
         return -1;
-    } else {
-        *w_ = *r_ = fd;
-        return 0;
     }
+    *w_ = *r_ = fd;
+    return 0;
+
 
 #elif defined ZMQ_HAVE_WINDOWS
 #ifdef ZMQ_HAVE_IPC
diff --git a/src/options.cpp b/src/options.cpp
index 8d0041e8..19a800e1 100644
--- a/src/options.cpp
+++ b/src/options.cpp
@@ -85,7 +85,7 @@ int zmq::do_getsockopt (void *const optval_,
 
 #ifdef ZMQ_HAVE_CURVE
 static int do_getsockopt_curve_key (void *const optval_,
-                                    size_t *const optvallen_,
+                                    const size_t *const optvallen_,
                                     const uint8_t (&curve_key_)[CURVE_KEYSIZE])
 {
     if (*optvallen_ == CURVE_KEYSIZE) {
diff --git a/src/proxy.cpp b/src/proxy.cpp
index 6c2f0127..d2bb43c9 100644
--- a/src/proxy.cpp
+++ b/src/proxy.cpp
@@ -128,8 +128,8 @@ int forward (class zmq::socket_base_t *from_,
             if (rc < 0) {
                 if (likely (errno == EAGAIN && i > 0))
                     return 0; // End of burst
-                else
-                    return -1;
+
+                return -1;
             }
 
             complete_msg_size += msg_->size ();
diff --git a/src/radix_tree.cpp b/src/radix_tree.cpp
index 6876381a..1f2c029f 100644
--- a/src/radix_tree.cpp
+++ b/src/radix_tree.cpp
@@ -540,7 +540,7 @@ bool zmq::radix_tree_t::check (const unsigned char *key_, size_t key_size_)
 static void
 visit_keys (node_t node_,
             std::vector<unsigned char> &buffer_,
-            void (*func_) (unsigned char *data, size_t size, void *arg),
+            void (*func_) (unsigned char *data_, size_t size_, void *arg_),
             void *arg_)
 {
     for (size_t i = 0; i < node_.prefix_length (); ++i)
@@ -558,7 +558,7 @@ visit_keys (node_t node_,
 }
 
 void zmq::radix_tree_t::apply (
-  void (*func_) (unsigned char *data, size_t size, void *arg), void *arg_)
+  void (*func_) (unsigned char *data_, size_t size_, void *arg_), void *arg_)
 {
     if (_root.refcount () > 0)
         func_ (NULL, 0, arg_); // Root node is always empty.
diff --git a/src/radix_tree.hpp b/src/radix_tree.hpp
index eeb79f6d..ca84e692 100644
--- a/src/radix_tree.hpp
+++ b/src/radix_tree.hpp
@@ -78,7 +78,7 @@ struct node_t
     inline void set_refcount (uint32_t value_);
     inline void set_prefix_length (uint32_t value_);
     inline void set_edgecount (uint32_t value_);
-    inline void set_prefix (const unsigned char *prefix_);
+    inline void set_prefix (const unsigned char *bytes_);
     inline void set_first_bytes (const unsigned char *bytes_);
     inline void set_first_byte_at (size_t index_, unsigned char byte_);
     inline void set_node_pointers (const unsigned char *pointers_);
diff --git a/src/session_base.cpp b/src/session_base.cpp
index 325f8e69..90d540f5 100644
--- a/src/session_base.cpp
+++ b/src/session_base.cpp
@@ -118,7 +118,8 @@ zmq::session_base_t::session_base_t (class io_thread_t *io_thread_,
     _wss_hostname (NULL)
 {
     if (options_.wss_hostname.length () > 0) {
-        _wss_hostname = (char *) malloc (options_.wss_hostname.length () + 1);
+        _wss_hostname =
+          static_cast<char *> (malloc (options_.wss_hostname.length () + 1));
         assert (_wss_hostname);
         strcpy (_wss_hostname, options_.wss_hostname.c_str ());
     }
diff --git a/src/socket_base.cpp b/src/socket_base.cpp
index 983612e6..fd756218 100644
--- a/src/socket_base.cpp
+++ b/src/socket_base.cpp
@@ -1777,98 +1777,98 @@ int zmq::socket_base_t::monitor (const char *endpoint_,
 void zmq::socket_base_t::event_connected (
   const endpoint_uri_pair_t &endpoint_uri_pair_, zmq::fd_t fd_)
 {
-    uint64_t values[1] = {(uint64_t) fd_};
+    uint64_t values[1] = {static_cast<uint64_t> (fd_)};
     event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_CONNECTED);
 }
 
 void zmq::socket_base_t::event_connect_delayed (
   const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
     event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_CONNECT_DELAYED);
 }
 
 void zmq::socket_base_t::event_connect_retried (
   const endpoint_uri_pair_t &endpoint_uri_pair_, int interval_)
 {
-    uint64_t values[1] = {(uint64_t) interval_};
+    uint64_t values[1] = {static_cast<uint64_t> (interval_)};
     event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_CONNECT_RETRIED);
 }
 
 void zmq::socket_base_t::event_listening (
   const endpoint_uri_pair_t &endpoint_uri_pair_, zmq::fd_t fd_)
 {
-    uint64_t values[1] = {(uint64_t) fd_};
+    uint64_t values[1] = {static_cast<uint64_t> (fd_)};
     event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_LISTENING);
 }
 
 void zmq::socket_base_t::event_bind_failed (
   const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
     event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_BIND_FAILED);
 }
 
 void zmq::socket_base_t::event_accepted (
   const endpoint_uri_pair_t &endpoint_uri_pair_, zmq::fd_t fd_)
 {
-    uint64_t values[1] = {(uint64_t) fd_};
+    uint64_t values[1] = {static_cast<uint64_t> (fd_)};
     event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_ACCEPTED);
 }
 
 void zmq::socket_base_t::event_accept_failed (
   const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
     event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_ACCEPT_FAILED);
 }
 
 void zmq::socket_base_t::event_closed (
   const endpoint_uri_pair_t &endpoint_uri_pair_, zmq::fd_t fd_)
 {
-    uint64_t values[1] = {(uint64_t) fd_};
+    uint64_t values[1] = {static_cast<uint64_t> (fd_)};
     event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_CLOSED);
 }
 
 void zmq::socket_base_t::event_close_failed (
   const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
     event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_CLOSE_FAILED);
 }
 
 void zmq::socket_base_t::event_disconnected (
   const endpoint_uri_pair_t &endpoint_uri_pair_, zmq::fd_t fd_)
 {
-    uint64_t values[1] = {(uint64_t) fd_};
+    uint64_t values[1] = {static_cast<uint64_t> (fd_)};
     event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_DISCONNECTED);
 }
 
 void zmq::socket_base_t::event_handshake_failed_no_detail (
   const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
     event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_HANDSHAKE_FAILED_NO_DETAIL);
 }
 
 void zmq::socket_base_t::event_handshake_failed_protocol (
   const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
     event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_HANDSHAKE_FAILED_PROTOCOL);
 }
 
 void zmq::socket_base_t::event_handshake_failed_auth (
   const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
     event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_HANDSHAKE_FAILED_AUTH);
 }
 
 void zmq::socket_base_t::event_handshake_succeeded (
   const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
     event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_HANDSHAKE_SUCCEEDED);
 }
 
diff --git a/src/socket_poller.cpp b/src/socket_poller.cpp
index bf3c92ff..88361515 100644
--- a/src/socket_poller.cpp
+++ b/src/socket_poller.cpp
@@ -91,11 +91,10 @@ int zmq::socket_poller_t::signaler_fd (fd_t *fd_)
     if (_signaler) {
         *fd_ = _signaler->get_fd ();
         return 0;
-    } else {
-        // Only thread-safe socket types are guaranteed to have a signaler.
-        errno = EINVAL;
-        return -1;
     }
+    // Only thread-safe socket types are guaranteed to have a signaler.
+    errno = EINVAL;
+    return -1;
 }
 
 int zmq::socket_poller_t::add (socket_base_t *socket_,
diff --git a/src/socket_poller.hpp b/src/socket_poller.hpp
index c3ee4171..1100cae2 100644
--- a/src/socket_poller.hpp
+++ b/src/socket_poller.hpp
@@ -78,7 +78,7 @@ class socket_poller_t
     // Returns the signaler's fd if there is one, otherwise errors.
     int signaler_fd (fd_t *fd_);
 
-    int wait (event_t *event_, int n_events_, long timeout_);
+    int wait (event_t *events_, int n_events_, long timeout_);
 
     inline int size () { return static_cast<int> (_items.size ()); };
 
diff --git a/src/socks.cpp b/src/socks.cpp
index 963f0d3d..9da12be6 100644
--- a/src/socks.cpp
+++ b/src/socks.cpp
@@ -130,7 +130,7 @@ void zmq::socks_choice_decoder_t::reset ()
 
 
 zmq::socks_basic_auth_request_t::socks_basic_auth_request_t (
-  std::string username_, std::string password_) :
+  const std::string &username_, const std::string &password_) :
     username (username_),
     password (password_)
 {
@@ -306,7 +306,7 @@ void zmq::socks_request_encoder_t::reset ()
 }
 
 zmq::socks_response_t::socks_response_t (uint8_t response_code_,
-                                         std::string address_,
+                                         const std::string &address_,
                                          uint16_t port_) :
     response_code (response_code_),
     address (address_),
diff --git a/src/socks.hpp b/src/socks.hpp
index 9c86abda..bc3d5e2f 100644
--- a/src/socks.hpp
+++ b/src/socks.hpp
@@ -84,7 +84,8 @@ class socks_choice_decoder_t
 
 struct socks_basic_auth_request_t
 {
-    socks_basic_auth_request_t (std::string username_, std::string password_);
+    socks_basic_auth_request_t (const std::string &username_,
+                                const std::string &password_);
 
     const std::string username;
     const std::string password;
@@ -152,7 +153,7 @@ class socks_request_encoder_t
 struct socks_response_t
 {
     socks_response_t (uint8_t response_code_,
-                      std::string address_,
+                      const std::string &address_,
                       uint16_t port_);
     uint8_t response_code;
     std::string address;
diff --git a/src/socks_connecter.cpp b/src/socks_connecter.cpp
index 29766c06..2a426637 100644
--- a/src/socks_connecter.cpp
+++ b/src/socks_connecter.cpp
@@ -79,12 +79,12 @@ void zmq::socks_connecter_t::set_auth_method_none ()
     _auth_password.clear ();
 }
 
-void zmq::socks_connecter_t::set_auth_method_basic (const std::string username,
-                                                    const std::string password)
+void zmq::socks_connecter_t::set_auth_method_basic (
+  const std::string &username_, const std::string &password_)
 {
     _auth_method = socks_basic_auth;
-    _auth_username = username;
-    _auth_password = password;
+    _auth_username = username_;
+    _auth_password = password_;
 }
 
 void zmq::socks_connecter_t::in_event ()
@@ -387,8 +387,8 @@ zmq::fd_t zmq::socks_connecter_t::check_proxy_connection ()
     rc = tune_tcp_socket (_s);
     rc = rc
          | tune_tcp_keepalives (
-             _s, options.tcp_keepalive, options.tcp_keepalive_cnt,
-             options.tcp_keepalive_idle, options.tcp_keepalive_intvl);
+           _s, options.tcp_keepalive, options.tcp_keepalive_cnt,
+           options.tcp_keepalive_idle, options.tcp_keepalive_intvl);
     if (rc != 0)
         return -1;
 
diff --git a/src/socks_connecter.hpp b/src/socks_connecter.hpp
index e563bffd..70df596c 100644
--- a/src/socks_connecter.hpp
+++ b/src/socks_connecter.hpp
@@ -54,8 +54,8 @@ class socks_connecter_t : public stream_connecter_base_t
                        bool delayed_start_);
     ~socks_connecter_t ();
 
-    void set_auth_method_basic (const std::string username,
-                                const std::string password);
+    void set_auth_method_basic (const std::string &username,
+                                const std::string &password);
     void set_auth_method_none ();
 
 
diff --git a/src/stream_connecter_base.cpp b/src/stream_connecter_base.cpp
index 427063da..2b3891e0 100644
--- a/src/stream_connecter_base.cpp
+++ b/src/stream_connecter_base.cpp
@@ -169,7 +169,7 @@ void zmq::stream_connecter_base_t::in_event ()
 }
 
 void zmq::stream_connecter_base_t::create_engine (
-  fd_t fd, const std::string &local_address_)
+  fd_t fd_, const std::string &local_address_)
 {
     const endpoint_uri_pair_t endpoint_pair (local_address_, _endpoint,
                                              endpoint_type_connect);
@@ -177,9 +177,9 @@ void zmq::stream_connecter_base_t::create_engine (
     //  Create the engine object for this connection.
     i_engine *engine;
     if (options.raw_socket)
-        engine = new (std::nothrow) raw_engine_t (fd, options, endpoint_pair);
+        engine = new (std::nothrow) raw_engine_t (fd_, options, endpoint_pair);
     else
-        engine = new (std::nothrow) zmtp_engine_t (fd, options, endpoint_pair);
+        engine = new (std::nothrow) zmtp_engine_t (fd_, options, endpoint_pair);
     alloc_assert (engine);
 
     //  Attach the engine to the corresponding session object.
@@ -188,7 +188,7 @@ void zmq::stream_connecter_base_t::create_engine (
     //  Shut the connecter down.
     terminate ();
 
-    _socket->event_connected (endpoint_pair, fd);
+    _socket->event_connected (endpoint_pair, fd_);
 }
 
 void zmq::stream_connecter_base_t::timer_event (int id_)
diff --git a/src/stream_engine_base.cpp b/src/stream_engine_base.cpp
index 46a2fac4..f75968e3 100644
--- a/src/stream_engine_base.cpp
+++ b/src/stream_engine_base.cpp
@@ -465,14 +465,13 @@ int zmq::stream_engine_base_t::next_handshake_command (msg_t *msg_)
     if (_mechanism->status () == mechanism_t::error) {
         errno = EPROTO;
         return -1;
-    } else {
-        const int rc = _mechanism->next_handshake_command (msg_);
-
-        if (rc == 0)
-            msg_->set_flags (msg_t::command);
-
-        return rc;
     }
+    const int rc = _mechanism->next_handshake_command (msg_);
+
+    if (rc == 0)
+        msg_->set_flags (msg_t::command);
+
+    return rc;
 }
 
 int zmq::stream_engine_base_t::process_handshake_command (msg_t *msg_)
diff --git a/src/stream_listener_base.cpp b/src/stream_listener_base.cpp
index d2d7b837..ecd21be0 100644
--- a/src/stream_listener_base.cpp
+++ b/src/stream_listener_base.cpp
@@ -97,17 +97,17 @@ int zmq::stream_listener_base_t::close ()
     return 0;
 }
 
-void zmq::stream_listener_base_t::create_engine (fd_t fd)
+void zmq::stream_listener_base_t::create_engine (fd_t fd_)
 {
     const endpoint_uri_pair_t endpoint_pair (
-      get_socket_name (fd, socket_end_local),
-      get_socket_name (fd, socket_end_remote), endpoint_type_bind);
+      get_socket_name (fd_, socket_end_local),
+      get_socket_name (fd_, socket_end_remote), endpoint_type_bind);
 
     i_engine *engine;
     if (options.raw_socket)
-        engine = new (std::nothrow) raw_engine_t (fd, options, endpoint_pair);
+        engine = new (std::nothrow) raw_engine_t (fd_, options, endpoint_pair);
     else
-        engine = new (std::nothrow) zmtp_engine_t (fd, options, endpoint_pair);
+        engine = new (std::nothrow) zmtp_engine_t (fd_, options, endpoint_pair);
     alloc_assert (engine);
 
     //  Choose I/O thread to run connecter in. Given that we are already
@@ -123,5 +123,5 @@ void zmq::stream_listener_base_t::create_engine (fd_t fd)
     launch_child (session);
     send_attach (session, engine, false);
 
-    _socket->event_accepted (endpoint_pair, fd);
+    _socket->event_accepted (endpoint_pair, fd_);
 }
diff --git a/src/tcp_address.cpp b/src/tcp_address.cpp
index b1e23d87..23cfb69c 100644
--- a/src/tcp_address.cpp
+++ b/src/tcp_address.cpp
@@ -113,23 +113,23 @@ int zmq::tcp_address_t::resolve (const char *name_, bool local_, bool ipv6_)
 }
 
 template <size_t N1, size_t N2>
-static std::string make_address_string (const char *hbuf,
-                                        uint16_t port,
-                                        const char (&ipv6_prefix)[N1],
-                                        const char (&ipv6_suffix)[N2])
+static std::string make_address_string (const char *hbuf_,
+                                        uint16_t port_,
+                                        const char (&ipv6_prefix_)[N1],
+                                        const char (&ipv6_suffix_)[N2])
 {
     const size_t max_port_str_length = 5;
-    char buf[NI_MAXHOST + sizeof ipv6_prefix + sizeof ipv6_suffix
+    char buf[NI_MAXHOST + sizeof ipv6_prefix_ + sizeof ipv6_suffix_
              + max_port_str_length];
     char *pos = buf;
-    memcpy (pos, ipv6_prefix, sizeof ipv6_prefix - 1);
-    pos += sizeof ipv6_prefix - 1;
-    const size_t hbuf_len = strlen (hbuf);
-    memcpy (pos, hbuf, hbuf_len);
+    memcpy (pos, ipv6_prefix_, sizeof ipv6_prefix_ - 1);
+    pos += sizeof ipv6_prefix_ - 1;
+    const size_t hbuf_len = strlen (hbuf_);
+    memcpy (pos, hbuf_, hbuf_len);
     pos += hbuf_len;
-    memcpy (pos, ipv6_suffix, sizeof ipv6_suffix - 1);
-    pos += sizeof ipv6_suffix - 1;
-    pos += sprintf (pos, "%d", ntohs (port));
+    memcpy (pos, ipv6_suffix_, sizeof ipv6_suffix_ - 1);
+    pos += sizeof ipv6_suffix_ - 1;
+    pos += sprintf (pos, "%d", ntohs (port_));
     return std::string (buf, pos - buf);
 }
 
diff --git a/src/thread.cpp b/src/thread.cpp
index d5c3be10..ff1f0706 100644
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -277,10 +277,10 @@ bool zmq::thread_t::is_current_thread () const
 }
 
 void zmq::thread_t::setSchedulingParameters (
-  int priority_, int schedulingPolicy_, const std::set<int> &affinity_cpus_)
+  int priority_, int scheduling_policy_, const std::set<int> &affinity_cpus_)
 {
     _thread_priority = priority_;
-    _thread_sched_policy = schedulingPolicy_;
+    _thread_sched_policy = scheduling_policy_;
     _thread_affinity_cpus = affinity_cpus_;
 }
 
diff --git a/src/tipc_address.cpp b/src/tipc_address.cpp
index 2c27e2c4..758b6a56 100644
--- a/src/tipc_address.cpp
+++ b/src/tipc_address.cpp
@@ -44,13 +44,13 @@ zmq::tipc_address_t::tipc_address_t ()
     _random = false;
 }
 
-zmq::tipc_address_t::tipc_address_t (const sockaddr *sa, socklen_t sa_len)
+zmq::tipc_address_t::tipc_address_t (const sockaddr *sa_, socklen_t sa_len_)
 {
-    zmq_assert (sa && sa_len > 0);
+    zmq_assert (sa_ && sa_len_ > 0);
 
     memset (&address, 0, sizeof address);
-    if (sa->sa_family == AF_TIPC)
-        memcpy (&address, sa, sa_len);
+    if (sa_->sa_family == AF_TIPC)
+        memcpy (&address, sa_, sa_len_);
 
     _random = false;
 }
@@ -70,7 +70,7 @@ bool zmq::tipc_address_t::is_service () const
 
     return true;
 }
-int zmq::tipc_address_t::resolve (const char *name)
+int zmq::tipc_address_t::resolve (const char *name_)
 {
     unsigned int type = 0;
     unsigned int lower = 0;
@@ -82,7 +82,7 @@ int zmq::tipc_address_t::resolve (const char *name)
     int res;
 
 
-    if (strncmp (name, "<*>", 3) == 0) {
+    if (strncmp (name_, "<*>", 3) == 0) {
         set_random ();
         address.family = AF_TIPC;
         address.addrtype = TIPC_ADDR_ID;
@@ -92,9 +92,9 @@ int zmq::tipc_address_t::resolve (const char *name)
         return 0;
     }
 
-    res = sscanf (name, "{%u,%u,%u}", &type, &lower, &upper);
+    res = sscanf (name_, "{%u,%u,%u}", &type, &lower, &upper);
     /* Fetch optional domain suffix. */
-    if ((domain = strchr (name, '@'))) {
+    if ((domain = strchr (name_, '@'))) {
         if (sscanf (domain, "@%u.%u.%u%c", &z, &c, &n, &eof) != 3)
             return EINVAL;
     }
@@ -108,7 +108,8 @@ int zmq::tipc_address_t::resolve (const char *name)
         address.addr.nameseq.upper = upper;
         address.scope = TIPC_ZONE_SCOPE;
         return 0;
-    } else if (res == 2 && type > TIPC_RESERVED_TYPES) {
+    }
+    if (res == 2 && type > TIPC_RESERVED_TYPES) {
         address.family = AF_TIPC;
         address.addrtype = TIPC_ADDR_NAME;
         address.addr.name.name.type = type;
@@ -117,7 +118,7 @@ int zmq::tipc_address_t::resolve (const char *name)
         address.scope = 0;
         return 0;
     } else if (res == 0) {
-        res = sscanf (name, "<%u.%u.%u:%u>", &z, &c, &n, &ref);
+        res = sscanf (name_, "<%u.%u.%u:%u>", &z, &c, &n, &ref);
         if (res == 4) {
             address.family = AF_TIPC;
             address.addrtype = TIPC_ADDR_ID;
@@ -165,7 +166,7 @@ const sockaddr *zmq::tipc_address_t::addr () const
 
 socklen_t zmq::tipc_address_t::addrlen () const
 {
-    return (socklen_t) sizeof address;
+    return static_cast<socklen_t> (sizeof address);
 }
 
 #endif
diff --git a/src/tipc_connecter.cpp b/src/tipc_connecter.cpp
index 351c25e7..f27d4657 100644
--- a/src/tipc_connecter.cpp
+++ b/src/tipc_connecter.cpp
@@ -153,7 +153,8 @@ zmq::fd_t zmq::tipc_connecter_t::connect ()
 #else
     socklen_t len = sizeof (err);
 #endif
-    int rc = getsockopt (_s, SOL_SOCKET, SO_ERROR, (char *) &err, &len);
+    int rc = getsockopt (_s, SOL_SOCKET, SO_ERROR,
+                         reinterpret_cast<char *> (&err), &len);
     if (rc == -1)
         err = errno;
     if (err != 0) {
diff --git a/src/tipc_listener.cpp b/src/tipc_listener.cpp
index 476d4bdc..8453a1ec 100644
--- a/src/tipc_listener.cpp
+++ b/src/tipc_listener.cpp
@@ -111,7 +111,8 @@ int zmq::tipc_listener_t::set_local_address (const char *addr_)
         if (sl == 0)
             goto error;
 
-        _address = tipc_address_t ((struct sockaddr *) &ss, sl);
+        _address =
+          tipc_address_t (reinterpret_cast<struct sockaddr *> (&ss), sl);
     }
 
 
@@ -156,7 +157,8 @@ zmq::fd_t zmq::tipc_listener_t::accept ()
 #ifdef ZMQ_HAVE_VXWORKS
     fd_t sock = ::accept (_s, (struct sockaddr *) &ss, (int *) &ss_len);
 #else
-    fd_t sock = ::accept (_s, (struct sockaddr *) &ss, &ss_len);
+    fd_t sock =
+      ::accept (_s, reinterpret_cast<struct sockaddr *> (&ss), &ss_len);
 #endif
     if (sock == -1) {
         errno_assert (errno == EAGAIN || errno == EWOULDBLOCK
diff --git a/src/udp_address.hpp b/src/udp_address.hpp
index c32f7064..a2530d8f 100644
--- a/src/udp_address.hpp
+++ b/src/udp_address.hpp
@@ -47,7 +47,7 @@ class udp_address_t
     udp_address_t ();
     virtual ~udp_address_t ();
 
-    int resolve (const char *name_, bool receiver_, bool ipv6_);
+    int resolve (const char *name_, bool bind_, bool ipv6_);
 
     //  The opposite to resolve()
     virtual int to_string (std::string &addr_);
diff --git a/src/udp_engine.hpp b/src/udp_engine.hpp
index 6c969b16..db4c30c5 100644
--- a/src/udp_engine.hpp
+++ b/src/udp_engine.hpp
@@ -46,7 +46,7 @@ class udp_engine_t : public io_object_t, public i_engine
     const endpoint_uri_pair_t &get_endpoint () const;
 
   private:
-    int resolve_raw_address (char *addr_, size_t length_);
+    int resolve_raw_address (char *name_, size_t length_);
     void sockaddr_to_msg (zmq::msg_t *msg_, sockaddr_in *addr_);
 
     int set_udp_reuse_address (fd_t s_, bool on_);
diff --git a/src/ws_connecter.cpp b/src/ws_connecter.cpp
index 2bf456bc..ca189d63 100644
--- a/src/ws_connecter.cpp
+++ b/src/ws_connecter.cpp
@@ -270,7 +270,7 @@ bool zmq::ws_connecter_t::tune_socket (const fd_t fd_)
     return rc == 0;
 }
 
-void zmq::ws_connecter_t::create_engine (fd_t fd,
+void zmq::ws_connecter_t::create_engine (fd_t fd_,
                                          const std::string &local_address_)
 {
     const endpoint_uri_pair_t endpoint_pair (local_address_, _endpoint,
@@ -281,14 +281,14 @@ void zmq::ws_connecter_t::create_engine (fd_t fd,
     if (_wss)
 #ifdef ZMQ_HAVE_WSS
         engine = new (std::nothrow)
-          wss_engine_t (fd, options, endpoint_pair, *_addr->resolved.ws_addr,
+          wss_engine_t (fd_, options, endpoint_pair, *_addr->resolved.ws_addr,
                         true, NULL, _hostname);
 #else
         assert (false);
 #endif
     else
         engine = new (std::nothrow) ws_engine_t (
-          fd, options, endpoint_pair, *_addr->resolved.ws_addr, true);
+          fd_, options, endpoint_pair, *_addr->resolved.ws_addr, true);
     alloc_assert (engine);
 
     //  Attach the engine to the corresponding session object.
@@ -297,5 +297,5 @@ void zmq::ws_connecter_t::create_engine (fd_t fd,
     //  Shut the connecter down.
     terminate ();
 
-    _socket->event_connected (endpoint_pair, fd);
+    _socket->event_connected (endpoint_pair, fd_);
 }
diff --git a/src/ws_decoder.cpp b/src/ws_decoder.cpp
index cd44250d..91837263 100644
--- a/src/ws_decoder.cpp
+++ b/src/ws_decoder.cpp
@@ -69,7 +69,7 @@ int zmq::ws_decoder_t::opcode_ready (unsigned char const *)
     if (!final)
         return -1; // non final messages are not supported
 
-    _opcode = (zmq::ws_protocol_t::opcode_t) (_tmpbuf[0] & 0xF);
+    _opcode = static_cast<zmq::ws_protocol_t::opcode_t> (_tmpbuf[0] & 0xF);
 
     _msg_flags = 0;
 
@@ -101,7 +101,7 @@ int zmq::ws_decoder_t::size_first_byte_ready (unsigned char const *read_from_)
     if (is_masked != _must_mask) // wrong mask value
         return -1;
 
-    _size = (uint64_t) (_tmpbuf[0] & 0x7F);
+    _size = static_cast<uint64_t> (_tmpbuf[0] & 0x7F);
 
     if (_size < 126) {
         if (_must_mask)
@@ -260,7 +260,8 @@ int zmq::ws_decoder_t::message_ready (unsigned char const *)
     if (_must_mask) {
         int mask_index = _opcode == ws_protocol_t::opcode_binary ? 1 : 0;
 
-        unsigned char *data = (unsigned char *) _in_progress.data ();
+        unsigned char *data =
+          static_cast<unsigned char *> (_in_progress.data ());
         for (size_t i = 0; i < _size; ++i, mask_index++)
             data[i] = data[i] ^ _mask[mask_index % 4];
     }
diff --git a/src/ws_encoder.cpp b/src/ws_encoder.cpp
index 8744fbae..5a6f8852 100644
--- a/src/ws_encoder.cpp
+++ b/src/ws_encoder.cpp
@@ -63,11 +63,11 @@ void zmq::ws_encoder_t::message_ready ()
     size++; // TODO: check if binary
 
     if (size <= 125)
-        _tmp_buf[offset++] |= (unsigned char) (size & 127);
+        _tmp_buf[offset++] |= static_cast<unsigned char> (size & 127);
     else if (size <= 0xFFFF) {
         _tmp_buf[offset++] |= 126;
-        _tmp_buf[offset++] = (unsigned char) ((size >> 8) & 0xFF);
-        _tmp_buf[offset++] = (unsigned char) (size & 0xFF);
+        _tmp_buf[offset++] = static_cast<unsigned char> ((size >> 8) & 0xFF);
+        _tmp_buf[offset++] = static_cast<unsigned char> (size & 0xFF);
     } else {
         _tmp_buf[offset++] |= 127;
         put_uint64 (_tmp_buf + offset, size);
@@ -106,8 +106,10 @@ void zmq::ws_encoder_t::size_ready ()
         _masked_msg.init_size (size);
 
         int mask_index = 1; // TODO: check if binary message
-        unsigned char *dest = (unsigned char *) _masked_msg.data ();
-        unsigned char *src = (unsigned char *) in_progress ()->data ();
+        unsigned char *dest =
+          static_cast<unsigned char *> (_masked_msg.data ());
+        unsigned char *src =
+          static_cast<unsigned char *> (in_progress ()->data ());
         for (size_t i = 0; i < in_progress ()->size (); ++i, mask_index++)
             dest[i] = src[i] ^ _mask[mask_index % 4];
 
diff --git a/src/ws_engine.cpp b/src/ws_engine.cpp
index 20da9fe4..61ef778c 100644
--- a/src/ws_engine.cpp
+++ b/src/ws_engine.cpp
@@ -83,10 +83,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 
 static int
-encode_base64 (const unsigned char *in, int in_len, char *out, int out_len);
+encode_base64 (const unsigned char *in_, int in_len_, char *out_, int out_len_);
 
-static void compute_accept_key (char *key,
-                                unsigned char output[SHA_DIGEST_LENGTH]);
+static void compute_accept_key (char *key_,
+                                unsigned char hash_[SHA_DIGEST_LENGTH]);
 
 zmq::ws_engine_t::ws_engine_t (fd_t fd_,
                                const options_t &options_,
@@ -131,7 +131,7 @@ void zmq::ws_engine_t::start_ws_handshake ()
             assert (false);
 
         unsigned char nonce[16];
-        int *p = (int *) nonce;
+        int *p = reinterpret_cast<int *> (nonce);
 
         // The nonce doesn't have to be secure one, it is just use to avoid proxy cache
         *p = zmq::generate_random ();
@@ -143,16 +143,16 @@ void zmq::ws_engine_t::start_ws_handshake ()
           encode_base64 (nonce, 16, _websocket_key, MAX_HEADER_VALUE_LENGTH);
         assert (size > 0);
 
-        size = snprintf ((char *) _write_buffer, WS_BUFFER_SIZE,
-                         "GET %s HTTP/1.1\r\n"
-                         "Host: %s\r\n"
-                         "Upgrade: websocket\r\n"
-                         "Connection: Upgrade\r\n"
-                         "Sec-WebSocket-Key: %s\r\n"
-                         "Sec-WebSocket-Protocol: %s\r\n"
-                         "Sec-WebSocket-Version: 13\r\n\r\n",
-                         _address.path (), _address.host (), _websocket_key,
-                         protocol);
+        size = snprintf (
+          reinterpret_cast<char *> (_write_buffer), WS_BUFFER_SIZE,
+          "GET %s HTTP/1.1\r\n"
+          "Host: %s\r\n"
+          "Upgrade: websocket\r\n"
+          "Connection: Upgrade\r\n"
+          "Sec-WebSocket-Key: %s\r\n"
+          "Sec-WebSocket-Protocol: %s\r\n"
+          "Sec-WebSocket-Version: 13\r\n\r\n",
+          _address.path (), _address.host (), _websocket_key, protocol);
         assert (size > 0 && size < WS_BUFFER_SIZE);
         _outpos = _write_buffer;
         _outsize = size;
@@ -196,22 +196,23 @@ int zmq::ws_engine_t::process_routing_id_msg (msg_t *msg_)
     return 0;
 }
 
-bool zmq::ws_engine_t::select_protocol (char *protocol)
+bool zmq::ws_engine_t::select_protocol (char *protocol_)
 {
-    if (_options.mechanism == ZMQ_NULL && (strcmp ("ZWS2.0", protocol) == 0)) {
+    if (_options.mechanism == ZMQ_NULL && (strcmp ("ZWS2.0", protocol_) == 0)) {
         _next_msg = static_cast<int (stream_engine_base_t::*) (msg_t *)> (
           &ws_engine_t::routing_id_msg);
         _process_msg = static_cast<int (stream_engine_base_t::*) (msg_t *)> (
           &ws_engine_t::process_routing_id_msg);
         return true;
-    } else if (_options.mechanism == ZMQ_NULL
-               && strcmp ("ZWS2.0/NULL", protocol) == 0) {
+    }
+    if (_options.mechanism == ZMQ_NULL
+        && strcmp ("ZWS2.0/NULL", protocol_) == 0) {
         _mechanism = new (std::nothrow)
           null_mechanism_t (session (), _peer_address, _options);
         alloc_assert (_mechanism);
         return true;
     } else if (_options.mechanism == ZMQ_PLAIN
-               && strcmp ("ZWS2.0/PLAIN", protocol) == 0) {
+               && strcmp ("ZWS2.0/PLAIN", protocol_) == 0) {
         if (_options.as_server)
             _mechanism = new (std::nothrow)
               plain_server_t (session (), _peer_address, _options);
@@ -223,7 +224,7 @@ bool zmq::ws_engine_t::select_protocol (char *protocol)
     }
 #ifdef ZMQ_HAVE_CURVE
     else if (_options.mechanism == ZMQ_CURVE
-             && strcmp ("ZWS2.0/CURVE", protocol) == 0) {
+             && strcmp ("ZWS2.0/CURVE", protocol_) == 0) {
         if (_options.as_server)
             _mechanism = new (std::nothrow)
               curve_server_t (session (), _peer_address, _options);
@@ -278,7 +279,7 @@ bool zmq::ws_engine_t::server_handshake ()
     _insize = nbytes;
 
     while (_insize > 0) {
-        char c = (char) *_inpos;
+        char c = static_cast<char> (*_inpos);
 
         switch (_server_handshake_state) {
             case handshake_initial:
@@ -391,7 +392,7 @@ bool zmq::ws_engine_t::server_handshake ()
                         _server_handshake_state = handshake_error;
                         break;
                     default:
-                        _header_name[0] = (char) c;
+                        _header_name[0] = c;
                         _header_name_position = 1;
                         _server_handshake_state = header_field_name;
                         break;
@@ -493,7 +494,8 @@ bool zmq::ws_engine_t::server_handshake ()
                         _websocket_accept[accept_key_len] = '\0';
 
                         int written =
-                          snprintf ((char *) _write_buffer, WS_BUFFER_SIZE,
+                          snprintf (reinterpret_cast<char *> (_write_buffer),
+                                    WS_BUFFER_SIZE,
                                     "HTTP/1.1 101 Switching Protocols\r\n"
                                     "Upgrade: websocket\r\n"
                                     "Connection: Upgrade\r\n"
@@ -509,8 +511,8 @@ bool zmq::ws_engine_t::server_handshake ()
                         _insize--;
 
                         return true;
-                    } else
-                        _server_handshake_state = handshake_error;
+                    }
+                    _server_handshake_state = handshake_error;
                 } else
                     _server_handshake_state = handshake_error;
                 break;
@@ -547,7 +549,7 @@ bool zmq::ws_engine_t::client_handshake ()
     _insize = nbytes;
 
     while (_insize > 0) {
-        char c = (char) *_inpos;
+        char c = static_cast<char> (*_inpos);
 
         switch (_client_handshake_state) {
             case client_handshake_initial:
@@ -769,7 +771,7 @@ bool zmq::ws_engine_t::client_handshake ()
                         _client_handshake_state = client_handshake_error;
                         break;
                     default:
-                        _header_name[0] = (char) c;
+                        _header_name[0] = c;
                         _header_name_position = 1;
                         _client_handshake_state = client_header_field_name;
                         break;
@@ -852,8 +854,8 @@ bool zmq::ws_engine_t::client_handshake ()
                         _insize--;
 
                         return true;
-                    } else
-                        _client_handshake_state = client_handshake_error;
+                    }
+                    _client_handshake_state = client_handshake_error;
                 } else
                     _client_handshake_state = client_handshake_error;
                 break;
@@ -877,7 +879,7 @@ bool zmq::ws_engine_t::client_handshake ()
 }
 
 static int
-encode_base64 (const unsigned char *in, int in_len, char *out, int out_len)
+encode_base64 (const unsigned char *in_, int in_len_, char *out_, int out_len_)
 {
     static const unsigned char base64enc_tab[65] =
       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -886,36 +888,36 @@ encode_base64 (const unsigned char *in, int in_len, char *out, int out_len)
     uint32_t v;
     int rem;
 
-    for (io = 0, ii = 0, v = 0, rem = 0; ii < in_len; ii++) {
+    for (io = 0, ii = 0, v = 0, rem = 0; ii < in_len_; ii++) {
         unsigned char ch;
-        ch = in[ii];
+        ch = in_[ii];
         v = (v << 8) | ch;
         rem += 8;
         while (rem >= 6) {
             rem -= 6;
-            if (io >= out_len)
+            if (io >= out_len_)
                 return -1; /* truncation is failure */
-            out[io++] = base64enc_tab[(v >> rem) & 63];
+            out_[io++] = base64enc_tab[(v >> rem) & 63];
         }
     }
     if (rem) {
         v <<= (6 - rem);
-        if (io >= out_len)
+        if (io >= out_len_)
             return -1; /* truncation is failure */
-        out[io++] = base64enc_tab[v & 63];
+        out_[io++] = base64enc_tab[v & 63];
     }
     while (io & 3) {
-        if (io >= out_len)
+        if (io >= out_len_)
             return -1; /* truncation is failure */
-        out[io++] = '=';
+        out_[io++] = '=';
     }
-    if (io >= out_len)
+    if (io >= out_len_)
         return -1; /* no room for null terminator */
-    out[io] = 0;
+    out_[io] = 0;
     return io;
 }
 
-static void compute_accept_key (char *key, unsigned char *hash)
+static void compute_accept_key (char *key_, unsigned char *hash_)
 {
     const char *magic_string = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 #ifdef ZMQ_USE_NSS
@@ -925,24 +927,24 @@ static void compute_accept_key (char *key, unsigned char *hash)
     assert (ctx);
 
     HASH_Begin (ctx);
-    HASH_Update (ctx, (unsigned char *) key, (unsigned int) strlen (key));
+    HASH_Update (ctx, (unsigned char *) key_, (unsigned int) strlen (key_));
     HASH_Update (ctx, (unsigned char *) magic_string,
                  (unsigned int) strlen (magic_string));
-    HASH_End (ctx, hash, &len, SHA_DIGEST_LENGTH);
+    HASH_End (ctx, hash_, &len, SHA_DIGEST_LENGTH);
     HASH_Destroy (ctx);
 #elif defined ZMQ_USE_BUILTIN_SHA1
     sha1_ctxt ctx;
     SHA1_Init (&ctx);
-    SHA1_Update (&ctx, (unsigned char *) key, strlen (key));
+    SHA1_Update (&ctx, (unsigned char *) key_, strlen (key_));
     SHA1_Update (&ctx, (unsigned char *) magic_string, strlen (magic_string));
 
-    SHA1_Final (hash, &ctx);
+    SHA1_Final (hash_, &ctx);
 #elif defined ZMQ_USE_GNUTLS
     gnutls_hash_hd_t hd;
     gnutls_hash_init (&hd, GNUTLS_DIG_SHA1);
-    gnutls_hash (hd, key, strlen (key));
+    gnutls_hash (hd, key_, strlen (key_));
     gnutls_hash (hd, magic_string, strlen (magic_string));
-    gnutls_hash_deinit (hd, hash);
+    gnutls_hash_deinit (hd, hash_);
 #else
 #error "No sha1 implementation set"
 #endif
diff --git a/src/ws_listener.cpp b/src/ws_listener.cpp
index b9582863..d86e49e1 100644
--- a/src/ws_listener.cpp
+++ b/src/ws_listener.cpp
@@ -126,8 +126,8 @@ std::string zmq::ws_listener_t::get_socket_name (zmq::fd_t fd_,
 {
     if (_wss)
         return zmq::get_socket_name<wss_address_t> (fd_, socket_end_);
-    else
-        return zmq::get_socket_name<ws_address_t> (fd_, socket_end_);
+
+    return zmq::get_socket_name<ws_address_t> (fd_, socket_end_);
 }
 
 int zmq::ws_listener_t::create_socket (const char *addr_)
@@ -285,23 +285,23 @@ zmq::fd_t zmq::ws_listener_t::accept ()
     return sock;
 }
 
-void zmq::ws_listener_t::create_engine (fd_t fd)
+void zmq::ws_listener_t::create_engine (fd_t fd_)
 {
     const endpoint_uri_pair_t endpoint_pair (
-      get_socket_name (fd, socket_end_local),
-      get_socket_name (fd, socket_end_remote), endpoint_type_bind);
+      get_socket_name (fd_, socket_end_local),
+      get_socket_name (fd_, socket_end_remote), endpoint_type_bind);
 
     i_engine *engine = NULL;
     if (_wss)
 #ifdef ZMQ_HAVE_WSS
         engine = new (std::nothrow) wss_engine_t (
-          fd, options, endpoint_pair, _address, false, _tls_cred, NULL);
+          fd_, options, endpoint_pair, _address, false, _tls_cred, NULL);
 #else
         assert (false);
 #endif
     else
         engine = new (std::nothrow)
-          ws_engine_t (fd, options, endpoint_pair, _address, false);
+          ws_engine_t (fd_, options, endpoint_pair, _address, false);
     alloc_assert (engine);
 
     //  Choose I/O thread to run connecter in. Given that we are already
@@ -317,5 +317,5 @@ void zmq::ws_listener_t::create_engine (fd_t fd)
     launch_child (session);
     send_attach (session, engine, false);
 
-    _socket->event_accepted (endpoint_pair, fd);
+    _socket->event_accepted (endpoint_pair, fd_);
 }
diff --git a/src/xpub.hpp b/src/xpub.hpp
index b6796dd3..c0abed6e 100644
--- a/src/xpub.hpp
+++ b/src/xpub.hpp
@@ -71,7 +71,7 @@ class xpub_t : public socket_base_t
                                      xpub_t *self_);
 
     //  Function to be applied to each matching pipes.
-    static void mark_as_matching (zmq::pipe_t *pipe_, xpub_t *arg_);
+    static void mark_as_matching (zmq::pipe_t *pipe_, xpub_t *self_);
 
     //  List of all subscriptions mapped to corresponding pipes.
     mtrie_t _subscriptions;
@@ -115,7 +115,7 @@ class xpub_t : public socket_base_t
     bool _send_last_pipe;
 
     //  Function to be applied to match the last pipe.
-    static void mark_last_pipe_as_matching (zmq::pipe_t *pipe_, xpub_t *arg_);
+    static void mark_last_pipe_as_matching (zmq::pipe_t *pipe_, xpub_t *self_);
 
     //  Last pipe that sent subscription message, only used if xpub is on manual
     pipe_t *_last_pipe;
diff --git a/src/xsub.cpp b/src/xsub.cpp
index 8f9aa1c6..dee9b7a5 100644
--- a/src/xsub.cpp
+++ b/src/xsub.cpp
@@ -109,10 +109,9 @@ int zmq::xsub_t::xsetsockopt (int option_,
         }
         _only_first_subscribe = (*static_cast<const int *> (optval_) != 0);
         return 0;
-    } else {
-        errno = EINVAL;
-        return -1;
     }
+    errno = EINVAL;
+    return -1;
 }
 
 int zmq::xsub_t::xsend (msg_t *msg_)
diff --git a/src/zap_client.cpp b/src/zap_client.cpp
index 2e17dd3c..7ba28c91 100644
--- a/src/zap_client.cpp
+++ b/src/zap_client.cpp
@@ -274,8 +274,8 @@ zmq::mechanism_t::status_t zap_client_common_handshake_t::status () const
         return mechanism_t::ready;
     if (state == error_sent)
         return mechanism_t::error;
-    else
-        return mechanism_t::handshaking;
+
+    return mechanism_t::handshaking;
 }
 
 int zap_client_common_handshake_t::zap_msg_available ()
diff --git a/src/zmq.cpp b/src/zmq.cpp
index 380cf1e3..a33813d5 100644
--- a/src/zmq.cpp
+++ b/src/zmq.cpp
@@ -194,10 +194,10 @@ int zmq_ctx_set_ext (void *ctx_,
 
 int zmq_ctx_get (void *ctx_, int option_)
 {
-    int optval_ = 0;
-    size_t optvallen_ = sizeof (int);
-    if (zmq_ctx_get_ext (ctx_, option_, &optval_, &optvallen_) == 0) {
-        return optval_;
+    int optval = 0;
+    size_t optvallen = sizeof (int);
+    if (zmq_ctx_get_ext (ctx_, option_, &optval, &optvallen) == 0) {
+        return optval;
     }
 
     errno = EFAULT;
@@ -1305,9 +1305,8 @@ int zmq_poller_fd (void *poller_, zmq_fd_t *fd_)
         || !(static_cast<zmq::socket_poller_t *> (poller_)->check_tag ())) {
         errno = EFAULT;
         return -1;
-    } else {
-        return static_cast<zmq::socket_poller_t *> (poller_)->signaler_fd (fd_);
     }
+    return static_cast<zmq::socket_poller_t *> (poller_)->signaler_fd (fd_);
 }
 
 //  Peer-specific state
diff --git a/src/zmtp_engine.cpp b/src/zmtp_engine.cpp
index 43221327..7892038e 100644
--- a/src/zmtp_engine.cpp
+++ b/src/zmtp_engine.cpp
@@ -229,14 +229,14 @@ void zmq::zmtp_engine_t::receive_greeting_versioned ()
 }
 
 zmq::zmtp_engine_t::handshake_fun_t
-zmq::zmtp_engine_t::select_handshake_fun (bool unversioned,
-                                          unsigned char revision)
+zmq::zmtp_engine_t::select_handshake_fun (bool unversioned_,
+                                          unsigned char revision_)
 {
     //  Is the peer using ZMTP/1.0 with no revision number?
-    if (unversioned) {
+    if (unversioned_) {
         return &zmtp_engine_t::handshake_v1_0_unversioned;
     }
-    switch (revision) {
+    switch (revision_) {
         case ZMTP_1_0:
             return &zmtp_engine_t::handshake_v1_0;
         case ZMTP_2_0:
diff --git a/tests/test_app_meta.cpp b/tests/test_app_meta.cpp
index 2a53f914..83ef6761 100644
--- a/tests/test_app_meta.cpp
+++ b/tests/test_app_meta.cpp
@@ -109,7 +109,7 @@ void test_app_meta_reqrep ()
     rc = zmq_msg_init_size (&msg, 1);
     TEST_ASSERT_EQUAL_INT (0, rc);
 
-    char *data = (char *) zmq_msg_data (&msg);
+    char *data = static_cast<char *> (zmq_msg_data (&msg));
     data[0] = 1;
 
     rc = zmq_msg_send (&msg, req_sock, 0);
@@ -123,7 +123,7 @@ void test_app_meta_reqrep ()
 
     TEST_ASSERT_EQUAL_STRING ("hello", zmq_msg_gets (&msg, "X-hello"));
     TEST_ASSERT_EQUAL_STRING ("primary", zmq_msg_gets (&msg, "X-connection"));
-    char *bindata = (char *) zmq_msg_gets (&msg, "X-bin");
+    char *bindata = const_cast<char *> (zmq_msg_gets (&msg, "X-bin"));
     TEST_ASSERT_NOT_NULL (bindata);
     uint8_t rawdata[4];
     void *ret = zmq_z85_decode (rawdata, bindata);
diff --git a/tests/test_client_server.cpp b/tests/test_client_server.cpp
index 39f75332..c74883d8 100644
--- a/tests/test_client_server.cpp
+++ b/tests/test_client_server.cpp
@@ -97,7 +97,7 @@ void test_routing_id ()
         zmq_msg_t msg;
         TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init_size (&msg, 1));
 
-        char *data = (char *) zmq_msg_data (&msg);
+        char *data = static_cast<char *> (zmq_msg_data (&msg));
         data[0] = 2;
 
         TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_set_routing_id (&msg, routing_id));
diff --git a/tests/test_ctx_destroy.cpp b/tests/test_ctx_destroy.cpp
index d64948a1..87f71577 100644
--- a/tests/test_ctx_destroy.cpp
+++ b/tests/test_ctx_destroy.cpp
@@ -124,7 +124,7 @@ struct poller_test_data_t
 void run_poller (void *data_)
 {
     struct poller_test_data_t *poller_test_data =
-      (struct poller_test_data_t *) data_;
+      static_cast<struct poller_test_data_t *> (data_);
 
     void *socket =
       zmq_socket (poller_test_data->ctx, poller_test_data->socket_type);
diff --git a/tests/test_disconnect_inproc.cpp b/tests/test_disconnect_inproc.cpp
index 401a18d7..5a941daa 100644
--- a/tests/test_disconnect_inproc.cpp
+++ b/tests/test_disconnect_inproc.cpp
@@ -68,7 +68,7 @@ void test_disconnect_inproc ()
                 zmq_msg_t msg;
                 zmq_msg_init (&msg);
                 TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&msg, pub_socket, 0));
-                char *buffer = (char *) zmq_msg_data (&msg);
+                char *buffer = static_cast<char *> (zmq_msg_data (&msg));
 
                 if (buffer[0] == 0) {
                     TEST_ASSERT_TRUE (isSubscribed);
diff --git a/tests/test_heartbeats.cpp b/tests/test_heartbeats.cpp
index 2f05e8a7..f422ff19 100644
--- a/tests/test_heartbeats.cpp
+++ b/tests/test_heartbeats.cpp
@@ -60,8 +60,8 @@ static int get_monitor_event (void *monitor_)
         }
         TEST_ASSERT_TRUE (zmq_msg_more (&msg));
 
-        uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
-        uint16_t event = *(uint16_t *) (data);
+        uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
+        uint16_t event = *reinterpret_cast<uint16_t *> (data);
 
         //  Second frame in message contains event address
         TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&msg));
diff --git a/tests/test_hwm_pubsub.cpp b/tests/test_hwm_pubsub.cpp
index a7d00579..b85e6dc6 100644
--- a/tests/test_hwm_pubsub.cpp
+++ b/tests/test_hwm_pubsub.cpp
@@ -38,13 +38,13 @@
 
 SETUP_TEARDOWN_TESTCONTEXT
 
-int test_defaults (int send_hwm_, int msg_cnt_, const char *endpoint)
+int test_defaults (int send_hwm_, int msg_cnt_, const char *endpoint_)
 {
     char pub_endpoint[SOCKET_STRING_LEN];
 
     // Set up and bind XPUB socket
     void *pub_socket = test_context_socket (ZMQ_XPUB);
-    test_bind (pub_socket, endpoint, pub_endpoint, sizeof pub_endpoint);
+    test_bind (pub_socket, endpoint_, pub_endpoint, sizeof pub_endpoint);
 
     // Set up and connect SUB socket
     void *sub_socket = test_context_socket (ZMQ_SUB);
@@ -86,10 +86,10 @@ int test_defaults (int send_hwm_, int msg_cnt_, const char *endpoint)
     return recv_count;
 }
 
-int receive (void *socket_, int *is_termination)
+int receive (void *socket_, int *is_termination_)
 {
     int recv_count = 0;
-    *is_termination = 0;
+    *is_termination_ = 0;
 
     // Now receive all sent messages
     char buffer[255];
@@ -98,7 +98,7 @@ int receive (void *socket_, int *is_termination)
         ++recv_count;
 
         if (len == 3 && strncmp (buffer, "end", len) == 0) {
-            *is_termination = 1;
+            *is_termination_ = 1;
             return recv_count;
         }
     }
@@ -106,13 +106,13 @@ int receive (void *socket_, int *is_termination)
     return recv_count;
 }
 
-int test_blocking (int send_hwm_, int msg_cnt_, const char *endpoint)
+int test_blocking (int send_hwm_, int msg_cnt_, const char *endpoint_)
 {
     char pub_endpoint[SOCKET_STRING_LEN];
 
     // Set up bind socket
     void *pub_socket = test_context_socket (ZMQ_XPUB);
-    test_bind (pub_socket, endpoint, pub_endpoint, sizeof pub_endpoint);
+    test_bind (pub_socket, endpoint_, pub_endpoint, sizeof pub_endpoint);
 
     // Set up connect socket
     void *sub_socket = test_context_socket (ZMQ_SUB);
diff --git a/tests/test_inproc_connect.cpp b/tests/test_inproc_connect.cpp
index 5f903b2f..de1923fb 100644
--- a/tests/test_inproc_connect.cpp
+++ b/tests/test_inproc_connect.cpp
@@ -236,10 +236,8 @@ void test_simultaneous_connect_bind_threads ()
 
     // Spawn all threads as simultaneously as possible
     for (unsigned int i = 0; i < no_of_times; ++i) {
-        threads[i * 2 + 0] =
-          zmq_threadstart (&simult_conn, (void *) thr_args[i]);
-        threads[i * 2 + 1] =
-          zmq_threadstart (&simult_bind, (void *) thr_args[i]);
+        threads[i * 2 + 0] = zmq_threadstart (&simult_conn, thr_args[i]);
+        threads[i * 2 + 1] = zmq_threadstart (&simult_bind, thr_args[i]);
     }
 
     // Close all threads
diff --git a/tests/test_mock_pub_sub.cpp b/tests/test_mock_pub_sub.cpp
index cac5d50a..2977a9b2 100644
--- a/tests/test_mock_pub_sub.cpp
+++ b/tests/test_mock_pub_sub.cpp
@@ -52,8 +52,8 @@ static int get_monitor_event (void *monitor_)
         }
         TEST_ASSERT_TRUE (zmq_msg_more (&msg));
 
-        uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
-        uint16_t event = *(uint16_t *) (data);
+        uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
+        uint16_t event = *reinterpret_cast<uint16_t *> (data);
 
         //  Second frame in message contains event address
         TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&msg));
@@ -136,7 +136,7 @@ static void prep_server_socket (void **server_out_,
     *mon_out_ = server_mon;
 }
 
-static void test_mock_sub (bool sub_command)
+static void test_mock_sub (bool sub_command_)
 {
     int rc;
     char my_endpoint[MAX_SOCKET_STRING];
@@ -167,7 +167,7 @@ static void test_mock_sub (bool sub_command)
     rc = get_monitor_event (server_mon);
     TEST_ASSERT_EQUAL_INT (ZMQ_EVENT_ACCEPTED, rc);
 
-    if (sub_command) {
+    if (sub_command_) {
         const uint8_t sub[13] = {4,   11,  9,   'S', 'U', 'B', 'S',
                                  'C', 'R', 'I', 'B', 'E', 'A'};
         rc =
diff --git a/tests/test_monitor.cpp b/tests/test_monitor.cpp
index 8d9881a9..82433d7a 100644
--- a/tests/test_monitor.cpp
+++ b/tests/test_monitor.cpp
@@ -196,12 +196,12 @@ void test_monitor_versioned_basic (bind_function_t bind_function_,
     //  Now do a basic ping test
     bind_function_ (server, server_endpoint, sizeof server_endpoint);
 
-    int ipv6_;
-    size_t ipv6_size_ = sizeof (ipv6_);
+    int ipv6;
+    size_t ipv6_size = sizeof (ipv6);
     TEST_ASSERT_SUCCESS_ERRNO (
-      zmq_getsockopt (server, ZMQ_IPV6, &ipv6_, &ipv6_size_));
+      zmq_getsockopt (server, ZMQ_IPV6, &ipv6, &ipv6_size));
     TEST_ASSERT_SUCCESS_ERRNO (
-      zmq_setsockopt (client, ZMQ_IPV6, &ipv6_, sizeof (int)));
+      zmq_setsockopt (client, ZMQ_IPV6, &ipv6, sizeof (int)));
     TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (client, server_endpoint));
     bounce (server, client);
 
@@ -327,14 +327,14 @@ void test_monitor_versioned_stats (bind_function_t bind_function_,
       push, ZMQ_SNDBUF, &tcp_buffer_size, sizeof (tcp_buffer_size)));
     bind_function_ (push, server_endpoint, sizeof (server_endpoint));
 
-    int ipv6_;
-    size_t ipv6_size_ = sizeof (ipv6_);
+    int ipv6;
+    size_t ipv6_size = sizeof (ipv6);
     TEST_ASSERT_SUCCESS_ERRNO (
-      zmq_getsockopt (push, ZMQ_IPV6, &ipv6_, &ipv6_size_));
+      zmq_getsockopt (push, ZMQ_IPV6, &ipv6, &ipv6_size));
     for (int i = 0; i < pulls_count; ++i) {
         pulls[i] = test_context_socket (ZMQ_PULL);
         TEST_ASSERT_SUCCESS_ERRNO (
-          zmq_setsockopt (pulls[i], ZMQ_IPV6, &ipv6_, sizeof (int)));
+          zmq_setsockopt (pulls[i], ZMQ_IPV6, &ipv6, sizeof (int)));
         int timeout_ms = 10;
         TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (
           pulls[i], ZMQ_RCVTIMEO, &timeout_ms, sizeof (timeout_ms)));
diff --git a/tests/test_proxy.cpp b/tests/test_proxy.cpp
index 3c63e20b..e9d0eda0 100644
--- a/tests/test_proxy.cpp
+++ b/tests/test_proxy.cpp
@@ -80,7 +80,7 @@ void *g_workers_pkts_out = NULL;
 
 static void client_task (void *db_)
 {
-    struct thread_data *databag = (struct thread_data *) db_;
+    struct thread_data *databag = static_cast<struct thread_data *> (db_);
     // Endpoint socket gets random port to avoid test failing when port in use
     void *endpoint = zmq_socket (get_test_context (), ZMQ_PAIR);
     TEST_ASSERT_NOT_NULL (endpoint);
@@ -373,16 +373,16 @@ void check_proxy_stats (void *control_proxy_)
     if (is_verbose) {
         printf (
           "frontend: pkts_in=%lu bytes_in=%lu  pkts_out=%lu bytes_out=%lu\n",
-          (unsigned long int) total_stats.frontend.msg_in,
-          (unsigned long int) total_stats.frontend.bytes_in,
-          (unsigned long int) total_stats.frontend.msg_out,
-          (unsigned long int) total_stats.frontend.bytes_out);
+          static_cast<unsigned long int> (total_stats.frontend.msg_in),
+          static_cast<unsigned long int> (total_stats.frontend.bytes_in),
+          static_cast<unsigned long int> (total_stats.frontend.msg_out),
+          static_cast<unsigned long int> (total_stats.frontend.bytes_out));
         printf (
           "backend: pkts_in=%lu bytes_in=%lu  pkts_out=%lu bytes_out=%lu\n",
-          (unsigned long int) total_stats.backend.msg_in,
-          (unsigned long int) total_stats.backend.bytes_in,
-          (unsigned long int) total_stats.backend.msg_out,
-          (unsigned long int) total_stats.backend.bytes_out);
+          static_cast<unsigned long int> (total_stats.backend.msg_in),
+          static_cast<unsigned long int> (total_stats.backend.bytes_in),
+          static_cast<unsigned long int> (total_stats.backend.msg_out),
+          static_cast<unsigned long int> (total_stats.backend.bytes_out));
 
         printf ("clients sent out %d requests\n",
                 zmq_atomic_counter_value (g_clients_pkts_out));
diff --git a/tests/test_proxy_hwm.cpp b/tests/test_proxy_hwm.cpp
index c2ebaaf1..c16f7dfa 100644
--- a/tests/test_proxy_hwm.cpp
+++ b/tests/test_proxy_hwm.cpp
@@ -71,19 +71,19 @@ typedef struct
     void *subscriber_received_all;
 } proxy_hwm_cfg_t;
 
-static void lower_hwm (void *skt)
+static void lower_hwm (void *skt_)
 {
-    int send_hwm_ = HWM;
+    int send_hwm = HWM;
     TEST_ASSERT_SUCCESS_ERRNO (
-      zmq_setsockopt (skt, ZMQ_SNDHWM, &send_hwm_, sizeof (send_hwm_)));
+      zmq_setsockopt (skt_, ZMQ_SNDHWM, &send_hwm, sizeof (send_hwm)));
 
     TEST_ASSERT_SUCCESS_ERRNO (
-      zmq_setsockopt (skt, ZMQ_RCVHWM, &send_hwm_, sizeof (send_hwm_)));
+      zmq_setsockopt (skt_, ZMQ_RCVHWM, &send_hwm, sizeof (send_hwm)));
 }
 
-static void publisher_thread_main (void *pvoid)
+static void publisher_thread_main (void *pvoid_)
 {
-    proxy_hwm_cfg_t *cfg = (proxy_hwm_cfg_t *) pvoid;
+    proxy_hwm_cfg_t *cfg = static_cast<proxy_hwm_cfg_t *> (pvoid_);
 
     void *pubsocket = zmq_socket (cfg->context, ZMQ_XPUB);
     assert (pubsocket);
@@ -136,9 +136,9 @@ static void publisher_thread_main (void *pvoid)
     zmq_close (pubsocket);
 }
 
-static void subscriber_thread_main (void *pvoid)
+static void subscriber_thread_main (void *pvoid_)
 {
-    proxy_hwm_cfg_t *cfg = (proxy_hwm_cfg_t *) pvoid;
+    proxy_hwm_cfg_t *cfg = static_cast<proxy_hwm_cfg_t *> (pvoid_);
 
     void *subsocket = zmq_socket (cfg->context, ZMQ_SUB);
     assert (subsocket);
@@ -190,7 +190,7 @@ static void subscriber_thread_main (void *pvoid)
     zmq_close (subsocket);
 }
 
-bool recv_stat (void *sock_, bool last_, uint64_t *res)
+bool recv_stat (void *sock_, bool last_, uint64_t *res_)
 {
     zmq_msg_t stats_msg;
 
@@ -205,7 +205,7 @@ bool recv_stat (void *sock_, bool last_, uint64_t *res)
     }
 
     assert (rc == sizeof (uint64_t));
-    memcpy (res, zmq_msg_data (&stats_msg), zmq_msg_size (&stats_msg));
+    memcpy (res_, zmq_msg_data (&stats_msg), zmq_msg_size (&stats_msg));
 
     rc = zmq_msg_close (&stats_msg);
     assert (rc == 0);
@@ -264,9 +264,9 @@ bool check_proxy_stats (void *control_proxy_)
     return true;
 }
 
-static void proxy_stats_asker_thread_main (void *pvoid)
+static void proxy_stats_asker_thread_main (void *pvoid_)
 {
-    proxy_hwm_cfg_t *cfg = (proxy_hwm_cfg_t *) pvoid;
+    proxy_hwm_cfg_t *cfg = static_cast<proxy_hwm_cfg_t *> (pvoid_);
 
 
     // CONTROL REQ
@@ -316,9 +316,9 @@ static void proxy_stats_asker_thread_main (void *pvoid)
     zmq_close (control_req);
 }
 
-static void proxy_thread_main (void *pvoid)
+static void proxy_thread_main (void *pvoid_)
 {
-    proxy_hwm_cfg_t *cfg = (proxy_hwm_cfg_t *) pvoid;
+    proxy_hwm_cfg_t *cfg = static_cast<proxy_hwm_cfg_t *> (pvoid_);
     int rc;
 
 
diff --git a/tests/test_radio_dish.cpp b/tests/test_radio_dish.cpp
index 2b4c9481..8a906507 100644
--- a/tests/test_radio_dish.cpp
+++ b/tests/test_radio_dish.cpp
@@ -257,9 +257,8 @@ static const char *mcast_url (int ipv6_)
 {
     if (ipv6_) {
         return "udp://[" MCAST_IPV6 "]:5555";
-    } else {
-        return "udp://" MCAST_IPV4 ":5555";
     }
+    return "udp://" MCAST_IPV4 ":5555";
 }
 
 //  OSX uses a different name for this socket option
diff --git a/tests/test_router_notify.cpp b/tests/test_router_notify.cpp
index 2256018a..ff3ca4b8 100644
--- a/tests/test_router_notify.cpp
+++ b/tests/test_router_notify.cpp
@@ -136,7 +136,7 @@ void test_sockopt_router_notify ()
 }
 
 
-void test_router_notify_helper (int opt_notify)
+void test_router_notify_helper (int opt_notify_)
 {
     void *router = test_context_socket (ZMQ_ROUTER);
     int opt_more;
@@ -148,7 +148,7 @@ void test_router_notify_helper (int opt_notify)
 
     // valid values
     TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (
-      router, ZMQ_ROUTER_NOTIFY, &opt_notify, sizeof (opt_notify)));
+      router, ZMQ_ROUTER_NOTIFY, &opt_notify_, sizeof (opt_notify_)));
 
     bind_loopback_ipv4 (router, connect_address, sizeof connect_address);
 
@@ -162,7 +162,7 @@ void test_router_notify_helper (int opt_notify)
     TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (dealer, connect_address));
 
     // connection notification msg
-    if (opt_notify & ZMQ_NOTIFY_CONNECT) {
+    if (opt_notify_ & ZMQ_NOTIFY_CONNECT) {
         // routing-id only message of the connect
         recv_string_expect_success (router, dealer_routing_id,
                                     0);             // 1st part: routing-id
@@ -188,7 +188,7 @@ void test_router_notify_helper (int opt_notify)
     zmq_getsockopt (dealer, ZMQ_EVENTS, &opt_events, &opt_events_length);
 
     // connection notification msg
-    if (opt_notify & ZMQ_NOTIFY_DISCONNECT) {
+    if (opt_notify_ & ZMQ_NOTIFY_DISCONNECT) {
         // routing-id only message of the connect
         recv_string_expect_success (router, dealer_routing_id,
                                     0);             // 1st part: routing-id
diff --git a/tests/test_security_curve.cpp b/tests/test_security_curve.cpp
index af25a344..bcf8076b 100644
--- a/tests/test_security_curve.cpp
+++ b/tests/test_security_curve.cpp
@@ -100,9 +100,9 @@ static void zap_handler_large_routing_id (void * /*unused_*/)
     zap_handler_generic (zap_ok, large_routing_id);
 }
 
-void expect_new_client_curve_bounce_fail (char *server_public_,
-                                          char *client_public_,
-                                          char *client_secret_,
+void expect_new_client_curve_bounce_fail (const char *server_public_,
+                                          const char *client_public_,
+                                          const char *client_secret_,
                                           char *my_endpoint_,
                                           void *server_,
                                           void **client_mon_ = NULL,
@@ -241,7 +241,8 @@ fd_t connect_vanilla_socket (char *my_endpoint_)
 #endif
 
     s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    rc = connect (s, (struct sockaddr *) &ip4addr, sizeof (ip4addr));
+    rc = connect (s, reinterpret_cast<struct sockaddr *> (&ip4addr),
+                  sizeof (ip4addr));
     TEST_ASSERT_GREATER_THAN_INT (-1, rc);
     return s;
 }
@@ -334,9 +335,8 @@ static uint64_t host_to_network (uint64_t value_)
           htonl (static_cast<uint32_t> (value_ & 0xFFFFFFFFLL));
 
         return (static_cast<uint64_t> (low_part) << 32) | high_part;
-    } else {
-        return value_;
     }
+    return value_;
 }
 
 template <size_t N> void send_command (fd_t s_, char (&command_)[N])
@@ -348,7 +348,7 @@ template <size_t N> void send_command (fd_t s_, char (&command_)[N])
     } else {
         send (s_, "\x06");
         uint64_t len = host_to_network (N);
-        send_all (s_, (char *) &len, 8);
+        send_all (s_, reinterpret_cast<char *> (&len), 8);
     }
     send_all (s_, command_, N);
 }
@@ -411,7 +411,7 @@ void recv_all (fd_t fd_, uint8_t *data_, socket_size_t len_)
 {
     socket_size_t received = 0;
     while (received < len_) {
-        int res = recv (fd_, (char *) data_, len_, 0);
+        int res = recv (fd_, reinterpret_cast<char *> (data_), len_, 0);
         TEST_ASSERT_GREATER_THAN_INT (0, res);
 
         data_ += res;
diff --git a/tests/test_security_gssapi.cpp b/tests/test_security_gssapi.cpp
index 0da6d748..394b5c0c 100644
--- a/tests/test_security_gssapi.cpp
+++ b/tests/test_security_gssapi.cpp
@@ -190,10 +190,10 @@ static int get_monitor_event (void *monitor_, int *value_, char **address_)
         return -1; //  Interruped, presumably
     TEST_ASSERT_TRUE (zmq_msg_more (&msg));
 
-    uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
-    uint16_t event = *(uint16_t *) (data);
+    uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
+    uint16_t event = *reinterpret_cast<uint16_t *> (data);
     if (value_)
-        *value_ = *(uint32_t *) (data + 2);
+        *value_ = *reinterpret_cast<uint32_t *> (data + 2);
     zmq_msg_close (&msg);
 
     //  Second frame in message contains event address
@@ -203,9 +203,9 @@ static int get_monitor_event (void *monitor_, int *value_, char **address_)
     TEST_ASSERT_FALSE (zmq_msg_more (&msg));
 
     if (address_) {
-        uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
+        uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
         size_t size = zmq_msg_size (&msg);
-        *address_ = (char *) malloc (size + 1);
+        *address_ = static_cast<char *> (malloc (size + 1));
         memcpy (*address_, data, size);
         *address_[size] = 0;
     }
@@ -302,7 +302,8 @@ void test_vanilla_socket ()
 #endif
 
     s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    rc = connect (s, (struct sockaddr *) &ip4addr, sizeof (ip4addr));
+    rc = connect (s, reinterpret_cast<struct sockaddr *> (&ip4addr),
+                  sizeof (ip4addr));
     TEST_ASSERT_GREATER_THAN (-1, rc);
     // send anonymous ZMTP/1.0 greeting
     send (s, "\x01\x00", 2, 0);
diff --git a/tests/test_security_null.cpp b/tests/test_security_null.cpp
index ef445f97..069c543c 100644
--- a/tests/test_security_null.cpp
+++ b/tests/test_security_null.cpp
@@ -185,7 +185,8 @@ void test_vanilla_socket ()
 #endif
 
     s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    rc = connect (s, (struct sockaddr *) &ip4addr, sizeof ip4addr);
+    rc = connect (s, reinterpret_cast<struct sockaddr *> (&ip4addr),
+                  sizeof ip4addr);
     TEST_ASSERT_GREATER_THAN_INT (-1, rc);
     // send anonymous ZMTP/1.0 greeting
     send (s, "\x01\x00", 2, 0);
diff --git a/tests/test_security_plain.cpp b/tests/test_security_plain.cpp
index 97214ac0..acb3789c 100644
--- a/tests/test_security_plain.cpp
+++ b/tests/test_security_plain.cpp
@@ -211,7 +211,8 @@ void test_plain_vanilla_socket ()
 #endif
 
     s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    rc = connect (s, (struct sockaddr *) &ip4addr, sizeof (ip4addr));
+    rc = connect (s, reinterpret_cast<struct sockaddr *> (&ip4addr),
+                  sizeof (ip4addr));
     TEST_ASSERT_GREATER_THAN_INT (-1, rc);
     // send anonymous ZMTP/1.0 greeting
     send (s, "\x01\x00", 2, 0);
diff --git a/tests/test_spec_pushpull.cpp b/tests/test_spec_pushpull.cpp
index d3602088..2c31c934 100644
--- a/tests/test_spec_pushpull.cpp
+++ b/tests/test_spec_pushpull.cpp
@@ -130,7 +130,7 @@ void test_pull_fair_queue_in (const char *bind_address_)
     for (size_t peer = 0; peer < services; ++peer) {
         TEST_ASSERT_EQUAL_INT (
           2, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&msg, pull, 0)));
-        const char *str = (const char *) zmq_msg_data (&msg);
+        const char *str = static_cast<const char *> (zmq_msg_data (&msg));
         first_half -= str[0];
     }
     TEST_ASSERT_EQUAL_INT (0, first_half);
@@ -139,7 +139,7 @@ void test_pull_fair_queue_in (const char *bind_address_)
     for (size_t peer = 0; peer < services; ++peer) {
         TEST_ASSERT_EQUAL_INT (
           2, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&msg, pull, 0)));
-        const char *str = (const char *) zmq_msg_data (&msg);
+        const char *str = static_cast<const char *> (zmq_msg_data (&msg));
         second_half -= str[0];
     }
     TEST_ASSERT_EQUAL_INT (0, second_half);
@@ -237,7 +237,7 @@ void test_destroy_queue_on_disconnect (const char *bind_address_)
 
 // PUSH and PULL: SHALL either receive or drop multipart messages atomically.
 void test_push_multipart_atomic_drop (const char *bind_address_,
-                                      const bool block)
+                                      const bool block_)
 {
     int linger = 0;
     int hwm = 1;
@@ -312,7 +312,7 @@ void test_push_multipart_atomic_drop (const char *bind_address_,
     send_string_expect_success (push, "3", ZMQ_SNDMORE);
     TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init_size (&msg_data, len));
     memset (zmq_msg_data (&msg_data), 'c', len);
-    if (block) {
+    if (block_) {
         TEST_ASSERT_EQUAL_INT (len,
                                zmq_msg_send (&msg_data, push, ZMQ_SNDMORE));
     } else {
diff --git a/tests/test_spec_rep.cpp b/tests/test_spec_rep.cpp
index 2e47d530..a183b0a4 100644
--- a/tests/test_spec_rep.cpp
+++ b/tests/test_spec_rep.cpp
@@ -36,7 +36,7 @@ SETUP_TEARDOWN_TESTCONTEXT
 
 char connect_address[MAX_SOCKET_STRING];
 
-void test_fair_queue_in (const char *bind_address)
+void test_fair_queue_in (const char *bind_address_)
 {
     void *rep = test_context_socket (ZMQ_REP);
 
@@ -44,7 +44,7 @@ void test_fair_queue_in (const char *bind_address)
     TEST_ASSERT_SUCCESS_ERRNO (
       zmq_setsockopt (rep, ZMQ_RCVTIMEO, &timeout, sizeof (int)));
 
-    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (rep, bind_address));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (rep, bind_address_));
     size_t len = MAX_SOCKET_STRING;
     TEST_ASSERT_SUCCESS_ERRNO (
       zmq_getsockopt (rep, ZMQ_LAST_ENDPOINT, connect_address, &len));
@@ -98,11 +98,11 @@ void test_fair_queue_in (const char *bind_address)
         test_context_socket_close_zero_linger (reqs[peer]);
 }
 
-void test_envelope (const char *bind_address)
+void test_envelope (const char *bind_address_)
 {
     void *rep = test_context_socket (ZMQ_REP);
 
-    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (rep, bind_address));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (rep, bind_address_));
     size_t len = MAX_SOCKET_STRING;
     TEST_ASSERT_SUCCESS_ERRNO (
       zmq_getsockopt (rep, ZMQ_LAST_ENDPOINT, connect_address, &len));
diff --git a/tests/test_spec_router.cpp b/tests/test_spec_router.cpp
index dc170de3..869b66eb 100644
--- a/tests/test_spec_router.cpp
+++ b/tests/test_spec_router.cpp
@@ -37,7 +37,7 @@ SETUP_TEARDOWN_TESTCONTEXT
 
 // SHALL receive incoming messages from its peers using a fair-queuing
 // strategy.
-void test_fair_queue_in (const char *bind_address)
+void test_fair_queue_in (const char *bind_address_)
 {
     char connect_address[MAX_SOCKET_STRING];
     void *receiver = test_context_socket (ZMQ_ROUTER);
@@ -46,7 +46,7 @@ void test_fair_queue_in (const char *bind_address)
     TEST_ASSERT_SUCCESS_ERRNO (
       zmq_setsockopt (receiver, ZMQ_RCVTIMEO, &timeout, sizeof (int)));
 
-    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (receiver, bind_address));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (receiver, bind_address_));
     size_t len = MAX_SOCKET_STRING;
     TEST_ASSERT_SUCCESS_ERRNO (
       zmq_getsockopt (receiver, ZMQ_LAST_ENDPOINT, connect_address, &len));
@@ -116,7 +116,7 @@ void test_fair_queue_in (const char *bind_address)
 // SHALL create a double queue when a peer connects to it. If this peer
 // disconnects, the ROUTER socket SHALL destroy its double queue and SHALL
 // discard any messages it contains.
-void test_destroy_queue_on_disconnect (const char *bind_address)
+void test_destroy_queue_on_disconnect (const char *bind_address_)
 {
     void *a = test_context_socket (ZMQ_ROUTER);
 
@@ -124,7 +124,7 @@ void test_destroy_queue_on_disconnect (const char *bind_address)
     TEST_ASSERT_SUCCESS_ERRNO (
       zmq_setsockopt (a, ZMQ_ROUTER_MANDATORY, &enabled, sizeof (enabled)));
 
-    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (a, bind_address));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (a, bind_address_));
     size_t len = MAX_SOCKET_STRING;
     char connect_address[MAX_SOCKET_STRING];
     TEST_ASSERT_SUCCESS_ERRNO (
diff --git a/tests/test_stream_disconnect.cpp b/tests/test_stream_disconnect.cpp
index d9865282..d46916f2 100644
--- a/tests/test_stream_disconnect.cpp
+++ b/tests/test_stream_disconnect.cpp
@@ -168,7 +168,8 @@ void test_stream_disconnect ()
               zmq_msg_recv (&data_frame, sockets[SERVER], 0));
 
             // Make sure payload matches what we expect.
-            const char *const data = (const char *) zmq_msg_data (&data_frame);
+            const char *const data =
+              static_cast<const char *> (zmq_msg_data (&data_frame));
             const size_t size = zmq_msg_size (&data_frame);
             // 0-length frame is a disconnection notification.  The server
             // should receive it as the last step in the dialogue.
@@ -222,7 +223,8 @@ void test_stream_disconnect ()
             TEST_ASSERT_GREATER_THAN_INT (0, zmq_msg_size (&data_frame));
 
             // Make sure payload matches what we expect.
-            const char *const data = (const char *) zmq_msg_data (&data_frame);
+            const char *const data =
+              static_cast<const char *> (zmq_msg_data (&data_frame));
             const size_t size = zmq_msg_size (&data_frame);
             TEST_ASSERT_EQUAL_INT (strlen (dialog[step].text), size);
             TEST_ASSERT_EQUAL_STRING_LEN (dialog[step].text, data, size);
diff --git a/tests/test_stream_timeout.cpp b/tests/test_stream_timeout.cpp
index 5364298e..ff493186 100644
--- a/tests/test_stream_timeout.cpp
+++ b/tests/test_stream_timeout.cpp
@@ -48,10 +48,10 @@ static int get_monitor_event (void *monitor_, int *value_, char **address_)
         return -1; //  Interruped, presumably
     TEST_ASSERT_TRUE (zmq_msg_more (&msg));
 
-    uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
-    uint16_t event = *(uint16_t *) (data);
+    uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
+    uint16_t event = *reinterpret_cast<uint16_t *> (data);
     if (value_)
-        *value_ = *(uint32_t *) (data + 2);
+        *value_ = *reinterpret_cast<uint32_t *> (data + 2);
 
     //  Second frame in message contains event address
     zmq_msg_init (&msg);
@@ -60,9 +60,9 @@ static int get_monitor_event (void *monitor_, int *value_, char **address_)
     TEST_ASSERT_TRUE (!zmq_msg_more (&msg));
 
     if (address_) {
-        uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
+        uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
         size_t size = zmq_msg_size (&msg);
-        *address_ = (char *) malloc (size + 1);
+        *address_ = static_cast<char *> (malloc (size + 1));
         memcpy (*address_, data, size);
         *address_[size] = 0;
     }
diff --git a/tests/test_timers.cpp b/tests/test_timers.cpp
index 3e2b39c9..fb4a7655 100644
--- a/tests/test_timers.cpp
+++ b/tests/test_timers.cpp
@@ -42,7 +42,7 @@ void tearDown ()
 void handler (int timer_id_, void *arg_)
 {
     (void) timer_id_; //  Stop 'unused' compiler warnings
-    *((bool *) arg_) = true;
+    *(static_cast<bool *> (arg_)) = true;
 }
 
 int sleep_and_execute (void *timers_)
diff --git a/tests/test_use_fd.cpp b/tests/test_use_fd.cpp
index 86d9c328..98de2199 100644
--- a/tests/test_use_fd.cpp
+++ b/tests/test_use_fd.cpp
@@ -119,7 +119,7 @@ void test_client_server (pre_allocate_sock_fun_t pre_allocate_sock_fun_)
     zmq_msg_t msg;
     TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init_size (&msg, 1));
 
-    char *data = (char *) zmq_msg_data (&msg);
+    char *data = static_cast<char *> (zmq_msg_data (&msg));
     data[0] = 1;
 
     int rc = zmq_msg_send (&msg, sc, ZMQ_SNDMORE);
@@ -141,7 +141,7 @@ void test_client_server (pre_allocate_sock_fun_t pre_allocate_sock_fun_)
 
     TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init_size (&msg, 1));
 
-    data = (char *) zmq_msg_data (&msg);
+    data = static_cast<char *> (zmq_msg_data (&msg));
     data[0] = 2;
 
     TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_set_routing_id (&msg, routing_id));
@@ -227,7 +227,8 @@ void pre_allocate_sock_ipc_int (void *zmq_socket_, const char *path_)
     // TODO check return value of unlink
     unlink (path_);
 
-    setup_socket_and_set_fd (zmq_socket_, AF_UNIX, 0, (struct sockaddr *) &addr,
+    setup_socket_and_set_fd (zmq_socket_, AF_UNIX, 0,
+                             reinterpret_cast<struct sockaddr *> (&addr),
                              sizeof (struct sockaddr_un));
 }
 
diff --git a/tests/test_xpub_nodrop.cpp b/tests/test_xpub_nodrop.cpp
index d5b610e5..8599f777 100644
--- a/tests/test_xpub_nodrop.cpp
+++ b/tests/test_xpub_nodrop.cpp
@@ -73,16 +73,16 @@ void test ()
         if (rc == -1) {
             TEST_ASSERT_EQUAL_INT (EAGAIN, errno);
             break;
-        } else {
-            TEST_ASSERT_EQUAL_INT (0, rc);
-            recv_count++;
-
-            if (recv_count == 1) {
-                const int sub_rcvtimeo = 250;
-                TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (
-                  sub, ZMQ_RCVTIMEO, &sub_rcvtimeo, sizeof (sub_rcvtimeo)));
-            }
         }
+        TEST_ASSERT_EQUAL_INT (0, rc);
+        recv_count++;
+
+        if (recv_count == 1) {
+            const int sub_rcvtimeo = 250;
+            TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (
+              sub, ZMQ_RCVTIMEO, &sub_rcvtimeo, sizeof (sub_rcvtimeo)));
+        }
+
     } while (true);
 
     TEST_ASSERT_EQUAL_INT (send_count, recv_count);
diff --git a/tests/testutil.cpp b/tests/testutil.cpp
index 7194bd63..f59c0d5a 100644
--- a/tests/testutil.cpp
+++ b/tests/testutil.cpp
@@ -284,7 +284,8 @@ int is_ipv6_available ()
         if (rc != 0)
             ipv6 = 0;
         else {
-            rc = bind (fd, (struct sockaddr *) &test_addr, sizeof (test_addr));
+            rc = bind (fd, reinterpret_cast<struct sockaddr *> (&test_addr),
+                       sizeof (test_addr));
             if (rc != 0)
                 ipv6 = 0;
         }
@@ -342,7 +343,7 @@ int test_inet_pton (int af_, const char *src_, void *dst_)
 #endif
 }
 
-sockaddr_in bind_bsd_socket (int socket)
+sockaddr_in bind_bsd_socket (int socket_)
 {
     struct sockaddr_in saddr;
     memset (&saddr, 0, sizeof (saddr));
@@ -355,23 +356,23 @@ sockaddr_in bind_bsd_socket (int socket)
 #endif
 
     TEST_ASSERT_SUCCESS_RAW_ERRNO (
-      bind (socket, (struct sockaddr *) &saddr, sizeof (saddr)));
+      bind (socket_, (struct sockaddr *) &saddr, sizeof (saddr)));
 
 #if !defined(_WIN32_WINNT) || (_WIN32_WINNT >= 0x0600)
     socklen_t saddr_len = sizeof (saddr);
     TEST_ASSERT_SUCCESS_RAW_ERRNO (
-      getsockname (socket, (struct sockaddr *) &saddr, &saddr_len));
+      getsockname (socket_, (struct sockaddr *) &saddr, &saddr_len));
 #endif
 
     return saddr;
 }
 
-bool streq (const char *lhs, const char *rhs)
+bool streq (const char *lhs_, const char *rhs_)
 {
-    return strcmp (lhs, rhs) == 0;
+    return strcmp (lhs_, rhs_) == 0;
 }
 
-bool strneq (const char *lhs, const char *rhs)
+bool strneq (const char *lhs_, const char *rhs_)
 {
-    return strcmp (lhs, rhs) != 0;
+    return strcmp (lhs_, rhs_) != 0;
 }
diff --git a/tests/testutil_monitoring.cpp b/tests/testutil_monitoring.cpp
index 0655e5bd..b8a5a57c 100644
--- a/tests/testutil_monitoring.cpp
+++ b/tests/testutil_monitoring.cpp
@@ -50,8 +50,8 @@ static int get_monitor_event_internal (void *monitor_,
     }
     TEST_ASSERT_TRUE (zmq_msg_more (&msg));
 
-    uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
-    uint16_t event = *(uint16_t *) (data);
+    uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
+    uint16_t event = *reinterpret_cast<uint16_t *> (data);
     if (value_)
         memcpy (value_, data + 2, sizeof (uint32_t));
 
@@ -61,9 +61,9 @@ static int get_monitor_event_internal (void *monitor_,
     TEST_ASSERT_FALSE (zmq_msg_more (&msg));
 
     if (address_) {
-        uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
+        uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
         size_t size = zmq_msg_size (&msg);
-        *address_ = (char *) malloc (size + 1);
+        *address_ = static_cast<char *> (malloc (size + 1));
         memcpy (*address_, data, size);
         (*address_)[size] = 0;
     }
@@ -246,9 +246,9 @@ static int64_t get_monitor_event_internal_v2 (void *monitor_,
     TEST_ASSERT_TRUE (zmq_msg_more (&msg));
 
     if (local_address_) {
-        uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
+        uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
         size_t size = zmq_msg_size (&msg);
-        *local_address_ = (char *) malloc (size + 1);
+        *local_address_ = static_cast<char *> (malloc (size + 1));
         memcpy (*local_address_, data, size);
         (*local_address_)[size] = 0;
     }
@@ -260,9 +260,9 @@ static int64_t get_monitor_event_internal_v2 (void *monitor_,
     TEST_ASSERT_TRUE (!zmq_msg_more (&msg));
 
     if (remote_address_) {
-        uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
+        uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
         size_t size = zmq_msg_size (&msg);
-        *remote_address_ = (char *) malloc (size + 1);
+        *remote_address_ = static_cast<char *> (malloc (size + 1));
         memcpy (*remote_address_, data, size);
         (*remote_address_)[size] = 0;
     }
@@ -328,7 +328,8 @@ void expect_monitor_event_v2 (void *monitor_,
     if (event != expected_event_) {
         pos += snprintf (pos, sizeof buf - (pos - buf),
                          "Expected monitor event %llx, but received %llx\n",
-                         (long long) expected_event_, (long long) event);
+                         static_cast<long long> (expected_event_),
+                         static_cast<long long> (event));
         failed = true;
     }
     if (expected_local_address_
diff --git a/tests/testutil_security.cpp b/tests/testutil_security.cpp
index 8512c986..ab70046b 100644
--- a/tests/testutil_security.cpp
+++ b/tests/testutil_security.cpp
@@ -44,7 +44,7 @@ void socket_config_null_server (void *server_, void *server_secret_)
     TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (
       server_, ZMQ_ZAP_DOMAIN, test_zap_domain, strlen (test_zap_domain)));
 #ifdef ZMQ_ZAP_ENFORCE_DOMAIN
-    int required = server_secret_ ? *(int *) server_secret_ : 0;
+    int required = server_secret_ ? *static_cast<int *> (server_secret_) : 0;
     TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (server_, ZMQ_ZAP_ENFORCE_DOMAIN,
                                                &required, sizeof (int)));
 #else
diff --git a/tests/testutil_unity.cpp b/tests/testutil_unity.cpp
index d31ba3a9..e35272de 100644
--- a/tests/testutil_unity.cpp
+++ b/tests/testutil_unity.cpp
@@ -40,7 +40,7 @@
 int test_assert_success_message_errno_helper (int rc_,
                                               const char *msg_,
                                               const char *expr_,
-                                              int line)
+                                              int line_)
 {
     if (rc_ == -1) {
         char buffer[512];
@@ -50,7 +50,7 @@ int test_assert_success_message_errno_helper (int rc_,
                   "%s failed%s%s%s, errno = %i (%s)", expr_,
                   msg_ ? " (additional info: " : "", msg_ ? msg_ : "",
                   msg_ ? ")" : "", zmq_errno (), zmq_strerror (zmq_errno ()));
-        UNITY_TEST_FAIL (line, buffer);
+        UNITY_TEST_FAIL (line_, buffer);
     }
     return rc_;
 }
@@ -58,7 +58,7 @@ int test_assert_success_message_errno_helper (int rc_,
 int test_assert_success_message_raw_errno_helper (int rc_,
                                                   const char *msg_,
                                                   const char *expr_,
-                                                  int line)
+                                                  int line_)
 {
     if (rc_ == -1) {
 #if defined ZMQ_HAVE_WINDOWS
@@ -73,13 +73,13 @@ int test_assert_success_message_raw_errno_helper (int rc_,
         snprintf (buffer, sizeof (buffer) - 1, "%s failed%s%s%s, errno = %i",
                   expr_, msg_ ? " (additional info: " : "", msg_ ? msg_ : "",
                   msg_ ? ")" : "", current_errno);
-        UNITY_TEST_FAIL (line, buffer);
+        UNITY_TEST_FAIL (line_, buffer);
     }
     return rc_;
 }
 
 int test_assert_failure_message_raw_errno_helper (
-  int rc_, int expected_errno_, const char *msg_, const char *expr_, int line)
+  int rc_, int expected_errno_, const char *msg_, const char *expr_, int line_)
 {
     char buffer[512];
     buffer[sizeof (buffer) - 1] =
@@ -90,7 +90,7 @@ int test_assert_failure_message_raw_errno_helper (
                   "errno = %i, actual return value = %i",
                   expr_, msg_ ? " (additional info: " : "", msg_ ? msg_ : "",
                   msg_ ? ")" : "", expected_errno_, rc_);
-        UNITY_TEST_FAIL (line, buffer);
+        UNITY_TEST_FAIL (line_, buffer);
     } else {
 #if defined ZMQ_HAVE_WINDOWS
         int current_errno = WSAGetLastError ();
@@ -104,7 +104,7 @@ int test_assert_failure_message_raw_errno_helper (
                       expr_, msg_ ? " (additional info: " : "",
                       msg_ ? msg_ : "", msg_ ? ")" : "", expected_errno_,
                       current_errno);
-            UNITY_TEST_FAIL (line, buffer);
+            UNITY_TEST_FAIL (line_, buffer);
         }
     }
     return rc_;
@@ -165,7 +165,7 @@ static void internal_manage_test_sockets (void *socket_, bool add_)
             fprintf (stderr,
                      "WARNING: Forced closure of %i sockets, this is an "
                      "implementation error unless the test case failed\n",
-                     (int) test_socket_count);
+                     static_cast<int> (test_socket_count));
             test_socket_count = 0;
         }
     } else {
diff --git a/unittests/unittest_ip_resolver.cpp b/unittests/unittest_ip_resolver.cpp
index 75939e0e..b50d6c75 100644
--- a/unittests/unittest_ip_resolver.cpp
+++ b/unittests/unittest_ip_resolver.cpp
@@ -160,9 +160,9 @@ static void test_resolve (zmq::ip_resolver_options_t opts_,
         // TODO also check the expected errno
         TEST_ASSERT_EQUAL (-1, rc);
         return;
-    } else {
-        TEST_ASSERT_SUCCESS_ERRNO (rc);
     }
+    TEST_ASSERT_SUCCESS_ERRNO (rc);
+
 
     validate_address (family, &addr, expected_addr_, expected_port_,
                       expected_zone_, expected_addr_v4_failover_);
diff --git a/unittests/unittest_mtrie.cpp b/unittests/unittest_mtrie.cpp
index 3d484dc2..e85f7f36 100644
--- a/unittests/unittest_mtrie.cpp
+++ b/unittests/unittest_mtrie.cpp
@@ -34,9 +34,9 @@ void tearDown ()
 {
 }
 
-int getlen (const zmq::generic_mtrie_t<int>::prefix_t &data)
+int getlen (const zmq::generic_mtrie_t<int>::prefix_t &data_)
 {
-    return (int) strlen (reinterpret_cast<const char *> (data));
+    return static_cast<int> (strlen (reinterpret_cast<const char *> (data_)));
 }
 
 void test_create ()
@@ -44,10 +44,10 @@ void test_create ()
     zmq::generic_mtrie_t<int> mtrie;
 }
 
-void mtrie_count (int *pipe, int *count)
+void mtrie_count (int *pipe_, int *count_)
 {
-    LIBZMQ_UNUSED (pipe);
-    ++*count;
+    LIBZMQ_UNUSED (pipe_);
+    ++*count_;
 }
 
 void test_check_empty_match_nonempty_data ()
@@ -187,14 +187,14 @@ void test_rm_nonexistent_empty ()
     TEST_ASSERT_EQUAL_INT (0, count);
 }
 
-void test_add_and_rm_other (const char *add_name, const char *rm_name)
+void test_add_and_rm_other (const char *add_name_, const char *rm_name_)
 {
     int addpipe, rmpipe;
     zmq::generic_mtrie_t<int> mtrie;
     const zmq::generic_mtrie_t<int>::prefix_t add_name_data =
-      reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (add_name);
+      reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (add_name_);
     const zmq::generic_mtrie_t<int>::prefix_t rm_name_data =
-      reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (rm_name);
+      reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (rm_name_);
 
     mtrie.add (add_name_data, getlen (add_name_data), &addpipe);
 
@@ -209,8 +209,8 @@ void test_add_and_rm_other (const char *add_name, const char *rm_name)
         TEST_ASSERT_EQUAL_INT (1, count);
     }
 
-    if (strncmp (add_name, rm_name,
-                 std::min (strlen (add_name), strlen (rm_name) + 1))
+    if (strncmp (add_name_, rm_name_,
+                 std::min (strlen (add_name_), strlen (rm_name_) + 1))
         != 0) {
         int count = 0;
         mtrie.match (rm_name_data, getlen (rm_name_data), mtrie_count, &count);
@@ -240,15 +240,15 @@ void test_rm_nonexistent_nonempty_prefixed ()
     test_add_and_rm_other ("foo", "foobar");
 }
 
-void add_indexed_expect_unique (zmq::generic_mtrie_t<int> &mtrie,
-                                int *pipes,
-                                const char **names,
-                                size_t i)
+void add_indexed_expect_unique (zmq::generic_mtrie_t<int> &mtrie_,
+                                int *pipes_,
+                                const char **names_,
+                                size_t i_)
 {
     const zmq::generic_mtrie_t<int>::prefix_t name_data =
-      reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (names[i]);
+      reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (names_[i_]);
 
-    bool res = mtrie.add (name_data, getlen (name_data), &pipes[i]);
+    bool res = mtrie_.add (name_data, getlen (name_data), &pipes_[i_]);
     TEST_ASSERT_EQUAL (zmq::generic_mtrie_t<int>::last_value_removed, res);
 }
 
@@ -270,12 +270,12 @@ void test_rm_nonexistent_between ()
 }
 
 template <size_t N>
-void add_entries (zmq::generic_mtrie_t<int> &mtrie,
-                  int (&pipes)[N],
-                  const char *(&names)[N])
+void add_entries (zmq::generic_mtrie_t<int> &mtrie_,
+                  int (&pipes_)[N],
+                  const char *(&names_)[N])
 {
     for (size_t i = 0; i < N; ++i) {
-        add_indexed_expect_unique (mtrie, pipes, names, i);
+        add_indexed_expect_unique (mtrie_, pipes_, names_, i);
     }
 }
 
@@ -303,7 +303,8 @@ void test_add_multiple_reverse ()
 
     zmq::generic_mtrie_t<int> mtrie;
     for (int i = 2; i >= 0; --i) {
-        add_indexed_expect_unique (mtrie, pipes, names, (size_t) i);
+        add_indexed_expect_unique (mtrie, pipes, names,
+                                   static_cast<size_t> (i));
     }
 
     for (size_t i = 0; i < 3; ++i) {
@@ -315,15 +316,15 @@ void test_add_multiple_reverse ()
     }
 }
 
-template <size_t N> void add_and_rm_entries (const char *(&names)[N])
+template <size_t N> void add_and_rm_entries (const char *(&names_)[N])
 {
     int pipes[N];
     zmq::generic_mtrie_t<int> mtrie;
-    add_entries (mtrie, pipes, names);
+    add_entries (mtrie, pipes, names_);
 
     for (size_t i = 0; i < N; ++i) {
         const zmq::generic_mtrie_t<int>::prefix_t name_data =
-          reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (names[i]);
+          reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (names_[i]);
 
         zmq::generic_mtrie_t<int>::rm_result res =
           mtrie.rm (name_data, getlen (name_data), &pipes[i]);
@@ -351,14 +352,14 @@ void check_name (zmq::generic_mtrie_t<int>::prefix_t data_,
     TEST_ASSERT_EQUAL_STRING_LEN (name_, data_, len_);
 }
 
-template <size_t N> void add_entries_rm_pipes_unique (const char *(&names)[N])
+template <size_t N> void add_entries_rm_pipes_unique (const char *(&names_)[N])
 {
     int pipes[N];
     zmq::generic_mtrie_t<int> mtrie;
-    add_entries (mtrie, pipes, names);
+    add_entries (mtrie, pipes, names_);
 
     for (size_t i = 0; i < N; ++i) {
-        mtrie.rm (&pipes[i], check_name, names[i], false);
+        mtrie.rm (&pipes[i], check_name, names_[i], false);
     }
 }
 
@@ -384,16 +385,16 @@ void check_count (zmq::generic_mtrie_t<int>::prefix_t data_,
     TEST_ASSERT_GREATER_OR_EQUAL (0, *count_);
 }
 
-void add_duplicate_entry (zmq::generic_mtrie_t<int> &mtrie, int (&pipes)[2])
+void add_duplicate_entry (zmq::generic_mtrie_t<int> &mtrie_, int (&pipes_)[2])
 {
     const char *name = "foo";
 
     const zmq::generic_mtrie_t<int>::prefix_t name_data =
       reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (name);
 
-    bool res = mtrie.add (name_data, getlen (name_data), &pipes[0]);
+    bool res = mtrie_.add (name_data, getlen (name_data), &pipes_[0]);
     TEST_ASSERT_TRUE (res);
-    res = mtrie.add (name_data, getlen (name_data), &pipes[1]);
+    res = mtrie_.add (name_data, getlen (name_data), &pipes_[1]);
     TEST_ASSERT_FALSE (res);
 }
 
diff --git a/unittests/unittest_poller.cpp b/unittests/unittest_poller.cpp
index 8c9f35e2..7f800685 100644
--- a/unittests/unittest_poller.cpp
+++ b/unittests/unittest_poller.cpp
@@ -57,16 +57,16 @@ void test_start_empty ()
 struct test_events_t : zmq::i_poll_events
 {
     test_events_t (zmq::fd_t fd_, zmq::poller_t &poller_) :
-        fd (fd_),
-        poller (poller_)
+        _fd (fd_),
+        _poller (poller_)
     {
-        (void)fd;
+        (void) _fd;
     }
 
     virtual void in_event ()
     {
-        poller.rm_fd (handle);
-        handle = (zmq::poller_t::handle_t) NULL;
+        _poller.rm_fd (_handle);
+        _handle = (zmq::poller_t::handle_t) NULL;
 
         // this must only be incremented after rm_fd
         in_events.add (1);
@@ -82,27 +82,27 @@ struct test_events_t : zmq::i_poll_events
     virtual void timer_event (int id_)
     {
         LIBZMQ_UNUSED (id_);
-        poller.rm_fd (handle);
-        handle = (zmq::poller_t::handle_t) NULL;
+        _poller.rm_fd (_handle);
+        _handle = (zmq::poller_t::handle_t) NULL;
 
         // this must only be incremented after rm_fd
         timer_events.add (1);
     }
 
-    void set_handle (zmq::poller_t::handle_t handle_) { handle = handle_; }
+    void set_handle (zmq::poller_t::handle_t handle_) { _handle = handle_; }
 
     zmq::atomic_counter_t in_events, timer_events;
 
   private:
-    zmq::fd_t fd;
-    zmq::poller_t &poller;
-    zmq::poller_t::handle_t handle;
+    zmq::fd_t _fd;
+    zmq::poller_t &_poller;
+    zmq::poller_t::handle_t _handle;
 };
 
-void wait_in_events (test_events_t &events)
+void wait_in_events (test_events_t &events_)
 {
     void *watch = zmq_stopwatch_start ();
-    while (events.in_events.get () < 1) {
+    while (events_.in_events.get () < 1) {
 #ifdef ZMQ_BUILD_DRAFT
         TEST_ASSERT_LESS_OR_EQUAL_MESSAGE (SETTLE_TIME,
                                            zmq_stopwatch_intermediate (watch),
@@ -112,10 +112,10 @@ void wait_in_events (test_events_t &events)
     zmq_stopwatch_stop (watch);
 }
 
-void wait_timer_events (test_events_t &events)
+void wait_timer_events (test_events_t &events_)
 {
     void *watch = zmq_stopwatch_start ();
-    while (events.timer_events.get () < 1) {
+    while (events_.timer_events.get () < 1) {
 #ifdef ZMQ_BUILD_DRAFT
         TEST_ASSERT_LESS_OR_EQUAL_MESSAGE (SETTLE_TIME,
                                            zmq_stopwatch_intermediate (watch),
@@ -125,40 +125,40 @@ void wait_timer_events (test_events_t &events)
     zmq_stopwatch_stop (watch);
 }
 
-void create_nonblocking_fdpair (zmq::fd_t *r, zmq::fd_t *w)
+void create_nonblocking_fdpair (zmq::fd_t *r_, zmq::fd_t *w_)
 {
-    int rc = zmq::make_fdpair (r, w);
+    int rc = zmq::make_fdpair (r_, w_);
     TEST_ASSERT_EQUAL_INT (0, rc);
-    TEST_ASSERT_NOT_EQUAL (zmq::retired_fd, *r);
-    TEST_ASSERT_NOT_EQUAL (zmq::retired_fd, *w);
-    zmq::unblock_socket (*r);
-    zmq::unblock_socket (*w);
+    TEST_ASSERT_NOT_EQUAL (zmq::retired_fd, *r_);
+    TEST_ASSERT_NOT_EQUAL (zmq::retired_fd, *w_);
+    zmq::unblock_socket (*r_);
+    zmq::unblock_socket (*w_);
 }
 
-void send_signal (zmq::fd_t w)
+void send_signal (zmq::fd_t w_)
 {
 #if defined ZMQ_HAVE_EVENTFD
     const uint64_t inc = 1;
-    ssize_t sz = write (w, &inc, sizeof (inc));
+    ssize_t sz = write (w_, &inc, sizeof (inc));
     assert (sz == sizeof (inc));
 #else
     {
         char msg[] = "test";
-        int rc = send (w, msg, sizeof (msg), 0);
+        int rc = send (w_, msg, sizeof (msg), 0);
         assert (rc == sizeof (msg));
     }
 #endif
 }
 
-void close_fdpair (zmq::fd_t w, zmq::fd_t r)
+void close_fdpair (zmq::fd_t w_, zmq::fd_t r_)
 {
-    int rc = closesocket (w);
+    int rc = closesocket (w_);
     TEST_ASSERT_EQUAL_INT (0, rc);
 #if !defined ZMQ_HAVE_EVENTFD
-    rc = closesocket (r);
+    rc = closesocket (r_);
     TEST_ASSERT_EQUAL_INT (0, rc);
 #else
-    LIBZMQ_UNUSED (r);
+    LIBZMQ_UNUSED (r_);
 #endif
 }
 
diff --git a/unittests/unittest_radix_tree.cpp b/unittests/unittest_radix_tree.cpp
index 872dc07e..380b573e 100644
--- a/unittests/unittest_radix_tree.cpp
+++ b/unittests/unittest_radix_tree.cpp
@@ -222,13 +222,13 @@ void test_size ()
     TEST_ASSERT_TRUE (tree.size () == 0);
 }
 
-void return_key (unsigned char *data, size_t size, void *arg)
+void return_key (unsigned char *data_, size_t size_, void *arg_)
 {
     std::vector<std::string> *vec =
-      reinterpret_cast<std::vector<std::string> *> (arg);
+      reinterpret_cast<std::vector<std::string> *> (arg_);
     std::string key;
-    for (size_t i = 0; i < size; ++i)
-        key.push_back (static_cast<char> (data[i]));
+    for (size_t i = 0; i < size_; ++i)
+        key.push_back (static_cast<char> (data_[i]));
     vec->push_back (key);
 }
 
diff --git a/unittests/unittest_udp_address.cpp b/unittests/unittest_udp_address.cpp
index d65c0923..84dfdc57 100644
--- a/unittests/unittest_udp_address.cpp
+++ b/unittests/unittest_udp_address.cpp
@@ -54,9 +54,9 @@ static void test_resolve (bool bind_,
         TEST_ASSERT_EQUAL (-1, rc);
         TEST_ASSERT_EQUAL (EINVAL, errno);
         return;
-    } else {
-        TEST_ASSERT_EQUAL (0, rc);
     }
+    TEST_ASSERT_EQUAL (0, rc);
+
 
     TEST_ASSERT_EQUAL (multicast_, addr.is_mcast ());
 
@@ -69,32 +69,36 @@ static void test_resolve (bool bind_,
         }
     }
 
-    validate_address (family_, addr.target_addr(), target_addr_, expected_port_);
-    validate_address (family_, addr.bind_addr(), bind_addr_, expected_port_);
+    validate_address (family_, addr.target_addr (), target_addr_,
+                      expected_port_);
+    validate_address (family_, addr.bind_addr (), bind_addr_, expected_port_);
 }
 
 static void test_resolve_bind (int family_,
-                               const char *name_, const char *dest_addr_,
-                                uint16_t expected_port_ = 0,
+                               const char *name_,
+                               const char *dest_addr_,
+                               uint16_t expected_port_ = 0,
                                const char *bind_addr_ = NULL,
                                bool multicast_ = false)
 {
-test_resolve (true, family_, name_, dest_addr_, expected_port_, bind_addr_,
+    test_resolve (true, family_, name_, dest_addr_, expected_port_, bind_addr_,
                   multicast_);
 }
 
-static void test_resolve_connect (int family_, const char *name_, const char *dest_addr_,
+static void test_resolve_connect (int family_,
+                                  const char *name_,
+                                  const char *dest_addr_,
                                   uint16_t expected_port_ = 0,
                                   const char *bind_addr_ = NULL,
                                   bool multicast_ = false)
 {
-test_resolve (false, family_, name_, dest_addr_, expected_port_, bind_addr_,
+    test_resolve (false, family_, name_, dest_addr_, expected_port_, bind_addr_,
                   multicast_);
 }
 
 static void test_resolve_ipv4_simple ()
 {
-test_resolve_connect (AF_INET, "127.0.0.1:5555", "127.0.0.1", 5555);
+    test_resolve_connect (AF_INET, "127.0.0.1:5555", "127.0.0.1", 5555);
 }
 
 static void test_resolve_ipv6_simple ()
@@ -104,12 +108,14 @@ static void test_resolve_ipv6_simple ()
 
 static void test_resolve_ipv4_bind ()
 {
-    test_resolve_bind (AF_INET, "127.0.0.1:5555", "127.0.0.1", 5555, "127.0.0.1");
+    test_resolve_bind (AF_INET, "127.0.0.1:5555", "127.0.0.1", 5555,
+                       "127.0.0.1");
 }
 
 static void test_resolve_ipv6_bind ()
 {
-    test_resolve_bind (AF_INET6, "[abcd::1234:1]:5555", "abcd::1234:1", 5555, "abcd::1234:1");
+    test_resolve_bind (AF_INET6, "[abcd::1234:1]:5555", "abcd::1234:1", 5555,
+                       "abcd::1234:1");
 }
 
 static void test_resolve_ipv4_bind_any ()
@@ -129,7 +135,8 @@ static void test_resolve_ipv4_bind_anyport ()
 
 static void test_resolve_ipv6_bind_anyport ()
 {
-    test_resolve_bind (AF_INET6, "[1:2:3:4::5]:*", "1:2:3:4::5", 0, "1:2:3:4::5");
+    test_resolve_bind (AF_INET6, "[1:2:3:4::5]:*", "1:2:3:4::5", 0,
+                       "1:2:3:4::5");
 }
 
 static void test_resolve_ipv4_bind_any_port ()
@@ -176,7 +183,8 @@ static void test_resolve_ipv6_connect_port0 ()
 
 static void test_resolve_ipv4_bind_mcast ()
 {
-    test_resolve_bind (AF_INET, "239.0.0.1:1234", "239.0.0.1", 1234, "0.0.0.0", true);
+    test_resolve_bind (AF_INET, "239.0.0.1:1234", "239.0.0.1", 1234, "0.0.0.0",
+                       true);
 }
 
 static void test_resolve_ipv6_bind_mcast ()
@@ -186,12 +194,14 @@ static void test_resolve_ipv6_bind_mcast ()
 
 static void test_resolve_ipv4_connect_mcast ()
 {
-    test_resolve_connect (AF_INET, "239.0.0.1:2222", "239.0.0.1", 2222, NULL, true);
+    test_resolve_connect (AF_INET, "239.0.0.1:2222", "239.0.0.1", 2222, NULL,
+                          true);
 }
 
 static void test_resolve_ipv6_connect_mcast ()
 {
-    test_resolve_connect (AF_INET6, "[ff00::1]:2222", "ff00::1", 2222, NULL, true);
+    test_resolve_connect (AF_INET6, "[ff00::1]:2222", "ff00::1", 2222, NULL,
+                          true);
 }
 
 static void test_resolve_ipv4_mcast_src_bind ()
@@ -223,14 +233,13 @@ static void test_resolve_ipv4_mcast_src_bind_any ()
 
 static void test_resolve_ipv6_mcast_src_bind_any ()
 {
-    test_resolve_bind (AF_INET6, "*;[ffff::]:5555", "ffff::", 5555,
-                       "::", true);
+    test_resolve_bind (AF_INET6, "*;[ffff::]:5555", "ffff::", 5555, "::", true);
 }
 
 static void test_resolve_ipv4_mcast_src_connect ()
 {
-    test_resolve_connect (AF_INET, "8.9.10.11;230.2.8.12:5555", "230.2.8.12", 5555,
-                          "8.9.10.11", true);
+    test_resolve_connect (AF_INET, "8.9.10.11;230.2.8.12:5555", "230.2.8.12",
+                          5555, "8.9.10.11", true);
 }
 
 static void test_resolve_ipv6_mcast_src_connect ()