#include "config.h"
#include <pthread.h>
#include <sys/types.h>
-#include <sys/socket.h>
-#include <netdb.h>
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <inttypes.h>
#include <stdbool.h>
#include <unistd.h>
-#include <poll.h>
#include <ctype.h>
+#include <libmemcached/memcached.h>
#include <libmemcached/memcached/protocol_binary.h>
#include <libmemcached/byteorder.h>
+#include "utilities.h"
#ifdef linux
/* /usr/include/netinet/in.h defines macros from ntohs() to _bswap_nn to
/* Should we generate coredumps when we enounter an error (-c) */
static bool do_core= false;
/* connection to the server */
-static int sock;
+static memcached_socket_t sock;
/* Should the output from test failures be verbose or quiet? */
static bool verbose= false;
* Set the socket in nonblocking mode
* @return -1 if failure, the socket otherwise
*/
-static int set_noblock(void)
+static memcached_socket_t set_noblock(void)
{
+#ifdef WIN32
+ u_long arg = 1;
+ if (ioctlsocket(sock, FIONBIO, &arg) == SOCKET_ERROR)
+ {
+ perror("Failed to set nonblocking io");
+ closesocket(sock);
+ return INVALID_SOCKET;
+ }
+#else
int flags= fcntl(sock, F_GETFL, 0);
if (flags == -1)
{
perror("Failed to get socket flags");
- close(sock);
- return -1;
+ closesocket(sock);
+ return INVALID_SOCKET;
}
if ((flags & O_NONBLOCK) != O_NONBLOCK)
if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1)
{
perror("Failed to set socket to nonblocking mode");
- close(sock);
- return -1;
+ closesocket(sock);
+ return INVALID_SOCKET;
}
}
-
+#endif
return sock;
}
* @param port the port number (or service) to connect to
* @return positive integer if success, -1 otherwise
*/
-static int connect_server(const char *hostname, const char *port)
+static memcached_socket_t connect_server(const char *hostname, const char *port)
{
struct addrinfo *ai= lookuphost(hostname, port);
- sock= -1;
+ sock= INVALID_SOCKET;
if (ai != NULL)
{
- if ((sock=socket(ai->ai_family, ai->ai_socktype,
- ai->ai_protocol)) != -1)
+ if ((sock= socket(ai->ai_family, ai->ai_socktype,
+ ai->ai_protocol)) != INVALID_SOCKET)
{
- if (connect(sock, ai->ai_addr, ai->ai_addrlen) == -1)
+ if (connect(sock, ai->ai_addr, ai->ai_addrlen) == SOCKET_ERROR)
{
fprintf(stderr, "Failed to connect socket: %s\n",
- strerror(errno));
- close(sock);
- sock= -1;
+ strerror(get_socket_errno()));
+ closesocket(sock);
+ sock= INVALID_SOCKET;
}
else
{
sock= set_noblock();
}
- } else
- fprintf(stderr, "Failed to create socket: %s\n", strerror(errno));
+ }
+ else
+ fprintf(stderr, "Failed to create socket: %s\n",
+ strerror(get_socket_errno()));
freeaddrinfo(ai);
}
return sock;
}
-static ssize_t timeout_io_op(int fd, short direction, void *buf, size_t len)
+static ssize_t timeout_io_op(memcached_socket_t fd, short direction, void *buf, size_t len)
{
ssize_t ret;
if (direction == POLLOUT)
- ret= write(fd, buf, len);
+ ret= send(fd, buf, len, 0);
else
- ret= read(fd, buf, len);
+ ret= recv(fd, buf, len, 0);
- if (ret == -1 && errno == EWOULDBLOCK) {
+ if (ret == SOCKET_ERROR && get_socket_errno() == EWOULDBLOCK) {
struct pollfd fds= {
.events= direction,
.fd= fd
};
+
int err= poll(&fds, 1, timeout * 1000);
if (err == 1)
{
if (direction == POLLOUT)
- ret= write(fd, buf, len);
+ ret= send(fd, buf, len, 0);
else
- ret= read(fd, buf, len);
+ ret= recv(fd, buf, len, 0);
}
else if (err == 0)
{
size_t num_bytes= len - offset;
ssize_t nw= timeout_io_op(sock, POLLOUT, (void*)(ptr + offset), num_bytes);
if (nw == -1)
- verify(errno == EINTR || errno == EAGAIN);
+ verify(get_socket_errno() == EINTR || get_socket_errno() == EAGAIN);
else
offset+= (size_t)nw;
} while (offset < len);
ssize_t nr= timeout_io_op(sock, POLLIN, ((char*) buf) + offset, len - offset);
switch (nr) {
case -1 :
- verify(errno == EINTR || errno == EAGAIN);
+ fprintf(stderr, "Errno: %d %s\n", get_socket_errno(), strerror(errno));
+ verify(get_socket_errno() == EINTR || get_socket_errno() == EAGAIN);
break;
case 0:
return TEST_FAIL;
*/
static enum test_return recv_packet(response *rsp)
{
- execute(retry_read(rsp, sizeof (protocol_binary_response_no_extras)));
+ execute(retry_read(rsp, sizeof(protocol_binary_response_no_extras)));
/* Fix the byte order in the packet header */
rsp->plain.message.header.response.keylen=
PROTOCOL_BINARY_RESPONSE_SUCCESS));
}
- /* Socket should be closed now, read should return 0 */
+ /* Socket should be closed now, read should return EXIT_SUCCESS */
verify(timeout_io_op(sock, POLLIN, rsp.bytes, sizeof(rsp.bytes)) == 0);
return TEST_PASS_RECONNECT;
cmd.plain.message.header.request.cas=
htonll(rsp.plain.message.header.response.cas - 1);
execute(resend_packet(&cmd));
+ execute(send_binary_noop());
execute(recv_packet(&rsp));
verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS));
+ execute(receive_binary_noop());
- return test_binary_noop();
+ return TEST_PASS;
}
static enum test_return test_binary_set(void)
else
expected_result= PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
+ execute(send_binary_noop());
execute(recv_packet(&rsp));
+ execute(receive_binary_noop());
verify(validate_response_header(&rsp, cc, expected_result));
}
else
else
expected_result=PROTOCOL_BINARY_RESPONSE_SUCCESS;
+ execute(send_binary_noop());
execute(recv_packet(&rsp));
+ execute(receive_binary_noop());
verify(validate_response_header(&rsp, cc, expected_result));
if (ii == 0)
cmd.plain.message.header.request.cas=
htonll(rsp.plain.message.header.response.cas - 1);
execute(resend_packet(&cmd));
+ execute(send_binary_noop());
execute(recv_packet(&rsp));
+ execute(receive_binary_noop());
verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS));
return TEST_PASS;
/* The delete shouldn't work the first time, because the item isn't there */
execute(send_packet(&cmd));
+ execute(send_binary_noop());
execute(recv_packet(&rsp));
verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT));
+ execute(receive_binary_noop());
execute(binary_set_item(key, key));
/* The item should be present now, resend*/
/* Verify that quit works */
execute(send_string("quit\r\n"));
- /* Socket should be closed now, read should return 0 */
+ /* Socket should be closed now, read should return EXIT_SUCCESS */
char buffer[80];
verify(timeout_io_op(sock, POLLIN, buffer, sizeof(buffer)) == 0);
return TEST_PASS_RECONNECT;
{
/* @todo add tests for bogus format! */
char buffer[1024];
- sprintf(buffer, "set %s 0 0 5%s\r\nvalue\r\n", key,
- noreply ? " noreply" : "");
+ snprintf(buffer, sizeof(buffer), "set %s 0 0 5%s\r\nvalue\r\n", key, noreply ? " noreply" : "");
execute(send_string(buffer));
if (!noreply)
{
/* @todo add tests for bogus format! */
char buffer[1024];
- sprintf(buffer, "add %s 0 0 5%s\r\nvalue\r\n", key,
- noreply ? " noreply" : "");
+ snprintf(buffer, sizeof(buffer), "add %s 0 0 5%s\r\nvalue\r\n", key, noreply ? " noreply" : "");
execute(send_string(buffer));
if (!noreply)
return test_ascii_add_impl("test_ascii_add_noreply", true);
}
+static enum test_return ascii_get_unknown_value(char **key, char **value, ssize_t *ndata)
+{
+ char buffer[1024];
+
+ execute(receive_line(buffer, sizeof(buffer)));
+ verify(strncmp(buffer, "VALUE ", 6) == 0);
+ char *end= strchr(buffer + 6, ' ');
+ verify(end != NULL);
+ *end= '\0';
+ *key= strdup(buffer + 6);
+ verify(*key != NULL);
+ char *ptr= end + 1;
+
+ unsigned long val= strtoul(ptr, &end, 10); /* flags */
+ verify(ptr != end);
+ verify(val == 0);
+ verify(end != NULL);
+ *ndata = (ssize_t)strtoul(end, &end, 10); /* size */
+ verify(ptr != end);
+ verify(end != NULL);
+ while (*end != '\n' && isspace(*end))
+ ++end;
+ verify(*end == '\n');
+
+ *value= malloc((size_t)*ndata);
+ verify(*value != NULL);
+
+ execute(retry_read(*value, (size_t)*ndata));
+
+ execute(retry_read(buffer, 2));
+ verify(memcmp(buffer, "\r\n", 2) == 0);
+
+ return TEST_PASS;
+}
+
static enum test_return ascii_get_value(const char *key, const char *value)
{
datasize= strlen(value);
verify(datasize < sizeof(buffer));
- sprintf(buffer, "get %s\r\n", key);
+ snprintf(buffer, sizeof(buffer), "get %s\r\n", key);
execute(send_string(buffer));
if (exist)
datasize= strlen(value);
verify(datasize < sizeof(buffer));
- sprintf(buffer, "gets %s\r\n", key);
+ snprintf(buffer, sizeof(buffer), "gets %s\r\n", key);
execute(send_string(buffer));
if (exist)
{
char buffer[300];
size_t len= strlen(value);
- sprintf(buffer, "set %s 0 0 %u\r\n", key, (unsigned int)len);
+ snprintf(buffer, sizeof(buffer), "set %s 0 0 %u\r\n", key, (unsigned int)len);
execute(send_string(buffer));
execute(retry_write(value, len));
execute(send_string("\r\n"));
static enum test_return test_ascii_replace_impl(const char* key, bool noreply)
{
char buffer[1024];
- sprintf(buffer, "replace %s 0 0 5%s\r\nvalue\r\n", key,
- noreply ? " noreply" : "");
+ snprintf(buffer, sizeof(buffer), "replace %s 0 0 5%s\r\nvalue\r\n", key, noreply ? " noreply" : "");
execute(send_string(buffer));
if (noreply)
execute(ascii_set_item(key, "value"));
execute(ascii_gets_item(key, "value", true, &cas));
- sprintf(buffer, "cas %s 0 0 6 %lu%s\r\nvalue2\r\n", key, cas,
- noreply ? " noreply" : "");
+ snprintf(buffer, sizeof(buffer), "cas %s 0 0 6 %lu%s\r\nvalue2\r\n", key, cas, noreply ? " noreply" : "");
execute(send_string(buffer));
if (noreply)
execute(receive_error_response());
char buffer[1024];
- sprintf(buffer, "delete %s%s\r\n", key, noreply ? " noreply" : "");
+ snprintf(buffer, sizeof(buffer), "delete %s%s\r\n", key, noreply ? " noreply" : "");
execute(send_string(buffer));
if (noreply)
static enum test_return test_ascii_mget(void)
{
- execute(ascii_set_item("test_ascii_mget1", "value"));
- execute(ascii_set_item("test_ascii_mget2", "value"));
- execute(ascii_set_item("test_ascii_mget3", "value"));
- execute(ascii_set_item("test_ascii_mget4", "value"));
- execute(ascii_set_item("test_ascii_mget5", "value"));
+ const uint32_t nkeys= 5;
+ const char * const keys[]= {
+ "test_ascii_mget1",
+ "test_ascii_mget2",
+ /* test_ascii_mget_3 does not exist :) */
+ "test_ascii_mget4",
+ "test_ascii_mget5",
+ "test_ascii_mget6"
+ };
+
+ for (uint32_t x= 0; x < nkeys; ++x)
+ execute(ascii_set_item(keys[x], "value"));
+ /* Ask for a key that doesn't exist as well */
execute(send_string("get test_ascii_mget1 test_ascii_mget2 test_ascii_mget3 "
"test_ascii_mget4 test_ascii_mget5 "
"test_ascii_mget6\r\n"));
- execute(ascii_get_value("test_ascii_mget1", "value"));
- execute(ascii_get_value("test_ascii_mget2", "value"));
- execute(ascii_get_value("test_ascii_mget3", "value"));
- execute(ascii_get_value("test_ascii_mget4", "value"));
- execute(ascii_get_value("test_ascii_mget5", "value"));
+
+ char *returned[nkeys];
+
+ for (uint32_t x= 0; x < nkeys; ++x)
+ {
+ ssize_t nbytes = 0;
+ char *v= NULL;
+ execute(ascii_get_unknown_value(&returned[x], &v, &nbytes));
+ verify(nbytes == 5);
+ verify(memcmp(v, "value", 5) == 0);
+ free(v);
+ }
char buffer[5];
execute(retry_read(buffer, 5));
verify(memcmp(buffer, "END\r\n", 5) == 0);
- return TEST_PASS;
+
+ /* verify that we got all the keys we expected */
+ for (uint32_t x= 0; x < nkeys; ++x)
+ {
+ bool found= false;
+ for (uint32_t y= 0; y < nkeys; ++y)
+ {
+ if (strcmp(keys[x], returned[y]) == 0)
+ {
+ found = true;
+ break;
+ }
+ }
+ verify(found);
+ }
+
+ for (uint32_t x= 0; x < nkeys; ++x)
+ free(returned[x]);
+
+ return TEST_PASS;
}
static enum test_return test_ascii_incr_impl(const char* key, bool noreply)
{
char cmd[300];
- sprintf(cmd, "incr %s 1%s\r\n", key, noreply ? " noreply" : "");
+ snprintf(cmd, sizeof(cmd), "incr %s 1%s\r\n", key, noreply ? " noreply" : "");
execute(ascii_set_item(key, "0"));
for (int x= 1; x < 11; ++x)
static enum test_return test_ascii_decr_impl(const char* key, bool noreply)
{
char cmd[300];
- sprintf(cmd, "decr %s 1%s\r\n", key, noreply ? " noreply" : "");
+ snprintf(cmd, sizeof(cmd), "decr %s 1%s\r\n", key, noreply ? " noreply" : "");
execute(ascii_set_item(key, "9"));
for (int x= 8; x > -1; --x)
value="hello";
char cmd[400];
- sprintf(cmd, "%s %s 0 0 %u%s\r\n%s\r\n",
- append ? "append" : "prepend",
- key, (unsigned int)strlen(value), noreply ? " noreply" : "",
- value);
+ snprintf(cmd, sizeof(cmd), "%s %s 0 0 %u%s\r\n%s\r\n",
+ append ? "append" : "prepend",
+ key, (unsigned int)strlen(value), noreply ? " noreply" : "",
+ value);
execute(send_string(cmd));
if (noreply)
execute(ascii_get_item(key, "hello world", true));
- sprintf(cmd, "%s %s_notfound 0 0 %u%s\r\n%s\r\n",
- append ? "append" : "prepend",
- key, (unsigned int)strlen(value), noreply ? " noreply" : "",
- value);
+ snprintf(cmd, sizeof(cmd), "%s %s_notfound 0 0 %u%s\r\n%s\r\n",
+ append ? "append" : "prepend",
+ key, (unsigned int)strlen(value), noreply ? " noreply" : "",
+ value);
execute(send_string(cmd));
if (noreply)
{ NULL, NULL}
};
+const int ascii_tests = 1;
+const int binary_tests = 2;
+
+struct test_type_st
+{
+ bool ascii;
+ bool binary;
+};
+
int main(int argc, char **argv)
{
static const char * const status_msg[]= {"[skip]", "[pass]", "[pass]", "[FAIL]"};
+ struct test_type_st tests= { true, true };
int total= 0;
int failed= 0;
const char *hostname= "localhost";
const char *port= "11211";
int cmd;
+ bool prompt= false;
+ const char *testname= NULL;
- while ((cmd= getopt(argc, argv, "t:vch:p:?")) != EOF)
+
+
+ while ((cmd= getopt(argc, argv, "t:vch:p:PT:?ab")) != EOF)
{
switch (cmd) {
+ case 'a':
+ tests.ascii= true;
+ tests.binary= false;
+ break;
+ case 'b':
+ tests.ascii= false;
+ tests.binary= true;
+ break;
case 't':
timeout= atoi(optarg);
if (timeout == 0)
{
fprintf(stderr, "Invalid timeout. Please specify a number for -t\n");
- return 1;
+ return EXIT_FAILURE;
}
break;
case 'v': verbose= true;
break;
case 'p': port= optarg;
break;
+ case 'P': prompt= true;
+ break;
+ case 'T': testname= optarg;
+ break;
default:
- fprintf(stderr, "Usage: %s [-h hostname] [-p port] [-c] [-v] [-t n]\n"
+ fprintf(stderr, "Usage: %s [-h hostname] [-p port] [-c] [-v] [-t n] [-P] [-T testname]'\n"
"\t-c\tGenerate coredump if a test fails\n"
"\t-v\tVerbose test output (print out the assertion)\n"
- "\t-t n\tSet the timeout for io-operations to n seconds\n",
+ "\t-t n\tSet the timeout for io-operations to n seconds\n"
+ "\t-P\tPrompt the user before starting a test.\n"
+ "\t\t\t\"skip\" will skip the test\n"
+ "\t\t\t\"quit\" will terminate memcapable\n"
+ "\t\t\tEverything else will start the test\n"
+ "\t-T n\tJust run the test named n\n"
+ "\t-a\tOnly test the ascii protocol\n"
+ "\t-b\tOnly test the binary protocol\n",
argv[0]);
- return 1;
+ return EXIT_FAILURE;
}
}
+ initialize_sockets();
sock= connect_server(hostname, port);
- if (sock == -1)
+ if (sock == INVALID_SOCKET)
{
fprintf(stderr, "Failed to connect to <%s:%s>: %s\n",
- hostname, port, strerror(errno));
- return 1;
+ hostname, port, strerror(get_socket_errno()));
+ return EXIT_FAILURE;
}
for (int ii= 0; testcases[ii].description != NULL; ++ii)
{
+ if (testname != NULL && strcmp(testcases[ii].description, testname) != 0)
+ continue;
+
+ if ((testcases[ii].description[0] == 'a' && (tests.ascii) == 0) ||
+ (testcases[ii].description[0] == 'b' && (tests.binary) == 0))
+ {
+ continue;
+ }
++total;
fprintf(stdout, "%-40s", testcases[ii].description);
fflush(stdout);
+ if (prompt)
+ {
+ fprintf(stdout, "\nPress <return> when you are ready? ");
+ char buffer[80] = {0};
+ if (fgets(buffer, sizeof(buffer), stdin) != NULL) {
+ if (strncmp(buffer, "skip", 4) == 0)
+ {
+ fprintf(stdout, "%-40s%s\n", testcases[ii].description,
+ status_msg[TEST_SKIP]);
+ fflush(stdout);
+ continue;
+ }
+ if (strncmp(buffer, "quit", 4) == 0)
+ exit(0);
+ }
+
+ fprintf(stdout, "%-40s", testcases[ii].description);
+ fflush(stdout);
+ }
+
bool reconnect= false;
enum test_return ret= testcases[ii].function();
if (ret == TEST_FAIL)
fprintf(stderr, "%s\n", status_msg[ret]);
if (reconnect)
{
- (void) close(sock);
- if ((sock=connect_server(hostname, port)) == -1)
+ closesocket(sock);
+ if ((sock= connect_server(hostname, port)) == INVALID_SOCKET)
{
fprintf(stderr, "Failed to connect to <%s:%s>: %s\n",
- hostname, port, strerror(errno));
+ hostname, port, strerror(get_socket_errno()));
fprintf(stderr, "%d of %d tests failed\n", failed, total);
- return 1;
+ return EXIT_FAILURE;
}
}
}
- (void) close(sock);
+ closesocket(sock);
if (failed == 0)
fprintf(stdout, "All tests passed\n");
else
projects / m6w6 / libmemcached / blobdiff