Merge lp:~tangent-org/libmemcached/1.0-build/ Build: jenkins-Libmemcached-187
[m6w6/libmemcached] / clients / memcapable.cc
1 /* LibMemcached
2 * Copyright (C) 2011-2012 Data Differential, http://datadifferential.com/
3 * Copyright (C) 2006-2009 Brian Aker
4 * All rights reserved.
5 *
6 * Use and distribution licensed under the BSD license. See
7 * the COPYING file in the parent directory for full text.
8 *
9 * Summary:
10 *
11 */
12
13 /* -*- Mode: C; tab-width: 2; c-basic-offset: 2; indent-tabs-mode: nil -*- */
14 #undef NDEBUG
15
16 #include <mem_config.h>
17
18 #ifdef HAVE_POLL_H
19 #include <poll.h>
20 #else
21 #include "poll/poll.h"
22 #endif
23
24 #include <cassert>
25 #include <cerrno>
26 #include <cstdio>
27 #include <cstdlib>
28 #include <cstring>
29 #include <ctype.h>
30 #include <fcntl.h>
31 #include <inttypes.h>
32 #include <pthread.h>
33 #include <signal.h>
34 #include <sys/types.h>
35 #include <unistd.h>
36
37 #include <libmemcached-1.0/memcached.h>
38
39 #include "libmemcached/socket.hpp"
40 #include "libmemcached/memcached/protocol_binary.h"
41 #include "libmemcached/byteorder.h"
42 #include "clients/utilities.h"
43
44 #include <vector>
45
46 #ifdef linux
47 /* /usr/include/netinet/in.h defines macros from ntohs() to _bswap_nn to
48 * optimize the conversion functions, but the prototypes generate warnings
49 * from gcc. The conversion methods isn't the bottleneck for my app, so
50 * just remove the warnings by undef'ing the optimization ..
51 */
52 #undef ntohs
53 #undef ntohl
54 #endif
55
56 /* Should we generate coredumps when we enounter an error (-c) */
57 static bool do_core= false;
58 /* connection to the server */
59 static memcached_socket_t sock;
60 /* Should the output from test failures be verbose or quiet? */
61 static bool verbose= false;
62
63 /* The number of seconds to wait for an IO-operation */
64 static int timeout= 2;
65
66 /*
67 * Instead of having to cast between the different datatypes we create
68 * a union of all of the different types of pacages we want to send.
69 * A lot of the different commands use the same packet layout, so I'll
70 * just define the different types I need. The typedefs only contain
71 * the header of the message, so we need some space for keys and body
72 * To avoid to have to do multiple writes, lets add a chunk of memory
73 * to use. 1k should be more than enough for header, key and body.
74 */
75 typedef union
76 {
77 protocol_binary_request_no_extras plain;
78 protocol_binary_request_flush flush;
79 protocol_binary_request_incr incr;
80 protocol_binary_request_set set;
81 char bytes[1024];
82 } command;
83
84 typedef union
85 {
86 protocol_binary_response_no_extras plain;
87 protocol_binary_response_incr incr;
88 protocol_binary_response_decr decr;
89 char bytes[1024];
90 } response;
91
92 enum test_return
93 {
94 TEST_SKIP, TEST_PASS, TEST_PASS_RECONNECT, TEST_FAIL
95 };
96
97 /**
98 * Try to get an addrinfo struct for a given port on a given host
99 */
100 static struct addrinfo *lookuphost(const char *hostname, const char *port)
101 {
102 struct addrinfo *ai= 0;
103 struct addrinfo hints;
104 memset(&hints, 0, sizeof(struct addrinfo));
105 hints.ai_family=AF_UNSPEC;
106 hints.ai_protocol=IPPROTO_TCP;
107 hints.ai_socktype=SOCK_STREAM;
108
109 int error= getaddrinfo(hostname, port, &hints, &ai);
110 if (error != 0)
111 {
112 if (error != EAI_SYSTEM)
113 fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(error));
114 else
115 perror("getaddrinfo()");
116 }
117
118 return ai;
119 }
120
121 /**
122 * Set the socket in nonblocking mode
123 * @return -1 if failure, the socket otherwise
124 */
125 static memcached_socket_t set_noblock(void)
126 {
127 #ifdef WIN32
128 u_long arg = 1;
129 if (ioctlsocket(sock, FIONBIO, &arg) == SOCKET_ERROR)
130 {
131 perror("Failed to set nonblocking io");
132 closesocket(sock);
133 return INVALID_SOCKET;
134 }
135 #else
136 int flags= fcntl(sock, F_GETFL, 0);
137 if (flags == -1)
138 {
139 perror("Failed to get socket flags");
140 memcached_close_socket(sock);
141 return INVALID_SOCKET;
142 }
143
144 if ((flags & O_NONBLOCK) != O_NONBLOCK)
145 {
146 if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1)
147 {
148 perror("Failed to set socket to nonblocking mode");
149 memcached_close_socket(sock);
150 return INVALID_SOCKET;
151 }
152 }
153 #endif
154 return sock;
155 }
156
157 /**
158 * Try to open a connection to the server
159 * @param hostname the name of the server to connect to
160 * @param port the port number (or service) to connect to
161 * @return positive integer if success, -1 otherwise
162 */
163 static memcached_socket_t connect_server(const char *hostname, const char *port)
164 {
165 struct addrinfo *ai= lookuphost(hostname, port);
166 sock= INVALID_SOCKET;
167 if (ai != NULL)
168 {
169 if ((sock= socket(ai->ai_family, ai->ai_socktype,
170 ai->ai_protocol)) != INVALID_SOCKET)
171 {
172 if (connect(sock, ai->ai_addr, ai->ai_addrlen) == SOCKET_ERROR)
173 {
174 fprintf(stderr, "Failed to connect socket: %s\n",
175 strerror(get_socket_errno()));
176 closesocket(sock);
177 sock= INVALID_SOCKET;
178 }
179 else
180 {
181 sock= set_noblock();
182 }
183 }
184 else
185 fprintf(stderr, "Failed to create socket: %s\n",
186 strerror(get_socket_errno()));
187
188 freeaddrinfo(ai);
189 }
190
191 return sock;
192 }
193
194 static ssize_t timeout_io_op(memcached_socket_t fd, short direction, void *buf, size_t len)
195 {
196 ssize_t ret;
197
198 if (direction == POLLOUT)
199 {
200 ret= send(fd, buf, len, 0);
201 }
202 else
203 {
204 ret= recv(fd, buf, len, 0);
205 }
206
207 if (ret == SOCKET_ERROR && get_socket_errno() == EWOULDBLOCK)
208 {
209 struct pollfd fds;
210 memset(&fds, 0, sizeof(struct pollfd));
211 fds.events= direction;
212 fds.fd= fd;
213
214 int err= poll(&fds, 1, timeout * 1000);
215 if (err == 1)
216 {
217 if (direction == POLLOUT)
218 {
219 ret= send(fd, buf, len, 0);
220 }
221 else
222 {
223 ret= recv(fd, buf, len, 0);
224 }
225 }
226 else if (err == 0)
227 {
228 errno= ETIMEDOUT;
229 }
230 else
231 {
232 perror("Failed to poll");
233 return -1;
234 }
235 }
236
237 return ret;
238 }
239
240 /**
241 * Ensure that an expression is true. If it isn't print out a message similar
242 * to assert() and create a coredump if the user wants that. If not an error
243 * message is returned.
244 *
245 */
246 static enum test_return ensure(bool val, const char *expression, const char *file, int line)
247 {
248 if (!val)
249 {
250 if (verbose)
251 {
252 fprintf(stderr, "\n%s:%d: %s", file, line, expression);
253 }
254
255 if (do_core)
256 {
257 abort();
258 }
259
260 return TEST_FAIL;
261 }
262
263 return TEST_PASS;
264 }
265
266 #define verify(expression) do { if (ensure(expression, #expression, __FILE__, __LINE__) == TEST_FAIL) return TEST_FAIL; } while (0)
267 #define execute(expression) do { if (ensure(expression == TEST_PASS, #expression, __FILE__, __LINE__) == TEST_FAIL) return TEST_FAIL; } while (0)
268
269 /**
270 * Send a chunk of memory over the socket (retry if the call is iterrupted
271 */
272 static enum test_return retry_write(const void* buf, size_t len)
273 {
274 size_t offset= 0;
275 const char* ptr= static_cast<const char *>(buf);
276
277 do
278 {
279 size_t num_bytes= len - offset;
280 ssize_t nw= timeout_io_op(sock, POLLOUT, (void*)(ptr + offset), num_bytes);
281 if (nw == -1)
282 {
283 verify(get_socket_errno() == EINTR || get_socket_errno() == EAGAIN);
284 }
285 else
286 {
287 offset+= (size_t)nw;
288 }
289
290 } while (offset < len);
291
292 return TEST_PASS;
293 }
294
295 /**
296 * Resend a packet to the server (All fields in the command header should
297 * be in network byte order)
298 */
299 static enum test_return resend_packet(command *cmd)
300 {
301 size_t length= sizeof (protocol_binary_request_no_extras) +
302 ntohl(cmd->plain.message.header.request.bodylen);
303
304 execute(retry_write(cmd, length));
305 return TEST_PASS;
306 }
307
308 /**
309 * Send a command to the server. The command header needs to be updated
310 * to network byte order
311 */
312 static enum test_return send_packet(command *cmd)
313 {
314 /* Fix the byteorder of the header */
315 cmd->plain.message.header.request.keylen=
316 ntohs(cmd->plain.message.header.request.keylen);
317 cmd->plain.message.header.request.bodylen=
318 ntohl(cmd->plain.message.header.request.bodylen);
319 cmd->plain.message.header.request.cas=
320 memcached_ntohll(cmd->plain.message.header.request.cas);
321
322 execute(resend_packet(cmd));
323 return TEST_PASS;
324 }
325
326 /**
327 * Read a fixed length chunk of data from the server
328 */
329 static enum test_return retry_read(void *buf, size_t len)
330 {
331 size_t offset= 0;
332 do
333 {
334 ssize_t nr= timeout_io_op(sock, POLLIN, ((char*) buf) + offset, len - offset);
335 switch (nr) {
336 case -1 :
337 fprintf(stderr, "Errno: %d %s\n", get_socket_errno(), strerror(errno));
338 verify(get_socket_errno() == EINTR || get_socket_errno() == EAGAIN);
339 break;
340
341 case 0:
342 return TEST_FAIL;
343
344 default:
345 offset+= (size_t)nr;
346 }
347 } while (offset < len);
348
349 return TEST_PASS;
350 }
351
352 /**
353 * Receive a response from the server and conver the fields in the header
354 * to local byte order
355 */
356 static enum test_return recv_packet(response *rsp)
357 {
358 execute(retry_read(rsp, sizeof(protocol_binary_response_no_extras)));
359
360 /* Fix the byte order in the packet header */
361 rsp->plain.message.header.response.keylen=
362 ntohs(rsp->plain.message.header.response.keylen);
363 rsp->plain.message.header.response.status=
364 ntohs(rsp->plain.message.header.response.status);
365 rsp->plain.message.header.response.bodylen=
366 ntohl(rsp->plain.message.header.response.bodylen);
367 rsp->plain.message.header.response.cas=
368 memcached_ntohll(rsp->plain.message.header.response.cas);
369
370 size_t bodysz= rsp->plain.message.header.response.bodylen;
371 if (bodysz > 0)
372 execute(retry_read(rsp->bytes + sizeof (protocol_binary_response_no_extras), bodysz));
373
374 return TEST_PASS;
375 }
376
377 /**
378 * Create a storage command (add, set, replace etc)
379 *
380 * @param cmd destination buffer
381 * @param cc the storage command to create
382 * @param key the key to store
383 * @param keylen the length of the key
384 * @param dta the data to store with the key
385 * @param dtalen the length of the data to store with the key
386 * @param flags the flags to store along with the key
387 * @param exptime the expiry time for the key
388 */
389 static void storage_command(command *cmd,
390 uint8_t cc,
391 const void* key,
392 size_t keylen,
393 const void* dta,
394 size_t dtalen,
395 uint32_t flags,
396 uint32_t exptime)
397 {
398 /* all of the storage commands use the same command layout */
399 protocol_binary_request_set *request= &cmd->set;
400
401 memset(request, 0, sizeof (*request));
402 request->message.header.request.magic= PROTOCOL_BINARY_REQ;
403 request->message.header.request.opcode= cc;
404 request->message.header.request.keylen= (uint16_t)keylen;
405 request->message.header.request.extlen= 8;
406 request->message.header.request.bodylen= (uint32_t)(keylen + 8 + dtalen);
407 request->message.header.request.opaque= 0xdeadbeef;
408 request->message.body.flags= flags;
409 request->message.body.expiration= exptime;
410
411 off_t key_offset= sizeof (protocol_binary_request_no_extras) + 8;
412 memcpy(cmd->bytes + key_offset, key, keylen);
413 if (dta != NULL)
414 memcpy(cmd->bytes + key_offset + keylen, dta, dtalen);
415 }
416
417 /**
418 * Create a basic command to send to the server
419 * @param cmd destination buffer
420 * @param cc the command to create
421 * @param key the key to store
422 * @param keylen the length of the key
423 * @param dta the data to store with the key
424 * @param dtalen the length of the data to store with the key
425 */
426 static void raw_command(command *cmd,
427 uint8_t cc,
428 const void* key,
429 size_t keylen,
430 const void* dta,
431 size_t dtalen)
432 {
433 /* all of the storage commands use the same command layout */
434 memset(cmd, 0, sizeof (*cmd));
435 cmd->plain.message.header.request.magic= PROTOCOL_BINARY_REQ;
436 cmd->plain.message.header.request.opcode= cc;
437 cmd->plain.message.header.request.keylen= (uint16_t)keylen;
438 cmd->plain.message.header.request.bodylen= (uint32_t)(keylen + dtalen);
439 cmd->plain.message.header.request.opaque= 0xdeadbeef;
440
441 off_t key_offset= sizeof (protocol_binary_request_no_extras);
442
443 if (key != NULL)
444 memcpy(cmd->bytes + key_offset, key, keylen);
445
446 if (dta != NULL)
447 memcpy(cmd->bytes + key_offset + keylen, dta, dtalen);
448 }
449
450 /**
451 * Create the flush command
452 * @param cmd destination buffer
453 * @param cc the command to create (FLUSH/FLUSHQ)
454 * @param exptime when to flush
455 * @param use_extra to force using of the extra field?
456 */
457 static void flush_command(command *cmd,
458 uint8_t cc, uint32_t exptime, bool use_extra)
459 {
460 memset(cmd, 0, sizeof (cmd->flush));
461 cmd->flush.message.header.request.magic= PROTOCOL_BINARY_REQ;
462 cmd->flush.message.header.request.opcode= cc;
463 cmd->flush.message.header.request.opaque= 0xdeadbeef;
464
465 if (exptime != 0 || use_extra)
466 {
467 cmd->flush.message.header.request.extlen= 4;
468 cmd->flush.message.body.expiration= htonl(exptime);
469 cmd->flush.message.header.request.bodylen= 4;
470 }
471 }
472
473 /**
474 * Create a incr/decr command
475 * @param cc the cmd to create (FLUSH/FLUSHQ)
476 * @param key the key to operate on
477 * @param keylen the number of bytes in the key
478 * @param delta the number to add/subtract
479 * @param initial the initial value if the key doesn't exist
480 * @param exptime when the key should expire if it isn't set
481 */
482 static void arithmetic_command(command *cmd,
483 uint8_t cc,
484 const void* key,
485 size_t keylen,
486 uint64_t delta,
487 uint64_t initial,
488 uint32_t exptime)
489 {
490 memset(cmd, 0, sizeof (cmd->incr));
491 cmd->incr.message.header.request.magic= PROTOCOL_BINARY_REQ;
492 cmd->incr.message.header.request.opcode= cc;
493 cmd->incr.message.header.request.keylen= (uint16_t)keylen;
494 cmd->incr.message.header.request.extlen= 20;
495 cmd->incr.message.header.request.bodylen= (uint32_t)(keylen + 20);
496 cmd->incr.message.header.request.opaque= 0xdeadbeef;
497 cmd->incr.message.body.delta= memcached_htonll(delta);
498 cmd->incr.message.body.initial= memcached_htonll(initial);
499 cmd->incr.message.body.expiration= htonl(exptime);
500
501 off_t key_offset= sizeof (protocol_binary_request_no_extras) + 20;
502 memcpy(cmd->bytes + key_offset, key, keylen);
503 }
504
505 /**
506 * Validate the response header from the server
507 * @param rsp the response to check
508 * @param cc the expected command
509 * @param status the expected status
510 */
511 static enum test_return do_validate_response_header(response *rsp,
512 uint8_t cc, uint16_t status)
513 {
514 verify(rsp->plain.message.header.response.magic == PROTOCOL_BINARY_RES);
515 verify(rsp->plain.message.header.response.opcode == cc);
516 verify(rsp->plain.message.header.response.datatype == PROTOCOL_BINARY_RAW_BYTES);
517 verify(rsp->plain.message.header.response.status == status);
518 verify(rsp->plain.message.header.response.opaque == 0xdeadbeef);
519
520 if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS)
521 {
522 switch (cc) {
523 case PROTOCOL_BINARY_CMD_ADDQ:
524 case PROTOCOL_BINARY_CMD_APPENDQ:
525 case PROTOCOL_BINARY_CMD_DECREMENTQ:
526 case PROTOCOL_BINARY_CMD_DELETEQ:
527 case PROTOCOL_BINARY_CMD_FLUSHQ:
528 case PROTOCOL_BINARY_CMD_INCREMENTQ:
529 case PROTOCOL_BINARY_CMD_PREPENDQ:
530 case PROTOCOL_BINARY_CMD_QUITQ:
531 case PROTOCOL_BINARY_CMD_REPLACEQ:
532 case PROTOCOL_BINARY_CMD_SETQ:
533 verify("Quiet command shouldn't return on success" == NULL);
534 default:
535 break;
536 }
537
538 switch (cc) {
539 case PROTOCOL_BINARY_CMD_ADD:
540 case PROTOCOL_BINARY_CMD_REPLACE:
541 case PROTOCOL_BINARY_CMD_SET:
542 case PROTOCOL_BINARY_CMD_APPEND:
543 case PROTOCOL_BINARY_CMD_PREPEND:
544 verify(rsp->plain.message.header.response.keylen == 0);
545 verify(rsp->plain.message.header.response.extlen == 0);
546 verify(rsp->plain.message.header.response.bodylen == 0);
547 verify(rsp->plain.message.header.response.cas != 0);
548 break;
549 case PROTOCOL_BINARY_CMD_FLUSH:
550 case PROTOCOL_BINARY_CMD_NOOP:
551 case PROTOCOL_BINARY_CMD_QUIT:
552 case PROTOCOL_BINARY_CMD_DELETE:
553 verify(rsp->plain.message.header.response.keylen == 0);
554 verify(rsp->plain.message.header.response.extlen == 0);
555 verify(rsp->plain.message.header.response.bodylen == 0);
556 verify(rsp->plain.message.header.response.cas == 0);
557 break;
558
559 case PROTOCOL_BINARY_CMD_DECREMENT:
560 case PROTOCOL_BINARY_CMD_INCREMENT:
561 verify(rsp->plain.message.header.response.keylen == 0);
562 verify(rsp->plain.message.header.response.extlen == 0);
563 verify(rsp->plain.message.header.response.bodylen == 8);
564 verify(rsp->plain.message.header.response.cas != 0);
565 break;
566
567 case PROTOCOL_BINARY_CMD_STAT:
568 verify(rsp->plain.message.header.response.extlen == 0);
569 /* key and value exists in all packets except in the terminating */
570 verify(rsp->plain.message.header.response.cas == 0);
571 break;
572
573 case PROTOCOL_BINARY_CMD_VERSION:
574 verify(rsp->plain.message.header.response.keylen == 0);
575 verify(rsp->plain.message.header.response.extlen == 0);
576 verify(rsp->plain.message.header.response.bodylen != 0);
577 verify(rsp->plain.message.header.response.cas == 0);
578 break;
579
580 case PROTOCOL_BINARY_CMD_GET:
581 case PROTOCOL_BINARY_CMD_GETQ:
582 verify(rsp->plain.message.header.response.keylen == 0);
583 verify(rsp->plain.message.header.response.extlen == 4);
584 verify(rsp->plain.message.header.response.cas != 0);
585 break;
586
587 case PROTOCOL_BINARY_CMD_GETK:
588 case PROTOCOL_BINARY_CMD_GETKQ:
589 verify(rsp->plain.message.header.response.keylen != 0);
590 verify(rsp->plain.message.header.response.extlen == 4);
591 verify(rsp->plain.message.header.response.cas != 0);
592 break;
593
594 default:
595 /* Undefined command code */
596 break;
597 }
598 }
599 else
600 {
601 verify(rsp->plain.message.header.response.cas == 0);
602 verify(rsp->plain.message.header.response.extlen == 0);
603 if (cc != PROTOCOL_BINARY_CMD_GETK)
604 {
605 verify(rsp->plain.message.header.response.keylen == 0);
606 }
607 }
608
609 return TEST_PASS;
610 }
611
612 /* We call verify(validate_response_header), but that macro
613 * expects a boolean expression, and the function returns
614 * an enum.... Let's just create a macro to avoid cluttering
615 * the code with all of the == TEST_PASS ;-)
616 */
617 #define validate_response_header(a,b,c) \
618 do_validate_response_header(a,b,c) == TEST_PASS
619
620
621 static enum test_return send_binary_noop(void)
622 {
623 command cmd;
624 raw_command(&cmd, PROTOCOL_BINARY_CMD_NOOP, NULL, 0, NULL, 0);
625 execute(send_packet(&cmd));
626 return TEST_PASS;
627 }
628
629 static enum test_return receive_binary_noop(void)
630 {
631 response rsp;
632 execute(recv_packet(&rsp));
633 verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_NOOP,
634 PROTOCOL_BINARY_RESPONSE_SUCCESS));
635 return TEST_PASS;
636 }
637
638 static enum test_return test_binary_noop(void)
639 {
640 execute(send_binary_noop());
641 execute(receive_binary_noop());
642 return TEST_PASS;
643 }
644
645 static enum test_return test_binary_quit_impl(uint8_t cc)
646 {
647 command cmd;
648 response rsp;
649 raw_command(&cmd, cc, NULL, 0, NULL, 0);
650
651 execute(send_packet(&cmd));
652 if (cc == PROTOCOL_BINARY_CMD_QUIT)
653 {
654 execute(recv_packet(&rsp));
655 verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_QUIT,
656 PROTOCOL_BINARY_RESPONSE_SUCCESS));
657 }
658
659 /* Socket should be closed now, read should return EXIT_SUCCESS */
660 verify(timeout_io_op(sock, POLLIN, rsp.bytes, sizeof(rsp.bytes)) == 0);
661
662 return TEST_PASS_RECONNECT;
663 }
664
665 static enum test_return test_binary_quit(void)
666 {
667 return test_binary_quit_impl(PROTOCOL_BINARY_CMD_QUIT);
668 }
669
670 static enum test_return test_binary_quitq(void)
671 {
672 return test_binary_quit_impl(PROTOCOL_BINARY_CMD_QUITQ);
673 }
674
675 static enum test_return test_binary_set_impl(const char* key, uint8_t cc)
676 {
677 command cmd;
678 response rsp;
679
680 uint64_t value= 0xdeadbeefdeadcafeULL;
681 storage_command(&cmd, cc, key, strlen(key), &value, sizeof (value), 0, 0);
682
683 /* set should always work */
684 for (int ii= 0; ii < 10; ii++)
685 {
686 if (ii == 0)
687 {
688 execute(send_packet(&cmd));
689 }
690 else
691 {
692 execute(resend_packet(&cmd));
693 }
694
695 if (cc == PROTOCOL_BINARY_CMD_SET)
696 {
697 execute(recv_packet(&rsp));
698 verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
699 }
700 else
701 execute(test_binary_noop());
702 }
703
704 /*
705 * We need to get the current CAS id, and at this time we haven't
706 * verified that we have a working get
707 */
708 if (cc == PROTOCOL_BINARY_CMD_SETQ)
709 {
710 cmd.set.message.header.request.opcode= PROTOCOL_BINARY_CMD_SET;
711 execute(resend_packet(&cmd));
712 execute(recv_packet(&rsp));
713 verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_SET,
714 PROTOCOL_BINARY_RESPONSE_SUCCESS));
715 cmd.set.message.header.request.opcode= PROTOCOL_BINARY_CMD_SETQ;
716 }
717
718 /* try to set with the correct CAS value */
719 cmd.plain.message.header.request.cas= memcached_htonll(rsp.plain.message.header.response.cas);
720 execute(resend_packet(&cmd));
721 if (cc == PROTOCOL_BINARY_CMD_SET)
722 {
723 execute(recv_packet(&rsp));
724 verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
725 }
726 else
727 execute(test_binary_noop());
728
729 /* try to set with an incorrect CAS value */
730 cmd.plain.message.header.request.cas= memcached_htonll(rsp.plain.message.header.response.cas - 1);
731 execute(resend_packet(&cmd));
732 execute(send_binary_noop());
733 execute(recv_packet(&rsp));
734 verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS));
735 execute(receive_binary_noop());
736
737 return TEST_PASS;
738 }
739
740 static enum test_return test_binary_set(void)
741 {
742 return test_binary_set_impl("test_binary_set", PROTOCOL_BINARY_CMD_SET);
743 }
744
745 static enum test_return test_binary_setq(void)
746 {
747 return test_binary_set_impl("test_binary_setq", PROTOCOL_BINARY_CMD_SETQ);
748 }
749
750 static enum test_return test_binary_add_impl(const char* key, uint8_t cc)
751 {
752 command cmd;
753 response rsp;
754 uint64_t value= 0xdeadbeefdeadcafeULL;
755 storage_command(&cmd, cc, key, strlen(key), &value, sizeof (value), 0, 0);
756
757 /* first add should work, rest of them should fail (even with cas
758 as wildcard */
759 for (int ii=0; ii < 10; ii++)
760 {
761 if (ii == 0)
762 execute(send_packet(&cmd));
763 else
764 execute(resend_packet(&cmd));
765
766 if (cc == PROTOCOL_BINARY_CMD_ADD || ii > 0)
767 {
768 uint16_t expected_result;
769 if (ii == 0)
770 expected_result= PROTOCOL_BINARY_RESPONSE_SUCCESS;
771 else
772 expected_result= PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
773
774 execute(send_binary_noop());
775 execute(recv_packet(&rsp));
776 execute(receive_binary_noop());
777 verify(validate_response_header(&rsp, cc, expected_result));
778 }
779 else
780 execute(test_binary_noop());
781 }
782
783 return TEST_PASS;
784 }
785
786 static enum test_return test_binary_add(void)
787 {
788 return test_binary_add_impl("test_binary_add", PROTOCOL_BINARY_CMD_ADD);
789 }
790
791 static enum test_return test_binary_addq(void)
792 {
793 return test_binary_add_impl("test_binary_addq", PROTOCOL_BINARY_CMD_ADDQ);
794 }
795
796 static enum test_return binary_set_item(const char *key, const char *value)
797 {
798 command cmd;
799 response rsp;
800 storage_command(&cmd, PROTOCOL_BINARY_CMD_SET, key, strlen(key),
801 value, strlen(value), 0, 0);
802 execute(send_packet(&cmd));
803 execute(recv_packet(&rsp));
804 verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_SET,
805 PROTOCOL_BINARY_RESPONSE_SUCCESS));
806 return TEST_PASS;
807 }
808
809 static enum test_return test_binary_replace_impl(const char* key, uint8_t cc)
810 {
811 command cmd;
812 response rsp;
813 uint64_t value= 0xdeadbeefdeadcafeULL;
814 storage_command(&cmd, cc, key, strlen(key), &value, sizeof (value), 0, 0);
815
816 /* first replace should fail, successive should succeed (when the
817 item is added! */
818 for (int ii= 0; ii < 10; ii++)
819 {
820 if (ii == 0)
821 {
822 execute(send_packet(&cmd));
823 }
824 else
825 {
826 execute(resend_packet(&cmd));
827 }
828
829 if (cc == PROTOCOL_BINARY_CMD_REPLACE || ii == 0)
830 {
831 uint16_t expected_result;
832 if (ii == 0)
833 {
834 expected_result=PROTOCOL_BINARY_RESPONSE_KEY_ENOENT;
835 }
836 else
837 {
838 expected_result=PROTOCOL_BINARY_RESPONSE_SUCCESS;
839 }
840
841 execute(send_binary_noop());
842 execute(recv_packet(&rsp));
843 execute(receive_binary_noop());
844 verify(validate_response_header(&rsp, cc, expected_result));
845
846 if (ii == 0)
847 execute(binary_set_item(key, key));
848 }
849 else
850 {
851 execute(test_binary_noop());
852 }
853 }
854
855 /* verify that replace with CAS value works! */
856 cmd.plain.message.header.request.cas= memcached_htonll(rsp.plain.message.header.response.cas);
857 execute(resend_packet(&cmd));
858
859 if (cc == PROTOCOL_BINARY_CMD_REPLACE)
860 {
861 execute(recv_packet(&rsp));
862 verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
863 }
864 else
865 execute(test_binary_noop());
866
867 /* try to set with an incorrect CAS value */
868 cmd.plain.message.header.request.cas= memcached_htonll(rsp.plain.message.header.response.cas - 1);
869 execute(resend_packet(&cmd));
870 execute(send_binary_noop());
871 execute(recv_packet(&rsp));
872 execute(receive_binary_noop());
873 verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS));
874
875 return TEST_PASS;
876 }
877
878 static enum test_return test_binary_replace(void)
879 {
880 return test_binary_replace_impl("test_binary_replace", PROTOCOL_BINARY_CMD_REPLACE);
881 }
882
883 static enum test_return test_binary_replaceq(void)
884 {
885 return test_binary_replace_impl("test_binary_replaceq", PROTOCOL_BINARY_CMD_REPLACEQ);
886 }
887
888 static enum test_return test_binary_delete_impl(const char *key, uint8_t cc)
889 {
890 command cmd;
891 response rsp;
892 raw_command(&cmd, cc, key, strlen(key), NULL, 0);
893
894 /* The delete shouldn't work the first time, because the item isn't there */
895 execute(send_packet(&cmd));
896 execute(send_binary_noop());
897 execute(recv_packet(&rsp));
898 verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT));
899 execute(receive_binary_noop());
900 execute(binary_set_item(key, key));
901
902 /* The item should be present now, resend*/
903 execute(resend_packet(&cmd));
904 if (cc == PROTOCOL_BINARY_CMD_DELETE)
905 {
906 execute(recv_packet(&rsp));
907 verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
908 }
909
910 execute(test_binary_noop());
911
912 return TEST_PASS;
913 }
914
915 static enum test_return test_binary_delete(void)
916 {
917 return test_binary_delete_impl("test_binary_delete", PROTOCOL_BINARY_CMD_DELETE);
918 }
919
920 static enum test_return test_binary_deleteq(void)
921 {
922 return test_binary_delete_impl("test_binary_deleteq", PROTOCOL_BINARY_CMD_DELETEQ);
923 }
924
925 static enum test_return test_binary_get_impl(const char *key, uint8_t cc)
926 {
927 command cmd;
928 response rsp;
929
930 raw_command(&cmd, cc, key, strlen(key), NULL, 0);
931 execute(send_packet(&cmd));
932 execute(send_binary_noop());
933
934 if (cc == PROTOCOL_BINARY_CMD_GET || cc == PROTOCOL_BINARY_CMD_GETK)
935 {
936 execute(recv_packet(&rsp));
937 verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT));
938 }
939
940 execute(receive_binary_noop());
941
942 execute(binary_set_item(key, key));
943 execute(resend_packet(&cmd));
944 execute(send_binary_noop());
945
946 execute(recv_packet(&rsp));
947 verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
948 execute(receive_binary_noop());
949
950 return TEST_PASS;
951 }
952
953 static enum test_return test_binary_get(void)
954 {
955 return test_binary_get_impl("test_binary_get", PROTOCOL_BINARY_CMD_GET);
956 }
957
958 static enum test_return test_binary_getk(void)
959 {
960 return test_binary_get_impl("test_binary_getk", PROTOCOL_BINARY_CMD_GETK);
961 }
962
963 static enum test_return test_binary_getq(void)
964 {
965 return test_binary_get_impl("test_binary_getq", PROTOCOL_BINARY_CMD_GETQ);
966 }
967
968 static enum test_return test_binary_getkq(void)
969 {
970 return test_binary_get_impl("test_binary_getkq", PROTOCOL_BINARY_CMD_GETKQ);
971 }
972
973 static enum test_return test_binary_incr_impl(const char* key, uint8_t cc)
974 {
975 command cmd;
976 response rsp;
977 arithmetic_command(&cmd, cc, key, strlen(key), 1, 0, 0);
978
979 uint64_t ii;
980 for (ii= 0; ii < 10; ++ii)
981 {
982 if (ii == 0)
983 execute(send_packet(&cmd));
984 else
985 execute(resend_packet(&cmd));
986
987 if (cc == PROTOCOL_BINARY_CMD_INCREMENT)
988 {
989 execute(recv_packet(&rsp));
990 verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
991 verify(memcached_ntohll(rsp.incr.message.body.value) == ii);
992 }
993 else
994 execute(test_binary_noop());
995 }
996
997 /* @todo add incorrect CAS */
998 return TEST_PASS;
999 }
1000
1001 static enum test_return test_binary_incr(void)
1002 {
1003 return test_binary_incr_impl("test_binary_incr", PROTOCOL_BINARY_CMD_INCREMENT);
1004 }
1005
1006 static enum test_return test_binary_incrq(void)
1007 {
1008 return test_binary_incr_impl("test_binary_incrq", PROTOCOL_BINARY_CMD_INCREMENTQ);
1009 }
1010
1011 static enum test_return test_binary_decr_impl(const char* key, uint8_t cc)
1012 {
1013 command cmd;
1014 response rsp;
1015 arithmetic_command(&cmd, cc, key, strlen(key), 1, 9, 0);
1016
1017 int ii;
1018 for (ii= 9; ii > -1; --ii)
1019 {
1020 if (ii == 9)
1021 execute(send_packet(&cmd));
1022 else
1023 execute(resend_packet(&cmd));
1024
1025 if (cc == PROTOCOL_BINARY_CMD_DECREMENT)
1026 {
1027 execute(recv_packet(&rsp));
1028 verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
1029 verify(memcached_ntohll(rsp.decr.message.body.value) == (uint64_t)ii);
1030 }
1031 else
1032 execute(test_binary_noop());
1033 }
1034
1035 /* decr 0 should not wrap */
1036 execute(resend_packet(&cmd));
1037 if (cc == PROTOCOL_BINARY_CMD_DECREMENT)
1038 {
1039 execute(recv_packet(&rsp));
1040 verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
1041 verify(memcached_ntohll(rsp.decr.message.body.value) == 0);
1042 }
1043 else
1044 {
1045 /* @todo get the value and verify! */
1046
1047 }
1048
1049 /* @todo add incorrect cas */
1050 execute(test_binary_noop());
1051 return TEST_PASS;
1052 }
1053
1054 static enum test_return test_binary_decr(void)
1055 {
1056 return test_binary_decr_impl("test_binary_decr",
1057 PROTOCOL_BINARY_CMD_DECREMENT);
1058 }
1059
1060 static enum test_return test_binary_decrq(void)
1061 {
1062 return test_binary_decr_impl("test_binary_decrq",
1063 PROTOCOL_BINARY_CMD_DECREMENTQ);
1064 }
1065
1066 static enum test_return test_binary_version(void)
1067 {
1068 command cmd;
1069 response rsp;
1070 raw_command(&cmd, PROTOCOL_BINARY_CMD_VERSION, NULL, 0, NULL, 0);
1071
1072 execute(send_packet(&cmd));
1073 execute(recv_packet(&rsp));
1074 verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_VERSION,
1075 PROTOCOL_BINARY_RESPONSE_SUCCESS));
1076
1077 return TEST_PASS;
1078 }
1079
1080 static enum test_return test_binary_flush_impl(const char *key, uint8_t cc)
1081 {
1082 command cmd;
1083 response rsp;
1084
1085 for (int ii= 0; ii < 2; ++ii)
1086 {
1087 execute(binary_set_item(key, key));
1088 flush_command(&cmd, cc, 0, ii == 0);
1089 execute(send_packet(&cmd));
1090
1091 if (cc == PROTOCOL_BINARY_CMD_FLUSH)
1092 {
1093 execute(recv_packet(&rsp));
1094 verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
1095 }
1096 else
1097 execute(test_binary_noop());
1098
1099 raw_command(&cmd, PROTOCOL_BINARY_CMD_GET, key, strlen(key), NULL, 0);
1100 execute(send_packet(&cmd));
1101 execute(recv_packet(&rsp));
1102 verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_GET,
1103 PROTOCOL_BINARY_RESPONSE_KEY_ENOENT));
1104 }
1105
1106 return TEST_PASS;
1107 }
1108
1109 static enum test_return test_binary_flush(void)
1110 {
1111 return test_binary_flush_impl("test_binary_flush", PROTOCOL_BINARY_CMD_FLUSH);
1112 }
1113
1114 static enum test_return test_binary_flushq(void)
1115 {
1116 return test_binary_flush_impl("test_binary_flushq", PROTOCOL_BINARY_CMD_FLUSHQ);
1117 }
1118
1119 static enum test_return test_binary_concat_impl(const char *key, uint8_t cc)
1120 {
1121 command cmd;
1122 response rsp;
1123 const char *value;
1124
1125 if (cc == PROTOCOL_BINARY_CMD_APPEND || cc == PROTOCOL_BINARY_CMD_APPENDQ)
1126 {
1127 value="hello";
1128 }
1129 else
1130 {
1131 value=" world";
1132 }
1133
1134 execute(binary_set_item(key, value));
1135
1136 if (cc == PROTOCOL_BINARY_CMD_APPEND || cc == PROTOCOL_BINARY_CMD_APPENDQ)
1137 {
1138 value=" world";
1139 }
1140 else
1141 {
1142 value="hello";
1143 }
1144
1145 raw_command(&cmd, cc, key, strlen(key), value, strlen(value));
1146 execute(send_packet(&cmd));
1147 if (cc == PROTOCOL_BINARY_CMD_APPEND || cc == PROTOCOL_BINARY_CMD_PREPEND)
1148 {
1149 execute(recv_packet(&rsp));
1150 verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
1151 }
1152 else
1153 {
1154 execute(test_binary_noop());
1155 }
1156
1157 raw_command(&cmd, PROTOCOL_BINARY_CMD_GET, key, strlen(key), NULL, 0);
1158 execute(send_packet(&cmd));
1159 execute(recv_packet(&rsp));
1160 verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_GET,
1161 PROTOCOL_BINARY_RESPONSE_SUCCESS));
1162 verify(rsp.plain.message.header.response.bodylen - 4 == 11);
1163 verify(memcmp(rsp.bytes + 28, "hello world", 11) == 0);
1164
1165 return TEST_PASS;
1166 }
1167
1168 static enum test_return test_binary_append(void)
1169 {
1170 return test_binary_concat_impl("test_binary_append", PROTOCOL_BINARY_CMD_APPEND);
1171 }
1172
1173 static enum test_return test_binary_prepend(void)
1174 {
1175 return test_binary_concat_impl("test_binary_prepend", PROTOCOL_BINARY_CMD_PREPEND);
1176 }
1177
1178 static enum test_return test_binary_appendq(void)
1179 {
1180 return test_binary_concat_impl("test_binary_appendq", PROTOCOL_BINARY_CMD_APPENDQ);
1181 }
1182
1183 static enum test_return test_binary_prependq(void)
1184 {
1185 return test_binary_concat_impl("test_binary_prependq", PROTOCOL_BINARY_CMD_PREPENDQ);
1186 }
1187
1188 static enum test_return test_binary_stat(void)
1189 {
1190 command cmd;
1191 response rsp;
1192
1193 raw_command(&cmd, PROTOCOL_BINARY_CMD_STAT, NULL, 0, NULL, 0);
1194 execute(send_packet(&cmd));
1195
1196 do
1197 {
1198 execute(recv_packet(&rsp));
1199 verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_STAT,
1200 PROTOCOL_BINARY_RESPONSE_SUCCESS));
1201 } while (rsp.plain.message.header.response.keylen != 0);
1202
1203 return TEST_PASS;
1204 }
1205
1206 static enum test_return send_string(const char *cmd)
1207 {
1208 execute(retry_write(cmd, strlen(cmd)));
1209 return TEST_PASS;
1210 }
1211
1212 static enum test_return receive_line(char *buffer, size_t size)
1213 {
1214 size_t offset= 0;
1215 while (offset < size)
1216 {
1217 execute(retry_read(buffer + offset, 1));
1218 if (buffer[offset] == '\n')
1219 {
1220 if (offset + 1 < size)
1221 {
1222 buffer[offset + 1]= '\0';
1223 return TEST_PASS;
1224 }
1225 else
1226 return TEST_FAIL;
1227 }
1228 ++offset;
1229 }
1230
1231 return TEST_FAIL;
1232 }
1233
1234 static enum test_return receive_response(const char *msg) {
1235 char buffer[80];
1236 execute(receive_line(buffer, sizeof(buffer)));
1237 if (strcmp(msg, buffer) != 0) {
1238 fprintf(stderr, "[%s]\n", buffer);
1239 }
1240 verify(strcmp(msg, buffer) == 0);
1241 return TEST_PASS;
1242 }
1243
1244 static enum test_return receive_error_response(void)
1245 {
1246 char buffer[80];
1247 execute(receive_line(buffer, sizeof(buffer)));
1248 verify(strncmp(buffer, "ERROR", 5) == 0 ||
1249 strncmp(buffer, "CLIENT_ERROR", 12) == 0 ||
1250 strncmp(buffer, "SERVER_ERROR", 12) == 0);
1251 return TEST_PASS;
1252 }
1253
1254 static enum test_return test_ascii_quit(void)
1255 {
1256 /* Verify that quit handles unknown options */
1257 execute(send_string("quit foo bar\r\n"));
1258 execute(receive_error_response());
1259
1260 /* quit doesn't support noreply */
1261 execute(send_string("quit noreply\r\n"));
1262 execute(receive_error_response());
1263
1264 /* Verify that quit works */
1265 execute(send_string("quit\r\n"));
1266
1267 /* Socket should be closed now, read should return EXIT_SUCCESS */
1268 char buffer[80];
1269 verify(timeout_io_op(sock, POLLIN, buffer, sizeof(buffer)) == 0);
1270 return TEST_PASS_RECONNECT;
1271
1272 }
1273
1274 static enum test_return test_ascii_version(void)
1275 {
1276 /* Verify that version command handles unknown options */
1277 execute(send_string("version foo bar\r\n"));
1278 execute(receive_error_response());
1279
1280 /* version doesn't support noreply */
1281 execute(send_string("version noreply\r\n"));
1282 execute(receive_error_response());
1283
1284 /* Verify that verify works */
1285 execute(send_string("version\r\n"));
1286 char buffer[256];
1287 execute(receive_line(buffer, sizeof(buffer)));
1288 verify(strncmp(buffer, "VERSION ", 8) == 0);
1289
1290 return TEST_PASS;
1291 }
1292
1293 static enum test_return test_ascii_verbosity(void)
1294 {
1295 /* This command does not adhere to the spec! */
1296 execute(send_string("verbosity foo bar my\r\n"));
1297 execute(receive_error_response());
1298
1299 execute(send_string("verbosity noreply\r\n"));
1300 execute(receive_error_response());
1301
1302 execute(send_string("verbosity 0 noreply\r\n"));
1303 execute(test_ascii_version());
1304
1305 execute(send_string("verbosity\r\n"));
1306 execute(receive_error_response());
1307
1308 execute(send_string("verbosity 1\r\n"));
1309 execute(receive_response("OK\r\n"));
1310
1311 execute(send_string("verbosity 0\r\n"));
1312 execute(receive_response("OK\r\n"));
1313
1314 return TEST_PASS;
1315 }
1316
1317
1318
1319 static enum test_return test_ascii_set_impl(const char* key, bool noreply)
1320 {
1321 /* @todo add tests for bogus format! */
1322 char buffer[1024];
1323 snprintf(buffer, sizeof(buffer), "set %s 0 0 5%s\r\nvalue\r\n", key, noreply ? " noreply" : "");
1324 execute(send_string(buffer));
1325
1326 if (!noreply)
1327 {
1328 execute(receive_response("STORED\r\n"));
1329 }
1330
1331 return test_ascii_version();
1332 }
1333
1334 static enum test_return test_ascii_set(void)
1335 {
1336 return test_ascii_set_impl("test_ascii_set", false);
1337 }
1338
1339 static enum test_return test_ascii_set_noreply(void)
1340 {
1341 return test_ascii_set_impl("test_ascii_set_noreply", true);
1342 }
1343
1344 static enum test_return test_ascii_add_impl(const char* key, bool noreply)
1345 {
1346 /* @todo add tests for bogus format! */
1347 char buffer[1024];
1348 snprintf(buffer, sizeof(buffer), "add %s 0 0 5%s\r\nvalue\r\n", key, noreply ? " noreply" : "");
1349 execute(send_string(buffer));
1350
1351 if (!noreply)
1352 {
1353 execute(receive_response("STORED\r\n"));
1354 }
1355
1356 execute(send_string(buffer));
1357
1358 if (!noreply)
1359 {
1360 execute(receive_response("NOT_STORED\r\n"));
1361 }
1362
1363 return test_ascii_version();
1364 }
1365
1366 static enum test_return test_ascii_add(void)
1367 {
1368 return test_ascii_add_impl("test_ascii_add", false);
1369 }
1370
1371 static enum test_return test_ascii_add_noreply(void)
1372 {
1373 return test_ascii_add_impl("test_ascii_add_noreply", true);
1374 }
1375
1376 static enum test_return ascii_get_unknown_value(char **key, char **value, ssize_t *ndata)
1377 {
1378 char buffer[1024];
1379
1380 execute(receive_line(buffer, sizeof(buffer)));
1381 verify(strncmp(buffer, "VALUE ", 6) == 0);
1382 char *end= strchr(buffer + 6, ' ');
1383 verify(end != NULL);
1384 if (end)
1385 {
1386 *end= '\0';
1387 }
1388 *key= strdup(buffer + 6);
1389 verify(*key != NULL);
1390 char *ptr= end + 1;
1391
1392 unsigned long val= strtoul(ptr, &end, 10); /* flags */
1393 verify(ptr != end);
1394 verify(val == 0);
1395 verify(end != NULL);
1396 *ndata = (ssize_t)strtoul(end, &end, 10); /* size */
1397 verify(ptr != end);
1398 verify(end != NULL);
1399 while (end and *end != '\n' and isspace(*end))
1400 ++end;
1401 verify(end and *end == '\n');
1402
1403 *value= static_cast<char*>(malloc((size_t)*ndata));
1404 verify(*value != NULL);
1405
1406 execute(retry_read(*value, (size_t)*ndata));
1407
1408 execute(retry_read(buffer, 2));
1409 verify(memcmp(buffer, "\r\n", 2) == 0);
1410
1411 return TEST_PASS;
1412 }
1413
1414 static enum test_return ascii_get_value(const char *key, const char *value)
1415 {
1416
1417 char buffer[1024];
1418 size_t datasize= strlen(value);
1419
1420 verify(datasize < sizeof(buffer));
1421 execute(receive_line(buffer, sizeof(buffer)));
1422 verify(strncmp(buffer, "VALUE ", 6) == 0);
1423 verify(strncmp(buffer + 6, key, strlen(key)) == 0);
1424 char *ptr= buffer + 6 + strlen(key) + 1;
1425 char *end;
1426
1427 unsigned long val= strtoul(ptr, &end, 10); /* flags */
1428 verify(ptr != end);
1429 verify(val == 0);
1430 verify(end != NULL);
1431 val= strtoul(end, &end, 10); /* size */
1432 verify(ptr != end);
1433 verify(val == datasize);
1434 verify(end != NULL);
1435 while (end and *end != '\n' and isspace(*end))
1436 {
1437 ++end;
1438 }
1439 verify(end and *end == '\n');
1440
1441 execute(retry_read(buffer, datasize));
1442 verify(memcmp(buffer, value, datasize) == 0);
1443
1444 execute(retry_read(buffer, 2));
1445 verify(memcmp(buffer, "\r\n", 2) == 0);
1446
1447 return TEST_PASS;
1448 }
1449
1450 static enum test_return ascii_get_item(const char *key, const char *value,
1451 bool exist)
1452 {
1453 char buffer[1024];
1454 size_t datasize= 0;
1455 if (value != NULL)
1456 {
1457 datasize= strlen(value);
1458 }
1459
1460 verify(datasize < sizeof(buffer));
1461 snprintf(buffer, sizeof(buffer), "get %s\r\n", key);
1462 execute(send_string(buffer));
1463
1464 if (exist)
1465 {
1466 execute(ascii_get_value(key, value));
1467 }
1468
1469 execute(retry_read(buffer, 5));
1470 verify(memcmp(buffer, "END\r\n", 5) == 0);
1471
1472 return TEST_PASS;
1473 }
1474
1475 static enum test_return ascii_gets_value(const char *key, const char *value,
1476 unsigned long *cas)
1477 {
1478
1479 char buffer[1024];
1480 size_t datasize= strlen(value);
1481
1482 verify(datasize < sizeof(buffer));
1483 execute(receive_line(buffer, sizeof(buffer)));
1484 verify(strncmp(buffer, "VALUE ", 6) == 0);
1485 verify(strncmp(buffer + 6, key, strlen(key)) == 0);
1486 char *ptr= buffer + 6 + strlen(key) + 1;
1487 char *end;
1488
1489 unsigned long val= strtoul(ptr, &end, 10); /* flags */
1490 verify(ptr != end);
1491 verify(val == 0);
1492 verify(end != NULL);
1493 val= strtoul(end, &end, 10); /* size */
1494 verify(ptr != end);
1495 verify(val == datasize);
1496 verify(end != NULL);
1497 *cas= strtoul(end, &end, 10); /* cas */
1498 verify(ptr != end);
1499 verify(val == datasize);
1500 verify(end != NULL);
1501
1502 while (end and *end != '\n' and isspace(*end))
1503 {
1504 ++end;
1505 }
1506 verify(end and *end == '\n');
1507
1508 execute(retry_read(buffer, datasize));
1509 verify(memcmp(buffer, value, datasize) == 0);
1510
1511 execute(retry_read(buffer, 2));
1512 verify(memcmp(buffer, "\r\n", 2) == 0);
1513
1514 return TEST_PASS;
1515 }
1516
1517 static enum test_return ascii_gets_item(const char *key, const char *value,
1518 bool exist, unsigned long *cas)
1519 {
1520 char buffer[1024];
1521 size_t datasize= 0;
1522 if (value != NULL)
1523 {
1524 datasize= strlen(value);
1525 }
1526
1527 verify(datasize < sizeof(buffer));
1528 snprintf(buffer, sizeof(buffer), "gets %s\r\n", key);
1529 execute(send_string(buffer));
1530
1531 if (exist)
1532 execute(ascii_gets_value(key, value, cas));
1533
1534 execute(retry_read(buffer, 5));
1535 verify(memcmp(buffer, "END\r\n", 5) == 0);
1536
1537 return TEST_PASS;
1538 }
1539
1540 static enum test_return ascii_set_item(const char *key, const char *value)
1541 {
1542 char buffer[300];
1543 size_t len= strlen(value);
1544 snprintf(buffer, sizeof(buffer), "set %s 0 0 %u\r\n", key, (unsigned int)len);
1545 execute(send_string(buffer));
1546 execute(retry_write(value, len));
1547 execute(send_string("\r\n"));
1548 execute(receive_response("STORED\r\n"));
1549 return TEST_PASS;
1550 }
1551
1552 static enum test_return test_ascii_replace_impl(const char* key, bool noreply)
1553 {
1554 char buffer[1024];
1555 snprintf(buffer, sizeof(buffer), "replace %s 0 0 5%s\r\nvalue\r\n", key, noreply ? " noreply" : "");
1556 execute(send_string(buffer));
1557
1558 if (noreply)
1559 {
1560 execute(test_ascii_version());
1561 }
1562 else
1563 {
1564 execute(receive_response("NOT_STORED\r\n"));
1565 }
1566
1567 execute(ascii_set_item(key, "value"));
1568 execute(ascii_get_item(key, "value", true));
1569
1570
1571 execute(send_string(buffer));
1572
1573 if (noreply)
1574 execute(test_ascii_version());
1575 else
1576 execute(receive_response("STORED\r\n"));
1577
1578 return test_ascii_version();
1579 }
1580
1581 static enum test_return test_ascii_replace(void)
1582 {
1583 return test_ascii_replace_impl("test_ascii_replace", false);
1584 }
1585
1586 static enum test_return test_ascii_replace_noreply(void)
1587 {
1588 return test_ascii_replace_impl("test_ascii_replace_noreply", true);
1589 }
1590
1591 static enum test_return test_ascii_cas_impl(const char* key, bool noreply)
1592 {
1593 char buffer[1024];
1594 unsigned long cas;
1595
1596 execute(ascii_set_item(key, "value"));
1597 execute(ascii_gets_item(key, "value", true, &cas));
1598
1599 snprintf(buffer, sizeof(buffer), "cas %s 0 0 6 %lu%s\r\nvalue2\r\n", key, cas, noreply ? " noreply" : "");
1600 execute(send_string(buffer));
1601
1602 if (noreply)
1603 {
1604 execute(test_ascii_version());
1605 }
1606 else
1607 {
1608 execute(receive_response("STORED\r\n"));
1609 }
1610
1611 /* reexecute the same command should fail due to illegal cas */
1612 execute(send_string(buffer));
1613
1614 if (noreply)
1615 {
1616 execute(test_ascii_version());
1617 }
1618 else
1619 {
1620 execute(receive_response("EXISTS\r\n"));
1621 }
1622
1623 return test_ascii_version();
1624 }
1625
1626 static enum test_return test_ascii_cas(void)
1627 {
1628 return test_ascii_cas_impl("test_ascii_cas", false);
1629 }
1630
1631 static enum test_return test_ascii_cas_noreply(void)
1632 {
1633 return test_ascii_cas_impl("test_ascii_cas_noreply", true);
1634 }
1635
1636 static enum test_return test_ascii_delete_impl(const char *key, bool noreply)
1637 {
1638 execute(ascii_set_item(key, "value"));
1639
1640 execute(send_string("delete\r\n"));
1641 execute(receive_error_response());
1642 /* BUG: the server accepts delete a b */
1643 execute(send_string("delete a b c d e\r\n"));
1644 execute(receive_error_response());
1645
1646 char buffer[1024];
1647 snprintf(buffer, sizeof(buffer), "delete %s%s\r\n", key, noreply ? " noreply" : "");
1648 execute(send_string(buffer));
1649
1650 if (noreply)
1651 execute(test_ascii_version());
1652 else
1653 execute(receive_response("DELETED\r\n"));
1654
1655 execute(ascii_get_item(key, "value", false));
1656 execute(send_string(buffer));
1657 if (noreply)
1658 execute(test_ascii_version());
1659 else
1660 execute(receive_response("NOT_FOUND\r\n"));
1661
1662 return TEST_PASS;
1663 }
1664
1665 static enum test_return test_ascii_delete(void)
1666 {
1667 return test_ascii_delete_impl("test_ascii_delete", false);
1668 }
1669
1670 static enum test_return test_ascii_delete_noreply(void)
1671 {
1672 return test_ascii_delete_impl("test_ascii_delete_noreply", true);
1673 }
1674
1675 static enum test_return test_ascii_get(void)
1676 {
1677 execute(ascii_set_item("test_ascii_get", "value"));
1678
1679 execute(send_string("get\r\n"));
1680 execute(receive_error_response());
1681 execute(ascii_get_item("test_ascii_get", "value", true));
1682 execute(ascii_get_item("test_ascii_get_notfound", "value", false));
1683
1684 return TEST_PASS;
1685 }
1686
1687 static enum test_return test_ascii_gets(void)
1688 {
1689 execute(ascii_set_item("test_ascii_gets", "value"));
1690
1691 execute(send_string("gets\r\n"));
1692 execute(receive_error_response());
1693 unsigned long cas;
1694 execute(ascii_gets_item("test_ascii_gets", "value", true, &cas));
1695 execute(ascii_gets_item("test_ascii_gets_notfound", "value", false, &cas));
1696
1697 return TEST_PASS;
1698 }
1699
1700 static enum test_return test_ascii_mget(void)
1701 {
1702 const uint32_t nkeys= 5;
1703 const char * const keys[]= {
1704 "test_ascii_mget1",
1705 "test_ascii_mget2",
1706 /* test_ascii_mget_3 does not exist :) */
1707 "test_ascii_mget4",
1708 "test_ascii_mget5",
1709 "test_ascii_mget6"
1710 };
1711
1712 for (uint32_t x= 0; x < nkeys; ++x)
1713 {
1714 execute(ascii_set_item(keys[x], "value"));
1715 }
1716
1717 /* Ask for a key that doesn't exist as well */
1718 execute(send_string("get test_ascii_mget1 test_ascii_mget2 test_ascii_mget3 "
1719 "test_ascii_mget4 test_ascii_mget5 "
1720 "test_ascii_mget6\r\n"));
1721
1722 std::vector<char *> returned;
1723 returned.resize(nkeys);
1724
1725 for (uint32_t x= 0; x < nkeys; ++x)
1726 {
1727 ssize_t nbytes = 0;
1728 char *v= NULL;
1729 execute(ascii_get_unknown_value(&returned[x], &v, &nbytes));
1730 verify(nbytes == 5);
1731 verify(memcmp(v, "value", 5) == 0);
1732 free(v);
1733 }
1734
1735 char buffer[5];
1736 execute(retry_read(buffer, 5));
1737 verify(memcmp(buffer, "END\r\n", 5) == 0);
1738
1739 /* verify that we got all the keys we expected */
1740 for (uint32_t x= 0; x < nkeys; ++x)
1741 {
1742 bool found= false;
1743 for (uint32_t y= 0; y < nkeys; ++y)
1744 {
1745 if (strcmp(keys[x], returned[y]) == 0)
1746 {
1747 found = true;
1748 break;
1749 }
1750 }
1751 verify(found);
1752 }
1753
1754 for (uint32_t x= 0; x < nkeys; ++x)
1755 {
1756 free(returned[x]);
1757 }
1758
1759 return TEST_PASS;
1760 }
1761
1762 static enum test_return test_ascii_incr_impl(const char* key, bool noreply)
1763 {
1764 char cmd[300];
1765 snprintf(cmd, sizeof(cmd), "incr %s 1%s\r\n", key, noreply ? " noreply" : "");
1766
1767 execute(ascii_set_item(key, "0"));
1768 for (int x= 1; x < 11; ++x)
1769 {
1770 execute(send_string(cmd));
1771
1772 if (noreply)
1773 execute(test_ascii_version());
1774 else
1775 {
1776 char buffer[80];
1777 execute(receive_line(buffer, sizeof(buffer)));
1778 int val= atoi(buffer);
1779 verify(val == x);
1780 }
1781 }
1782
1783 execute(ascii_get_item(key, "10", true));
1784
1785 return TEST_PASS;
1786 }
1787
1788 static enum test_return test_ascii_incr(void)
1789 {
1790 return test_ascii_incr_impl("test_ascii_incr", false);
1791 }
1792
1793 static enum test_return test_ascii_incr_noreply(void)
1794 {
1795 return test_ascii_incr_impl("test_ascii_incr_noreply", true);
1796 }
1797
1798 static enum test_return test_ascii_decr_impl(const char* key, bool noreply)
1799 {
1800 char cmd[300];
1801 snprintf(cmd, sizeof(cmd), "decr %s 1%s\r\n", key, noreply ? " noreply" : "");
1802
1803 execute(ascii_set_item(key, "9"));
1804 for (int x= 8; x > -1; --x)
1805 {
1806 execute(send_string(cmd));
1807
1808 if (noreply)
1809 {
1810 execute(test_ascii_version());
1811 }
1812 else
1813 {
1814 char buffer[80];
1815 execute(receive_line(buffer, sizeof(buffer)));
1816 int val= atoi(buffer);
1817 verify(val == x);
1818 }
1819 }
1820
1821 execute(ascii_get_item(key, "0", true));
1822
1823 /* verify that it doesn't wrap */
1824 execute(send_string(cmd));
1825 if (noreply)
1826 {
1827 execute(test_ascii_version());
1828 }
1829 else
1830 {
1831 char buffer[80];
1832 execute(receive_line(buffer, sizeof(buffer)));
1833 }
1834 execute(ascii_get_item(key, "0", true));
1835
1836 return TEST_PASS;
1837 }
1838
1839 static enum test_return test_ascii_decr(void)
1840 {
1841 return test_ascii_decr_impl("test_ascii_decr", false);
1842 }
1843
1844 static enum test_return test_ascii_decr_noreply(void)
1845 {
1846 return test_ascii_decr_impl("test_ascii_decr_noreply", true);
1847 }
1848
1849
1850 static enum test_return test_ascii_flush_impl(const char *key, bool noreply)
1851 {
1852 #if 0
1853 /* Verify that the flush_all command handles unknown options */
1854 /* Bug in the current memcached server! */
1855 execute(send_string("flush_all foo bar\r\n"));
1856 execute(receive_error_response());
1857 #endif
1858
1859 execute(ascii_set_item(key, key));
1860 execute(ascii_get_item(key, key, true));
1861
1862 if (noreply)
1863 {
1864 execute(send_string("flush_all noreply\r\n"));
1865 execute(test_ascii_version());
1866 }
1867 else
1868 {
1869 execute(send_string("flush_all\r\n"));
1870 execute(receive_response("OK\r\n"));
1871 }
1872
1873 execute(ascii_get_item(key, key, false));
1874
1875 return TEST_PASS;
1876 }
1877
1878 static enum test_return test_ascii_flush(void)
1879 {
1880 return test_ascii_flush_impl("test_ascii_flush", false);
1881 }
1882
1883 static enum test_return test_ascii_flush_noreply(void)
1884 {
1885 return test_ascii_flush_impl("test_ascii_flush_noreply", true);
1886 }
1887
1888 static enum test_return test_ascii_concat_impl(const char *key,
1889 bool append,
1890 bool noreply)
1891 {
1892 const char *value;
1893
1894 if (append)
1895 value="hello";
1896 else
1897 value=" world";
1898
1899 execute(ascii_set_item(key, value));
1900
1901 if (append)
1902 {
1903 value=" world";
1904 }
1905 else
1906 {
1907 value="hello";
1908 }
1909
1910 char cmd[400];
1911 snprintf(cmd, sizeof(cmd), "%s %s 0 0 %u%s\r\n%s\r\n",
1912 append ? "append" : "prepend",
1913 key, (unsigned int)strlen(value), noreply ? " noreply" : "",
1914 value);
1915 execute(send_string(cmd));
1916
1917 if (noreply)
1918 {
1919 execute(test_ascii_version());
1920 }
1921 else
1922 {
1923 execute(receive_response("STORED\r\n"));
1924 }
1925
1926 execute(ascii_get_item(key, "hello world", true));
1927
1928 snprintf(cmd, sizeof(cmd), "%s %s_notfound 0 0 %u%s\r\n%s\r\n",
1929 append ? "append" : "prepend",
1930 key, (unsigned int)strlen(value), noreply ? " noreply" : "",
1931 value);
1932 execute(send_string(cmd));
1933
1934 if (noreply)
1935 {
1936 execute(test_ascii_version());
1937 }
1938 else
1939 {
1940 execute(receive_response("NOT_STORED\r\n"));
1941 }
1942
1943 return TEST_PASS;
1944 }
1945
1946 static enum test_return test_ascii_append(void)
1947 {
1948 return test_ascii_concat_impl("test_ascii_append", true, false);
1949 }
1950
1951 static enum test_return test_ascii_prepend(void)
1952 {
1953 return test_ascii_concat_impl("test_ascii_prepend", false, false);
1954 }
1955
1956 static enum test_return test_ascii_append_noreply(void)
1957 {
1958 return test_ascii_concat_impl("test_ascii_append_noreply", true, true);
1959 }
1960
1961 static enum test_return test_ascii_prepend_noreply(void)
1962 {
1963 return test_ascii_concat_impl("test_ascii_prepend_noreply", false, true);
1964 }
1965
1966 static enum test_return test_ascii_stat(void)
1967 {
1968 execute(send_string("stats noreply\r\n"));
1969 execute(receive_error_response());
1970 execute(send_string("stats\r\n"));
1971 char buffer[1024];
1972 do {
1973 execute(receive_line(buffer, sizeof(buffer)));
1974 } while (strcmp(buffer, "END\r\n") != 0);
1975
1976 return TEST_PASS_RECONNECT;
1977 }
1978
1979 typedef enum test_return(*TEST_FUNC)(void);
1980
1981 struct testcase
1982 {
1983 const char *description;
1984 TEST_FUNC function;
1985 };
1986
1987 struct testcase testcases[]= {
1988 { "ascii quit", test_ascii_quit },
1989 { "ascii version", test_ascii_version },
1990 { "ascii verbosity", test_ascii_verbosity },
1991 { "ascii set", test_ascii_set },
1992 { "ascii set noreply", test_ascii_set_noreply },
1993 { "ascii get", test_ascii_get },
1994 { "ascii gets", test_ascii_gets },
1995 { "ascii mget", test_ascii_mget },
1996 { "ascii flush", test_ascii_flush },
1997 { "ascii flush noreply", test_ascii_flush_noreply },
1998 { "ascii add", test_ascii_add },
1999 { "ascii add noreply", test_ascii_add_noreply },
2000 { "ascii replace", test_ascii_replace },
2001 { "ascii replace noreply", test_ascii_replace_noreply },
2002 { "ascii cas", test_ascii_cas },
2003 { "ascii cas noreply", test_ascii_cas_noreply },
2004 { "ascii delete", test_ascii_delete },
2005 { "ascii delete noreply", test_ascii_delete_noreply },
2006 { "ascii incr", test_ascii_incr },
2007 { "ascii incr noreply", test_ascii_incr_noreply },
2008 { "ascii decr", test_ascii_decr },
2009 { "ascii decr noreply", test_ascii_decr_noreply },
2010 { "ascii append", test_ascii_append },
2011 { "ascii append noreply", test_ascii_append_noreply },
2012 { "ascii prepend", test_ascii_prepend },
2013 { "ascii prepend noreply", test_ascii_prepend_noreply },
2014 { "ascii stat", test_ascii_stat },
2015 { "binary noop", test_binary_noop },
2016 { "binary quit", test_binary_quit },
2017 { "binary quitq", test_binary_quitq },
2018 { "binary set", test_binary_set },
2019 { "binary setq", test_binary_setq },
2020 { "binary flush", test_binary_flush },
2021 { "binary flushq", test_binary_flushq },
2022 { "binary add", test_binary_add },
2023 { "binary addq", test_binary_addq },
2024 { "binary replace", test_binary_replace },
2025 { "binary replaceq", test_binary_replaceq },
2026 { "binary delete", test_binary_delete },
2027 { "binary deleteq", test_binary_deleteq },
2028 { "binary get", test_binary_get },
2029 { "binary getq", test_binary_getq },
2030 { "binary getk", test_binary_getk },
2031 { "binary getkq", test_binary_getkq },
2032 { "binary incr", test_binary_incr },
2033 { "binary incrq", test_binary_incrq },
2034 { "binary decr", test_binary_decr },
2035 { "binary decrq", test_binary_decrq },
2036 { "binary version", test_binary_version },
2037 { "binary append", test_binary_append },
2038 { "binary appendq", test_binary_appendq },
2039 { "binary prepend", test_binary_prepend },
2040 { "binary prependq", test_binary_prependq },
2041 { "binary stat", test_binary_stat },
2042 { NULL, NULL}
2043 };
2044
2045 const int ascii_tests = 1;
2046 const int binary_tests = 2;
2047
2048 struct test_type_st
2049 {
2050 bool ascii;
2051 bool binary;
2052 };
2053
2054 int main(int argc, char **argv)
2055 {
2056 static const char * const status_msg[]= {"[skip]", "[pass]", "[pass]", "[FAIL]"};
2057 struct test_type_st tests= { true, true };
2058 int total= 0;
2059 int failed= 0;
2060 const char *hostname= "localhost";
2061 const char *port= "11211";
2062 int cmd;
2063 bool prompt= false;
2064 const char *testname= NULL;
2065
2066
2067
2068 while ((cmd= getopt(argc, argv, "qt:vch:p:PT:?ab")) != EOF)
2069 {
2070 switch (cmd) {
2071 case 'a':
2072 tests.ascii= true;
2073 tests.binary= false;
2074 break;
2075
2076 case 'b':
2077 tests.ascii= false;
2078 tests.binary= true;
2079 break;
2080
2081 case 't':
2082 timeout= atoi(optarg);
2083 if (timeout == 0)
2084 {
2085 fprintf(stderr, "Invalid timeout. Please specify a number for -t\n");
2086 return EXIT_FAILURE;
2087 }
2088 break;
2089
2090 case 'v': verbose= true;
2091 break;
2092
2093 case 'c': do_core= true;
2094 break;
2095
2096 case 'h': hostname= optarg;
2097 break;
2098
2099 case 'p': port= optarg;
2100 break;
2101
2102 case 'q':
2103 close_stdio();
2104 break;
2105
2106 case 'P': prompt= true;
2107 break;
2108
2109 case 'T': testname= optarg;
2110 break;
2111
2112 default:
2113 fprintf(stderr, "Usage: %s [-h hostname] [-p port] [-c] [-v] [-t n] [-P] [-T testname]'\n"
2114 "\t-c\tGenerate coredump if a test fails\n"
2115 "\t-v\tVerbose test output (print out the assertion)\n"
2116 "\t-t n\tSet the timeout for io-operations to n seconds\n"
2117 "\t-P\tPrompt the user before starting a test.\n"
2118 "\t\t\t\"skip\" will skip the test\n"
2119 "\t\t\t\"quit\" will terminate memcapable\n"
2120 "\t\t\tEverything else will start the test\n"
2121 "\t-T n\tJust run the test named n\n"
2122 "\t-a\tOnly test the ascii protocol\n"
2123 "\t-b\tOnly test the binary protocol\n",
2124 argv[0]);
2125 return EXIT_SUCCESS;
2126 }
2127 }
2128
2129 initialize_sockets();
2130 sock= connect_server(hostname, port);
2131 if (sock == INVALID_SOCKET)
2132 {
2133 fprintf(stderr, "Failed to connect to <%s:%s>: %s\n",
2134 hostname, port, strerror(get_socket_errno()));
2135 return EXIT_FAILURE;
2136 }
2137
2138 for (int ii= 0; testcases[ii].description != NULL; ++ii)
2139 {
2140 if (testname != NULL && strcmp(testcases[ii].description, testname) != 0)
2141 {
2142 continue;
2143 }
2144
2145 if ((testcases[ii].description[0] == 'a' && (tests.ascii) == 0) ||
2146 (testcases[ii].description[0] == 'b' && (tests.binary) == 0))
2147 {
2148 continue;
2149 }
2150 ++total;
2151 fprintf(stdout, "%-40s", testcases[ii].description);
2152 fflush(stdout);
2153
2154 if (prompt)
2155 {
2156 fprintf(stdout, "\nPress <return> when you are ready? ");
2157 char buffer[80] = {0};
2158 if (fgets(buffer, sizeof(buffer), stdin) != NULL) {
2159 if (strncmp(buffer, "skip", 4) == 0)
2160 {
2161 fprintf(stdout, "%-40s%s\n", testcases[ii].description,
2162 status_msg[TEST_SKIP]);
2163 fflush(stdout);
2164 continue;
2165 }
2166 if (strncmp(buffer, "quit", 4) == 0)
2167 {
2168 exit(EXIT_SUCCESS);
2169 }
2170 }
2171
2172 fprintf(stdout, "%-40s", testcases[ii].description);
2173 fflush(stdout);
2174 }
2175
2176 bool reconnect= false;
2177 enum test_return ret= testcases[ii].function();
2178 if (ret == TEST_FAIL)
2179 {
2180 reconnect= true;
2181 ++failed;
2182 if (verbose)
2183 fprintf(stderr, "\n");
2184 }
2185 else if (ret == TEST_PASS_RECONNECT)
2186 reconnect= true;
2187
2188 fprintf(stderr, "%s\n", status_msg[ret]);
2189 if (reconnect)
2190 {
2191 closesocket(sock);
2192 if ((sock= connect_server(hostname, port)) == INVALID_SOCKET)
2193 {
2194 fprintf(stderr, "Failed to connect to <%s:%s>: %s\n", hostname, port, strerror(get_socket_errno()));
2195 fprintf(stderr, "%d of %d tests failed\n", failed, total);
2196 return EXIT_FAILURE;
2197 }
2198 }
2199 }
2200
2201 closesocket(sock);
2202 if (failed == 0)
2203 {
2204 fprintf(stdout, "All tests passed\n");
2205 }
2206 else
2207 {
2208 fprintf(stderr, "%d of %d tests failed\n", failed, total);
2209 }
2210
2211 return (failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2212 }