generic-library/libzmq
1
0
Fork 0
mirror of https://github.com/zeromq/libzmq.git synced 2024-12-12 10:33:52 +01:00
Code Issues Projects Releases Wiki Activity

Problem: identifiers not conformant with naming convention

Browse Source 
Solution: fix identifier names
This commit is contained in:
Simon Giesecke 2019-12-08 14:21:43 +01:00 committed by Simon Giesecke
parent 18edd28955
commit a83c57d0bb
26 changed files with 209 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/ctx.cpp
View File

@ -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;

4
src/radix_tree.cpp
View File

@ -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.

12
src/socks_connecter.cpp
View File

@ -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;

8
src/stream_connecter_base.cpp
View File

@ -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_)

12
src/stream_listener_base.cpp
View File

@ -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_);
}

24
src/tcp_address.cpp
View File

@ -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);
}

4
src/thread.cpp
View File

@ -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_;
}

18
src/tipc_address.cpp
View File

@ -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;
}
@ -117,7 +117,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;

8
src/ws_connecter.cpp
View File

@ -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_);
}

52
src/ws_engine.cpp
View File

@ -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 output_[SHA_DIGEST_LENGTH]);
zmq::ws_engine_t::ws_engine_t (fd_t fd_,
const options_t &options_,
@ -196,22 +196,22 @@ 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) {
&& 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 +223,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);
@ -877,7 +877,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 +886,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 +925,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

12
src/ws_listener.cpp
View File

@ -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_);
}

8
src/zmq.cpp
View File

@ -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;

8
src/zmtp_engine.cpp
View File

@ -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:

14
tests/test_hwm_pubsub.cpp
View File

@ -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);

4
tests/test_mock_pub_sub.cpp
View File

@ -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 =

16
tests/test_monitor.cpp
View File

@ -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)));

28
tests/test_proxy_hwm.cpp
View File

@ -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 = (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 = (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 = (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 = (proxy_hwm_cfg_t *) pvoid_;
int rc;

8
tests/test_router_notify.cpp
View File

@ -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

4
tests/test_spec_pushpull.cpp
View File

@ -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 {

8
tests/test_spec_rep.cpp
View File

@ -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));

8
tests/test_spec_router.cpp
View File

@ -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 (

14
tests/testutil.cpp
View File

@ -342,7 +342,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 +355,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;
}

14
tests/testutil_unity.cpp
View File

@ -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_;

58
unittests/unittest_mtrie.cpp
View File

@ -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 (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);
}
}
@ -315,15 +315,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 +351,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 +384,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);
}

56
unittests/unittest_poller.cpp
View File

@ -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
}

8
unittests/unittest_radix_tree.cpp
View File

@ -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);
}