1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 #include <libtest/test.hpp>
41 #if defined(HAVE_LIBUUID) && HAVE_LIBUUID
42 #include <uuid/uuid.h>
49 #include <libmemcached-1.0/memcached.h>
50 #include <libmemcached/is.h>
51 #include <libmemcached/server_instance.h>
53 #include <libhashkit-1.0/hashkit.h>
55 #include <libtest/memcached.hpp>
60 #include <semaphore.h>
64 #include <sys/types.h>
69 #include <libtest/server.h>
71 #include "clients/generator.h"
73 #define SMALL_STRING_LEN 1024
75 #include <libtest/test.hpp>
77 using namespace libtest
;
79 #include <libmemcached/util.h>
81 #include "tests/hash_results.h"
83 #include "tests/libmemcached-1.0/callback_counter.h"
84 #include "tests/libmemcached-1.0/fetch_all_results.h"
85 #include "tests/libmemcached-1.0/mem_functions.h"
86 #include "tests/libmemcached-1.0/setup_and_teardowns.h"
87 #include "tests/print.h"
88 #include "tests/debug.h"
90 #define UUID_STRING_MAXLENGTH 36
92 #include "tests/keys.hpp"
94 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
97 If no options are given, copy over at least the binary flag.
99 char options_buffer
[1024]= { 0 };
102 if (memcached_is_binary(original_memc
))
104 snprintf(options_buffer
, sizeof(options_buffer
), "--BINARY");
109 * I only want to hit _one_ server so I know the number of requests I'm
110 * sending in the pipeline.
112 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
114 char server_string
[1024];
115 int server_string_length
;
116 if (instance
->type
== MEMCACHED_CONNECTION_UNIX_SOCKET
)
120 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\" %s",
121 memcached_server_name(instance
), options
);
125 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\"",
126 memcached_server_name(instance
));
133 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
134 memcached_server_name(instance
), int(memcached_server_port(instance
)),
139 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
140 memcached_server_name(instance
), int(memcached_server_port(instance
)));
144 if (server_string_length
<= 0)
149 char errror_buffer
[1024];
150 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, errror_buffer
, sizeof(errror_buffer
))))
152 Error
<< "Failed to parse (" << server_string
<< ") " << errror_buffer
;
156 return memcached(server_string
, server_string_length
);
160 test_return_t
init_test(memcached_st
*not_used
)
165 (void)memcached_create(&memc
);
166 memcached_free(&memc
);
171 #define TEST_PORT_COUNT 7
172 in_port_t test_ports
[TEST_PORT_COUNT
];
174 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
175 const memcached_server_st
*server
,
179 size_t bigger
= *((size_t *)(context
));
181 fatal_assert(bigger
<= memcached_server_port(server
));
182 *((size_t *)(context
))= memcached_server_port(server
);
184 return MEMCACHED_SUCCESS
;
187 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
188 const memcached_server_st
*instance
,
192 FILE *stream
= (FILE *)context
;
195 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
196 memcached_server_name(instance
),
197 memcached_server_port(instance
),
198 instance
->major_version
,
199 instance
->minor_version
,
200 instance
->micro_version
);
202 return MEMCACHED_SUCCESS
;
205 test_return_t
server_sort_test(memcached_st
*ptr
)
207 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
209 memcached_return_t rc
;
210 memcached_server_fn callbacks
[1];
211 memcached_st
*local_memc
;
214 local_memc
= memcached_create(NULL
);
215 test_true(local_memc
);
216 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
218 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
220 test_ports
[x
]= (in_port_t
)random() % 64000;
221 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
222 test_compare(memcached_server_count(local_memc
), x
+1);
224 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
226 test_compare(MEMCACHED_SUCCESS
, rc
);
229 callbacks
[0]= server_display_function
;
230 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
233 memcached_free(local_memc
);
238 test_return_t
server_sort2_test(memcached_st
*ptr
)
240 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
241 memcached_server_fn callbacks
[1];
242 memcached_st
*local_memc
;
243 memcached_server_instance_st instance
;
246 local_memc
= memcached_create(NULL
);
247 test_true(local_memc
);
248 test_compare(MEMCACHED_SUCCESS
,
249 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
251 test_compare(MEMCACHED_SUCCESS
,
252 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
253 instance
= memcached_server_instance_by_position(local_memc
, 0);
254 test_compare(in_port_t(43043), memcached_server_port(instance
));
256 test_compare(MEMCACHED_SUCCESS
,
257 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
259 instance
= memcached_server_instance_by_position(local_memc
, 0);
260 test_compare(in_port_t(43042), memcached_server_port(instance
));
262 instance
= memcached_server_instance_by_position(local_memc
, 1);
263 test_compare(in_port_t(43043), memcached_server_port(instance
));
265 callbacks
[0]= server_display_function
;
266 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
269 memcached_free(local_memc
);
274 test_return_t
memcached_server_remove_test(memcached_st
*)
276 const char *server_string
= "--server=localhost:4444 --server=localhost:4445 --server=localhost:4446 --server=localhost:4447 --server=localhost --server=memcache1.memcache.bk.sapo.pt:11211 --server=memcache1.memcache.bk.sapo.pt:11212 --server=memcache1.memcache.bk.sapo.pt:11213 --server=memcache1.memcache.bk.sapo.pt:11214 --server=memcache2.memcache.bk.sapo.pt:11211 --server=memcache2.memcache.bk.sapo.pt:11212 --server=memcache2.memcache.bk.sapo.pt:11213 --server=memcache2.memcache.bk.sapo.pt:11214";
279 test_compare(MEMCACHED_SUCCESS
,
280 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
281 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
284 memcached_server_fn callbacks
[1];
285 callbacks
[0]= server_print_callback
;
286 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
288 memcached_free(memc
);
293 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
294 const memcached_server_st
*server
,
298 uint32_t x
= *((uint32_t *)(context
));
300 if (! (test_ports
[x
] == server
->port
))
302 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
303 return MEMCACHED_FAILURE
;
306 *((uint32_t *)(context
))= ++x
;
308 return MEMCACHED_SUCCESS
;
311 test_return_t
server_unsort_test(memcached_st
*ptr
)
313 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
314 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
315 memcached_server_fn callbacks
[1];
316 memcached_st
*local_memc
;
319 local_memc
= memcached_create(NULL
);
320 test_true(local_memc
);
322 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
324 test_ports
[x
]= (in_port_t
)(random() % 64000);
325 test_compare(MEMCACHED_SUCCESS
,
326 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
327 test_compare(memcached_server_count(local_memc
), x
+1);
329 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
333 callbacks
[0]= server_display_unsort_function
;
334 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
336 /* Now we sort old data! */
337 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
338 callbacks
[0]= server_display_function
;
339 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
342 memcached_free(local_memc
);
347 test_return_t
allocation_test(memcached_st
*not_used
)
351 memc
= memcached_create(NULL
);
353 memcached_free(memc
);
358 test_return_t
clone_test(memcached_st
*memc
)
362 memcached_st
*memc_clone
;
363 memc_clone
= memcached_clone(NULL
, NULL
);
364 test_true(memc_clone
);
365 memcached_free(memc_clone
);
368 /* Can we init from null? */
370 memcached_st
*memc_clone
;
371 memc_clone
= memcached_clone(NULL
, memc
);
372 test_true(memc_clone
);
375 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
376 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
377 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
378 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
381 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
382 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
383 test_true(memc_clone
->distribution
== memc
->distribution
);
384 { // Test all of the flags
385 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
386 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
387 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
388 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
389 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
390 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
391 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
392 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
393 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
394 test_true(memc_clone
->flags
.reply
== memc
->flags
.reply
);
395 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
396 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
397 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
399 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
400 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
401 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
402 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
403 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
404 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
405 test_true(memc_clone
->on_clone
== memc
->on_clone
);
406 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
407 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
408 test_true(memc_clone
->recv_size
== memc
->recv_size
);
409 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
410 test_true(memc_clone
->send_size
== memc
->send_size
);
411 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
412 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
413 test_true(memc_clone
->user_data
== memc
->user_data
);
415 memcached_free(memc_clone
);
418 /* Can we init from struct? */
420 memcached_st declared_clone
;
421 memcached_st
*memc_clone
;
422 memset(&declared_clone
, 0 , sizeof(memcached_st
));
423 memc_clone
= memcached_clone(&declared_clone
, NULL
);
424 test_true(memc_clone
);
425 memcached_free(memc_clone
);
428 /* Can we init from struct? */
430 memcached_st declared_clone
;
431 memcached_st
*memc_clone
;
432 memset(&declared_clone
, 0 , sizeof(memcached_st
));
433 memc_clone
= memcached_clone(&declared_clone
, memc
);
434 test_true(memc_clone
);
435 memcached_free(memc_clone
);
441 test_return_t
userdata_test(memcached_st
*memc
)
444 test_false(memcached_set_user_data(memc
, foo
));
445 test_true(memcached_get_user_data(memc
) == foo
);
446 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
451 test_return_t
connection_test(memcached_st
*memc
)
453 test_compare(MEMCACHED_SUCCESS
,
454 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
459 test_return_t
libmemcached_string_behavior_test(memcached_st
*)
461 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
463 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
465 test_compare(37, int(MEMCACHED_BEHAVIOR_MAX
));
470 test_return_t
libmemcached_string_distribution_test(memcached_st
*)
472 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
474 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
476 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
481 test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
483 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
484 982370485U, 1263635348U, 4242906218U, 3829656100U,
485 1891735253U, 334139633U, 2257084983U, 3351789013U,
486 13199785U, 2542027183U, 1097051614U, 199566778U,
487 2748246961U, 2465192557U, 1664094137U, 2405439045U,
488 1842224848U, 692413798U, 3479807801U, 919913813U,
489 4269430871U, 610793021U, 527273862U, 1437122909U,
490 2300930706U, 2943759320U, 674306647U, 2400528935U,
491 54481931U, 4186304426U, 1741088401U, 2979625118U,
492 4159057246U, 3425930182U, 2593724503U, 1868899624U,
493 1769812374U, 2302537950U, 1110330676U, 3365377466U,
494 1336171666U, 3021258493U, 2334992265U, 3861994737U,
495 3582734124U, 3365377466U };
497 // You have updated the memcache_error messages but not updated docs/tests.
498 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
501 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
502 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
503 MEMCACHED_HASH_JENKINS
);
504 if (values
[rc
] != hash_val
)
506 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
507 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
509 test_compare(values
[rc
], hash_val
);
511 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
516 test_return_t
set_test(memcached_st
*memc
)
518 memcached_return_t rc
= memcached_set(memc
,
519 test_literal_param("foo"),
520 test_literal_param("when we sanitize"),
521 time_t(0), (uint32_t)0);
522 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
527 test_return_t
append_test(memcached_st
*memc
)
529 memcached_return_t rc
;
530 const char *in_value
= "we";
534 test_compare(MEMCACHED_SUCCESS
,
535 memcached_flush(memc
, 0));
537 test_compare(MEMCACHED_SUCCESS
,
539 test_literal_param(__func__
),
540 in_value
, strlen(in_value
),
541 time_t(0), uint32_t(0)));
543 test_compare(MEMCACHED_SUCCESS
,
544 memcached_append(memc
,
545 test_literal_param(__func__
),
546 " the", strlen(" the"),
547 time_t(0), uint32_t(0)));
549 test_compare(MEMCACHED_SUCCESS
,
550 memcached_append(memc
,
551 test_literal_param(__func__
),
552 " people", strlen(" people"),
553 time_t(0), uint32_t(0)));
555 char *out_value
= memcached_get(memc
,
556 test_literal_param(__func__
),
557 &value_length
, &flags
, &rc
);
558 test_memcmp(out_value
, "we the people", strlen("we the people"));
559 test_compare(strlen("we the people"), value_length
);
560 test_compare(MEMCACHED_SUCCESS
, rc
);
566 test_return_t
append_binary_test(memcached_st
*memc
)
568 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
570 test_compare(MEMCACHED_SUCCESS
,
571 memcached_flush(memc
, 0));
573 test_compare(MEMCACHED_SUCCESS
,
575 test_literal_param(__func__
),
577 time_t(0), uint32_t(0)));
580 for (uint32_t x
= 0; store_list
[x
] ; x
++)
582 test_compare(MEMCACHED_SUCCESS
,
583 memcached_append(memc
,
584 test_literal_param(__func__
),
585 (char *)&store_list
[x
], sizeof(uint32_t),
586 time_t(0), uint32_t(0)));
592 memcached_return_t rc
;
593 uint32_t *value
= (uint32_t *)memcached_get(memc
,
594 test_literal_param(__func__
),
595 &value_length
, &flags
, &rc
);
596 test_compare(value_length
, sizeof(uint32_t) * count
);
597 test_compare(MEMCACHED_SUCCESS
, rc
);
599 for (uint32_t counter
= count
, *ptr
= value
; counter
; counter
--)
601 test_compare(*ptr
, store_list
[count
- counter
]);
609 test_return_t
memcached_mget_mixed_memcached_get_TEST(memcached_st
*memc
)
613 for (libtest::vchar_ptr_t::iterator iter
= keys
.begin();
617 test_compare_hint(MEMCACHED_SUCCESS
,
621 time_t(0), uint32_t(0)),
622 memcached_last_error_message(memc
));
625 for (ptrdiff_t loop
= 0; loop
< 20; loop
++)
629 test_compare(MEMCACHED_SUCCESS
,
630 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
632 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
635 size_t result_count
= 0;
636 memcached_return_t rc
;
637 while (memcached_fetch_result(memc
, results
, &rc
))
641 test_true(keys
.size() >= result_count
);
645 int which_key
= random() %keys
.size();
648 memcached_return_t rc
;
649 char *out_value
= memcached_get(memc
, keys
.key_at(which_key
), keys
.length_at(which_key
),
650 &value_length
, &flags
, &rc
);
651 if (rc
== MEMCACHED_NOTFOUND
)
652 { } // It is possible that the value has been purged.
655 test_compare(MEMCACHED_SUCCESS
, rc
);
657 test_null(out_value
);
658 test_zero(value_length
);
666 test_return_t
cas2_test(memcached_st
*memc
)
668 const char *keys
[]= {"fudge", "son", "food"};
669 size_t key_length
[]= {5, 3, 4};
670 const char *value
= "we the people";
671 size_t value_length
= strlen("we the people");
673 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
675 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
677 for (uint32_t x
= 0; x
< 3; x
++)
679 test_compare(MEMCACHED_SUCCESS
,
680 memcached_set(memc
, keys
[x
], key_length
[x
],
681 keys
[x
], key_length
[x
],
682 time_t(50), uint32_t(9)));
685 test_compare(MEMCACHED_SUCCESS
,
686 memcached_mget(memc
, keys
, key_length
, 3));
688 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
691 memcached_return_t rc
;
692 results
= memcached_fetch_result(memc
, results
, &rc
);
694 test_true(results
->item_cas
);
695 test_compare(MEMCACHED_SUCCESS
, rc
);
696 test_true(memcached_result_cas(results
));
698 test_memcmp(value
, "we the people", strlen("we the people"));
699 test_compare(strlen("we the people"), value_length
);
700 test_compare(MEMCACHED_SUCCESS
, rc
);
702 memcached_result_free(results
);
707 test_return_t
cas_test(memcached_st
*memc
)
709 const char* keys
[2] = { __func__
, NULL
};
710 size_t keylengths
[2] = { strlen(__func__
), 0 };
712 memcached_result_st results_obj
;
714 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
716 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
718 test_compare(MEMCACHED_SUCCESS
,
720 test_literal_param(__func__
),
721 test_literal_param("we the people"),
722 (time_t)0, (uint32_t)0));
724 test_compare(MEMCACHED_SUCCESS
,
725 memcached_mget(memc
, keys
, keylengths
, 1));
727 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
730 memcached_return_t rc
;
731 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
733 test_compare(MEMCACHED_SUCCESS
, rc
);
734 test_true(memcached_result_cas(results
));
735 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
736 test_compare(test_literal_param_size("we the people"),
737 strlen(memcached_result_value(results
)));
739 uint64_t cas
= memcached_result_cas(results
);
742 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
743 test_true(rc
== MEMCACHED_END
);
744 test_true(results
== NULL
);
747 test_compare(MEMCACHED_SUCCESS
,
749 test_literal_param(__func__
),
750 test_literal_param("change the value"),
754 * The item will have a new cas value, so try to set it again with the old
755 * value. This should fail!
757 test_compare(MEMCACHED_DATA_EXISTS
,
759 test_literal_param(__func__
),
760 test_literal_param("change the value"),
763 memcached_result_free(&results_obj
);
769 test_return_t
prepend_test(memcached_st
*memc
)
771 const char *key
= "fig";
772 const char *value
= "people";
774 test_compare(MEMCACHED_SUCCESS
,
775 memcached_flush(memc
, 0));
777 test_compare(MEMCACHED_SUCCESS
,
778 memcached_set(memc
, key
, strlen(key
),
779 value
, strlen(value
),
780 time_t(0), uint32_t(0)));
782 test_compare(MEMCACHED_SUCCESS
,
783 memcached_prepend(memc
, key
, strlen(key
),
784 "the ", strlen("the "),
785 time_t(0), uint32_t(0)));
787 test_compare(MEMCACHED_SUCCESS
,
788 memcached_prepend(memc
, key
, strlen(key
),
789 "we ", strlen("we "),
790 time_t(0), uint32_t(0)));
794 memcached_return_t rc
;
795 char *out_value
= memcached_get(memc
, key
, strlen(key
),
796 &value_length
, &flags
, &rc
);
797 test_memcmp(out_value
, "we the people", strlen("we the people"));
798 test_compare(strlen("we the people"), value_length
);
799 test_compare(MEMCACHED_SUCCESS
, rc
);
806 Set the value, then quit to make sure it is flushed.
807 Come back in and test that add fails.
809 test_return_t
memcached_add_SUCCESS_TEST(memcached_st
*memc
)
811 memcached_return_t rc
;
812 test_null(memcached_get(memc
, test_literal_param(__func__
), NULL
, NULL
, &rc
));
813 test_compare(MEMCACHED_NOTFOUND
, rc
);
815 test_compare(MEMCACHED_SUCCESS
,
817 test_literal_param(__func__
),
818 test_literal_param("try something else"),
819 time_t(0), uint32_t(0)));
825 Set the value, then quit to make sure it is flushed.
826 Come back in and test that add fails.
828 test_return_t
add_test(memcached_st
*memc
)
830 test_compare(return_value_based_on_buffering(memc
),
832 test_literal_param(__func__
),
833 test_literal_param("when we sanitize"),
834 time_t(0), uint32_t(0)));
836 memcached_quit(memc
);
840 memcached_return_t rc
;
841 char *check_value
= memcached_get(memc
,
842 test_literal_param(__func__
),
843 &value_length
, &flags
, &rc
);
844 test_memcmp(check_value
, "when we sanitize", strlen("when we sanitize"));
845 test_compare(test_literal_param_size("when we sanitize"), value_length
);
846 test_compare(MEMCACHED_SUCCESS
, rc
);
849 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
851 test_literal_param(__func__
),
852 test_literal_param("try something else"),
853 time_t(0), uint32_t(0)));
859 ** There was a problem of leaking filedescriptors in the initial release
860 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
861 ** systems it seems that the kernel is slow on reclaiming the resources
862 ** because the connects starts to time out (the test doesn't do much
863 ** anyway, so just loop 10 iterations)
865 test_return_t
add_wrapper(memcached_st
*memc
)
867 unsigned int max
= 10000;
875 for (uint32_t x
= 0; x
< max
; x
++)
883 test_return_t
replace_test(memcached_st
*memc
)
885 test_compare(return_value_based_on_buffering(memc
),
887 test_literal_param(__func__
),
888 test_literal_param("when we sanitize"),
889 time_t(0), uint32_t(0)));
891 test_compare(MEMCACHED_SUCCESS
,
892 memcached_replace(memc
,
893 test_literal_param(__func__
),
894 test_literal_param("first we insert some data"),
895 time_t(0), uint32_t(0)));
900 test_return_t
delete_test(memcached_st
*memc
)
902 test_compare(return_value_based_on_buffering(memc
),
904 test_literal_param(__func__
),
905 test_literal_param("when we sanitize"),
906 time_t(0), uint32_t(0)));
908 test_compare(return_value_based_on_buffering(memc
),
909 memcached_delete(memc
,
910 test_literal_param(__func__
),
916 test_return_t
flush_test(memcached_st
*memc
)
918 uint64_t query_id
= memcached_query_id(memc
);
919 test_compare(MEMCACHED_SUCCESS
,
920 memcached_flush(memc
, 0));
921 test_compare(query_id
+1, memcached_query_id(memc
));
926 static memcached_return_t
server_function(const memcached_st
*,
927 const memcached_server_st
*,
931 return MEMCACHED_SUCCESS
;
934 test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
937 strncpy(context
, "foo bad", sizeof(context
));
938 memcached_server_fn callbacks
[1];
940 callbacks
[0]= server_function
;
941 memcached_server_cursor(memc
, callbacks
, context
, 1);
945 test_return_t
bad_key_test(memcached_st
*memc
)
947 memcached_return_t rc
;
948 const char *key
= "foo bad";
951 uint64_t query_id
= memcached_query_id(memc
);
953 // Just skip if we are in binary mode.
954 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
956 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
958 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
959 test_true(memc_clone
);
961 query_id
= memcached_query_id(memc_clone
);
962 test_compare(MEMCACHED_SUCCESS
,
963 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
964 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
966 /* All keys are valid in the binary protocol (except for length) */
967 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == false)
969 uint64_t before_query_id
= memcached_query_id(memc_clone
);
971 size_t string_length
;
972 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
973 &string_length
, &flags
, &rc
);
974 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
975 test_zero(string_length
);
978 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
980 query_id
= memcached_query_id(memc_clone
);
981 test_compare(MEMCACHED_SUCCESS
,
982 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
983 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
985 size_t string_length
;
986 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
987 &string_length
, &flags
, &rc
);
988 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
989 test_zero(string_length
);
993 /* Test multi key for bad keys */
994 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
995 size_t key_lengths
[] = { 7, 7, 7 };
996 query_id
= memcached_query_id(memc_clone
);
997 test_compare(MEMCACHED_SUCCESS
,
998 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
999 test_compare(query_id
, memcached_query_id(memc_clone
));
1001 query_id
= memcached_query_id(memc_clone
);
1002 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
1003 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
1004 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1006 query_id
= memcached_query_id(memc_clone
);
1007 // Grouping keys are not required to follow normal key behaviors
1008 test_compare(MEMCACHED_SUCCESS
,
1009 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
1010 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1012 /* The following test should be moved to the end of this function when the
1013 memcached server is updated to allow max size length of the keys in the
1016 test_compare(MEMCACHED_SUCCESS
,
1017 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
1019 libtest::vchar_t longkey
;
1021 libtest::vchar_t::iterator it
= longkey
.begin();
1022 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
1025 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
1027 size_t string_length
;
1029 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
1030 test_compare(MEMCACHED_NOTFOUND
, rc
);
1031 test_zero(string_length
);
1033 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
1034 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1035 test_zero(string_length
);
1039 /* Make sure zero length keys are marked as bad */
1041 test_compare(MEMCACHED_SUCCESS
,
1042 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1043 size_t string_length
;
1044 char *string
= memcached_get(memc_clone
, key
, 0,
1045 &string_length
, &flags
, &rc
);
1046 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1047 test_zero(string_length
);
1051 memcached_free(memc_clone
);
1053 return TEST_SUCCESS
;
1056 #define READ_THROUGH_VALUE "set for me"
1057 static memcached_return_t
read_through_trigger(memcached_st
*, // memc
1059 size_t, // key_length,
1060 memcached_result_st
*result
)
1062 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
1065 #ifndef __INTEL_COMPILER
1066 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1069 test_return_t
read_through(memcached_st
*memc
)
1071 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1073 size_t string_length
;
1075 memcached_return_t rc
;
1076 char *string
= memcached_get(memc
,
1077 test_literal_param(__func__
),
1078 &string_length
, &flags
, &rc
);
1080 test_compare(MEMCACHED_NOTFOUND
, rc
);
1081 test_false(string_length
);
1084 test_compare(MEMCACHED_SUCCESS
,
1085 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1087 string
= memcached_get(memc
,
1088 test_literal_param(__func__
),
1089 &string_length
, &flags
, &rc
);
1091 test_compare(MEMCACHED_SUCCESS
, rc
);
1092 test_compare(sizeof(READ_THROUGH_VALUE
) -1, string_length
);
1093 test_compare(0, string
[sizeof(READ_THROUGH_VALUE
) -1]);
1094 test_strcmp(READ_THROUGH_VALUE
, string
);
1097 string
= memcached_get(memc
,
1098 test_literal_param(__func__
),
1099 &string_length
, &flags
, &rc
);
1101 test_compare(MEMCACHED_SUCCESS
, rc
);
1103 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1104 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1105 test_strcmp(READ_THROUGH_VALUE
, string
);
1108 return TEST_SUCCESS
;
1111 test_return_t
set_test2(memcached_st
*memc
)
1113 for (uint32_t x
= 0; x
< 10; x
++)
1115 test_compare(return_value_based_on_buffering(memc
),
1117 test_literal_param("foo"),
1118 test_literal_param("train in the brain"),
1119 time_t(0), uint32_t(0)));
1122 return TEST_SUCCESS
;
1125 test_return_t
set_test3(memcached_st
*memc
)
1127 size_t value_length
= 8191;
1129 libtest::vchar_t value
;
1130 value
.reserve(value_length
);
1131 for (uint32_t x
= 0; x
< value_length
; x
++)
1133 value
.push_back(char(x
% 127));
1136 /* The dump test relies on there being at least 32 items in memcached */
1137 for (uint32_t x
= 0; x
< 32; x
++)
1141 snprintf(key
, sizeof(key
), "foo%u", x
);
1143 uint64_t query_id
= memcached_query_id(memc
);
1144 test_compare(return_value_based_on_buffering(memc
),
1145 memcached_set(memc
, key
, strlen(key
),
1146 &value
[0], value
.size(),
1147 time_t(0), uint32_t(0)));
1148 test_compare(query_id
+1, memcached_query_id(memc
));
1151 return TEST_SUCCESS
;
1154 test_return_t
mget_end(memcached_st
*memc
)
1156 const char *keys
[]= { "foo", "foo2" };
1157 size_t lengths
[]= { 3, 4 };
1158 const char *values
[]= { "fjord", "41" };
1161 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1163 test_compare(MEMCACHED_SUCCESS
,
1165 keys
[x
], lengths
[x
],
1166 values
[x
], strlen(values
[x
]),
1167 time_t(0), uint32_t(0)));
1171 size_t string_length
;
1174 // retrieve both via mget
1175 test_compare(MEMCACHED_SUCCESS
,
1176 memcached_mget(memc
,
1178 test_array_length(keys
)));
1180 char key
[MEMCACHED_MAX_KEY
];
1182 memcached_return_t rc
;
1184 // this should get both
1185 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1187 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1189 test_compare(MEMCACHED_SUCCESS
, rc
);
1191 if (key_length
== 4)
1196 test_compare(string_length
, strlen(values
[val
]));
1197 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1201 // this should indicate end
1202 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1203 test_compare(MEMCACHED_END
, rc
);
1207 test_compare(MEMCACHED_SUCCESS
,
1208 memcached_mget(memc
, keys
, lengths
, 1));
1210 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1211 test_compare(key_length
, lengths
[0]);
1212 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1213 test_compare(string_length
, strlen(values
[0]));
1214 test_true(strncmp(values
[0], string
, string_length
) == 0);
1215 test_compare(MEMCACHED_SUCCESS
, rc
);
1218 // this should indicate end
1219 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1220 test_compare(MEMCACHED_END
, rc
);
1223 return TEST_SUCCESS
;
1226 /* Do not copy the style of this code, I just access hosts to testthis function */
1227 test_return_t
stats_servername_test(memcached_st
*memc
)
1229 memcached_stat_st memc_stat
;
1230 memcached_server_instance_st instance
=
1231 memcached_server_instance_by_position(memc
, 0);
1233 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1235 return TEST_SKIPPED
;
1238 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1239 memcached_server_name(instance
),
1240 memcached_server_port(instance
)));
1242 return TEST_SUCCESS
;
1245 test_return_t
increment_test(memcached_st
*memc
)
1247 uint64_t new_number
;
1249 test_compare(MEMCACHED_SUCCESS
,
1251 test_literal_param("number"),
1252 test_literal_param("0"),
1253 (time_t)0, (uint32_t)0));
1255 test_compare(MEMCACHED_SUCCESS
,
1256 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1257 test_compare(uint64_t(1), new_number
);
1259 test_compare(MEMCACHED_SUCCESS
,
1260 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1261 test_compare(uint64_t(2), new_number
);
1263 return TEST_SUCCESS
;
1266 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1268 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1270 uint64_t new_number
;
1271 uint64_t initial
= 0;
1273 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1275 test_compare(MEMCACHED_SUCCESS
,
1276 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1277 test_compare(new_number
, initial
);
1279 test_compare(MEMCACHED_SUCCESS
,
1280 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1281 test_compare(new_number
, (initial
+1));
1283 return TEST_SUCCESS
;
1286 test_return_t
decrement_test(memcached_st
*memc
)
1288 test_compare(return_value_based_on_buffering(memc
),
1290 test_literal_param(__func__
),
1291 test_literal_param("3"),
1292 time_t(0), uint32_t(0)));
1294 // Make sure we flush the value we just set
1295 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1297 uint64_t new_number
;
1298 test_compare(MEMCACHED_SUCCESS
,
1299 memcached_decrement(memc
,
1300 test_literal_param(__func__
),
1302 test_compare(uint64_t(2), new_number
);
1304 test_compare(MEMCACHED_SUCCESS
,
1305 memcached_decrement(memc
,
1306 test_literal_param(__func__
),
1308 test_compare(uint64_t(1), new_number
);
1310 return TEST_SUCCESS
;
1313 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1315 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1317 uint64_t initial
= 3;
1319 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1321 uint64_t new_number
;
1322 test_compare(MEMCACHED_SUCCESS
,
1323 memcached_decrement_with_initial(memc
,
1324 test_literal_param(__func__
),
1327 test_compare(new_number
, initial
);
1329 test_compare(MEMCACHED_SUCCESS
,
1330 memcached_decrement_with_initial(memc
,
1331 test_literal_param(__func__
),
1334 test_compare(new_number
, (initial
- 1));
1336 return TEST_SUCCESS
;
1339 test_return_t
increment_by_key_test(memcached_st
*memc
)
1341 const char *master_key
= "foo";
1342 const char *key
= "number";
1343 const char *value
= "0";
1345 test_compare(return_value_based_on_buffering(memc
),
1346 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1348 value
, strlen(value
),
1349 time_t(0), uint32_t(0)));
1351 // Make sure we flush the value we just set
1352 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1354 uint64_t new_number
;
1355 test_compare(MEMCACHED_SUCCESS
,
1356 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1357 key
, strlen(key
), 1, &new_number
));
1358 test_compare(uint64_t(1), new_number
);
1360 test_compare(MEMCACHED_SUCCESS
,
1361 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1362 key
, strlen(key
), 1, &new_number
));
1363 test_compare(uint64_t(2), new_number
);
1365 return TEST_SUCCESS
;
1368 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1370 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1372 uint64_t new_number
;
1373 const char *master_key
= "foo";
1374 const char *key
= "number";
1375 uint64_t initial
= 0;
1377 test_compare(MEMCACHED_SUCCESS
,
1378 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1380 1, initial
, 0, &new_number
));
1381 test_compare(new_number
, initial
);
1383 test_compare(MEMCACHED_SUCCESS
,
1384 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1386 1, initial
, 0, &new_number
));
1387 test_compare(new_number
, (initial
+1));
1389 return TEST_SUCCESS
;
1392 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1394 uint64_t new_number
;
1395 const char *value
= "3";
1397 test_compare(return_value_based_on_buffering(memc
),
1398 memcached_set_by_key(memc
,
1399 test_literal_param("foo"),
1400 test_literal_param("number"),
1401 value
, strlen(value
),
1402 (time_t)0, (uint32_t)0));
1404 test_compare(MEMCACHED_SUCCESS
,
1405 memcached_decrement_by_key(memc
,
1406 test_literal_param("foo"),
1407 test_literal_param("number"),
1409 test_compare(uint64_t(2), new_number
);
1411 test_compare(MEMCACHED_SUCCESS
,
1412 memcached_decrement_by_key(memc
,
1413 test_literal_param("foo"),
1414 test_literal_param("number"),
1416 test_compare(uint64_t(1), new_number
);
1418 return TEST_SUCCESS
;
1421 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1423 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1425 uint64_t new_number
;
1426 uint64_t initial
= 3;
1428 test_compare(MEMCACHED_SUCCESS
,
1429 memcached_decrement_with_initial_by_key(memc
,
1430 test_literal_param("foo"),
1431 test_literal_param("number"),
1432 1, initial
, 0, &new_number
));
1433 test_compare(new_number
, initial
);
1435 test_compare(MEMCACHED_SUCCESS
,
1436 memcached_decrement_with_initial_by_key(memc
,
1437 test_literal_param("foo"),
1438 test_literal_param("number"),
1439 1, initial
, 0, &new_number
));
1440 test_compare(new_number
, (initial
- 1));
1442 return TEST_SUCCESS
;
1444 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1446 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1448 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1450 test_compare(return_value_based_on_buffering(memc
),
1452 test_literal_param("number"),
1453 test_literal_param("0"),
1454 (time_t)0, (uint32_t)0));
1456 uint64_t new_number
;
1457 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1458 test_literal_param("number"),
1460 test_compare(uint64_t(1), new_number
);
1462 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1463 test_literal_param("number"),
1465 test_compare(uint64_t(2), new_number
);
1467 return TEST_SUCCESS
;
1470 test_return_t
quit_test(memcached_st
*memc
)
1472 const char *value
= "sanford and sun";
1474 test_compare(return_value_based_on_buffering(memc
),
1476 test_literal_param(__func__
),
1477 value
, strlen(value
),
1478 time_t(10), uint32_t(3)));
1479 memcached_quit(memc
);
1481 test_compare(return_value_based_on_buffering(memc
),
1483 test_literal_param(__func__
),
1484 value
, strlen(value
),
1485 time_t(50), uint32_t(9)));
1487 return TEST_SUCCESS
;
1490 test_return_t
mget_result_test(memcached_st
*memc
)
1492 const char *keys
[]= {"fudge", "son", "food"};
1493 size_t key_length
[]= {5, 3, 4};
1495 memcached_result_st results_obj
;
1496 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1498 test_true(&results_obj
== results
);
1500 /* We need to empty the server before continueing test */
1501 test_compare(MEMCACHED_SUCCESS
,
1502 memcached_flush(memc
, 0));
1504 test_compare(MEMCACHED_SUCCESS
,
1505 memcached_mget(memc
, keys
, key_length
, 3));
1507 memcached_return_t rc
;
1508 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1513 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1514 test_false(results
);
1515 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1517 for (uint32_t x
= 0; x
< 3; x
++)
1519 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1520 keys
[x
], key_length
[x
],
1521 (time_t)50, (uint32_t)9);
1522 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1525 test_compare(MEMCACHED_SUCCESS
,
1526 memcached_mget(memc
, keys
, key_length
, 3));
1528 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1531 test_true(&results_obj
== results
);
1532 test_compare(MEMCACHED_SUCCESS
, rc
);
1533 test_memcmp(memcached_result_key_value(results
),
1534 memcached_result_value(results
),
1535 memcached_result_length(results
));
1536 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1539 memcached_result_free(&results_obj
);
1541 return TEST_SUCCESS
;
1544 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1546 const char *keys
[]= {"fudge", "son", "food"};
1547 size_t key_length
[]= {5, 3, 4};
1549 memcached_result_st
*results
;
1551 /* We need to empty the server before continueing test */
1552 test_compare(MEMCACHED_SUCCESS
,
1553 memcached_flush(memc
, 0));
1555 test_compare(MEMCACHED_SUCCESS
,
1556 memcached_mget(memc
, keys
, key_length
, 3));
1558 memcached_return_t rc
;
1559 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1563 test_false(results
);
1564 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1566 for (uint32_t x
= 0; x
< 3; x
++)
1568 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1569 keys
[x
], key_length
[x
],
1570 (time_t)50, (uint32_t)9);
1571 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1574 test_compare(MEMCACHED_SUCCESS
,
1575 memcached_mget(memc
, keys
, key_length
, 3));
1578 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1581 test_compare(MEMCACHED_SUCCESS
, rc
);
1582 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1583 test_memcmp(memcached_result_key_value(results
),
1584 memcached_result_value(results
),
1585 memcached_result_length(results
));
1586 memcached_result_free(results
);
1590 return TEST_SUCCESS
;
1593 test_return_t
mget_result_function(memcached_st
*memc
)
1595 const char *keys
[]= {"fudge", "son", "food"};
1596 size_t key_length
[]= {5, 3, 4};
1598 memcached_execute_fn callbacks
[1];
1600 for (uint32_t x
= 0; x
< 3; x
++)
1602 test_compare(return_value_based_on_buffering(memc
),
1603 memcached_set(memc
, keys
[x
], key_length
[x
],
1604 keys
[x
], key_length
[x
],
1605 time_t(50), uint32_t(9)));
1607 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1608 memcached_quit(memc
);
1610 test_compare(MEMCACHED_SUCCESS
,
1611 memcached_mget(memc
, keys
, key_length
, 3));
1613 callbacks
[0]= &callback_counter
;
1616 test_compare(MEMCACHED_SUCCESS
,
1617 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1619 test_compare(size_t(3), counter
);
1621 return TEST_SUCCESS
;
1624 test_return_t
mget_test(memcached_st
*memc
)
1626 const char *keys
[]= {"fudge", "son", "food"};
1627 size_t key_length
[]= {5, 3, 4};
1629 char return_key
[MEMCACHED_MAX_KEY
];
1630 size_t return_key_length
;
1632 size_t return_value_length
;
1634 test_compare(MEMCACHED_SUCCESS
,
1635 memcached_mget(memc
, keys
, key_length
, 3));
1638 memcached_return_t rc
;
1639 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1640 &return_value_length
, &flags
, &rc
)))
1642 test_true(return_value
);
1644 test_false(return_value
);
1645 test_zero(return_value_length
);
1646 test_compare(MEMCACHED_NOTFOUND
, rc
);
1648 for (uint32_t x
= 0; x
< 3; x
++)
1650 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1651 keys
[x
], key_length
[x
],
1652 (time_t)50, (uint32_t)9);
1653 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1655 test_compare(MEMCACHED_SUCCESS
,
1656 memcached_mget(memc
, keys
, key_length
, 3));
1659 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1660 &return_value_length
, &flags
, &rc
)))
1662 test_true(return_value
);
1663 test_compare(MEMCACHED_SUCCESS
, rc
);
1664 if (not memc
->_namespace
)
1666 test_compare(return_key_length
, return_value_length
);
1667 test_memcmp(return_value
, return_key
, return_value_length
);
1673 return TEST_SUCCESS
;
1676 test_return_t
mget_execute(memcached_st
*original_memc
)
1678 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1680 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1683 keys_st
keys(20480);
1685 /* First add all of the items.. */
1686 char blob
[1024] = {0};
1688 for (size_t x
= 0; x
< keys
.size(); ++x
)
1690 uint64_t query_id
= memcached_query_id(memc
);
1691 memcached_return_t rc
= memcached_add(memc
,
1692 keys
.key_at(x
), keys
.length_at(x
),
1695 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1696 test_compare(query_id
+1, memcached_query_id(memc
));
1699 /* Try to get all of them with a large multiget */
1701 memcached_execute_fn callbacks
[]= { &callback_counter
};
1702 test_compare(MEMCACHED_SUCCESS
,
1703 memcached_mget_execute(memc
,
1704 keys
.keys_ptr(), keys
.lengths_ptr(),
1705 keys
.size(), callbacks
, &counter
, 1));
1708 uint64_t query_id
= memcached_query_id(memc
);
1709 test_compare(MEMCACHED_SUCCESS
,
1710 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1711 test_compare(query_id
, memcached_query_id(memc
));
1713 /* Verify that we got all of the items */
1714 test_compare(keys
.size(), counter
);
1717 memcached_free(memc
);
1719 return TEST_SUCCESS
;
1722 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1723 static pairs_st
*global_pairs
= NULL
;
1725 test_return_t
key_setup(memcached_st
*memc
)
1727 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1729 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1731 return TEST_SUCCESS
;
1734 test_return_t
key_teardown(memcached_st
*)
1736 pairs_free(global_pairs
);
1739 return TEST_SUCCESS
;
1742 test_return_t
block_add_regression(memcached_st
*memc
)
1744 /* First add all of the items.. */
1745 for (ptrdiff_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1747 libtest::vchar_t blob
;
1748 libtest::vchar::make(blob
, 1024);
1750 memcached_return_t rc
= memcached_add_by_key(memc
,
1751 test_literal_param("bob"),
1752 global_pairs
[x
].key
, global_pairs
[x
].key_length
,
1753 &blob
[0], blob
.size(),
1754 time_t(0), uint32_t(0));
1755 test_compare(*memc
, MEMCACHED_SUCCESS
);
1756 test_compare(rc
, MEMCACHED_SUCCESS
);
1759 return TEST_SUCCESS
;
1762 test_return_t
binary_add_regression(memcached_st
*memc
)
1764 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1765 return block_add_regression(memc
);
1768 test_return_t
get_stats_keys(memcached_st
*memc
)
1772 memcached_stat_st memc_stat
;
1773 memcached_return_t rc
;
1775 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1776 test_compare(MEMCACHED_SUCCESS
, rc
);
1777 for (ptr
= stat_list
; *ptr
; ptr
++)
1782 return TEST_SUCCESS
;
1785 test_return_t
version_string_test(memcached_st
*)
1787 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1789 return TEST_SUCCESS
;
1792 test_return_t
get_stats(memcached_st
*memc
)
1794 memcached_return_t rc
;
1796 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1797 test_compare(MEMCACHED_SUCCESS
, rc
);
1798 test_true(memc_stat
);
1800 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1802 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1803 test_compare(MEMCACHED_SUCCESS
, rc
);
1804 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1809 memcached_stat_free(NULL
, memc_stat
);
1811 return TEST_SUCCESS
;
1814 test_return_t
add_host_test(memcached_st
*memc
)
1816 char servername
[]= "0.example.com";
1818 memcached_return_t rc
;
1819 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1820 test_compare(1U, memcached_server_list_count(servers
));
1822 for (unsigned int x
= 2; x
< 20; x
++)
1824 char buffer
[SMALL_STRING_LEN
];
1826 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1827 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1829 test_compare(MEMCACHED_SUCCESS
, rc
);
1830 test_compare(x
, memcached_server_list_count(servers
));
1833 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1834 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1836 memcached_server_list_free(servers
);
1838 return TEST_SUCCESS
;
1841 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1843 memcached_return_t rc
;
1845 const char *key
= "not_found";
1846 size_t key_length
= test_literal_param_size("not_found");
1848 test_compare(MEMCACHED_SUCCESS
,
1849 memcached_mget(memc
, &key
, &key_length
, 1));
1851 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1853 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1855 memcached_result_free(result
);
1857 return TEST_SUCCESS
;
1860 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1862 return MEMCACHED_SUCCESS
;
1865 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1867 return MEMCACHED_SUCCESS
;
1870 test_return_t
callback_test(memcached_st
*memc
)
1872 /* Test User Data */
1876 memcached_return_t rc
;
1878 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1879 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1880 test_true(*test_ptr
== x
);
1883 /* Test Clone Callback */
1885 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1886 void *clone_cb_ptr
= *(void **)&clone_cb
;
1887 void *temp_function
= NULL
;
1889 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
1890 memcached_return_t rc
;
1891 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1892 test_true(temp_function
== clone_cb_ptr
);
1893 test_compare(MEMCACHED_SUCCESS
, rc
);
1896 /* Test Cleanup Callback */
1898 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
1899 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1900 void *temp_function
= NULL
;
1901 memcached_return_t rc
;
1903 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
1904 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1905 test_true(temp_function
== cleanup_cb_ptr
);
1908 return TEST_SUCCESS
;
1911 /* We don't test the behavior itself, we test the switches */
1912 test_return_t
behavior_test(memcached_st
*memc
)
1914 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
1915 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
1917 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
1918 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
1920 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
1921 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1923 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
1924 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
1926 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
1927 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
1929 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
1930 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1932 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
1933 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1935 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
1937 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
1939 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
1940 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
1941 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
1943 return TEST_SUCCESS
;
1946 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
1948 test_compare(MEMCACHED_DEPRECATED
,
1949 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
1951 // Platform dependent
1953 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
1957 return TEST_SUCCESS
;
1961 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
1963 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
1964 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
1966 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
1968 if (memcached_success(rc
))
1977 return TEST_SUCCESS
;
1981 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
1983 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
1984 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
1986 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
1988 if (memcached_success(rc
))
1997 return TEST_SUCCESS
;
2000 /* Make sure we behave properly if server list has no values */
2001 test_return_t
user_supplied_bug4(memcached_st
*memc
)
2003 const char *keys
[]= {"fudge", "son", "food"};
2004 size_t key_length
[]= {5, 3, 4};
2006 /* Here we free everything before running a bunch of mget tests */
2007 memcached_servers_reset(memc
);
2010 /* We need to empty the server before continueing test */
2011 test_compare(MEMCACHED_NO_SERVERS
,
2012 memcached_flush(memc
, 0));
2014 test_compare(MEMCACHED_NO_SERVERS
,
2015 memcached_mget(memc
, keys
, key_length
, 3));
2018 unsigned int keys_returned
;
2019 memcached_return_t rc
;
2020 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2021 test_compare(MEMCACHED_NOTFOUND
, rc
);
2022 test_zero(keys_returned
);
2025 for (uint32_t x
= 0; x
< 3; x
++)
2027 test_compare(MEMCACHED_NO_SERVERS
,
2028 memcached_set(memc
, keys
[x
], key_length
[x
],
2029 keys
[x
], key_length
[x
],
2030 (time_t)50, (uint32_t)9));
2033 test_compare(MEMCACHED_NO_SERVERS
,
2034 memcached_mget(memc
, keys
, key_length
, 3));
2038 char return_key
[MEMCACHED_MAX_KEY
];
2039 memcached_return_t rc
;
2040 size_t return_key_length
;
2041 size_t return_value_length
;
2044 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2045 &return_value_length
, &flags
, &rc
)))
2047 test_true(return_value
);
2048 test_compare(MEMCACHED_SUCCESS
, rc
);
2049 test_true(return_key_length
== return_value_length
);
2050 test_memcmp(return_value
, return_key
, return_value_length
);
2056 return TEST_SUCCESS
;
2059 #define VALUE_SIZE_BUG5 1048064
2060 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2062 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2063 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2065 size_t value_length
;
2067 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2069 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2071 insert_data
[x
]= (signed char)rand();
2074 test_compare(MEMCACHED_SUCCESS
,
2075 memcached_flush(memc
, 0));
2077 memcached_return_t rc
;
2078 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2079 test_compare(MEMCACHED_SUCCESS
,
2080 memcached_mget(memc
, keys
, key_length
, 4));
2083 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2084 test_compare(MEMCACHED_NOTFOUND
, rc
);
2087 for (uint32_t x
= 0; x
< 4; x
++)
2089 test_compare(MEMCACHED_SUCCESS
,
2090 memcached_set(memc
, keys
[x
], key_length
[x
],
2091 insert_data
, VALUE_SIZE_BUG5
,
2092 (time_t)0, (uint32_t)0));
2095 for (uint32_t x
= 0; x
< 10; x
++)
2097 value
= memcached_get(memc
, keys
[0], key_length
[0],
2098 &value_length
, &flags
, &rc
);
2099 test_compare(rc
, MEMCACHED_SUCCESS
);
2103 test_compare(MEMCACHED_SUCCESS
,
2104 memcached_mget(memc
, keys
, key_length
, 4));
2106 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2107 test_compare(4U, count
);
2109 delete [] insert_data
;
2111 return TEST_SUCCESS
;
2114 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2116 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2117 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2118 char return_key
[MEMCACHED_MAX_KEY
];
2119 size_t return_key_length
;
2121 size_t value_length
;
2123 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2125 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2127 insert_data
[x
]= (signed char)rand();
2130 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2132 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2134 // We will now confirm that memcached_mget() returns success, but we will
2135 // then check to make sure that no actual keys are returned.
2136 test_compare(MEMCACHED_SUCCESS
,
2137 memcached_mget(memc
, keys
, key_length
, 4));
2139 memcached_return_t rc
;
2141 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2142 &value_length
, &flags
, &rc
)))
2147 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2149 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2151 test_compare(MEMCACHED_SUCCESS
,
2152 memcached_set(memc
, keys
[x
], key_length
[x
],
2153 insert_data
, VALUE_SIZE_BUG5
,
2154 (time_t)0, (uint32_t)0));
2156 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2158 for (uint32_t x
= 0; x
< 2; x
++)
2160 value
= memcached_get(memc
, keys
[0], key_length
[0],
2161 &value_length
, &flags
, &rc
);
2165 test_compare(MEMCACHED_SUCCESS
,
2166 memcached_mget(memc
, keys
, key_length
, 4));
2167 /* We test for purge of partial complete fetches */
2168 for (count
= 3; count
; count
--)
2170 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2171 &value_length
, &flags
, &rc
);
2172 test_compare(MEMCACHED_SUCCESS
, rc
);
2173 test_memcmp(value
, insert_data
, value_length
);
2174 test_true(value_length
);
2178 delete [] insert_data
;
2180 return TEST_SUCCESS
;
2183 test_return_t
user_supplied_bug8(memcached_st
*)
2185 memcached_return_t rc
;
2187 memcached_st
*memc_clone
;
2189 memcached_server_st
*servers
;
2190 const char *server_list
= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
2192 servers
= memcached_servers_parse(server_list
);
2195 mine
= memcached_create(NULL
);
2196 rc
= memcached_server_push(mine
, servers
);
2197 test_compare(MEMCACHED_SUCCESS
, rc
);
2198 memcached_server_list_free(servers
);
2201 memc_clone
= memcached_clone(NULL
, mine
);
2203 memcached_quit(mine
);
2204 memcached_quit(memc_clone
);
2207 memcached_free(mine
);
2208 memcached_free(memc_clone
);
2210 return TEST_SUCCESS
;
2213 /* Test flag store/retrieve */
2214 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2216 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2217 test_true(insert_data
);
2219 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2221 insert_data
[x
]= (signed char)rand();
2224 memcached_flush(memc
, 0);
2226 const char *keys
= "036790384900";
2227 size_t key_length
= strlen(keys
);
2228 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2229 insert_data
, VALUE_SIZE_BUG5
,
2232 memcached_return_t rc
;
2233 size_t value_length
;
2235 char *value
= memcached_get(memc
, keys
, key_length
,
2236 &value_length
, &flags
, &rc
);
2237 test_compare(245U, flags
);
2241 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2243 char return_key
[MEMCACHED_MAX_KEY
];
2244 size_t return_key_length
;
2246 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2247 &value_length
, &flags
, &rc
);
2248 test_compare(uint32_t(245), flags
);
2251 delete [] insert_data
;
2254 return TEST_SUCCESS
;
2257 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2259 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2260 size_t key_length
[3];
2264 char return_key
[MEMCACHED_MAX_KEY
];
2265 size_t return_key_length
;
2267 size_t return_value_length
;
2270 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2271 key_length
[1]= strlen("fudge&*@#");
2272 key_length
[2]= strlen("for^#@&$not");
2275 for (unsigned int x
= 0; x
< 3; x
++)
2277 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2278 keys
[x
], key_length
[x
],
2279 (time_t)50, (uint32_t)9);
2280 test_compare(MEMCACHED_SUCCESS
, rc
);
2283 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2284 test_compare(MEMCACHED_SUCCESS
, rc
);
2286 /* We need to empty the server before continueing test */
2287 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2288 &return_value_length
, &flags
, &rc
)) != NULL
)
2290 test_true(return_value
);
2294 test_compare(3U, count
);
2296 return TEST_SUCCESS
;
2299 /* We are testing with aggressive timeout to get failures */
2300 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2302 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
2304 size_t value_length
= 512;
2305 unsigned int set
= 1;
2306 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2308 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2309 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2310 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2312 libtest::vchar_t value
;
2313 value
.reserve(value_length
);
2314 for (uint32_t x
= 0; x
< value_length
; x
++)
2316 value
.push_back(char(x
% 127));
2319 for (unsigned int x
= 1; x
<= 100000; ++x
)
2321 memcached_return_t rc
= memcached_set(mclone
,
2322 test_literal_param("foo"),
2323 &value
[0], value
.size(),
2326 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2327 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2328 memcached_strerror(NULL
, rc
));
2330 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2336 memcached_free(mclone
);
2338 return TEST_SUCCESS
;
2342 We are looking failures in the async protocol
2344 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2346 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2348 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2349 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2350 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2352 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2355 libtest::vchar_t value
;
2357 for (unsigned int x
= 0; x
< 512; x
++)
2359 value
.push_back(char(x
% 127));
2362 for (unsigned int x
= 1; x
<= 100000; ++x
)
2364 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2368 memcached_free(mclone
);
2370 return TEST_SUCCESS
;
2374 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2376 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2378 memcached_return_t rc
;
2380 size_t value_length
;
2382 uint64_t number_value
;
2384 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2385 &value_length
, &flags
, &rc
);
2387 test_compare(MEMCACHED_NOTFOUND
, rc
);
2389 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2392 /* The binary protocol will set the key if it doesn't exist */
2393 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2395 test_compare(MEMCACHED_SUCCESS
, rc
);
2399 test_compare(MEMCACHED_NOTFOUND
, rc
);
2402 test_compare(MEMCACHED_SUCCESS
,
2403 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2405 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2409 test_compare(MEMCACHED_SUCCESS
,
2410 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2411 test_compare(2UL, number_value
);
2413 return TEST_SUCCESS
;
2417 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2418 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2420 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2422 char key
[] = "key34567890";
2424 char commandFirst
[]= "set key34567890 0 0 ";
2425 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2426 size_t commandLength
;
2428 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2430 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2432 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2434 char *overflow
= new (std::nothrow
) char[testSize
];
2435 test_true(overflow
);
2437 memset(overflow
, 'x', testSize
);
2438 test_compare(MEMCACHED_SUCCESS
,
2439 memcached_set(memc
, key
, strlen(key
),
2440 overflow
, testSize
, 0, 0));
2444 return TEST_SUCCESS
;
2449 Test values of many different sizes
2450 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2451 set key34567890 0 0 8169 \r\n
2452 is sent followed by buffer of size 8169, followed by 8169
2454 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2456 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2458 libtest::vchar_t value
;
2459 value
.reserve(18000);
2460 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2462 value
.push_back((char) (x
% 127));
2465 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2467 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2468 &value
[0], current_length
,
2469 (time_t)0, (uint32_t)0);
2470 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2472 size_t string_length
;
2474 char *string
= memcached_get(memc
, test_literal_param("foo"),
2475 &string_length
, &flags
, &rc
);
2477 test_compare(MEMCACHED_SUCCESS
, rc
);
2478 test_compare(string_length
, current_length
);
2480 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2481 test_memcmp_hint(string
, &value
[0], string_length
, buffer
);
2486 return TEST_SUCCESS
;
2490 Look for zero length value problems
2492 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2494 for (uint32_t x
= 0; x
< 2; x
++)
2496 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2498 (time_t)0, (uint32_t)0);
2500 test_compare(MEMCACHED_SUCCESS
, rc
);
2504 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2505 &length
, &flags
, &rc
);
2507 test_compare(MEMCACHED_SUCCESS
, rc
);
2512 value
= memcached_get(memc
, test_literal_param("mykey"),
2513 &length
, &flags
, &rc
);
2515 test_compare(MEMCACHED_SUCCESS
, rc
);
2521 return TEST_SUCCESS
;
2524 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2525 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2527 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2529 (time_t)0, UINT32_MAX
),
2530 memcached_last_error_message(memc
));
2535 memcached_return_t rc
;
2536 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2537 &length
, &flags
, &rc
);
2539 test_compare(MEMCACHED_SUCCESS
, rc
);
2542 test_compare(flags
, UINT32_MAX
);
2544 return TEST_SUCCESS
;
2547 #if !defined(__sun) && !defined(__OpenBSD__)
2548 /* Check the validity of chinese key*/
2549 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2551 const char *key
= "豆瓣";
2552 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2553 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2554 value
, strlen(value
),
2557 test_compare(MEMCACHED_SUCCESS
, rc
);
2561 char *value2
= memcached_get(memc
, key
, strlen(key
),
2562 &length
, &flags
, &rc
);
2564 test_compare(length
, strlen(value
));
2565 test_compare(MEMCACHED_SUCCESS
, rc
);
2566 test_memcmp(value
, value2
, length
);
2569 return TEST_SUCCESS
;
2577 test_return_t
user_supplied_bug19(memcached_st
*)
2579 memcached_return_t res
;
2581 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2583 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2586 memcached_free(memc
);
2588 return TEST_SUCCESS
;
2591 /* CAS test from Andei */
2592 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2594 const char *key
= "abc";
2595 size_t key_len
= strlen("abc");
2597 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2599 test_compare(MEMCACHED_SUCCESS
,
2601 test_literal_param("abc"),
2602 test_literal_param("foobar"),
2603 (time_t)0, (uint32_t)0));
2605 test_compare(MEMCACHED_SUCCESS
,
2606 memcached_mget(memc
, &key
, &key_len
, 1));
2608 memcached_result_st result_obj
;
2609 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2612 memcached_result_create(memc
, &result_obj
);
2613 memcached_return_t status
;
2614 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2617 test_compare(MEMCACHED_SUCCESS
, status
);
2619 memcached_result_free(result
);
2621 return TEST_SUCCESS
;
2624 /* Large mget() of missing keys with binary proto
2626 * If many binary quiet commands (such as getq's in an mget) fill the output
2627 * buffer and the server chooses not to respond, memcached_flush hangs. See
2628 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2631 /* sighandler_t function that always asserts false */
2632 static void fail(int)
2638 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2643 return TEST_SKIPPED
;
2645 void (*oldalarm
)(int);
2647 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2648 test_true(memc_clone
);
2650 /* only binproto uses getq for mget */
2651 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2653 /* empty the cache to ensure misses (hence non-responses) */
2654 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2656 keys_st
keys(key_count
);
2658 oldalarm
= signal(SIGALRM
, fail
);
2661 test_compare_got(MEMCACHED_SUCCESS
,
2662 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2663 memcached_last_error_message(memc_clone
));
2666 signal(SIGALRM
, oldalarm
);
2668 memcached_return_t rc
;
2670 char return_key
[MEMCACHED_MAX_KEY
];
2671 size_t return_key_length
;
2673 size_t return_value_length
;
2674 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2675 &return_value_length
, &flags
, &rc
)))
2677 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2679 test_compare(MEMCACHED_NOTFOUND
, rc
);
2680 test_zero(return_value_length
);
2681 test_zero(return_key_length
);
2682 test_false(return_key
[0]);
2683 test_false(return_value
);
2685 memcached_free(memc_clone
);
2687 return TEST_SUCCESS
;
2691 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2693 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2695 /* should work as of r580 */
2696 test_compare(TEST_SUCCESS
,
2697 _user_supplied_bug21(memc
, 10));
2699 /* should fail as of r580 */
2700 test_compare(TEST_SUCCESS
,
2701 _user_supplied_bug21(memc
, 1000));
2703 return TEST_SUCCESS
;
2706 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2708 memcached_st
*memc
= memcached_create(NULL
);
2712 test_compare(MEMCACHED_SUCCESS
,
2713 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2715 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2716 test_compare(value
, uint64_t(1));
2718 test_compare(MEMCACHED_SUCCESS
,
2719 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2721 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2722 test_true(value
== MEMCACHED_HASH_MD5
);
2725 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2727 memcached_server_st
*server_pool
;
2728 server_pool
= memcached_servers_parse("10.0.1.1:11211,10.0.1.2:11211,10.0.1.3:11211,10.0.1.4:11211,10.0.1.5:11211,10.0.1.6:11211,10.0.1.7:11211,10.0.1.8:11211,192.168.1.1:11211,192.168.100.1:11211");
2729 memcached_server_push(memc
, server_pool
);
2731 // @todo this needs to be refactored to actually test something.
2734 if ((fp
= fopen("ketama_keys.txt", "w")))
2738 printf("cannot write to file ketama_keys.txt");
2739 return TEST_FAILURE
;
2742 for (int x
= 0; x
< 10000; x
++)
2745 snprintf(key
, sizeof(key
), "%d", x
);
2747 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2748 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2749 in_port_t port
= memc
->hosts
[server_idx
].port
;
2750 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2751 memcached_server_instance_st instance
=
2752 memcached_server_instance_by_position(memc
, host_index
);
2756 memcached_server_list_free(server_pool
);
2757 memcached_free(memc
);
2759 return TEST_SUCCESS
;
2763 test_return_t
result_static(memcached_st
*memc
)
2765 memcached_result_st result
;
2766 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
2767 test_false(result
.options
.is_allocated
);
2768 test_true(memcached_is_initialized(&result
));
2769 test_true(result_ptr
);
2770 test_true(result_ptr
== &result
);
2772 memcached_result_free(&result
);
2774 test_false(result
.options
.is_allocated
);
2775 test_false(memcached_is_initialized(&result
));
2777 return TEST_SUCCESS
;
2780 test_return_t
result_alloc(memcached_st
*memc
)
2782 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
2783 test_true(result_ptr
);
2784 test_true(result_ptr
->options
.is_allocated
);
2785 test_true(memcached_is_initialized(result_ptr
));
2786 memcached_result_free(result_ptr
);
2788 return TEST_SUCCESS
;
2792 test_return_t
add_host_test1(memcached_st
*memc
)
2794 memcached_return_t rc
;
2795 char servername
[]= "0.example.com";
2797 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2799 test_compare(1U, memcached_server_list_count(servers
));
2801 for (uint32_t x
= 2; x
< 20; x
++)
2803 char buffer
[SMALL_STRING_LEN
];
2805 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
2806 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2808 test_compare(MEMCACHED_SUCCESS
, rc
);
2809 test_compare(x
, memcached_server_list_count(servers
));
2812 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2813 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2815 memcached_server_list_free(servers
);
2817 return TEST_SUCCESS
;
2821 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
2825 #ifdef HARD_MALLOC_TESTS
2826 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
2834 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
2838 #ifdef HARD_MALLOC_TESTS
2839 void *ret
= malloc(size
+ 8);
2842 ret
= (void*)((caddr_t
)ret
+ 8);
2845 void *ret
= malloc(size
);
2850 memset(ret
, 0xff, size
);
2857 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
2859 #ifdef HARD_MALLOC_TESTS
2860 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
2861 void *nmem
= realloc(real_ptr
, size
+ 8);
2866 ret
= (void*)((caddr_t
)nmem
+ 8);
2872 return realloc(mem
, size
);
2877 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
2879 #ifdef HARD_MALLOC_TESTS
2880 void *mem
= my_malloc(ptr
, nelem
* size
);
2883 memset(mem
, 0, nelem
* size
);
2889 return calloc(nelem
, size
);
2893 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
2895 memcached_return_t rc
;
2896 const char *key
= "mine";
2899 /* Make sure be default none exists */
2900 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2902 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2904 /* Test a clean set */
2905 test_compare(MEMCACHED_SUCCESS
,
2906 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2908 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2910 test_memcmp(value
, key
, 4);
2911 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2913 /* Test that we can turn it off */
2914 test_compare(MEMCACHED_SUCCESS
,
2915 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
2917 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2919 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2921 /* Now setup for main test */
2922 test_compare(MEMCACHED_SUCCESS
,
2923 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2925 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2927 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2928 test_memcmp(value
, key
, 4);
2930 /* Set to Zero, and then Set to something too large */
2933 memset(long_key
, 0, 255);
2935 test_compare(MEMCACHED_SUCCESS
,
2936 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
2938 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2940 test_compare(MEMCACHED_SUCCESS
, rc
);
2942 /* Test a long key for failure */
2943 /* TODO, extend test to determine based on setting, what result should be */
2944 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
2945 test_compare(MEMCACHED_SUCCESS
,
2946 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
2948 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
2949 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
2950 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
2951 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
2953 /* Test for a bad prefix, but with a short key */
2954 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
2955 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
2957 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
2958 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
2961 return TEST_SUCCESS
;
2964 test_return_t
set_namespace(memcached_st
*memc
)
2966 memcached_return_t rc
;
2967 const char *key
= "mine";
2970 // Make sure we default to a null namespace
2971 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2973 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2975 /* Test a clean set */
2976 test_compare(MEMCACHED_SUCCESS
,
2977 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2979 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2981 test_memcmp(value
, key
, 4);
2982 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2984 return TEST_SUCCESS
;
2987 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
2989 test_return_if(pre_binary(memc
));
2990 test_return_if(set_namespace(memc
));
2992 return TEST_SUCCESS
;
2995 #ifdef MEMCACHED_ENABLE_DEPRECATED
2996 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
2998 void *test_ptr
= NULL
;
3001 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
3002 cb_ptr
= *(void **)&malloc_cb
;
3003 memcached_return_t rc
;
3005 test_compare(MEMCACHED_SUCCESS
,
3006 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3007 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3008 test_compare(MEMCACHED_SUCCESS
, rc
);
3009 test_true(test_ptr
== cb_ptr
);
3013 memcached_realloc_fn realloc_cb
=
3014 (memcached_realloc_fn
)my_realloc
;
3015 cb_ptr
= *(void **)&realloc_cb
;
3016 memcached_return_t rc
;
3018 test_compare(MEMCACHED_SUCCESS
,
3019 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3020 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3021 test_compare(MEMCACHED_SUCCESS
, rc
);
3022 test_true(test_ptr
== cb_ptr
);
3026 memcached_free_fn free_cb
=
3027 (memcached_free_fn
)my_free
;
3028 cb_ptr
= *(void **)&free_cb
;
3029 memcached_return_t rc
;
3031 test_compare(MEMCACHED_SUCCESS
,
3032 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3033 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3034 test_compare(MEMCACHED_SUCCESS
, rc
);
3035 test_true(test_ptr
== cb_ptr
);
3038 return TEST_SUCCESS
;
3043 test_return_t
set_memory_alloc(memcached_st
*memc
)
3045 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3046 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3047 my_realloc
, my_calloc
, NULL
));
3049 test_compare(MEMCACHED_SUCCESS
,
3050 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3051 my_realloc
, my_calloc
, NULL
));
3053 memcached_malloc_fn mem_malloc
;
3054 memcached_free_fn mem_free
;
3055 memcached_realloc_fn mem_realloc
;
3056 memcached_calloc_fn mem_calloc
;
3057 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3058 &mem_realloc
, &mem_calloc
);
3060 test_true(mem_malloc
== my_malloc
);
3061 test_true(mem_realloc
== my_realloc
);
3062 test_true(mem_calloc
== my_calloc
);
3063 test_true(mem_free
== my_free
);
3065 return TEST_SUCCESS
;
3068 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3070 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
));
3071 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3074 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3079 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3081 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_CRC
)
3083 return TEST_SKIPPED
;
3086 return TEST_SUCCESS
;
3089 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3092 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
);
3093 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3098 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3100 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_HSIEH
)
3102 return TEST_SKIPPED
;
3105 return TEST_SUCCESS
;
3108 test_return_t
enable_cas(memcached_st
*memc
)
3110 unsigned int set
= 1;
3112 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3114 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3116 return TEST_SUCCESS
;
3119 return TEST_SKIPPED
;
3122 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3124 memcached_version(memc
);
3126 memcached_server_instance_st instance
=
3127 memcached_server_instance_by_position(memc
, 0);
3129 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3130 or instance
->minor_version
> 2)
3132 return TEST_SUCCESS
;
3135 return TEST_SKIPPED
;
3138 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3140 const uint64_t timeout
= 100; // Not using, just checking that it sets
3142 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3144 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3146 return TEST_SUCCESS
;
3149 test_return_t
noreply_test(memcached_st
*memc
)
3151 test_compare(MEMCACHED_SUCCESS
,
3152 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3153 test_compare(MEMCACHED_SUCCESS
,
3154 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3155 test_compare(MEMCACHED_SUCCESS
,
3156 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3157 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3158 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3159 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3161 memcached_return_t ret
;
3162 for (int count
= 0; count
< 5; ++count
)
3164 for (size_t x
= 0; x
< 100; ++x
)
3166 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3167 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3168 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3170 size_t len
= (size_t)check_length
;
3175 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3178 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3181 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3184 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3187 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3193 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3194 memcached_strerror(NULL
, ret
));
3198 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3199 ** API and is _ONLY_ done this way to verify that the library works the
3200 ** way it is supposed to do!!!!
3204 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3206 memcached_server_instance_st instance
=
3207 memcached_server_instance_by_position(memc
, x
);
3208 no_msg
+=(int)(instance
->cursor_active
);
3211 test_true(no_msg
== 0);
3213 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3216 ** Now validate that all items was set properly!
3218 for (size_t x
= 0; x
< 100; ++x
)
3222 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3224 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3226 size_t len
= (size_t)check_length
;
3229 char* value
=memcached_get(memc
, key
, strlen(key
),
3230 &length
, &flags
, &ret
);
3231 // For the moment we will just go to the next key
3232 if (MEMCACHED_TIMEOUT
== ret
)
3236 test_true(ret
== MEMCACHED_SUCCESS
and value
!= NULL
);
3239 case 0: /* FALLTHROUGH */
3240 case 1: /* FALLTHROUGH */
3242 test_true(strncmp(value
, key
, len
) == 0);
3243 test_true(len
== length
);
3246 test_true(length
== len
* 2);
3249 test_true(length
== len
* 3);
3259 /* Try setting an illegal cas value (should not return an error to
3260 * the caller (because we don't expect a return message from the server)
3262 const char* keys
[]= {"0"};
3263 size_t lengths
[]= {1};
3266 memcached_result_st results_obj
;
3267 memcached_result_st
*results
;
3268 test_compare(MEMCACHED_SUCCESS
,
3269 memcached_mget(memc
, keys
, lengths
, 1));
3271 results
= memcached_result_create(memc
, &results_obj
);
3273 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3275 test_compare(MEMCACHED_SUCCESS
, ret
);
3276 uint64_t cas
= memcached_result_cas(results
);
3277 memcached_result_free(&results_obj
);
3279 test_compare(MEMCACHED_SUCCESS
,
3280 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3283 * The item will have a new cas value, so try to set it again with the old
3284 * value. This should fail!
3286 test_compare(MEMCACHED_SUCCESS
,
3287 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3288 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3289 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3290 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3293 return TEST_SUCCESS
;
3296 test_return_t
analyzer_test(memcached_st
*memc
)
3298 memcached_analysis_st
*report
;
3299 memcached_return_t rc
;
3301 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3302 test_compare(MEMCACHED_SUCCESS
, rc
);
3303 test_true(memc_stat
);
3305 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3306 test_compare(MEMCACHED_SUCCESS
, rc
);
3310 memcached_stat_free(NULL
, memc_stat
);
3312 return TEST_SUCCESS
;
3315 test_return_t
util_version_test(memcached_st
*memc
)
3317 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
3318 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3320 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3322 // We expect failure
3325 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3326 fprintf(stderr
, "\nDumping Server Information\n\n");
3327 memcached_server_fn callbacks
[1];
3329 callbacks
[0]= dump_server_information
;
3330 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3331 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3333 test_true(if_successful
== false);
3335 memcached_server_instance_st instance
=
3336 memcached_server_instance_by_position(memc
, 0);
3338 memcached_version(memc
);
3340 // We only use one binary when we test, so this should be just fine.
3341 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3342 test_true(if_successful
== true);
3344 if (instance
->micro_version
> 0)
3346 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3348 else if (instance
->minor_version
> 0)
3350 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3352 else if (instance
->major_version
> 0)
3354 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3357 test_true(if_successful
== true);
3359 if (instance
->micro_version
> 0)
3361 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3363 else if (instance
->minor_version
> 0)
3365 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3367 else if (instance
->major_version
> 0)
3369 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3372 test_true(if_successful
== false);
3374 return TEST_SUCCESS
;
3377 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3379 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3380 memcached_return_t rc
;
3381 memcached_server_instance_st instance
=
3382 memcached_server_instance_by_position(memc
, 0);
3384 // Test both the version that returns a code, and the one that does not.
3385 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3386 memcached_server_port(instance
) -1, NULL
) == -1);
3388 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3389 memcached_server_port(instance
) -1, &rc
) == -1);
3390 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3392 return TEST_SUCCESS
;
3396 test_return_t
getpid_test(memcached_st
*memc
)
3398 memcached_return_t rc
;
3399 memcached_server_instance_st instance
=
3400 memcached_server_instance_by_position(memc
, 0);
3402 // Test both the version that returns a code, and the one that does not.
3403 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3404 memcached_server_port(instance
), NULL
) > -1);
3406 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3407 memcached_server_port(instance
), &rc
) > -1);
3408 test_compare(MEMCACHED_SUCCESS
, rc
);
3410 return TEST_SUCCESS
;
3413 static memcached_return_t
ping_each_server(const memcached_st
*,
3414 const memcached_server_st
*instance
,
3417 // Test both the version that returns a code, and the one that does not.
3418 memcached_return_t rc
;
3419 if (libmemcached_util_ping(memcached_server_name(instance
),
3420 memcached_server_port(instance
), &rc
) == false)
3422 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d %s", memcached_server_name(instance
),
3423 memcached_server_port(instance
), memcached_strerror(NULL
, rc
));
3426 if (libmemcached_util_ping(memcached_server_name(instance
),
3427 memcached_server_port(instance
), NULL
) == false)
3429 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d", memcached_server_name(instance
), memcached_server_port(instance
));
3432 return MEMCACHED_SUCCESS
;
3435 test_return_t
libmemcached_util_ping_TEST(memcached_st
*memc
)
3437 memcached_server_fn callbacks
[1]= { ping_each_server
};
3438 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
3440 return TEST_SUCCESS
;
3445 test_return_t
hash_sanity_test (memcached_st
*memc
)
3449 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3450 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3451 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3452 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3453 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3454 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3455 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3456 #ifdef HAVE_HSIEH_HASH
3457 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3459 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3460 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3461 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3463 return TEST_SUCCESS
;
3467 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3469 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3471 test_compare(MEMCACHED_SUCCESS
,
3472 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3473 (uint64_t)MEMCACHED_HASH_HSIEH
));
3475 return TEST_SUCCESS
;
3478 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3480 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3482 test_compare(MEMCACHED_SUCCESS
,
3483 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3485 return TEST_SUCCESS
;
3488 test_return_t
one_at_a_time_run (memcached_st
*)
3493 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3495 test_compare(one_at_a_time_values
[x
],
3496 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3499 return TEST_SUCCESS
;
3502 test_return_t
md5_run (memcached_st
*)
3507 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3509 test_compare(md5_values
[x
],
3510 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3513 return TEST_SUCCESS
;
3516 test_return_t
crc_run (memcached_st
*)
3521 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3523 test_compare(crc_values
[x
],
3524 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3527 return TEST_SUCCESS
;
3530 test_return_t
fnv1_64_run (memcached_st
*)
3532 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3537 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3539 test_compare(fnv1_64_values
[x
],
3540 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3543 return TEST_SUCCESS
;
3546 test_return_t
fnv1a_64_run (memcached_st
*)
3548 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3553 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3555 test_compare(fnv1a_64_values
[x
],
3556 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3559 return TEST_SUCCESS
;
3562 test_return_t
fnv1_32_run (memcached_st
*)
3567 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3569 test_compare(fnv1_32_values
[x
],
3570 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3573 return TEST_SUCCESS
;
3576 test_return_t
fnv1a_32_run (memcached_st
*)
3581 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3583 test_compare(fnv1a_32_values
[x
],
3584 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3587 return TEST_SUCCESS
;
3590 test_return_t
hsieh_run (memcached_st
*)
3592 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3597 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3599 test_compare(hsieh_values
[x
],
3600 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3603 return TEST_SUCCESS
;
3606 test_return_t
murmur_run (memcached_st
*)
3608 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3610 #ifdef WORDS_BIGENDIAN
3611 (void)murmur_values
;
3612 return TEST_SKIPPED
;
3617 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3619 test_compare(murmur_values
[x
],
3620 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3623 return TEST_SUCCESS
;
3627 test_return_t
jenkins_run (memcached_st
*)
3632 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3634 test_compare(jenkins_values
[x
],
3635 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3638 return TEST_SUCCESS
;
3641 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3643 return libhashkit_md5(string
, string_length
);
3646 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3648 return libhashkit_crc32(string
, string_length
);
3651 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3657 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3659 uint32_t md5_hosts
[]= {4U, 1U, 0U, 1U, 4U, 2U, 0U, 3U, 0U, 0U, 3U, 1U, 0U, 0U, 1U, 3U, 0U, 0U, 0U, 3U, 1U, 0U, 4U, 4U, 3U};
3660 uint32_t crc_hosts
[]= {2U, 4U, 1U, 0U, 2U, 4U, 4U, 4U, 1U, 2U, 3U, 4U, 3U, 4U, 1U, 3U, 3U, 2U, 0U, 0U, 0U, 1U, 2U, 4U, 0U};
3662 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3664 hashkit_clone(&new_kit
, kit
);
3665 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3667 memcached_set_hashkit(memc
, &new_kit
);
3670 Verify Setting the hash.
3672 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3676 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3677 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3682 Now check memcached_st.
3684 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3688 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3689 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3692 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3694 memcached_set_hashkit(memc
, &new_kit
);
3697 Verify Setting the hash.
3699 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3703 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3704 test_true(crc_values
[x
] == hash_val
);
3707 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3711 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3712 test_compare(crc_hosts
[x
], hash_val
);
3715 memcached_free(memc
);
3717 return TEST_SUCCESS
;
3721 Test case adapted from John Gorman <johngorman2@gmail.com>
3723 We are testing the error condition when we connect to a server via memcached_get()
3724 but find that the server is not available.
3726 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3730 memcached_return rc
;
3733 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3735 // See if memcached is reachable.
3736 char *value
= memcached_get(tl_memc_h
,
3737 test_literal_param(__func__
),
3742 test_true(memcached_failed(rc
));
3744 memcached_free(tl_memc_h
);
3746 return TEST_SUCCESS
;
3750 We connect to a server which exists, but search for a key that does not exist.
3752 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3756 memcached_return rc
;
3758 // See if memcached is reachable.
3759 char *value
= memcached_get(memc
,
3760 test_literal_param(__func__
),
3765 test_compare(MEMCACHED_NOTFOUND
, rc
);
3767 return TEST_SUCCESS
;
3771 Test case adapted from John Gorman <johngorman2@gmail.com>
3773 We are testing the error condition when we connect to a server via memcached_get_by_key()
3774 but find that the server is not available.
3776 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
3780 memcached_return rc
;
3783 memcached_st
*tl_memc_h
= memcached_create(NULL
);
3784 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
3785 memcached_server_push(tl_memc_h
, servers
);
3786 memcached_server_list_free(servers
);
3788 // See if memcached is reachable.
3789 char *value
= memcached_get_by_key(tl_memc_h
,
3790 test_literal_param(__func__
), // Key
3791 test_literal_param(__func__
), // Value
3796 test_true(memcached_failed(rc
));
3798 memcached_free(tl_memc_h
);
3800 return TEST_SUCCESS
;
3804 We connect to a server which exists, but search for a key that does not exist.
3806 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3810 memcached_return rc
;
3812 // See if memcached is reachable.
3813 char *value
= memcached_get_by_key(memc
,
3814 test_literal_param(__func__
), // Key
3815 test_literal_param(__func__
), // Value
3820 test_compare(MEMCACHED_NOTFOUND
, rc
);
3822 return TEST_SUCCESS
;
3825 test_return_t
regression_bug_434484(memcached_st
*memc
)
3827 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3829 test_compare(MEMCACHED_NOTSTORED
,
3830 memcached_append(memc
,
3831 test_literal_param(__func__
), // Key
3832 test_literal_param(__func__
), // Value
3835 libtest::vchar_t data
;
3836 data
.resize(2048 * 1024);
3837 test_compare(MEMCACHED_E2BIG
,
3839 test_literal_param(__func__
), // Key
3840 &data
[0], data
.size(), 0, 0));
3842 return TEST_SUCCESS
;
3845 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
3847 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
3849 memcached_return_t rc
;
3851 memcached_execute_fn callbacks
[]= { &callback_counter
};
3854 * I only want to hit only _one_ server so I know the number of requests I'm
3855 * sending in the pipleine to the server. Let's try to do a multiget of
3856 * 1024 (that should satisfy most users don't you think?). Future versions
3857 * will include a mget_execute function call if you need a higher number.
3859 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
3864 * Run two times.. the first time we should have 100% cache miss,
3865 * and the second time we should have 100% cache hits
3867 for (ptrdiff_t y
= 0; y
< 2; y
++)
3869 test_compare(MEMCACHED_SUCCESS
,
3870 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
3872 // One the first run we should get a NOT_FOUND, but on the second some data
3873 // should be returned.
3874 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
3875 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3879 /* The first iteration should give me a 100% cache miss. verify that*/
3880 char blob
[1024]= { 0 };
3882 test_false(counter
);
3884 for (size_t x
= 0; x
< keys
.size(); ++x
)
3886 rc
= memcached_add(memc
,
3887 keys
.key_at(x
), keys
.length_at(x
),
3888 blob
, sizeof(blob
), 0, 0);
3889 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3894 /* Verify that we received all of the key/value pairs */
3895 test_compare(counter
, keys
.size());
3899 memcached_free(memc
);
3901 return TEST_SUCCESS
;
3904 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
3906 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3908 return regression_bug_434843(memc
);
3911 test_return_t
regression_bug_421108(memcached_st
*memc
)
3913 memcached_return_t rc
;
3914 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3915 test_compare(MEMCACHED_SUCCESS
, rc
);
3917 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
3918 test_compare(MEMCACHED_SUCCESS
, rc
);
3919 test_true(bytes_str
);
3920 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
3922 test_compare(MEMCACHED_SUCCESS
, rc
);
3923 test_true(bytes_read_str
);
3925 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
3926 "bytes_written", &rc
);
3927 test_compare(MEMCACHED_SUCCESS
, rc
);
3928 test_true(bytes_written_str
);
3930 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
3931 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
3932 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
3934 test_true(bytes
!= bytes_read
);
3935 test_true(bytes
!= bytes_written
);
3937 /* Release allocated resources */
3939 free(bytes_read_str
);
3940 free(bytes_written_str
);
3941 memcached_stat_free(NULL
, memc_stat
);
3943 return TEST_SUCCESS
;
3947 * The test case isn't obvious so I should probably document why
3948 * it works the way it does. Bug 442914 was caused by a bug
3949 * in the logic in memcached_purge (it did not handle the case
3950 * where the number of bytes sent was equal to the watermark).
3951 * In this test case, create messages so that we hit that case
3952 * and then disable noreply mode and issue a new command to
3953 * verify that it isn't stuck. If we change the format for the
3954 * delete command or the watermarks, we need to update this
3957 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
3959 test_skip(original_memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3961 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
3963 for (uint32_t x
= 0; x
< 250; ++x
)
3966 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
3967 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
3968 char error_buffer
[2048]= { 0 };
3969 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
3970 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
3973 // Delete, and then delete again to look for not found
3976 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
3977 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
3978 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
3980 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
3981 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
3984 memcached_free(memc
);
3986 return TEST_SUCCESS
;
3989 test_return_t
regression_bug_447342(memcached_st
*memc
)
3991 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
3993 return TEST_SKIPPED
;
3996 test_compare(MEMCACHED_SUCCESS
,
3997 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4001 for (size_t x
= 0; x
< keys
.size(); ++x
)
4003 test_compare(MEMCACHED_SUCCESS
,
4005 keys
.key_at(x
), keys
.length_at(x
), // Keys
4006 keys
.key_at(x
), keys
.length_at(x
), // Values
4011 ** We are using the quiet commands to store the replicas, so we need
4012 ** to ensure that all of them are processed before we can continue.
4013 ** In the test we go directly from storing the object to trying to
4014 ** receive the object from all of the different servers, so we
4015 ** could end up in a race condition (the memcached server hasn't yet
4016 ** processed the quiet command from the replication set when it process
4017 ** the request from the other client (created by the clone)). As a
4018 ** workaround for that we call memcached_quit to send the quit command
4019 ** to the server and wait for the response ;-) If you use the test code
4020 ** as an example for your own code, please note that you shouldn't need
4023 memcached_quit(memc
);
4025 /* Verify that all messages are stored, and we didn't stuff too much
4028 test_compare(MEMCACHED_SUCCESS
,
4029 memcached_mget(memc
,
4030 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4032 unsigned int counter
= 0;
4033 memcached_execute_fn callbacks
[]= { &callback_counter
};
4034 test_compare(MEMCACHED_SUCCESS
,
4035 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4037 /* Verify that we received all of the key/value pairs */
4038 test_compare(counter
, keys
.size());
4040 memcached_quit(memc
);
4042 * Don't do the following in your code. I am abusing the internal details
4043 * within the library, and this is not a supported interface.
4044 * This is to verify correct behavior in the library. Fake that two servers
4047 memcached_server_instance_st instance_one
= memcached_server_instance_by_position(memc
, 0);
4048 memcached_server_instance_st instance_two
= memcached_server_instance_by_position(memc
, 2);
4049 in_port_t port0
= instance_one
->port
;
4050 in_port_t port2
= instance_two
->port
;
4052 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4053 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4055 test_compare(MEMCACHED_SUCCESS
,
4056 memcached_mget(memc
,
4057 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4060 test_compare(MEMCACHED_SUCCESS
,
4061 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4062 test_compare(counter
, keys
.size());
4064 /* restore the memc handle */
4065 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4066 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4068 memcached_quit(memc
);
4070 /* Remove half of the objects */
4071 for (size_t x
= 0; x
< keys
.size(); ++x
)
4075 test_compare(MEMCACHED_SUCCESS
,
4076 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4080 memcached_quit(memc
);
4081 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4082 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4084 /* now retry the command, this time we should have cache misses */
4085 test_compare(MEMCACHED_SUCCESS
,
4086 memcached_mget(memc
,
4087 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4090 test_compare(MEMCACHED_SUCCESS
,
4091 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4092 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4094 /* restore the memc handle */
4095 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4096 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4098 return TEST_SUCCESS
;
4101 test_return_t
regression_bug_463297(memcached_st
*memc
)
4103 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4105 // Since we blocked timed delete, this test is no longer valid.
4107 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4108 test_true(memc_clone
);
4109 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4111 memcached_server_instance_st instance
=
4112 memcached_server_instance_by_position(memc_clone
, 0);
4114 if (instance
->major_version
> 1 ||
4115 (instance
->major_version
== 1 &&
4116 instance
->minor_version
> 2))
4118 /* Binary protocol doesn't support deferred delete */
4119 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4120 test_true(bin_clone
);
4121 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4122 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4123 memcached_free(bin_clone
);
4125 memcached_quit(memc_clone
);
4127 /* If we know the server version, deferred delete should fail
4128 * with invalid arguments */
4129 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4131 /* If we don't know the server version, we should get a protocol error */
4132 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4134 /* but there is a bug in some of the memcached servers (1.4) that treats
4135 * the counter as noreply so it doesn't send the proper error message
4137 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4139 /* And buffered mode should be disabled and we should get protocol error */
4140 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4141 rc
= memcached_delete(memc
, "foo", 3, 1);
4142 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4144 /* Same goes for noreply... */
4145 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4146 rc
= memcached_delete(memc
, "foo", 3, 1);
4147 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4149 /* but a normal request should go through (and be buffered) */
4150 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4151 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4153 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4154 /* unbuffered noreply should be success */
4155 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4156 /* unbuffered with reply should be not found... */
4157 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4158 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4161 memcached_free(memc_clone
);
4164 return TEST_SUCCESS
;
4168 /* Test memcached_server_get_last_disconnect
4169 * For a working server set, shall be NULL
4170 * For a set of non existing server, shall not be NULL
4172 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4174 memcached_return_t rc
;
4175 memcached_server_instance_st disconnected_server
;
4177 /* With the working set of server */
4178 const char *key
= "marmotte";
4179 const char *value
= "milka";
4181 memcached_reset_last_disconnected_server(memc
);
4182 test_false(memc
->last_disconnected_server
);
4183 rc
= memcached_set(memc
, key
, strlen(key
),
4184 value
, strlen(value
),
4185 (time_t)0, (uint32_t)0);
4186 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4188 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4189 test_false(disconnected_server
);
4191 /* With a non existing server */
4193 memcached_server_st
*servers
;
4195 const char *server_list
= "localhost:9";
4197 servers
= memcached_servers_parse(server_list
);
4199 mine
= memcached_create(NULL
);
4200 rc
= memcached_server_push(mine
, servers
);
4201 test_compare(MEMCACHED_SUCCESS
, rc
);
4202 memcached_server_list_free(servers
);
4205 rc
= memcached_set(mine
, key
, strlen(key
),
4206 value
, strlen(value
),
4207 (time_t)0, (uint32_t)0);
4208 test_true(memcached_failed(rc
));
4210 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4211 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4212 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4213 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4215 memcached_quit(mine
);
4216 memcached_free(mine
);
4218 return TEST_SUCCESS
;
4221 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4223 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4224 char buffer
[BUFSIZ
];
4226 test_compare(MEMCACHED_SUCCESS
,
4227 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4229 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4232 // We will just use the error strings as our keys
4233 uint32_t counter
= 100;
4236 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4238 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4239 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4240 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4242 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
4243 test_true(disconnected_server
);
4244 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4245 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4249 memcached_reset_last_disconnected_server(memc
);
4254 memcached_free(memc
);
4256 return TEST_SUCCESS
;
4259 test_return_t
test_verbosity(memcached_st
*memc
)
4261 memcached_verbosity(memc
, 3);
4263 return TEST_SUCCESS
;
4267 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
4268 const char *key
, size_t key_length
,
4269 const char *value
, size_t value_length
,
4279 return MEMCACHED_SUCCESS
;
4282 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4284 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4285 test_compare(MEMCACHED_SUCCESS
, rc
);
4287 test_compare(MEMCACHED_SUCCESS
,
4288 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4290 test_compare(MEMCACHED_SUCCESS
,
4291 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4293 test_compare(MEMCACHED_SUCCESS
,
4294 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4296 return TEST_SUCCESS
;
4300 * This test ensures that the failure counter isn't incremented during
4301 * normal termination of the memcached instance.
4303 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4305 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4307 /* Ensure that we are connected to the server by setting a value */
4308 memcached_return_t rc
= memcached_set(memc
,
4309 test_literal_param(__func__
), // Key
4310 test_literal_param(__func__
), // Value
4311 time_t(0), uint32_t(0));
4312 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4315 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4317 /* The test is to see that the memcached_quit doesn't increase the
4318 * the server failure conter, so let's ensure that it is zero
4319 * before sending quit
4321 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4323 memcached_quit(memc
);
4325 /* Verify that it memcached_quit didn't increment the failure counter
4326 * Please note that this isn't bullet proof, because an error could
4329 test_zero(instance
->server_failure_counter
);
4331 memcached_free(memc
);
4333 return TEST_SUCCESS
;
4337 * This tests ensures expected disconnections (for some behavior changes
4338 * for instance) do not wrongly increase failure counter
4340 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4342 /* Set value to force connection to the server */
4343 const char *key
= "marmotte";
4344 const char *value
= "milka";
4346 test_compare_hint(MEMCACHED_SUCCESS
,
4347 memcached_set(memc
, key
, strlen(key
),
4348 value
, strlen(value
),
4349 (time_t)0, (uint32_t)0),
4350 memcached_last_error_message(memc
));
4353 /* put failure limit to 1 */
4354 test_compare(MEMCACHED_SUCCESS
,
4355 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4357 /* Put a retry timeout to effectively activate failure_limit effect */
4358 test_compare(MEMCACHED_SUCCESS
,
4359 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4361 /* change behavior that triggers memcached_quit()*/
4362 test_compare(MEMCACHED_SUCCESS
,
4363 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4366 /* Check if we still are connected */
4368 size_t string_length
;
4369 memcached_return rc
;
4370 char *string
= memcached_get(memc
, key
, strlen(key
),
4371 &string_length
, &flags
, &rc
);
4373 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4377 return TEST_SUCCESS
;
4380 test_return_t
regression_996813_TEST(memcached_st
*)
4382 memcached_st
* memc
= memcached_create(NULL
);
4384 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
4385 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
4386 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4387 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4388 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1));
4389 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 300));
4390 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 30));
4392 // We will never connect to these servers
4393 in_port_t base_port
= 11211;
4394 for (size_t x
= 0; x
< 17; x
++)
4396 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", base_port
+x
));
4398 test_compare(6U, memcached_generate_hash(memc
, test_literal_param("SZ6hu0SHweFmpwpc0w2R")));
4399 test_compare(1U, memcached_generate_hash(memc
, test_literal_param("SQCK9eiCf53YxHWnYA.o")));
4400 test_compare(9U, memcached_generate_hash(memc
, test_literal_param("SUSDkGXuuZC9t9VhMwa.")));
4401 test_compare(0U, memcached_generate_hash(memc
, test_literal_param("SnnqnJARfaCNT679iAF_")));
4403 memcached_free(memc
);
4405 return TEST_SUCCESS
;
4410 * Test that ensures mget_execute does not end into recursive calls that finally fails
4412 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4416 return TEST_SKIPPED
; // My MAC can't handle this test
4419 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4422 * I only want to hit _one_ server so I know the number of requests I'm
4423 * sending in the pipeline.
4425 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4428 keys_st
keys(20480);
4430 /* First add all of the items.. */
4431 char blob
[1024]= { 0 };
4432 for (size_t x
= 0; x
< keys
.size(); ++x
)
4434 memcached_return rc
= memcached_set(memc
,
4435 keys
.key_at(x
), keys
.length_at(x
),
4436 blob
, sizeof(blob
), 0, 0);
4437 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4442 /* Try to get all of them with a large multiget */
4444 memcached_execute_function callbacks
[]= { &callback_counter
};
4445 memcached_return_t rc
= memcached_mget_execute(memc
,
4446 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4447 callbacks
, &counter
, 1);
4448 test_compare(MEMCACHED_SUCCESS
, rc
);
4450 char* the_value
= NULL
;
4451 char the_key
[MEMCACHED_MAX_KEY
];
4452 size_t the_key_length
;
4453 size_t the_value_length
;
4457 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4459 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4465 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4468 test_compare(MEMCACHED_END
, rc
);
4470 /* Verify that we got all of the items */
4471 test_compare(counter
, keys
.size());
4474 memcached_free(memc
);
4476 return TEST_SUCCESS
;
4479 test_return_t
regression_bug_583031(memcached_st
*)
4481 memcached_st
*memc
= memcached_create(NULL
);
4483 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
4485 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
4486 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4487 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4488 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4489 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4490 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4492 memcached_return_t rc
;
4496 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4500 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
4502 memcached_free(memc
);
4504 return TEST_SUCCESS
;
4507 test_return_t
regression_bug_581030(memcached_st
*)
4510 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4511 test_false(local_stat
);
4513 memcached_stat_free(NULL
, NULL
);
4516 return TEST_SUCCESS
;
4519 #define regression_bug_655423_COUNT 6000
4520 test_return_t
regression_bug_655423(memcached_st
*memc
)
4522 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4523 memc
= NULL
; // Just to make sure it is not used
4528 return TEST_SKIPPED
;
4531 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4532 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4533 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4534 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4536 memset(payload
, int('x'), sizeof(payload
));
4538 keys_st
keys(regression_bug_655423_COUNT
);
4540 for (size_t x
= 0; x
< keys
.size(); x
++)
4542 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4545 payload
, sizeof(payload
), 0, 0));
4548 for (size_t x
= 0; x
< keys
.size(); x
++)
4550 size_t value_length
;
4551 memcached_return_t rc
;
4552 char *value
= memcached_get(clone
,
4555 &value_length
, NULL
, &rc
);
4557 if (rc
== MEMCACHED_NOTFOUND
)
4560 test_zero(value_length
);
4564 test_compare(MEMCACHED_SUCCESS
, rc
);
4566 test_compare(100LLU, value_length
);
4570 test_compare(MEMCACHED_SUCCESS
,
4571 memcached_mget(clone
,
4572 keys
.keys_ptr(), keys
.lengths_ptr(),
4576 memcached_result_st
*result
= NULL
;
4577 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4579 test_compare(size_t(100), memcached_result_length(result
));
4583 test_true(count
> 100); // If we don't get back atleast this, something is up
4585 memcached_free(clone
);
4587 return TEST_SUCCESS
;
4591 * Test that ensures that buffered set to not trigger problems during io_flush
4593 #define regression_bug_490520_COUNT 200480
4594 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4596 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4598 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4599 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4600 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4601 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4602 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4604 /* First add all of the items.. */
4605 char blob
[3333] = {0};
4606 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4609 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4611 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4612 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4615 memcached_free(memc
);
4617 return TEST_SUCCESS
;
4620 test_return_t
regression_1009493_TEST(memcached_st
*)
4622 memcached_st
* memc
= memcached_create(NULL
);
4624 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, true));
4626 memcached_st
* clone
= memcached_clone(NULL
, memc
);
4629 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
),
4630 memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
4632 memcached_free(memc
);
4633 memcached_free(clone
);
4635 return TEST_SUCCESS
;
4638 test_return_t
regression_994772_TEST(memcached_st
* memc
)
4640 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4642 test_compare(MEMCACHED_SUCCESS
,
4644 test_literal_param(__func__
), // Key
4645 test_literal_param(__func__
), // Value
4646 time_t(0), uint32_t(0)));
4648 const char *keys
[] = { __func__
};
4649 size_t key_length
[]= { strlen(__func__
) };
4650 test_compare(MEMCACHED_SUCCESS
,
4651 memcached_mget(memc
, keys
, key_length
, 1));
4653 memcached_return_t rc
;
4654 memcached_result_st
*results
= memcached_fetch_result(memc
, NULL
, &rc
);
4656 test_compare(MEMCACHED_SUCCESS
, rc
);
4658 test_strcmp(__func__
, memcached_result_value(results
));
4659 uint64_t cas_value
= memcached_result_cas(results
);
4660 test_true(cas_value
);
4662 memcached_result_free(results
);
4664 // Bad cas value, sanity check
4665 test_true(cas_value
!= 9999);
4666 test_compare(MEMCACHED_END
,
4668 test_literal_param(__func__
), // Key
4669 test_literal_param(__FILE__
), // Value
4670 time_t(0), uint32_t(0), 9999));
4672 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
4673 "different", strlen("different"), // Key
4674 test_literal_param(__FILE__
), // Value
4675 time_t(0), uint32_t(0)));
4677 return TEST_SUCCESS
;
4680 test_return_t
regression_bug_854604(memcached_st
*)
4684 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4686 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4688 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4689 test_compare(buffer
[0], 0);
4691 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4692 test_true(strlen(buffer
));
4694 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4695 test_true(strlen(buffer
));
4697 return TEST_SUCCESS
;
4700 static void die_message(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4702 fprintf(stderr
, "Iteration #%u: ", it
);
4704 if (error
== MEMCACHED_ERRNO
)
4706 fprintf(stderr
, "system error %d from %s: %s\n",
4707 errno
, what
, strerror(errno
));
4711 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4712 memcached_strerror(mc
, error
));
4716 #define TEST_CONSTANT_CREATION 200
4718 test_return_t
regression_bug_(memcached_st
*memc
)
4720 const char *remote_server
;
4723 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4725 return TEST_SKIPPED
;
4728 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4730 memcached_st
* mc
= memcached_create(NULL
);
4731 memcached_return rc
;
4733 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4734 if (rc
!= MEMCACHED_SUCCESS
)
4736 die_message(mc
, rc
, "memcached_behavior_set", x
);
4739 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4740 if (rc
!= MEMCACHED_SUCCESS
)
4742 die_message(mc
, rc
, "memcached_behavior_set", x
);
4745 rc
= memcached_server_add(mc
, remote_server
, 0);
4746 if (rc
!= MEMCACHED_SUCCESS
)
4748 die_message(mc
, rc
, "memcached_server_add", x
);
4751 const char *set_key
= "akey";
4752 const size_t set_key_len
= strlen(set_key
);
4753 const char *set_value
= "a value";
4754 const size_t set_value_len
= strlen(set_value
);
4756 if (rc
== MEMCACHED_SUCCESS
)
4760 size_t get_value_len
;
4762 uint32_t get_value_flags
;
4764 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
4765 &get_value_flags
, &rc
);
4766 if (rc
!= MEMCACHED_SUCCESS
)
4768 die_message(mc
, rc
, "memcached_get", x
);
4774 (get_value_len
!= set_value_len
4775 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
4777 fprintf(stderr
, "Values don't match?\n");
4778 rc
= MEMCACHED_FAILURE
;
4784 rc
= memcached_set(mc
,
4785 set_key
, set_key_len
,
4786 set_value
, set_value_len
,
4790 if (rc
!= MEMCACHED_SUCCESS
)
4792 die_message(mc
, rc
, "memcached_set", x
);
4799 if (rc
!= MEMCACHED_SUCCESS
)
4805 return TEST_SUCCESS
;
4808 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
4810 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
4813 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4816 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
4817 memcached_server_port(instance
), NULL
)) > -1);
4820 test_compare(MEMCACHED_SUCCESS
,
4822 test_literal_param(__func__
), // Keys
4823 test_literal_param(__func__
), // Values
4825 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
4827 test_compare(MEMCACHED_CONNECTION_FAILURE
,
4829 test_literal_param(__func__
), // Keys
4830 test_literal_param(__func__
), // Values
4833 memcached_free(memc
);
4835 return TEST_SUCCESS
;