void test_plain_vanilla_socket () { // Unauthenticated messages from a vanilla socket shouldn't be received struct sockaddr_in ip4addr; fd_t s; unsigned short int port; int rc = sscanf (my_endpoint, "tcp://127.0.0.1:%hu", &port); TEST_ASSERT_EQUAL_INT (1, rc); ip4addr.sin_family = AF_INET; ip4addr.sin_port = htons (port); #if defined(ZMQ_HAVE_WINDOWS) && (_WIN32_WINNT < 0x0600) ip4addr.sin_addr.s_addr = inet_addr ("127.0.0.1"); #else inet_pton (AF_INET, "127.0.0.1", &ip4addr.sin_addr); #endif s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); rc = connect (s, (struct sockaddr *) &ip4addr, sizeof (ip4addr)); TEST_ASSERT_GREATER_THAN_INT (-1, rc); // send anonymous ZMTP/1.0 greeting send (s, "\x01\x00", 2, 0); // send sneaky message that shouldn't be received send (s, "\x08\x00sneaky\0", 9, 0); int timeout = 250; zmq_setsockopt (server, ZMQ_RCVTIMEO, &timeout, sizeof (timeout)); char *buf = s_recv (server); if (buf != NULL) { printf ("Received unauthenticated message: %s\n", buf); TEST_ASSERT_NULL (buf); } close (s); }
static void recv_with_retry (raw_socket fd_, char *buffer_, int bytes_) { int received = 0; while (true) { int rc = TEST_ASSERT_SUCCESS_RAW_ERRNO ( recv (fd_, buffer_ + received, bytes_ - received, 0)); TEST_ASSERT_GREATER_THAN_INT (0, rc); received += rc; TEST_ASSERT_LESS_OR_EQUAL_INT (bytes_, received); if (received == bytes_) break; } }
// This checks for a broken TCP connection (or, in this case a stuck one // where the peer never responds to PINGS). There should be an accepted event // then a disconnect event. static void test_heartbeat_timeout (int server_type_, int mock_ping_) { int rc; char my_endpoint[MAX_SOCKET_STRING]; void *server, *server_mon; prep_server_socket (!mock_ping_, 0, &server, &server_mon, my_endpoint, MAX_SOCKET_STRING, server_type_); struct sockaddr_in ip4addr; raw_socket s; ip4addr.sin_family = AF_INET; ip4addr.sin_port = htons (atoi (strrchr (my_endpoint, ':') + 1)); #if defined(ZMQ_HAVE_WINDOWS) && (_WIN32_WINNT < 0x0600) ip4addr.sin_addr.s_addr = inet_addr ("127.0.0.1"); #else inet_pton (AF_INET, "127.0.0.1", &ip4addr.sin_addr); #endif s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); rc = TEST_ASSERT_SUCCESS_RAW_ERRNO ( connect (s, (struct sockaddr *) &ip4addr, sizeof ip4addr)); TEST_ASSERT_GREATER_THAN_INT (-1, rc); // Mock a ZMTP 3 client so we can forcibly time out a connection mock_handshake (s, mock_ping_); // By now everything should report as connected rc = get_monitor_event (server_mon); TEST_ASSERT_EQUAL_INT (ZMQ_EVENT_ACCEPTED, rc); if (!mock_ping_) { // We should have been disconnected rc = get_monitor_event (server_mon); TEST_ASSERT_EQUAL_INT (ZMQ_EVENT_DISCONNECTED, rc); } close (s); test_context_socket_close (server); test_context_socket_close (server_mon); }
static void test_stream_to_dealer () { int rc; char my_endpoint[MAX_SOCKET_STRING]; // We'll be using this socket in raw mode void *stream = test_context_socket (ZMQ_STREAM); int zero = 0; TEST_ASSERT_SUCCESS_ERRNO ( zmq_setsockopt (stream, ZMQ_LINGER, &zero, sizeof (zero))); int enabled = 1; TEST_ASSERT_SUCCESS_ERRNO ( zmq_setsockopt (stream, ZMQ_STREAM_NOTIFY, &enabled, sizeof (enabled))); bind_loopback_ipv4 (stream, my_endpoint, sizeof my_endpoint); // We'll be using this socket as the other peer void *dealer = test_context_socket (ZMQ_DEALER); TEST_ASSERT_SUCCESS_ERRNO ( zmq_setsockopt (dealer, ZMQ_LINGER, &zero, sizeof (zero))); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (dealer, my_endpoint)); // Send a message on the dealer socket send_string_expect_success (dealer, "Hello", 0); // Connecting sends a zero message // First frame is routing id zmq_msg_t routing_id; TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&routing_id)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&routing_id, stream, 0)); TEST_ASSERT_TRUE (zmq_msg_more (&routing_id)); // Verify the existence of Peer-Address metadata char const *peer_address = zmq_msg_gets (&routing_id, "Peer-Address"); TEST_ASSERT_NOT_NULL (peer_address); TEST_ASSERT_EQUAL_STRING ("127.0.0.1", peer_address); // Second frame is zero byte buffer[255]; TEST_ASSERT_EQUAL_INT ( 0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (stream, buffer, 255, 0))); // Verify the existence of Peer-Address metadata peer_address = zmq_msg_gets (&routing_id, "Peer-Address"); TEST_ASSERT_NOT_NULL (peer_address); TEST_ASSERT_EQUAL_STRING ("127.0.0.1", peer_address); // Real data follows // First frame is routing id TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&routing_id, stream, 0)); TEST_ASSERT_TRUE (zmq_msg_more (&routing_id)); // Verify the existence of Peer-Address metadata peer_address = zmq_msg_gets (&routing_id, "Peer-Address"); TEST_ASSERT_NOT_NULL (peer_address); TEST_ASSERT_EQUAL_STRING ("127.0.0.1", peer_address); // Second frame is greeting signature recv_array_expect_success (stream, greeting.signature, 0); // Send our own protocol greeting TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_send (&routing_id, stream, ZMQ_SNDMORE)); TEST_ASSERT_EQUAL_INT ( sizeof (greeting), TEST_ASSERT_SUCCESS_ERRNO ( zmq_send (stream, &greeting, sizeof (greeting), 0))); // Now we expect the data from the DEALER socket // We want the rest of greeting along with the Ready command int bytes_read = 0; while (bytes_read < 97) { // First frame is the routing id of the connection (each time) TEST_ASSERT_GREATER_THAN_INT ( 0, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&routing_id, stream, 0))); TEST_ASSERT_TRUE (zmq_msg_more (&routing_id)); // Second frame contains the next chunk of data TEST_ASSERT_SUCCESS_ERRNO ( rc = zmq_recv (stream, buffer + bytes_read, 255 - bytes_read, 0)); bytes_read += rc; } // First two bytes are major and minor version numbers. TEST_ASSERT_EQUAL_INT (3, buffer[0]); // ZMTP/3.0 TEST_ASSERT_EQUAL_INT (0, buffer[1]); // Mechanism is "NULL" TEST_ASSERT_EQUAL_INT8_ARRAY (buffer + 2, "NULL\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 20); TEST_ASSERT_EQUAL_INT8_ARRAY (buffer + 54, "\4\51\5READY", 8); TEST_ASSERT_EQUAL_INT8_ARRAY (buffer + 62, "\13Socket-Type\0\0\0\6DEALER", 22); TEST_ASSERT_EQUAL_INT8_ARRAY (buffer + 84, "\10Identity\0\0\0\0", 13); // Announce we are ready memcpy (buffer, "\4\51\5READY", 8); memcpy (buffer + 8, "\13Socket-Type\0\0\0\6ROUTER", 22); memcpy (buffer + 30, "\10Identity\0\0\0\0", 13); // Send Ready command TEST_ASSERT_GREATER_THAN_INT (0, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_send ( &routing_id, stream, ZMQ_SNDMORE))); TEST_ASSERT_EQUAL_INT ( 43, TEST_ASSERT_SUCCESS_ERRNO (zmq_send (stream, buffer, 43, 0))); // Now we expect the data from the DEALER socket // First frame is, again, the routing id of the connection TEST_ASSERT_GREATER_THAN_INT ( 0, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&routing_id, stream, 0))); TEST_ASSERT_TRUE (zmq_msg_more (&routing_id)); // Third frame contains Hello message from DEALER TEST_ASSERT_EQUAL_INT (7, TEST_ASSERT_SUCCESS_ERRNO ( zmq_recv (stream, buffer, sizeof buffer, 0))); // Then we have a 5-byte message "Hello" TEST_ASSERT_EQUAL_INT (0, buffer[0]); // Flags = 0 TEST_ASSERT_EQUAL_INT (5, buffer[1]); // Size = 5 TEST_ASSERT_EQUAL_INT8_ARRAY (buffer + 2, "Hello", 5); // Send "World" back to DEALER TEST_ASSERT_GREATER_THAN_INT (0, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_send ( &routing_id, stream, ZMQ_SNDMORE))); byte world[] = {0, 5, 'W', 'o', 'r', 'l', 'd'}; TEST_ASSERT_EQUAL_INT ( sizeof (world), TEST_ASSERT_SUCCESS_ERRNO (zmq_send (stream, world, sizeof (world), 0))); // Expect response on DEALER socket recv_string_expect_success (dealer, "World", 0); // Test large messages over STREAM socket #define size 64000 uint8_t msgout[size]; memset (msgout, 0xAB, size); zmq_send (dealer, msgout, size, 0); uint8_t msgin[9 + size]; memset (msgin, 0, 9 + size); bytes_read = 0; while (bytes_read < 9 + size) { // Get routing id frame TEST_ASSERT_GREATER_THAN_INT ( 0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (stream, buffer, 256, 0))); // Get next chunk TEST_ASSERT_GREATER_THAN_INT ( 0, TEST_ASSERT_SUCCESS_ERRNO (rc = zmq_recv (stream, msgin + bytes_read, 9 + size - bytes_read, 0))); bytes_read += rc; } for (int byte_nbr = 0; byte_nbr < size; byte_nbr++) { TEST_ASSERT_EQUAL_UINT8 (0xAB, msgin[9 + byte_nbr]); } test_context_socket_close (dealer); test_context_socket_close (stream); }
static void test_stream_to_stream () { char my_endpoint[MAX_SOCKET_STRING]; // Set-up our context and sockets void *server = test_context_socket (ZMQ_STREAM); int enabled = 1; TEST_ASSERT_SUCCESS_ERRNO ( zmq_setsockopt (server, ZMQ_STREAM_NOTIFY, &enabled, sizeof (enabled))); bind_loopback_ipv4 (server, my_endpoint, sizeof my_endpoint); void *client = test_context_socket (ZMQ_STREAM); TEST_ASSERT_SUCCESS_ERRNO ( zmq_setsockopt (client, ZMQ_STREAM_NOTIFY, &enabled, sizeof (enabled))); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (client, my_endpoint)); uint8_t id[256]; uint8_t buffer[256]; // Connecting sends a zero message // Server: First frame is routing id, second frame is zero TEST_ASSERT_GREATER_THAN_INT ( 0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (server, id, 256, 0))); TEST_ASSERT_EQUAL_INT ( 0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (server, buffer, 256, 0))); // Client: First frame is routing id, second frame is zero TEST_ASSERT_GREATER_THAN_INT ( 0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (client, id, 256, 0))); TEST_ASSERT_EQUAL_INT ( 0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (client, buffer, 256, 0))); // Sent HTTP request on client socket // Get server routing id size_t id_size = sizeof id; TEST_ASSERT_SUCCESS_ERRNO ( zmq_getsockopt (client, ZMQ_ROUTING_ID, id, &id_size)); // First frame is server routing id TEST_ASSERT_EQUAL_INT ((int) id_size, TEST_ASSERT_SUCCESS_ERRNO (zmq_send ( client, id, id_size, ZMQ_SNDMORE))); // Second frame is HTTP GET request TEST_ASSERT_EQUAL_INT ( 7, TEST_ASSERT_SUCCESS_ERRNO (zmq_send (client, "GET /\n\n", 7, 0))); // Get HTTP request; ID frame and then request TEST_ASSERT_GREATER_THAN_INT ( 0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (server, id, 256, 0))); TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (server, buffer, 256, 0)); TEST_ASSERT_EQUAL_INT8_ARRAY (buffer, "GET /\n\n", 7); // Send reply back to client char http_response[] = "HTTP/1.0 200 OK\r\n" "Content-Type: text/plain\r\n" "\r\n" "Hello, World!"; TEST_ASSERT_SUCCESS_ERRNO (zmq_send (server, id, id_size, ZMQ_SNDMORE)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_send (server, http_response, sizeof (http_response), ZMQ_SNDMORE)); // Send zero to close connection to client TEST_ASSERT_SUCCESS_ERRNO (zmq_send (server, id, id_size, ZMQ_SNDMORE)); TEST_ASSERT_SUCCESS_ERRNO (zmq_send (server, NULL, 0, ZMQ_SNDMORE)); // Get reply at client and check that it's complete TEST_ASSERT_GREATER_THAN_INT ( 0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (client, id, 256, 0))); TEST_ASSERT_EQUAL_INT ( sizeof http_response, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (client, buffer, 256, 0))); TEST_ASSERT_EQUAL_INT8_ARRAY (buffer, http_response, sizeof (http_response)); // // Get disconnection notification // FIXME: why does this block? Bug in STREAM disconnect notification? // id_size = zmq_recv (client, id, 256, 0); // assert (id_size > 0); // rc = zmq_recv (client, buffer, 256, 0); // assert (rc == 0); test_context_socket_close (server); test_context_socket_close (client); }
void test_stream_disconnect () { size_t len = MAX_SOCKET_STRING; char bind_endpoint[MAX_SOCKET_STRING]; char connect_endpoint[MAX_SOCKET_STRING]; void *sockets[2]; sockets[SERVER] = test_context_socket (ZMQ_STREAM); int enabled = 1; TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt ( sockets[SERVER], ZMQ_STREAM_NOTIFY, &enabled, sizeof (enabled))); TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sockets[SERVER], "tcp://0.0.0.0:*")); TEST_ASSERT_SUCCESS_ERRNO ( zmq_getsockopt (sockets[SERVER], ZMQ_LAST_ENDPOINT, bind_endpoint, &len)); // Apparently Windows can't connect to 0.0.0.0. A better fix would be welcome. #ifdef ZMQ_HAVE_WINDOWS sprintf (connect_endpoint, "tcp://127.0.0.1:%s", strrchr (bind_endpoint, ':') + 1); #else strcpy (connect_endpoint, bind_endpoint); #endif sockets[CLIENT] = test_context_socket (ZMQ_STREAM); TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt ( sockets[CLIENT], ZMQ_STREAM_NOTIFY, &enabled, sizeof (enabled))); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sockets[CLIENT], connect_endpoint)); // wait for connect notification // Server: Grab the 1st frame (peer routing id). zmq_msg_t peer_frame; TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&peer_frame, sockets[SERVER], 0)); TEST_ASSERT_GREATER_THAN_INT (0, zmq_msg_size (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&peer_frame)); TEST_ASSERT_TRUE (has_more (sockets[SERVER])); // Server: Grab the 2nd frame (actual payload). zmq_msg_t data_frame; TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&data_frame, sockets[SERVER], 0)); TEST_ASSERT_EQUAL_INT (0, zmq_msg_size (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&data_frame)); // Client: Grab the 1st frame (peer routing id). TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&peer_frame, sockets[CLIENT], 0)); TEST_ASSERT_GREATER_THAN_INT (0, zmq_msg_size (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&peer_frame)); TEST_ASSERT_TRUE (has_more (sockets[CLIENT])); // Client: Grab the 2nd frame (actual payload). TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&data_frame, sockets[CLIENT], 0)); TEST_ASSERT_EQUAL_INT (0, zmq_msg_size (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&data_frame)); // Send initial message. char blob_data[256]; size_t blob_size = sizeof (blob_data); TEST_ASSERT_SUCCESS_ERRNO ( zmq_getsockopt (sockets[CLIENT], ZMQ_ROUTING_ID, blob_data, &blob_size)); TEST_ASSERT_GREATER_THAN (0, blob_size); zmq_msg_t msg; TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init_size (&msg, blob_size)); memcpy (zmq_msg_data (&msg), blob_data, blob_size); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_send (&msg, sockets[dialog[0].turn], ZMQ_SNDMORE)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&msg)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_init_size (&msg, strlen (dialog[0].text))); memcpy (zmq_msg_data (&msg), dialog[0].text, strlen (dialog[0].text)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_send (&msg, sockets[dialog[0].turn], ZMQ_SNDMORE)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&msg)); // TODO: make sure this loop doesn't loop forever if something is wrong // with the test (or the implementation). int step = 0; while (step < steps) { // Wait until something happens. zmq_pollitem_t items[] = { {sockets[SERVER], 0, ZMQ_POLLIN, 0}, {sockets[CLIENT], 0, ZMQ_POLLIN, 0}, }; TEST_ASSERT_SUCCESS_ERRNO (zmq_poll (items, 2, 100)); // Check for data received by the server. if (items[SERVER].revents & ZMQ_POLLIN) { TEST_ASSERT_EQUAL_INT (CLIENT, dialog[step].turn); // Grab the 1st frame (peer routing id). zmq_msg_t peer_frame; TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_recv (&peer_frame, sockets[SERVER], 0)); TEST_ASSERT_GREATER_THAN_INT (0, zmq_msg_size (&peer_frame)); TEST_ASSERT_TRUE (has_more (sockets[SERVER])); // Grab the 2nd frame (actual payload). zmq_msg_t data_frame; TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO ( 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 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. if (size == 0) { ++step; TEST_ASSERT_EQUAL_INT (steps, step); } else { TEST_ASSERT_EQUAL_INT (strlen (dialog[step].text), size); TEST_ASSERT_EQUAL_STRING_LEN (dialog[step].text, data, size); ++step; TEST_ASSERT_LESS_THAN_INT (steps, step); // Prepare the response. TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_init_size (&data_frame, strlen (dialog[step].text))); memcpy (zmq_msg_data (&data_frame), dialog[step].text, zmq_msg_size (&data_frame)); // Send the response. TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_send (&peer_frame, sockets[SERVER], ZMQ_SNDMORE)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_send (&data_frame, sockets[SERVER], ZMQ_SNDMORE)); } // Release resources. TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&data_frame)); } // Check for data received by the client. if (items[CLIENT].revents & ZMQ_POLLIN) { TEST_ASSERT_EQUAL_INT (SERVER, dialog[step].turn); // Grab the 1st frame (peer routing id). zmq_msg_t peer_frame; TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_recv (&peer_frame, sockets[CLIENT], 0)); TEST_ASSERT_GREATER_THAN_INT (0, zmq_msg_size (&peer_frame)); TEST_ASSERT_TRUE (has_more (sockets[CLIENT])); // Grab the 2nd frame (actual payload). zmq_msg_t data_frame; TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_recv (&data_frame, sockets[CLIENT], 0)); 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 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); ++step; // Prepare the response (next line in the dialog). TEST_ASSERT_LESS_THAN_INT (steps, step); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_init_size (&data_frame, strlen (dialog[step].text))); memcpy (zmq_msg_data (&data_frame), dialog[step].text, zmq_msg_size (&data_frame)); // Send the response. TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_send (&peer_frame, sockets[CLIENT], ZMQ_SNDMORE)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_send (&data_frame, sockets[CLIENT], ZMQ_SNDMORE)); // Release resources. TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&data_frame)); } } TEST_ASSERT_EQUAL_INT (steps, step); test_context_socket_close (sockets[CLIENT]); test_context_socket_close (sockets[SERVER]); }