diff --git a/tests/test_spec_dealer.cpp b/tests/test_spec_dealer.cpp
index 4bf653bb..50359399 100644
--- a/tests/test_spec_dealer.cpp
+++ b/tests/test_spec_dealer.cpp
@@ -34,16 +34,15 @@ void test_round_robin_out (void *ctx)
 
     const size_t services = 5;
     void *rep [services];
-    for (size_t i = 0; i < services; ++i)
-    {
-        rep[i] = zmq_socket (ctx, ZMQ_REP);
-        assert (rep[i]);
+    for (size_t peer = 0; peer < services; ++peer) {
+        rep [peer] = zmq_socket (ctx, ZMQ_REP);
+        assert (rep [peer]);
 
         int timeout = 100;
-        rc = zmq_setsockopt (rep[i], ZMQ_RCVTIMEO, &timeout, sizeof(int));
+        rc = zmq_setsockopt (rep [peer], ZMQ_RCVTIMEO, &timeout, sizeof (int));
         assert (rc == 0);
 
-        rc = zmq_connect (rep[i], connect_address);
+        rc = zmq_connect (rep [peer], connect_address);
         assert (rc == 0);
     }
 
@@ -53,28 +52,22 @@ void test_round_robin_out (void *ctx)
 
     // Send all requests
     for (size_t i = 0; i < services; ++i)
-    {
         s_send_seq (dealer, 0, "ABC", SEQ_END);
-    }
 
     // Expect every REP got one message
     zmq_msg_t msg;
     zmq_msg_init (&msg);
 
-    for (size_t i = 0; i < services; ++i)
-    {
-        s_recv_seq (rep[i], "ABC", SEQ_END);
-    }
+    for (size_t peer = 0; peer < services; ++peer)
+        s_recv_seq (rep [peer], "ABC", SEQ_END);
 
     rc = zmq_msg_close (&msg);
     assert (rc == 0);
 
     close_zero_linger (dealer);
 
-    for (size_t i = 0; i < services; ++i)
-    {
-        close_zero_linger (rep[i]);
-    }
+    for (size_t peer = 0; peer < services; ++peer)
+        close_zero_linger (rep [peer]);
 
     // Wait for disconnects.
     rc = zmq_poll (0, 0, 100);
@@ -87,7 +80,7 @@ void test_fair_queue_in (void *ctx)
     assert (receiver);
 
     int timeout = 100;
-    int rc = zmq_setsockopt (receiver, ZMQ_RCVTIMEO, &timeout, sizeof(int));
+    int rc = zmq_setsockopt (receiver, ZMQ_RCVTIMEO, &timeout, sizeof (int));
     assert (rc == 0);
 
     rc = zmq_bind (receiver, bind_address);
@@ -95,15 +88,14 @@ void test_fair_queue_in (void *ctx)
 
     const size_t services = 5;
     void *senders [services];
-    for (size_t i = 0; i < services; ++i)
-    {
-        senders[i] = zmq_socket (ctx, ZMQ_DEALER);
-        assert (senders[i]);
+    for (size_t peer = 0; peer < services; ++peer) {
+        senders [peer] = zmq_socket (ctx, ZMQ_DEALER);
+        assert (senders [peer]);
 
-        rc = zmq_setsockopt (senders[i], ZMQ_RCVTIMEO, &timeout, sizeof(int));
+        rc = zmq_setsockopt (senders [peer], ZMQ_RCVTIMEO, &timeout, sizeof (int));
         assert (rc == 0);
 
-        rc = zmq_connect (senders[i], connect_address);
+        rc = zmq_connect (senders [peer], connect_address);
         assert (rc == 0);
     }
 
@@ -111,22 +103,22 @@ void test_fair_queue_in (void *ctx)
     rc = zmq_msg_init (&msg);
     assert (rc == 0);
 
-    s_send_seq (senders[0], "A", SEQ_END);
+    s_send_seq (senders [0], "A", SEQ_END);
     s_recv_seq (receiver, "A", SEQ_END);
 
-    s_send_seq (senders[0], "A", SEQ_END);
+    s_send_seq (senders [0], "A", SEQ_END);
     s_recv_seq (receiver, "A", SEQ_END);
 
     // send our requests
-    for (size_t i = 0; i < services; ++i)
-        s_send_seq (senders[i], "B", SEQ_END);
+    for (size_t peer = 0; peer < services; ++peer)
+        s_send_seq (senders [peer], "B", SEQ_END);
 
     // Wait for data.
     rc = zmq_poll (0, 0, 50);
     assert (rc == 0);
 
     // handle the requests
-    for (size_t i = 0; i < services; ++i)
+    for (size_t peer = 0; peer < services; ++peer)
         s_recv_seq (receiver, "B", SEQ_END);
 
     rc = zmq_msg_close (&msg);
@@ -134,8 +126,8 @@ void test_fair_queue_in (void *ctx)
 
     close_zero_linger (receiver);
 
-    for (size_t i = 0; i < services; ++i)
-        close_zero_linger (senders[i]);
+    for (size_t peer = 0; peer < services; ++peer)
+        close_zero_linger (senders [peer]);
 
     // Wait for disconnects.
     rc = zmq_poll (0, 0, 100);
@@ -164,7 +156,7 @@ void test_destroy_queue_on_disconnect (void *ctx)
     assert (rc == 0);
 
     // Disconnect may take time and need command processing.
-    zmq_pollitem_t poller[2] = { { A, 0, 0, 0 }, { B, 0, 0, 0 } };
+    zmq_pollitem_t poller [2] = { { A, 0, 0, 0 }, { B, 0, 0, 0 } };
     rc = zmq_poll (poller, 2, 100);
     assert (rc == 0);
     rc = zmq_poll (poller, 2, 100);
@@ -211,7 +203,7 @@ void test_block_on_send_no_peers (void *ctx)
     assert (sc);
 
     int timeout = 100;
-    int rc = zmq_setsockopt (sc, ZMQ_SNDTIMEO, &timeout, sizeof(timeout));
+    int rc = zmq_setsockopt (sc, ZMQ_SNDTIMEO, &timeout, sizeof (timeout));
     assert (rc == 0);
 
     rc = zmq_send (sc, 0, 0, ZMQ_DONTWAIT);
@@ -231,12 +223,12 @@ int main (void)
     void *ctx = zmq_ctx_new ();
     assert (ctx);
 
-    const char *binds[] =    { "inproc://a", "tcp://*:5555" };
-    const char *connects[] = { "inproc://a", "tcp://localhost:5555" };
+    const char *binds [] = { "inproc://a", "tcp://*:5555" };
+    const char *connects [] = { "inproc://a", "tcp://localhost:5555" };
 
-    for (int i = 0; i < 2; ++i) {
-        bind_address = binds[i];
-        connect_address = connects[i];
+    for (int transports = 0; transports < 2; ++transports) {
+        bind_address = binds [transports];
+        connect_address = connects [transports];
 
         // SHALL route outgoing messages to available peers using a round-robin
         // strategy.
diff --git a/tests/test_spec_pushpull.cpp b/tests/test_spec_pushpull.cpp
index 61aa20e7..5af091ea 100644
--- a/tests/test_spec_pushpull.cpp
+++ b/tests/test_spec_pushpull.cpp
@@ -32,18 +32,17 @@ void test_push_round_robin_out (void *ctx)
     int rc = zmq_bind (push, bind_address);
     assert (rc == 0);
 
-    const size_t N = 5;
-    void *pulls[N];
-    for (size_t i = 0; i < N; ++i)
-    {
-        pulls[i] = zmq_socket (ctx, ZMQ_PULL);
-        assert (pulls[i]);
+    const size_t services = 5;
+    void *pulls [services];
+    for (size_t peer = 0; peer < services; ++peer) {
+        pulls [peer] = zmq_socket (ctx, ZMQ_PULL);
+        assert (pulls [peer]);
 
         int timeout = 100;
-        rc = zmq_setsockopt (pulls[i], ZMQ_RCVTIMEO, &timeout, sizeof(int));
+        rc = zmq_setsockopt (pulls [peer], ZMQ_RCVTIMEO, &timeout, sizeof (int));
         assert (rc == 0);
 
-        rc = zmq_connect (pulls[i], connect_address);
+        rc = zmq_connect (pulls [peer], connect_address);
         assert (rc == 0);
     }
 
@@ -52,28 +51,21 @@ void test_push_round_robin_out (void *ctx)
     assert (rc == 0);
 
     // Send 2N messages
-    for (size_t i = 0; i < N; ++i)
-    {
+    for (size_t peer = 0; peer < services; ++peer)
         s_send_seq (push, "ABC", SEQ_END);
-    }
-    for (size_t i = 0; i < N; ++i)
-    {
+    for (size_t peer = 0; peer < services; ++peer)
         s_send_seq (push, "DEF", SEQ_END);
-    }
 
     // Expect every PULL got one of each
-    for (size_t i = 0; i < N; ++i)
-    {
-        s_recv_seq (pulls[i], "ABC", SEQ_END);
-        s_recv_seq (pulls[i], "DEF", SEQ_END);
+    for (size_t peer = 0; peer < services; ++peer) {
+        s_recv_seq (pulls [peer], "ABC", SEQ_END);
+        s_recv_seq (pulls [peer], "DEF", SEQ_END);
     }
 
     close_zero_linger (push);
 
-    for (size_t i = 0; i < N; ++i)
-    {
-        close_zero_linger (pulls[i]);
-    }
+    for (size_t peer = 0; peer < services; ++peer)
+        close_zero_linger (pulls [peer]);
 
     // Wait for disconnects.
     rc = zmq_poll (0, 0, 100);
@@ -88,14 +80,14 @@ void test_pull_fair_queue_in (void *ctx)
     int rc = zmq_bind (pull, bind_address);
     assert (rc == 0);
 
-    const size_t N = 5;
-    void *pushs[N];
-    for (size_t i = 0; i < N; ++i)
+    const size_t services = 5;
+    void *pushs [services];
+    for (size_t peer = 0; peer < services; ++peer)
     {
-        pushs[i] = zmq_socket (ctx, ZMQ_PUSH);
-        assert (pushs[i]);
+        pushs [peer] = zmq_socket (ctx, ZMQ_PUSH);
+        assert (pushs [peer]);
 
-        rc = zmq_connect (pushs[i], connect_address);
+        rc = zmq_connect (pushs [peer], connect_address);
         assert (rc == 0);
     }
 
@@ -107,17 +99,16 @@ void test_pull_fair_queue_in (void *ctx)
     int second_half = 0;
 
     // Send 2N messages
-    for (size_t i = 0; i < N; ++i)
-    {
+    for (size_t peer = 0; peer < services; ++peer) {
         char *str = strdup("A");
 
-        str[0] += i;
-        s_send_seq (pushs[i], str, SEQ_END);
-        first_half += str[0];
+        str [0] += peer;
+        s_send_seq (pushs [peer], str, SEQ_END);
+        first_half += str [0];
 
-        str[0] += N;
-        s_send_seq (pushs[i], str, SEQ_END);
-        second_half += str[0];
+        str [0] += services;
+        s_send_seq (pushs [peer], str, SEQ_END);
+        second_half += str [0];
 
         free (str);
     }
@@ -131,22 +122,20 @@ void test_pull_fair_queue_in (void *ctx)
     assert (rc == 0);
 
     // Expect to pull one from each first
-    for (size_t i = 0; i < N; ++i)
-    {
+    for (size_t peer = 0; peer < services; ++peer) {
         rc = zmq_msg_recv (&msg, pull, 0);
         assert (rc == 2);
         const char *str = (const char *)zmq_msg_data (&msg);
-        first_half -= str[0];
+        first_half -= str [0];
     }
     assert (first_half == 0);
 
     // And then get the second batch
-    for (size_t i = 0; i < N; ++i)
-    {
+    for (size_t peer = 0; peer < services; ++peer) {
         rc = zmq_msg_recv (&msg, pull, 0);
         assert (rc == 2);
         const char *str = (const char *)zmq_msg_data (&msg);
-        second_half -= str[0];
+        second_half -= str [0];
     }
     assert (second_half == 0);
 
@@ -155,10 +144,8 @@ void test_pull_fair_queue_in (void *ctx)
 
     close_zero_linger (pull);
 
-    for (size_t i = 0; i < N; ++i)
-    {
-        close_zero_linger (pushs[i]);
-    }
+    for (size_t peer = 0; peer < services; ++peer)
+        close_zero_linger (pushs [peer]);
 
     // Wait for disconnects.
     rc = zmq_poll (0, 0, 100);
@@ -171,7 +158,7 @@ void test_push_block_on_send_no_peers (void *ctx)
     assert (sc);
 
     int timeout = 100;
-    int rc = zmq_setsockopt (sc, ZMQ_SNDTIMEO, &timeout, sizeof(timeout));
+    int rc = zmq_setsockopt (sc, ZMQ_SNDTIMEO, &timeout, sizeof (timeout));
     assert (rc == 0);
 
     rc = zmq_send (sc, 0, 0, ZMQ_DONTWAIT);
@@ -192,7 +179,7 @@ void test_destroy_queue_on_disconnect (void *ctx)
     assert (A);
 
     int hwm = 1;
-    int rc = zmq_setsockopt (A, ZMQ_SNDHWM, &hwm, sizeof(hwm));
+    int rc = zmq_setsockopt (A, ZMQ_SNDHWM, &hwm, sizeof (hwm));
     assert (rc == 0);
 
     rc = zmq_bind (A, bind_address);
@@ -201,7 +188,7 @@ void test_destroy_queue_on_disconnect (void *ctx)
     void *B = zmq_socket (ctx, ZMQ_PULL);
     assert (B);
 
-    rc = zmq_setsockopt (B, ZMQ_RCVHWM, &hwm, sizeof(hwm));
+    rc = zmq_setsockopt (B, ZMQ_RCVHWM, &hwm, sizeof (hwm));
     assert (rc == 0);
 
     rc = zmq_connect (B, connect_address);
@@ -221,7 +208,7 @@ void test_destroy_queue_on_disconnect (void *ctx)
     assert (rc == 0);
 
     // Disconnect may take time and need command processing.
-    zmq_pollitem_t poller[2] = { { A, 0, 0, 0 }, { B, 0, 0, 0 } };
+    zmq_pollitem_t poller [2] = { { A, 0, 0, 0 }, { B, 0, 0, 0 } };
     rc = zmq_poll (poller, 2, 100);
     assert (rc == 0);
     rc = zmq_poll (poller, 2, 100);
@@ -269,17 +256,17 @@ void test_destroy_queue_on_disconnect (void *ctx)
     assert (rc == 0);
 }
 
-int main ()
+int main (void)
 {
     void *ctx = zmq_ctx_new ();
     assert (ctx);
 
-    const char *binds[] =    { "inproc://a", "tcp://*:5555" };
-    const char *connects[] = { "inproc://a", "tcp://localhost:5555" };
+    const char *binds [] = { "inproc://a", "tcp://*:5555" };
+    const char *connects [] = { "inproc://a", "tcp://localhost:5555" };
 
-    for (int i = 0; i < 2; ++i) {
-        bind_address = binds[i];
-        connect_address = connects[i];
+    for (int transport = 0; transport < 2; ++transport) {
+        bind_address = binds [transport];
+        connect_address = connects [transport];
 
         // PUSH: SHALL route outgoing messages to connected peers using a
         // round-robin strategy.
diff --git a/tests/test_spec_rep.cpp b/tests/test_spec_rep.cpp
index 53402e45..3459b743 100644
--- a/tests/test_spec_rep.cpp
+++ b/tests/test_spec_rep.cpp
@@ -30,62 +30,57 @@ void test_fair_queue_in (void *ctx)
     assert (rep);
 
     int timeout = 100;
-    int rc = zmq_setsockopt (rep, ZMQ_RCVTIMEO, &timeout, sizeof(int));
+    int rc = zmq_setsockopt (rep, ZMQ_RCVTIMEO, &timeout, sizeof (int));
     assert (rc == 0);
 
     rc = zmq_bind (rep, bind_address);
     assert (rc == 0);
 
-    const size_t N = 5;
-    void *reqs[N];
-    for (size_t i = 0; i < N; ++i)
-    {
-        reqs[i] = zmq_socket (ctx, ZMQ_REQ);
-        assert (reqs[i]);
+    const size_t services = 5;
+    void *reqs [services];
+    for (size_t peer = 0; peer < services; ++peer) {
+        reqs [peer] = zmq_socket (ctx, ZMQ_REQ);
+        assert (reqs [peer]);
 
-        rc = zmq_setsockopt (reqs[i], ZMQ_RCVTIMEO, &timeout, sizeof(int));
+        rc = zmq_setsockopt (reqs [peer], ZMQ_RCVTIMEO, &timeout, sizeof (int));
         assert (rc == 0);
 
-        rc = zmq_connect (reqs[i], connect_address);
+        rc = zmq_connect (reqs [peer], connect_address);
         assert (rc == 0);
     }
 
-    s_send_seq (reqs[0], "A", SEQ_END);
+    s_send_seq (reqs [0], "A", SEQ_END);
     s_recv_seq (rep, "A", SEQ_END);
     s_send_seq (rep, "A", SEQ_END);
-    s_recv_seq (reqs[0], "A", SEQ_END);
+    s_recv_seq (reqs [0], "A", SEQ_END);
 
-    s_send_seq (reqs[0], "A", SEQ_END);
+    s_send_seq (reqs [0], "A", SEQ_END);
     s_recv_seq (rep, "A", SEQ_END);
     s_send_seq (rep, "A", SEQ_END);
-    s_recv_seq (reqs[0], "A", SEQ_END);
+    s_recv_seq (reqs [0], "A", SEQ_END);
 
     // send N requests
-    for (size_t i = 0; i < N; ++i)
-    {
+    for (size_t peer = 0; peer < services; ++peer) {
         char * str = strdup("A");
-        str[0] += i;
-        s_send_seq (reqs[i], str, SEQ_END);
+        str [0] += peer;
+        s_send_seq (reqs [peer], str, SEQ_END);
         free (str);
     }
 
     // handle N requests
-    for (size_t i = 0; i < N; ++i)
-    {
+    for (size_t peer = 0; peer < services; ++peer) {
         char * str = strdup("A");
-        str[0] += i;
+        str [0] += peer;
         s_recv_seq (rep, str, SEQ_END);
         s_send_seq (rep, str, SEQ_END);
-        s_recv_seq (reqs[i], str, SEQ_END);
+        s_recv_seq (reqs [peer], str, SEQ_END);
         free (str);
     }
 
     close_zero_linger (rep);
 
-    for (size_t i = 0; i < N; ++i)
-    {
-        close_zero_linger (reqs[i]);
-    }
+    for (size_t peer = 0; peer < services; ++peer)
+        close_zero_linger (reqs [peer]);
 
     // Wait for disconnects.
     rc = zmq_poll (0, 0, 100);
@@ -126,17 +121,17 @@ void test_envelope (void *ctx)
     assert (rc == 0);
 }
 
-int main ()
+int main (void)
 {
     void *ctx = zmq_ctx_new ();
     assert (ctx);
 
-    const char *binds[] =    { "inproc://a", "tcp://*:5555" };
-    const char *connects[] = { "inproc://a", "tcp://localhost:5555" };
+    const char *binds [] = { "inproc://a", "tcp://*:5555" };
+    const char *connects [] = { "inproc://a", "tcp://localhost:5555" };
 
-    for (int i = 0; i < 2; ++i) {
-        bind_address = binds[i];
-        connect_address = connects[i];
+    for (int transport = 0; transport < 2; ++transport) {
+        bind_address = binds [transport];
+        connect_address = connects [transport];
 
         // SHALL receive incoming messages from its peers using a fair-queuing
         // strategy.
diff --git a/tests/test_spec_req.cpp b/tests/test_spec_req.cpp
index 7e682d7a..2b12219b 100644
--- a/tests/test_spec_req.cpp
+++ b/tests/test_spec_req.cpp
@@ -88,11 +88,11 @@ void test_req_only_listens_to_current_peer (void *ctx)
         assert (router [i]);
 
         int timeout = 100;
-        rc = zmq_setsockopt (router [i], ZMQ_RCVTIMEO, &timeout, sizeof(timeout));
+        rc = zmq_setsockopt (router [i], ZMQ_RCVTIMEO, &timeout, sizeof (timeout));
         assert (rc == 0);
 
         int enabled = 1;
-        rc = zmq_setsockopt (router [i], ZMQ_ROUTER_MANDATORY, &enabled, sizeof(enabled));
+        rc = zmq_setsockopt (router [i], ZMQ_ROUTER_MANDATORY, &enabled, sizeof (enabled));
         assert (rc == 0);
 
         rc = zmq_connect (router [i], connect_address);
@@ -154,7 +154,7 @@ void test_req_message_format (void *ctx)
     zmq_msg_copy (&peer_id_msg, &msg);
 
     int more = 0;
-    size_t more_size = sizeof(more);
+    size_t more_size = sizeof (more);
     rc = zmq_getsockopt (router, ZMQ_RCVMORE, &more, &more_size);
     assert (rc == 0);
     assert (more);
@@ -190,7 +190,7 @@ void test_block_on_send_no_peers (void *ctx)
     assert (sc);
 
     int timeout = 100;
-    int rc = zmq_setsockopt (sc, ZMQ_SNDTIMEO, &timeout, sizeof(timeout));
+    int rc = zmq_setsockopt (sc, ZMQ_SNDTIMEO, &timeout, sizeof (timeout));
     assert (rc == 0);
 
     rc = zmq_send (sc, 0, 0, ZMQ_DONTWAIT);
diff --git a/tests/test_spec_router.cpp b/tests/test_spec_router.cpp
index 6ff7000c..8083e29d 100644
--- a/tests/test_spec_router.cpp
+++ b/tests/test_spec_router.cpp
@@ -30,29 +30,28 @@ void test_fair_queue_in (void *ctx)
     assert (receiver);
 
     int timeout = 100;
-    int rc = zmq_setsockopt (receiver, ZMQ_RCVTIMEO, &timeout, sizeof(int));
+    int rc = zmq_setsockopt (receiver, ZMQ_RCVTIMEO, &timeout, sizeof (int));
     assert (rc == 0);
 
     rc = zmq_bind (receiver, bind_address);
     assert (rc == 0);
 
-    const size_t N = 5;
-    void *senders[N];
-    for (size_t i = 0; i < N; ++i)
-    {
-        senders[i] = zmq_socket (ctx, ZMQ_DEALER);
-        assert (senders[i]);
+    const size_t services = 5;
+    void *senders [services];
+    for (size_t peer = 0; peer < services; ++peer) {
+        senders [peer] = zmq_socket (ctx, ZMQ_DEALER);
+        assert (senders [peer]);
 
-        rc = zmq_setsockopt (senders[i], ZMQ_RCVTIMEO, &timeout, sizeof(int));
+        rc = zmq_setsockopt (senders [peer], ZMQ_RCVTIMEO, &timeout, sizeof (int));
         assert (rc == 0);
 
         char *str = strdup("A");
-        str[0] += i;
-        rc = zmq_setsockopt (senders[i], ZMQ_IDENTITY, str, 2);
+        str [0] += peer;
+        rc = zmq_setsockopt (senders [peer], ZMQ_IDENTITY, str, 2);
         assert (rc == 0);
         free (str);
 
-        rc = zmq_connect (senders[i], connect_address);
+        rc = zmq_connect (senders [peer], connect_address);
         assert (rc == 0);
     }
 
@@ -60,30 +59,28 @@ void test_fair_queue_in (void *ctx)
     rc = zmq_msg_init (&msg);
     assert (rc == 0);
 
-    s_send_seq (senders[0], "M", SEQ_END);
+    s_send_seq (senders [0], "M", SEQ_END);
     s_recv_seq (receiver, "A", "M", SEQ_END);
 
-    s_send_seq (senders[0], "M", SEQ_END);
+    s_send_seq (senders [0], "M", SEQ_END);
     s_recv_seq (receiver, "A", "M", SEQ_END);
 
     int sum = 0;
 
     // send N requests
-    for (size_t i = 0; i < N; ++i)
-    {
-        s_send_seq (senders[i], "M", SEQ_END);
-        sum += 'A' + i;
+    for (size_t peer = 0; peer < services; ++peer) {
+        s_send_seq (senders [peer], "M", SEQ_END);
+        sum += 'A' + peer;
     }
 
-    assert (sum == N*'A' + N*(N-1)/2);
+    assert (sum == services * 'A' + services * (services - 1) / 2);
 
     // handle N requests
-    for (size_t i = 0; i < N; ++i)
-    {
+    for (size_t peer = 0; peer < services; ++peer) {
         rc = zmq_msg_recv (&msg, receiver, 0);
         assert (rc == 2);
         const char *id = (const char *)zmq_msg_data (&msg);
-        sum -= id[0];
+        sum -= id [0];
 
         s_recv_seq (receiver, "M", SEQ_END);
     }
@@ -95,10 +92,8 @@ void test_fair_queue_in (void *ctx)
 
     close_zero_linger (receiver);
 
-    for (size_t i = 0; i < N; ++i)
-    {
-        close_zero_linger (senders[i]);
-    }
+    for (size_t peer = 0; peer < services; ++peer)
+        close_zero_linger (senders [peer]);
 
     // Wait for disconnects.
     rc = zmq_poll (0, 0, 100);
@@ -111,7 +106,7 @@ void test_destroy_queue_on_disconnect (void *ctx)
     assert (A);
 
     int enabled = 1;
-    int rc = zmq_setsockopt (A, ZMQ_ROUTER_MANDATORY, &enabled, sizeof(enabled));
+    int rc = zmq_setsockopt (A, ZMQ_ROUTER_MANDATORY, &enabled, sizeof (enabled));
     assert (rc == 0);
 
     rc = zmq_bind (A, bind_address);
@@ -138,7 +133,7 @@ void test_destroy_queue_on_disconnect (void *ctx)
     assert (rc == 0);
 
     // Disconnect may take time and need command processing.
-    zmq_pollitem_t poller[2] = { { A, 0, 0, 0 }, { B, 0, 0, 0 } };
+    zmq_pollitem_t poller [2] = { { A, 0, 0, 0 }, { B, 0, 0, 0 } };
     rc = zmq_poll (poller, 2, 100);
     assert (rc == 0);
     rc = zmq_poll (poller, 2, 100);
@@ -180,17 +175,17 @@ void test_destroy_queue_on_disconnect (void *ctx)
 }
 
 
-int main ()
+int main (void)
 {
     void *ctx = zmq_ctx_new ();
     assert (ctx);
 
-    const char *binds[] =    { "inproc://a", "tcp://*:5555" };
-    const char *connects[] = { "inproc://a", "tcp://localhost:5555" };
+    const char *binds [] = { "inproc://a", "tcp://*:5555" };
+    const char *connects [] = { "inproc://a", "tcp://localhost:5555" };
 
-    for (int i = 0; i < 2; ++i) {
-        bind_address = binds[i];
-        connect_address = connects[i];
+    for (int transport = 0; transport < 2; ++transport) {
+        bind_address = binds [transport];
+        connect_address = connects [transport];
 
         // SHALL receive incoming messages from its peers using a fair-queuing
         // strategy.