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.
38 #include <mem_config.h>
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 <libmemcachedutil-1.0/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"
89 #include "tests/memc.hpp"
91 #define UUID_STRING_MAXLENGTH 36
93 #include "tests/keys.hpp"
95 #include "libmemcached/instance.hpp"
97 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
100 If no options are given, copy over at least the binary flag.
102 char options_buffer
[1024]= { 0 };
105 if (memcached_is_binary(original_memc
))
107 snprintf(options_buffer
, sizeof(options_buffer
), "--BINARY");
112 * I only want to hit _one_ server so I know the number of requests I'm
113 * sending in the pipeline.
115 const memcached_instance_st
* instance
= memcached_server_instance_by_position(original_memc
, 0);
117 char server_string
[1024];
118 int server_string_length
;
119 if (instance
->type
== MEMCACHED_CONNECTION_UNIX_SOCKET
)
123 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\" %s",
124 memcached_server_name(instance
), options
);
128 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\"",
129 memcached_server_name(instance
));
136 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
137 memcached_server_name(instance
), int(memcached_server_port(instance
)),
142 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
143 memcached_server_name(instance
), int(memcached_server_port(instance
)));
147 if (server_string_length
<= 0)
152 char errror_buffer
[1024];
153 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, errror_buffer
, sizeof(errror_buffer
))))
155 Error
<< "Failed to parse (" << server_string
<< ") " << errror_buffer
;
159 return memcached(server_string
, server_string_length
);
163 test_return_t
init_test(memcached_st
*not_used
)
168 (void)memcached_create(&memc
);
169 memcached_free(&memc
);
174 #define TEST_PORT_COUNT 7
175 in_port_t test_ports
[TEST_PORT_COUNT
];
177 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
178 const memcached_instance_st
* server
,
182 size_t bigger
= *((size_t *)(context
));
184 fatal_assert(bigger
<= memcached_server_port(server
));
185 *((size_t *)(context
))= memcached_server_port(server
);
187 return MEMCACHED_SUCCESS
;
190 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
191 const memcached_instance_st
* instance
,
195 FILE *stream
= (FILE *)context
;
198 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
199 memcached_server_name(instance
),
200 memcached_server_port(instance
),
201 instance
->major_version
,
202 instance
->minor_version
,
203 instance
->micro_version
);
205 return MEMCACHED_SUCCESS
;
208 test_return_t
server_sort_test(memcached_st
*ptr
)
210 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
212 memcached_return_t rc
;
213 memcached_server_fn callbacks
[1];
214 memcached_st
*local_memc
;
217 local_memc
= memcached_create(NULL
);
218 test_true(local_memc
);
219 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
221 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
223 test_ports
[x
]= (in_port_t
)random() % 64000;
224 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
225 test_compare(memcached_server_count(local_memc
), x
+1);
227 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
229 test_compare(MEMCACHED_SUCCESS
, rc
);
232 callbacks
[0]= server_display_function
;
233 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
236 memcached_free(local_memc
);
241 test_return_t
server_sort2_test(memcached_st
*ptr
)
243 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
244 memcached_server_fn callbacks
[1];
245 memcached_st
*local_memc
;
246 const memcached_instance_st
* instance
;
249 local_memc
= memcached_create(NULL
);
250 test_true(local_memc
);
251 test_compare(MEMCACHED_SUCCESS
,
252 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
254 test_compare(MEMCACHED_SUCCESS
,
255 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
256 instance
= memcached_server_instance_by_position(local_memc
, 0);
257 test_compare(in_port_t(43043), memcached_server_port(instance
));
259 test_compare(MEMCACHED_SUCCESS
,
260 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
262 instance
= memcached_server_instance_by_position(local_memc
, 0);
263 test_compare(in_port_t(43042), memcached_server_port(instance
));
265 instance
= memcached_server_instance_by_position(local_memc
, 1);
266 test_compare(in_port_t(43043), memcached_server_port(instance
));
268 callbacks
[0]= server_display_function
;
269 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
272 memcached_free(local_memc
);
277 test_return_t
memcached_server_remove_test(memcached_st
*)
279 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";
282 test_compare(MEMCACHED_SUCCESS
,
283 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
284 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
287 memcached_server_fn callbacks
[1];
288 callbacks
[0]= server_print_callback
;
289 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
291 memcached_free(memc
);
296 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
297 const memcached_instance_st
* server
,
301 uint32_t x
= *((uint32_t *)(context
));
303 if (! (test_ports
[x
] == memcached_server_port(server
)))
305 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)memcached_server_port(server
));
306 return MEMCACHED_FAILURE
;
309 *((uint32_t *)(context
))= ++x
;
311 return MEMCACHED_SUCCESS
;
314 test_return_t
server_unsort_test(memcached_st
*ptr
)
316 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
317 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
318 memcached_server_fn callbacks
[1];
319 memcached_st
*local_memc
;
322 local_memc
= memcached_create(NULL
);
323 test_true(local_memc
);
325 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
327 test_ports
[x
]= (in_port_t
)(random() % 64000);
328 test_compare(MEMCACHED_SUCCESS
,
329 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
330 test_compare(memcached_server_count(local_memc
), x
+1);
332 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
336 callbacks
[0]= server_display_unsort_function
;
337 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
339 /* Now we sort old data! */
340 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
341 callbacks
[0]= server_display_function
;
342 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
345 memcached_free(local_memc
);
350 test_return_t
allocation_test(memcached_st
*not_used
)
354 memc
= memcached_create(NULL
);
356 memcached_free(memc
);
361 test_return_t
clone_test(memcached_st
*memc
)
365 memcached_st
*memc_clone
;
366 memc_clone
= memcached_clone(NULL
, NULL
);
367 test_true(memc_clone
);
368 memcached_free(memc_clone
);
371 /* Can we init from null? */
373 memcached_st
*memc_clone
;
374 memc_clone
= memcached_clone(NULL
, memc
);
375 test_true(memc_clone
);
378 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
379 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
380 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
381 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
384 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
385 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
386 test_true(memc_clone
->distribution
== memc
->distribution
);
387 { // Test all of the flags
388 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
389 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
390 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
391 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
392 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
393 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
394 test_true(memc_clone
->ketama
.weighted_
== memc
->ketama
.weighted_
);
395 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
396 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
397 test_true(memc_clone
->flags
.reply
== memc
->flags
.reply
);
398 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
399 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
400 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
402 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
403 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
404 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
405 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
406 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
407 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
408 test_true(memc_clone
->on_clone
== memc
->on_clone
);
409 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
410 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
411 test_true(memc_clone
->recv_size
== memc
->recv_size
);
412 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
413 test_true(memc_clone
->send_size
== memc
->send_size
);
414 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
415 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
416 test_true(memc_clone
->user_data
== memc
->user_data
);
418 memcached_free(memc_clone
);
421 /* Can we init from struct? */
423 memcached_st declared_clone
;
424 memcached_st
*memc_clone
;
425 memset(&declared_clone
, 0 , sizeof(memcached_st
));
426 memc_clone
= memcached_clone(&declared_clone
, NULL
);
427 test_true(memc_clone
);
428 memcached_free(memc_clone
);
431 /* Can we init from struct? */
433 memcached_st declared_clone
;
434 memcached_st
*memc_clone
;
435 memset(&declared_clone
, 0 , sizeof(memcached_st
));
436 memc_clone
= memcached_clone(&declared_clone
, memc
);
437 test_true(memc_clone
);
438 memcached_free(memc_clone
);
444 test_return_t
userdata_test(memcached_st
*memc
)
447 test_false(memcached_set_user_data(memc
, foo
));
448 test_true(memcached_get_user_data(memc
) == foo
);
449 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
454 test_return_t
connection_test(memcached_st
*memc
)
456 test_compare(MEMCACHED_SUCCESS
,
457 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
462 test_return_t
libmemcached_string_behavior_test(memcached_st
*)
464 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
466 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
468 test_compare(37, int(MEMCACHED_BEHAVIOR_MAX
));
473 test_return_t
libmemcached_string_distribution_test(memcached_st
*)
475 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
477 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
479 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
484 test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
486 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
487 982370485U, 1263635348U, 4242906218U, 3829656100U,
488 1891735253U, 334139633U, 2257084983U, 3351789013U,
489 13199785U, 2542027183U, 1097051614U, 199566778U,
490 2748246961U, 2465192557U, 1664094137U, 2405439045U,
491 1842224848U, 692413798U, 3479807801U, 919913813U,
492 4269430871U, 610793021U, 527273862U, 1437122909U,
493 2300930706U, 2943759320U, 674306647U, 2400528935U,
494 54481931U, 4186304426U, 1741088401U, 2979625118U,
495 4159057246U, 3425930182U, 2593724503U, 1868899624U,
496 1769812374U, 2302537950U, 1110330676U, 3365377466U,
497 1336171666U, 3021258493U, 2334992265U, 3861994737U,
498 3582734124U, 3365377466U };
500 // You have updated the memcache_error messages but not updated docs/tests.
501 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
504 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
505 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
506 MEMCACHED_HASH_JENKINS
);
507 if (values
[rc
] != hash_val
)
509 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
510 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
512 test_compare(values
[rc
], hash_val
);
514 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
519 test_return_t
set_test(memcached_st
*memc
)
521 memcached_return_t rc
= memcached_set(memc
,
522 test_literal_param("foo"),
523 test_literal_param("when we sanitize"),
524 time_t(0), (uint32_t)0);
525 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
530 test_return_t
append_test(memcached_st
*memc
)
532 memcached_return_t rc
;
533 const char *in_value
= "we";
537 test_compare(MEMCACHED_SUCCESS
,
538 memcached_flush(memc
, 0));
540 test_compare(MEMCACHED_SUCCESS
,
542 test_literal_param(__func__
),
543 in_value
, strlen(in_value
),
544 time_t(0), uint32_t(0)));
546 test_compare(MEMCACHED_SUCCESS
,
547 memcached_append(memc
,
548 test_literal_param(__func__
),
549 " the", strlen(" the"),
550 time_t(0), uint32_t(0)));
552 test_compare(MEMCACHED_SUCCESS
,
553 memcached_append(memc
,
554 test_literal_param(__func__
),
555 " people", strlen(" people"),
556 time_t(0), uint32_t(0)));
558 char *out_value
= memcached_get(memc
,
559 test_literal_param(__func__
),
560 &value_length
, &flags
, &rc
);
561 test_memcmp(out_value
, "we the people", strlen("we the people"));
562 test_compare(strlen("we the people"), value_length
);
563 test_compare(MEMCACHED_SUCCESS
, rc
);
569 test_return_t
append_binary_test(memcached_st
*memc
)
571 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
573 test_compare(MEMCACHED_SUCCESS
,
574 memcached_flush(memc
, 0));
576 test_compare(MEMCACHED_SUCCESS
,
578 test_literal_param(__func__
),
580 time_t(0), uint32_t(0)));
583 for (uint32_t x
= 0; store_list
[x
] ; x
++)
585 test_compare(MEMCACHED_SUCCESS
,
586 memcached_append(memc
,
587 test_literal_param(__func__
),
588 (char *)&store_list
[x
], sizeof(uint32_t),
589 time_t(0), uint32_t(0)));
595 memcached_return_t rc
;
596 uint32_t *value
= (uint32_t *)memcached_get(memc
,
597 test_literal_param(__func__
),
598 &value_length
, &flags
, &rc
);
599 test_compare(value_length
, sizeof(uint32_t) * count
);
600 test_compare(MEMCACHED_SUCCESS
, rc
);
602 for (uint32_t counter
= uint32_t(count
), *ptr
= value
; counter
; counter
--)
604 test_compare(*ptr
, store_list
[count
- counter
]);
612 test_return_t
memcached_mget_mixed_memcached_get_TEST(memcached_st
*memc
)
616 for (libtest::vchar_ptr_t::iterator iter
= keys
.begin();
620 test_compare_hint(MEMCACHED_SUCCESS
,
624 time_t(0), uint32_t(0)),
625 memcached_last_error_message(memc
));
628 for (ptrdiff_t loop
= 0; loop
< 20; loop
++)
632 test_compare(MEMCACHED_SUCCESS
,
633 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
635 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
638 size_t result_count
= 0;
639 memcached_return_t rc
;
640 while (memcached_fetch_result(memc
, results
, &rc
))
644 test_true(keys
.size() >= result_count
);
648 int which_key
= random() % int(keys
.size());
651 memcached_return_t rc
;
652 char *out_value
= memcached_get(memc
, keys
.key_at(which_key
), keys
.length_at(which_key
),
653 &value_length
, &flags
, &rc
);
654 if (rc
== MEMCACHED_NOTFOUND
)
655 { } // It is possible that the value has been purged.
658 test_compare(MEMCACHED_SUCCESS
, rc
);
660 test_null(out_value
);
661 test_zero(value_length
);
669 test_return_t
cas2_test(memcached_st
*memc
)
671 const char *keys
[]= {"fudge", "son", "food"};
672 size_t key_length
[]= {5, 3, 4};
673 const char *value
= "we the people";
674 size_t value_length
= strlen("we the people");
676 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
678 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
680 for (uint32_t x
= 0; x
< 3; x
++)
682 test_compare(MEMCACHED_SUCCESS
,
683 memcached_set(memc
, keys
[x
], key_length
[x
],
684 keys
[x
], key_length
[x
],
685 time_t(50), uint32_t(9)));
688 test_compare(MEMCACHED_SUCCESS
,
689 memcached_mget(memc
, keys
, key_length
, 3));
691 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
694 memcached_return_t rc
;
695 results
= memcached_fetch_result(memc
, results
, &rc
);
697 test_true(results
->item_cas
);
698 test_compare(MEMCACHED_SUCCESS
, rc
);
699 test_true(memcached_result_cas(results
));
701 test_memcmp(value
, "we the people", strlen("we the people"));
702 test_compare(strlen("we the people"), value_length
);
703 test_compare(MEMCACHED_SUCCESS
, rc
);
705 memcached_result_free(results
);
710 test_return_t
cas_test(memcached_st
*memc
)
712 const char* keys
[2] = { __func__
, NULL
};
713 size_t keylengths
[2] = { strlen(__func__
), 0 };
715 memcached_result_st results_obj
;
717 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
719 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
721 test_compare(MEMCACHED_SUCCESS
,
723 test_literal_param(__func__
),
724 test_literal_param("we the people"),
725 (time_t)0, (uint32_t)0));
727 test_compare(MEMCACHED_SUCCESS
,
728 memcached_mget(memc
, keys
, keylengths
, 1));
730 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
733 memcached_return_t rc
;
734 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
736 test_compare(MEMCACHED_SUCCESS
, rc
);
737 test_true(memcached_result_cas(results
));
738 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
739 test_compare(test_literal_param_size("we the people"),
740 strlen(memcached_result_value(results
)));
742 uint64_t cas
= memcached_result_cas(results
);
745 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
746 test_true(rc
== MEMCACHED_END
);
747 test_true(results
== NULL
);
750 test_compare(MEMCACHED_SUCCESS
,
752 test_literal_param(__func__
),
753 test_literal_param("change the value"),
757 * The item will have a new cas value, so try to set it again with the old
758 * value. This should fail!
760 test_compare(MEMCACHED_DATA_EXISTS
,
762 test_literal_param(__func__
),
763 test_literal_param("change the value"),
766 memcached_result_free(&results_obj
);
772 test_return_t
prepend_test(memcached_st
*memc
)
774 const char *key
= "fig";
775 const char *value
= "people";
777 test_compare(MEMCACHED_SUCCESS
,
778 memcached_flush(memc
, 0));
780 test_compare(MEMCACHED_SUCCESS
,
781 memcached_set(memc
, key
, strlen(key
),
782 value
, strlen(value
),
783 time_t(0), uint32_t(0)));
785 test_compare(MEMCACHED_SUCCESS
,
786 memcached_prepend(memc
, key
, strlen(key
),
787 "the ", strlen("the "),
788 time_t(0), uint32_t(0)));
790 test_compare(MEMCACHED_SUCCESS
,
791 memcached_prepend(memc
, key
, strlen(key
),
792 "we ", strlen("we "),
793 time_t(0), uint32_t(0)));
797 memcached_return_t rc
;
798 char *out_value
= memcached_get(memc
, key
, strlen(key
),
799 &value_length
, &flags
, &rc
);
800 test_memcmp(out_value
, "we the people", strlen("we the people"));
801 test_compare(strlen("we the people"), value_length
);
802 test_compare(MEMCACHED_SUCCESS
, rc
);
809 Set the value, then quit to make sure it is flushed.
810 Come back in and test that add fails.
812 test_return_t
memcached_add_SUCCESS_TEST(memcached_st
*memc
)
814 memcached_return_t rc
;
815 test_null(memcached_get(memc
, test_literal_param(__func__
), NULL
, NULL
, &rc
));
816 test_compare(MEMCACHED_NOTFOUND
, rc
);
818 test_compare(MEMCACHED_SUCCESS
,
820 test_literal_param(__func__
),
821 test_literal_param("try something else"),
822 time_t(0), uint32_t(0)));
827 test_return_t
regression_1067242_TEST(memcached_st
*memc
)
829 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
830 test_literal_param(__func__
),
831 test_literal_param("-2"),
834 memcached_return_t rc
;
836 test_true((value
= memcached_get(memc
, test_literal_param(__func__
), NULL
, NULL
, &rc
)));
837 test_compare(MEMCACHED_SUCCESS
, rc
);
840 for (size_t x
= 0; x
< 10; x
++)
843 test_compare(MEMCACHED_CLIENT_ERROR
,
844 memcached_increment(memc
,
845 test_literal_param(__func__
), 1, &new_number
));
846 test_compare(MEMCACHED_CLIENT_ERROR
, memcached_last_error(memc
));
847 test_true((value
= memcached_get(memc
, test_literal_param(__func__
), NULL
, NULL
, &rc
)));
848 test_compare(MEMCACHED_SUCCESS
, rc
);
856 Set the value, then quit to make sure it is flushed.
857 Come back in and test that add fails.
859 test_return_t
add_test(memcached_st
*memc
)
861 test_compare(return_value_based_on_buffering(memc
),
863 test_literal_param(__func__
),
864 test_literal_param("when we sanitize"),
865 time_t(0), uint32_t(0)));
867 memcached_quit(memc
);
871 memcached_return_t rc
;
872 char *check_value
= memcached_get(memc
,
873 test_literal_param(__func__
),
874 &value_length
, &flags
, &rc
);
875 test_memcmp(check_value
, "when we sanitize", strlen("when we sanitize"));
876 test_compare(test_literal_param_size("when we sanitize"), value_length
);
877 test_compare(MEMCACHED_SUCCESS
, rc
);
880 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
882 test_literal_param(__func__
),
883 test_literal_param("try something else"),
884 time_t(0), uint32_t(0)));
890 ** There was a problem of leaking filedescriptors in the initial release
891 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
892 ** systems it seems that the kernel is slow on reclaiming the resources
893 ** because the connects starts to time out (the test doesn't do much
894 ** anyway, so just loop 10 iterations)
896 test_return_t
add_wrapper(memcached_st
*memc
)
898 unsigned int max
= 10000;
906 for (uint32_t x
= 0; x
< max
; x
++)
914 test_return_t
replace_test(memcached_st
*memc
)
916 test_compare(return_value_based_on_buffering(memc
),
918 test_literal_param(__func__
),
919 test_literal_param("when we sanitize"),
920 time_t(0), uint32_t(0)));
922 test_compare(MEMCACHED_SUCCESS
,
923 memcached_replace(memc
,
924 test_literal_param(__func__
),
925 test_literal_param("first we insert some data"),
926 time_t(0), uint32_t(0)));
931 test_return_t
delete_test(memcached_st
*memc
)
933 test_compare(return_value_based_on_buffering(memc
),
935 test_literal_param(__func__
),
936 test_literal_param("when we sanitize"),
937 time_t(0), uint32_t(0)));
939 test_compare(return_value_based_on_buffering(memc
),
940 memcached_delete(memc
,
941 test_literal_param(__func__
),
947 test_return_t
flush_test(memcached_st
*memc
)
949 uint64_t query_id
= memcached_query_id(memc
);
950 test_compare(MEMCACHED_SUCCESS
,
951 memcached_flush(memc
, 0));
952 test_compare(query_id
+1, memcached_query_id(memc
));
957 static memcached_return_t
server_function(const memcached_st
*,
958 const memcached_instance_st
*,
962 return MEMCACHED_SUCCESS
;
965 test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
968 strncpy(context
, "foo bad", sizeof(context
));
969 memcached_server_fn callbacks
[1];
971 callbacks
[0]= server_function
;
972 memcached_server_cursor(memc
, callbacks
, context
, 1);
976 test_return_t
bad_key_test(memcached_st
*memc
)
978 memcached_return_t rc
;
979 const char *key
= "foo bad";
982 uint64_t query_id
= memcached_query_id(memc
);
984 // Just skip if we are in binary mode.
985 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
987 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
989 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
990 test_true(memc_clone
);
992 query_id
= memcached_query_id(memc_clone
);
993 test_compare(MEMCACHED_SUCCESS
,
994 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
995 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
996 ASSERT_TRUE(memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
));
998 /* All keys are valid in the binary protocol (except for length) */
999 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == false)
1001 uint64_t before_query_id
= memcached_query_id(memc_clone
);
1003 size_t string_length
;
1004 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1005 &string_length
, &flags
, &rc
);
1006 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1007 test_zero(string_length
);
1010 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
1012 query_id
= memcached_query_id(memc_clone
);
1013 test_compare(MEMCACHED_SUCCESS
,
1014 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
1015 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
1017 size_t string_length
;
1018 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1019 &string_length
, &flags
, &rc
);
1020 test_compare(MEMCACHED_NOTFOUND
, rc
);
1021 test_zero(string_length
);
1025 /* Test multi key for bad keys */
1026 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
1027 size_t key_lengths
[] = { 7, 7, 7 };
1028 query_id
= memcached_query_id(memc_clone
);
1029 test_compare(MEMCACHED_SUCCESS
,
1030 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1031 test_compare(query_id
, memcached_query_id(memc_clone
));
1033 query_id
= memcached_query_id(memc_clone
);
1034 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
1035 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
1036 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1038 query_id
= memcached_query_id(memc_clone
);
1039 // Grouping keys are not required to follow normal key behaviors
1040 test_compare(MEMCACHED_SUCCESS
,
1041 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
1042 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1044 /* The following test should be moved to the end of this function when the
1045 memcached server is updated to allow max size length of the keys in the
1048 test_compare(MEMCACHED_SUCCESS
,
1049 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
1051 libtest::vchar_t longkey
;
1053 libtest::vchar_t::iterator it
= longkey
.begin();
1054 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
1057 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
1059 size_t string_length
;
1061 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
1062 test_compare(MEMCACHED_NOTFOUND
, rc
);
1063 test_zero(string_length
);
1065 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
1066 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1067 test_zero(string_length
);
1071 /* Make sure zero length keys are marked as bad */
1073 test_compare(MEMCACHED_SUCCESS
,
1074 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1075 size_t string_length
;
1076 char *string
= memcached_get(memc_clone
, key
, 0,
1077 &string_length
, &flags
, &rc
);
1078 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1079 test_zero(string_length
);
1083 memcached_free(memc_clone
);
1085 return TEST_SUCCESS
;
1088 #define READ_THROUGH_VALUE "set for me"
1089 static memcached_return_t
read_through_trigger(memcached_st
*, // memc
1091 size_t, // key_length,
1092 memcached_result_st
*result
)
1094 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
1097 #ifndef __INTEL_COMPILER
1098 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1101 test_return_t
read_through(memcached_st
*memc
)
1103 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1105 size_t string_length
;
1107 memcached_return_t rc
;
1108 char *string
= memcached_get(memc
,
1109 test_literal_param(__func__
),
1110 &string_length
, &flags
, &rc
);
1112 test_compare(MEMCACHED_NOTFOUND
, rc
);
1113 test_false(string_length
);
1116 test_compare(MEMCACHED_SUCCESS
,
1117 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1119 string
= memcached_get(memc
,
1120 test_literal_param(__func__
),
1121 &string_length
, &flags
, &rc
);
1123 test_compare(MEMCACHED_SUCCESS
, rc
);
1124 test_compare(sizeof(READ_THROUGH_VALUE
) -1, string_length
);
1125 test_compare(0, string
[sizeof(READ_THROUGH_VALUE
) -1]);
1126 test_strcmp(READ_THROUGH_VALUE
, string
);
1129 string
= memcached_get(memc
,
1130 test_literal_param(__func__
),
1131 &string_length
, &flags
, &rc
);
1133 test_compare(MEMCACHED_SUCCESS
, rc
);
1135 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1136 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1137 test_strcmp(READ_THROUGH_VALUE
, string
);
1140 return TEST_SUCCESS
;
1143 test_return_t
set_test2(memcached_st
*memc
)
1145 for (uint32_t x
= 0; x
< 10; x
++)
1147 test_compare(return_value_based_on_buffering(memc
),
1149 test_literal_param("foo"),
1150 test_literal_param("train in the brain"),
1151 time_t(0), uint32_t(0)));
1154 return TEST_SUCCESS
;
1157 test_return_t
set_test3(memcached_st
*memc
)
1159 size_t value_length
= 8191;
1161 libtest::vchar_t value
;
1162 value
.reserve(value_length
);
1163 for (uint32_t x
= 0; x
< value_length
; x
++)
1165 value
.push_back(char(x
% 127));
1168 /* The dump test relies on there being at least 32 items in memcached */
1169 for (uint32_t x
= 0; x
< 32; x
++)
1173 snprintf(key
, sizeof(key
), "foo%u", x
);
1175 uint64_t query_id
= memcached_query_id(memc
);
1176 test_compare(return_value_based_on_buffering(memc
),
1177 memcached_set(memc
, key
, strlen(key
),
1178 &value
[0], value
.size(),
1179 time_t(0), uint32_t(0)));
1180 test_compare(query_id
+1, memcached_query_id(memc
));
1183 return TEST_SUCCESS
;
1186 test_return_t
mget_end(memcached_st
*memc
)
1188 const char *keys
[]= { "foo", "foo2" };
1189 size_t lengths
[]= { 3, 4 };
1190 const char *values
[]= { "fjord", "41" };
1193 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1195 test_compare(MEMCACHED_SUCCESS
,
1197 keys
[x
], lengths
[x
],
1198 values
[x
], strlen(values
[x
]),
1199 time_t(0), uint32_t(0)));
1203 size_t string_length
;
1206 // retrieve both via mget
1207 test_compare(MEMCACHED_SUCCESS
,
1208 memcached_mget(memc
,
1210 test_array_length(keys
)));
1212 char key
[MEMCACHED_MAX_KEY
];
1214 memcached_return_t rc
;
1216 // this should get both
1217 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1219 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1221 test_compare(MEMCACHED_SUCCESS
, rc
);
1223 if (key_length
== 4)
1228 test_compare(string_length
, strlen(values
[val
]));
1229 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1233 // this should indicate end
1234 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1235 test_compare(MEMCACHED_END
, rc
);
1239 test_compare(MEMCACHED_SUCCESS
,
1240 memcached_mget(memc
, keys
, lengths
, 1));
1242 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1243 test_compare(key_length
, lengths
[0]);
1244 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1245 test_compare(string_length
, strlen(values
[0]));
1246 test_true(strncmp(values
[0], string
, string_length
) == 0);
1247 test_compare(MEMCACHED_SUCCESS
, rc
);
1250 // this should indicate end
1251 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1252 test_compare(MEMCACHED_END
, rc
);
1255 return TEST_SUCCESS
;
1258 /* Do not copy the style of this code, I just access hosts to testthis function */
1259 test_return_t
stats_servername_test(memcached_st
*memc
)
1261 memcached_stat_st memc_stat
;
1262 const memcached_instance_st
* instance
=
1263 memcached_server_instance_by_position(memc
, 0);
1265 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1267 return TEST_SKIPPED
;
1270 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1271 memcached_server_name(instance
),
1272 memcached_server_port(instance
)));
1274 return TEST_SUCCESS
;
1277 test_return_t
increment_test(memcached_st
*memc
)
1279 uint64_t new_number
;
1281 test_compare(MEMCACHED_SUCCESS
,
1283 test_literal_param("number"),
1284 test_literal_param("0"),
1285 (time_t)0, (uint32_t)0));
1287 test_compare(MEMCACHED_SUCCESS
,
1288 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1289 test_compare(uint64_t(1), new_number
);
1291 test_compare(MEMCACHED_SUCCESS
,
1292 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1293 test_compare(uint64_t(2), new_number
);
1295 return TEST_SUCCESS
;
1298 static test_return_t
__increment_with_initial_test(memcached_st
*memc
, uint64_t initial
)
1300 uint64_t new_number
;
1302 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1304 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
1306 test_compare(MEMCACHED_SUCCESS
,
1307 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1308 test_compare(new_number
, initial
);
1310 test_compare(MEMCACHED_SUCCESS
,
1311 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1312 test_compare(new_number
, (initial
+1));
1316 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
1317 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1320 return TEST_SUCCESS
;
1323 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1325 return __increment_with_initial_test(memc
, 0);
1328 test_return_t
increment_with_initial_999_test(memcached_st
*memc
)
1330 return __increment_with_initial_test(memc
, 999);
1333 test_return_t
decrement_test(memcached_st
*memc
)
1335 test_compare(return_value_based_on_buffering(memc
),
1337 test_literal_param(__func__
),
1338 test_literal_param("3"),
1339 time_t(0), uint32_t(0)));
1341 // Make sure we flush the value we just set
1342 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1344 uint64_t new_number
;
1345 test_compare(MEMCACHED_SUCCESS
,
1346 memcached_decrement(memc
,
1347 test_literal_param(__func__
),
1349 test_compare(uint64_t(2), new_number
);
1351 test_compare(MEMCACHED_SUCCESS
,
1352 memcached_decrement(memc
,
1353 test_literal_param(__func__
),
1355 test_compare(uint64_t(1), new_number
);
1357 return TEST_SUCCESS
;
1360 static test_return_t
__decrement_with_initial_test(memcached_st
*memc
, uint64_t initial
)
1362 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1364 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1366 uint64_t new_number
;
1367 test_compare(MEMCACHED_SUCCESS
,
1368 memcached_decrement_with_initial(memc
,
1369 test_literal_param(__func__
),
1372 test_compare(new_number
, initial
);
1374 test_compare(MEMCACHED_SUCCESS
,
1375 memcached_decrement_with_initial(memc
,
1376 test_literal_param(__func__
),
1379 test_compare(new_number
, (initial
- 1));
1381 return TEST_SUCCESS
;
1384 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1386 return __decrement_with_initial_test(memc
, 3);
1389 test_return_t
decrement_with_initial_999_test(memcached_st
*memc
)
1391 return __decrement_with_initial_test(memc
, 999);
1394 test_return_t
increment_by_key_test(memcached_st
*memc
)
1396 const char *master_key
= "foo";
1397 const char *key
= "number";
1398 const char *value
= "0";
1400 test_compare(return_value_based_on_buffering(memc
),
1401 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1403 value
, strlen(value
),
1404 time_t(0), uint32_t(0)));
1406 // Make sure we flush the value we just set
1407 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1409 uint64_t new_number
;
1410 test_compare(MEMCACHED_SUCCESS
,
1411 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1412 key
, strlen(key
), 1, &new_number
));
1413 test_compare(uint64_t(1), new_number
);
1415 test_compare(MEMCACHED_SUCCESS
,
1416 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1417 key
, strlen(key
), 1, &new_number
));
1418 test_compare(uint64_t(2), new_number
);
1420 return TEST_SUCCESS
;
1423 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1425 uint64_t new_number
;
1426 const char *master_key
= "foo";
1427 const char *key
= "number";
1428 uint64_t initial
= 0;
1430 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
1432 test_compare(MEMCACHED_SUCCESS
,
1433 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1435 1, initial
, 0, &new_number
));
1436 test_compare(new_number
, initial
);
1438 test_compare(MEMCACHED_SUCCESS
,
1439 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1441 1, initial
, 0, &new_number
));
1442 test_compare(new_number
, (initial
+1));
1446 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
1447 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1449 1, initial
, 0, &new_number
));
1452 return TEST_SUCCESS
;
1455 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1457 uint64_t new_number
;
1458 const char *value
= "3";
1460 test_compare(return_value_based_on_buffering(memc
),
1461 memcached_set_by_key(memc
,
1462 test_literal_param("foo"),
1463 test_literal_param("number"),
1464 value
, strlen(value
),
1465 (time_t)0, (uint32_t)0));
1467 test_compare(MEMCACHED_SUCCESS
,
1468 memcached_decrement_by_key(memc
,
1469 test_literal_param("foo"),
1470 test_literal_param("number"),
1472 test_compare(uint64_t(2), new_number
);
1474 test_compare(MEMCACHED_SUCCESS
,
1475 memcached_decrement_by_key(memc
,
1476 test_literal_param("foo"),
1477 test_literal_param("number"),
1479 test_compare(uint64_t(1), new_number
);
1481 return TEST_SUCCESS
;
1484 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1486 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1488 uint64_t new_number
;
1489 uint64_t initial
= 3;
1491 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
1493 test_compare(MEMCACHED_SUCCESS
,
1494 memcached_decrement_with_initial_by_key(memc
,
1495 test_literal_param("foo"),
1496 test_literal_param("number"),
1497 1, initial
, 0, &new_number
));
1498 test_compare(new_number
, initial
);
1500 test_compare(MEMCACHED_SUCCESS
,
1501 memcached_decrement_with_initial_by_key(memc
,
1502 test_literal_param("foo"),
1503 test_literal_param("number"),
1504 1, initial
, 0, &new_number
));
1505 test_compare(new_number
, (initial
- 1));
1509 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
1510 memcached_decrement_with_initial_by_key(memc
,
1511 test_literal_param("foo"),
1512 test_literal_param("number"),
1513 1, initial
, 0, &new_number
));
1516 return TEST_SUCCESS
;
1518 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1520 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1522 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1524 test_compare(return_value_based_on_buffering(memc
),
1526 test_literal_param("number"),
1527 test_literal_param("0"),
1528 (time_t)0, (uint32_t)0));
1530 uint64_t new_number
;
1531 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1532 test_literal_param("number"),
1534 test_compare(uint64_t(1), new_number
);
1536 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1537 test_literal_param("number"),
1539 test_compare(uint64_t(2), new_number
);
1541 return TEST_SUCCESS
;
1544 test_return_t
quit_test(memcached_st
*memc
)
1546 const char *value
= "sanford and sun";
1548 test_compare(return_value_based_on_buffering(memc
),
1550 test_literal_param(__func__
),
1551 value
, strlen(value
),
1552 time_t(10), uint32_t(3)));
1553 memcached_quit(memc
);
1555 test_compare(return_value_based_on_buffering(memc
),
1557 test_literal_param(__func__
),
1558 value
, strlen(value
),
1559 time_t(50), uint32_t(9)));
1561 return TEST_SUCCESS
;
1564 test_return_t
mget_result_test(memcached_st
*memc
)
1566 const char *keys
[]= {"fudge", "son", "food"};
1567 size_t key_length
[]= {5, 3, 4};
1569 memcached_result_st results_obj
;
1570 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1572 test_true(&results_obj
== results
);
1574 /* We need to empty the server before continueing test */
1575 test_compare(MEMCACHED_SUCCESS
,
1576 memcached_flush(memc
, 0));
1578 test_compare(MEMCACHED_SUCCESS
,
1579 memcached_mget(memc
, keys
, key_length
, 3));
1581 memcached_return_t rc
;
1582 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1587 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1588 test_false(results
);
1589 test_compare(MEMCACHED_NOTFOUND
, rc
);
1591 for (uint32_t x
= 0; x
< 3; x
++)
1593 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1594 keys
[x
], key_length
[x
],
1595 (time_t)50, (uint32_t)9);
1596 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1599 test_compare(MEMCACHED_SUCCESS
,
1600 memcached_mget(memc
, keys
, key_length
, 3));
1602 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1605 test_true(&results_obj
== results
);
1606 test_compare(MEMCACHED_SUCCESS
, rc
);
1607 test_memcmp(memcached_result_key_value(results
),
1608 memcached_result_value(results
),
1609 memcached_result_length(results
));
1610 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1613 memcached_result_free(&results_obj
);
1615 return TEST_SUCCESS
;
1618 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1620 const char *keys
[]= {"fudge", "son", "food"};
1621 size_t key_length
[]= {5, 3, 4};
1623 memcached_result_st
*results
;
1625 /* We need to empty the server before continueing test */
1626 test_compare(MEMCACHED_SUCCESS
,
1627 memcached_flush(memc
, 0));
1629 test_compare(MEMCACHED_SUCCESS
,
1630 memcached_mget(memc
, keys
, key_length
, 3));
1632 memcached_return_t rc
;
1633 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1637 test_false(results
);
1638 test_compare(MEMCACHED_NOTFOUND
, rc
);
1640 for (uint32_t x
= 0; x
< 3; x
++)
1642 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1643 keys
[x
], key_length
[x
],
1644 (time_t)50, (uint32_t)9);
1645 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1648 test_compare(MEMCACHED_SUCCESS
,
1649 memcached_mget(memc
, keys
, key_length
, 3));
1652 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1655 test_compare(MEMCACHED_SUCCESS
, rc
);
1656 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1657 test_memcmp(memcached_result_key_value(results
),
1658 memcached_result_value(results
),
1659 memcached_result_length(results
));
1660 memcached_result_free(results
);
1664 return TEST_SUCCESS
;
1667 test_return_t
mget_result_function(memcached_st
*memc
)
1669 const char *keys
[]= {"fudge", "son", "food"};
1670 size_t key_length
[]= {5, 3, 4};
1672 memcached_execute_fn callbacks
[1];
1674 for (uint32_t x
= 0; x
< 3; x
++)
1676 test_compare(return_value_based_on_buffering(memc
),
1677 memcached_set(memc
, keys
[x
], key_length
[x
],
1678 keys
[x
], key_length
[x
],
1679 time_t(50), uint32_t(9)));
1681 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1682 memcached_quit(memc
);
1684 test_compare(MEMCACHED_SUCCESS
,
1685 memcached_mget(memc
, keys
, key_length
, 3));
1687 callbacks
[0]= &callback_counter
;
1690 test_compare(MEMCACHED_SUCCESS
,
1691 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1693 test_compare(size_t(3), counter
);
1695 return TEST_SUCCESS
;
1698 test_return_t
mget_test(memcached_st
*memc
)
1700 const char *keys
[]= {"fudge", "son", "food"};
1701 size_t key_length
[]= {5, 3, 4};
1703 char return_key
[MEMCACHED_MAX_KEY
];
1704 size_t return_key_length
;
1706 size_t return_value_length
;
1708 test_compare(MEMCACHED_SUCCESS
,
1709 memcached_mget(memc
, keys
, key_length
, 3));
1712 memcached_return_t rc
;
1713 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1714 &return_value_length
, &flags
, &rc
)))
1716 test_true(return_value
);
1718 test_false(return_value
);
1719 test_zero(return_value_length
);
1720 test_compare(MEMCACHED_NOTFOUND
, rc
);
1722 for (uint32_t x
= 0; x
< 3; x
++)
1724 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1725 keys
[x
], key_length
[x
],
1726 (time_t)50, (uint32_t)9);
1727 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1729 test_compare(MEMCACHED_SUCCESS
,
1730 memcached_mget(memc
, keys
, key_length
, 3));
1733 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1734 &return_value_length
, &flags
, &rc
)))
1736 test_true(return_value
);
1737 test_compare(MEMCACHED_SUCCESS
, rc
);
1738 if (not memc
->_namespace
)
1740 test_compare(return_key_length
, return_value_length
);
1741 test_memcmp(return_value
, return_key
, return_value_length
);
1747 return TEST_SUCCESS
;
1750 test_return_t
mget_execute(memcached_st
*original_memc
)
1752 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1754 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1757 keys_st
keys(20480);
1759 /* First add all of the items.. */
1760 char blob
[1024] = {0};
1762 for (size_t x
= 0; x
< keys
.size(); ++x
)
1764 uint64_t query_id
= memcached_query_id(memc
);
1765 memcached_return_t rc
= memcached_add(memc
,
1766 keys
.key_at(x
), keys
.length_at(x
),
1769 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1770 test_compare(query_id
+1, memcached_query_id(memc
));
1773 /* Try to get all of them with a large multiget */
1775 memcached_execute_fn callbacks
[]= { &callback_counter
};
1776 test_compare(MEMCACHED_SUCCESS
,
1777 memcached_mget_execute(memc
,
1778 keys
.keys_ptr(), keys
.lengths_ptr(),
1779 keys
.size(), callbacks
, &counter
, 1));
1782 uint64_t query_id
= memcached_query_id(memc
);
1783 test_compare(MEMCACHED_SUCCESS
,
1784 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1785 test_compare(query_id
, memcached_query_id(memc
));
1787 /* Verify that we got all of the items */
1788 test_compare(keys
.size(), counter
);
1791 memcached_free(memc
);
1793 return TEST_SUCCESS
;
1796 test_return_t
MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST(memcached_st
*original_memc
)
1798 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1800 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1803 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 8));
1805 keys_st
keys(20480);
1807 /* First add all of the items.. */
1808 char blob
[1024] = {0};
1810 for (size_t x
= 0; x
< keys
.size(); ++x
)
1812 uint64_t query_id
= memcached_query_id(memc
);
1813 memcached_return_t rc
= memcached_add(memc
,
1814 keys
.key_at(x
), keys
.length_at(x
),
1817 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1818 test_compare(query_id
+1, memcached_query_id(memc
));
1821 /* Try to get all of them with a large multiget */
1823 memcached_execute_fn callbacks
[]= { &callback_counter
};
1824 test_compare(MEMCACHED_SUCCESS
,
1825 memcached_mget_execute(memc
,
1826 keys
.keys_ptr(), keys
.lengths_ptr(),
1827 keys
.size(), callbacks
, &counter
, 1));
1830 uint64_t query_id
= memcached_query_id(memc
);
1831 test_compare(MEMCACHED_SUCCESS
,
1832 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1833 test_compare(query_id
, memcached_query_id(memc
));
1835 /* Verify that we got all of the items */
1836 test_compare(keys
.size(), counter
);
1839 memcached_free(memc
);
1841 return TEST_SUCCESS
;
1844 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1845 static pairs_st
*global_pairs
= NULL
;
1847 test_return_t
key_setup(memcached_st
*memc
)
1849 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1851 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1853 return TEST_SUCCESS
;
1856 test_return_t
key_teardown(memcached_st
*)
1858 pairs_free(global_pairs
);
1861 return TEST_SUCCESS
;
1864 test_return_t
block_add_regression(memcached_st
*memc
)
1866 /* First add all of the items.. */
1867 for (ptrdiff_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1869 libtest::vchar_t blob
;
1870 libtest::vchar::make(blob
, 1024);
1872 memcached_return_t rc
= memcached_add_by_key(memc
,
1873 test_literal_param("bob"),
1874 global_pairs
[x
].key
, global_pairs
[x
].key_length
,
1875 &blob
[0], blob
.size(),
1876 time_t(0), uint32_t(0));
1877 if (rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
)
1879 Error
<< memcached_last_error_message(memc
);
1880 return TEST_SKIPPED
;
1882 test_compare(*memc
, MEMCACHED_SUCCESS
);
1883 test_compare(rc
, MEMCACHED_SUCCESS
);
1886 return TEST_SUCCESS
;
1889 test_return_t
binary_add_regression(memcached_st
*memc
)
1891 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1892 return block_add_regression(memc
);
1895 test_return_t
get_stats_keys(memcached_st
*memc
)
1899 memcached_stat_st memc_stat
;
1900 memcached_return_t rc
;
1902 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1903 test_compare(MEMCACHED_SUCCESS
, rc
);
1904 for (ptr
= stat_list
; *ptr
; ptr
++)
1909 return TEST_SUCCESS
;
1912 test_return_t
version_string_test(memcached_st
*)
1914 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1916 return TEST_SUCCESS
;
1919 test_return_t
get_stats(memcached_st
*memc
)
1921 memcached_return_t rc
;
1923 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1924 test_compare(MEMCACHED_SUCCESS
, rc
);
1925 test_true(memc_stat
);
1927 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1929 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1930 test_compare(MEMCACHED_SUCCESS
, rc
);
1931 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1936 memcached_stat_free(NULL
, memc_stat
);
1938 return TEST_SUCCESS
;
1941 test_return_t
add_host_test(memcached_st
*memc
)
1943 char servername
[]= "0.example.com";
1945 memcached_return_t rc
;
1946 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1947 test_compare(1U, memcached_server_list_count(servers
));
1949 for (unsigned int x
= 2; x
< 20; x
++)
1951 char buffer
[SMALL_STRING_LEN
];
1953 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1954 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1956 test_compare(MEMCACHED_SUCCESS
, rc
);
1957 test_compare(x
, memcached_server_list_count(servers
));
1960 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1961 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1963 memcached_server_list_free(servers
);
1965 return TEST_SUCCESS
;
1968 test_return_t
regression_1048945_TEST(memcached_st
*)
1970 memcached_return status
;
1972 memcached_server_st
* list
= memcached_server_list_append_with_weight(NULL
, "a", 11211, 0, &status
);
1973 test_compare(status
, MEMCACHED_SUCCESS
);
1975 list
= memcached_server_list_append_with_weight(list
, "b", 11211, 0, &status
);
1976 test_compare(status
, MEMCACHED_SUCCESS
);
1978 list
= memcached_server_list_append_with_weight(list
, "c", 11211, 0, &status
);
1979 test_compare(status
, MEMCACHED_SUCCESS
);
1981 memcached_st
* memc
= memcached_create(NULL
);
1983 status
= memcached_server_push(memc
, list
);
1984 memcached_server_list_free(list
);
1985 test_compare(status
, MEMCACHED_SUCCESS
);
1987 const memcached_instance_st
* server
= memcached_server_by_key(memc
, test_literal_param(__func__
), &status
);
1989 test_compare(status
, MEMCACHED_SUCCESS
);
1991 memcached_free(memc
);
1993 return TEST_SUCCESS
;
1996 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1998 memcached_return_t rc
;
2000 const char *key
= "not_found";
2001 size_t key_length
= test_literal_param_size("not_found");
2003 test_compare(MEMCACHED_SUCCESS
,
2004 memcached_mget(memc
, &key
, &key_length
, 1));
2006 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
2008 test_compare(MEMCACHED_NOTFOUND
, rc
);
2010 memcached_result_free(result
);
2012 return TEST_SUCCESS
;
2015 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
2017 return MEMCACHED_SUCCESS
;
2020 static memcached_return_t
cleanup_test_callback(memcached_st
*)
2022 return MEMCACHED_SUCCESS
;
2025 test_return_t
callback_test(memcached_st
*memc
)
2027 /* Test User Data */
2031 memcached_return_t rc
;
2033 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
2034 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
2035 test_true(*test_ptr
== x
);
2038 /* Test Clone Callback */
2040 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2041 void *clone_cb_ptr
= *(void **)&clone_cb
;
2042 void *temp_function
= NULL
;
2044 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
2045 memcached_return_t rc
;
2046 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2047 test_true(temp_function
== clone_cb_ptr
);
2048 test_compare(MEMCACHED_SUCCESS
, rc
);
2051 /* Test Cleanup Callback */
2053 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2054 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2055 void *temp_function
= NULL
;
2056 memcached_return_t rc
;
2058 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2059 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2060 test_true(temp_function
== cleanup_cb_ptr
);
2063 return TEST_SUCCESS
;
2066 /* We don't test the behavior itself, we test the switches */
2067 test_return_t
behavior_test(memcached_st
*memc
)
2069 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2070 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2072 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2073 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2075 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2076 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2078 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2079 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2081 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2082 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2084 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2085 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2087 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2088 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2090 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2092 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2094 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2095 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2096 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2098 return TEST_SUCCESS
;
2101 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2103 test_compare(MEMCACHED_DEPRECATED
,
2104 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2106 // Platform dependent
2108 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2112 return TEST_SUCCESS
;
2116 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2118 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2119 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2121 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2123 if (memcached_success(rc
))
2132 return TEST_SUCCESS
;
2136 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2138 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2139 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2141 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2143 if (memcached_success(rc
))
2152 return TEST_SUCCESS
;
2155 /* Make sure we behave properly if server list has no values */
2156 test_return_t
user_supplied_bug4(memcached_st
*memc
)
2158 const char *keys
[]= {"fudge", "son", "food"};
2159 size_t key_length
[]= {5, 3, 4};
2161 /* Here we free everything before running a bunch of mget tests */
2162 memcached_servers_reset(memc
);
2165 /* We need to empty the server before continueing test */
2166 test_compare(MEMCACHED_NO_SERVERS
,
2167 memcached_flush(memc
, 0));
2169 test_compare(MEMCACHED_NO_SERVERS
,
2170 memcached_mget(memc
, keys
, key_length
, 3));
2173 unsigned int keys_returned
;
2174 memcached_return_t rc
;
2175 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2176 test_compare(MEMCACHED_NOTFOUND
, rc
);
2177 test_zero(keys_returned
);
2180 for (uint32_t x
= 0; x
< 3; x
++)
2182 test_compare(MEMCACHED_NO_SERVERS
,
2183 memcached_set(memc
, keys
[x
], key_length
[x
],
2184 keys
[x
], key_length
[x
],
2185 (time_t)50, (uint32_t)9));
2188 test_compare(MEMCACHED_NO_SERVERS
,
2189 memcached_mget(memc
, keys
, key_length
, 3));
2193 char return_key
[MEMCACHED_MAX_KEY
];
2194 memcached_return_t rc
;
2195 size_t return_key_length
;
2196 size_t return_value_length
;
2199 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2200 &return_value_length
, &flags
, &rc
)))
2202 test_true(return_value
);
2203 test_compare(MEMCACHED_SUCCESS
, rc
);
2204 test_true(return_key_length
== return_value_length
);
2205 test_memcmp(return_value
, return_key
, return_value_length
);
2211 return TEST_SUCCESS
;
2214 #define VALUE_SIZE_BUG5 1048064
2215 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2217 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2218 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2220 size_t value_length
;
2222 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2224 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2226 insert_data
[x
]= (signed char)rand();
2229 test_compare(MEMCACHED_SUCCESS
,
2230 memcached_flush(memc
, 0));
2232 memcached_return_t rc
;
2233 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2234 test_compare(MEMCACHED_SUCCESS
,
2235 memcached_mget(memc
, keys
, key_length
, 4));
2238 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2239 test_compare(MEMCACHED_NOTFOUND
, rc
);
2242 for (uint32_t x
= 0; x
< 4; x
++)
2244 test_compare(MEMCACHED_SUCCESS
,
2245 memcached_set(memc
, keys
[x
], key_length
[x
],
2246 insert_data
, VALUE_SIZE_BUG5
,
2247 (time_t)0, (uint32_t)0));
2250 for (uint32_t x
= 0; x
< 10; x
++)
2252 value
= memcached_get(memc
, keys
[0], key_length
[0],
2253 &value_length
, &flags
, &rc
);
2254 test_compare(rc
, MEMCACHED_SUCCESS
);
2258 test_compare(MEMCACHED_SUCCESS
,
2259 memcached_mget(memc
, keys
, key_length
, 4));
2261 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2262 test_compare(4U, count
);
2264 delete [] insert_data
;
2266 return TEST_SUCCESS
;
2269 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2271 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2272 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2273 char return_key
[MEMCACHED_MAX_KEY
];
2274 size_t return_key_length
;
2276 size_t value_length
;
2278 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2280 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2282 insert_data
[x
]= (signed char)rand();
2285 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2287 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2289 // We will now confirm that memcached_mget() returns success, but we will
2290 // then check to make sure that no actual keys are returned.
2291 test_compare(MEMCACHED_SUCCESS
,
2292 memcached_mget(memc
, keys
, key_length
, 4));
2294 memcached_return_t rc
;
2296 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2297 &value_length
, &flags
, &rc
)))
2302 test_compare(MEMCACHED_NOTFOUND
, rc
);
2304 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2306 test_compare(MEMCACHED_SUCCESS
,
2307 memcached_set(memc
, keys
[x
], key_length
[x
],
2308 insert_data
, VALUE_SIZE_BUG5
,
2309 (time_t)0, (uint32_t)0));
2311 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2313 for (uint32_t x
= 0; x
< 2; x
++)
2315 value
= memcached_get(memc
, keys
[0], key_length
[0],
2316 &value_length
, &flags
, &rc
);
2320 test_compare(MEMCACHED_SUCCESS
,
2321 memcached_mget(memc
, keys
, key_length
, 4));
2322 /* We test for purge of partial complete fetches */
2323 for (count
= 3; count
; count
--)
2325 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2326 &value_length
, &flags
, &rc
);
2327 test_compare(MEMCACHED_SUCCESS
, rc
);
2328 test_memcmp(value
, insert_data
, value_length
);
2329 test_true(value_length
);
2333 delete [] insert_data
;
2335 return TEST_SUCCESS
;
2338 test_return_t
user_supplied_bug8(memcached_st
*)
2340 memcached_return_t rc
;
2342 memcached_st
*memc_clone
;
2344 memcached_server_st
*servers
;
2345 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";
2347 servers
= memcached_servers_parse(server_list
);
2350 mine
= memcached_create(NULL
);
2351 rc
= memcached_server_push(mine
, servers
);
2352 test_compare(MEMCACHED_SUCCESS
, rc
);
2353 memcached_server_list_free(servers
);
2356 memc_clone
= memcached_clone(NULL
, mine
);
2358 memcached_quit(mine
);
2359 memcached_quit(memc_clone
);
2362 memcached_free(mine
);
2363 memcached_free(memc_clone
);
2365 return TEST_SUCCESS
;
2368 /* Test flag store/retrieve */
2369 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2371 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2372 test_true(insert_data
);
2374 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2376 insert_data
[x
]= (signed char)rand();
2379 memcached_flush(memc
, 0);
2381 const char *keys
= "036790384900";
2382 size_t key_length
= strlen(keys
);
2383 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2384 insert_data
, VALUE_SIZE_BUG5
,
2387 memcached_return_t rc
;
2388 size_t value_length
;
2390 char *value
= memcached_get(memc
, keys
, key_length
,
2391 &value_length
, &flags
, &rc
);
2392 test_compare(245U, flags
);
2396 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2398 char return_key
[MEMCACHED_MAX_KEY
];
2399 size_t return_key_length
;
2401 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2402 &value_length
, &flags
, &rc
);
2403 test_compare(uint32_t(245), flags
);
2406 delete [] insert_data
;
2409 return TEST_SUCCESS
;
2412 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2414 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2415 size_t key_length
[3];
2419 char return_key
[MEMCACHED_MAX_KEY
];
2420 size_t return_key_length
;
2422 size_t return_value_length
;
2425 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2426 key_length
[1]= strlen("fudge&*@#");
2427 key_length
[2]= strlen("for^#@&$not");
2430 for (unsigned int x
= 0; x
< 3; x
++)
2432 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2433 keys
[x
], key_length
[x
],
2434 (time_t)50, (uint32_t)9);
2435 test_compare(MEMCACHED_SUCCESS
, rc
);
2438 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2439 test_compare(MEMCACHED_SUCCESS
, rc
);
2441 /* We need to empty the server before continueing test */
2442 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2443 &return_value_length
, &flags
, &rc
)) != NULL
)
2445 test_true(return_value
);
2449 test_compare(3U, count
);
2451 return TEST_SUCCESS
;
2454 /* We are testing with aggressive timeout to get failures */
2455 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2457 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
2459 size_t value_length
= 512;
2460 unsigned int set
= 1;
2461 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2463 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2464 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2465 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2467 libtest::vchar_t value
;
2468 value
.reserve(value_length
);
2469 for (uint32_t x
= 0; x
< value_length
; x
++)
2471 value
.push_back(char(x
% 127));
2474 for (unsigned int x
= 1; x
<= 100000; ++x
)
2476 memcached_return_t rc
= memcached_set(mclone
,
2477 test_literal_param("foo"),
2478 &value
[0], value
.size(),
2481 test_true((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2482 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
));
2484 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2490 memcached_free(mclone
);
2492 return TEST_SUCCESS
;
2496 We are looking failures in the async protocol
2498 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2500 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2502 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2503 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2504 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2506 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2509 libtest::vchar_t value
;
2511 for (unsigned int x
= 0; x
< 512; x
++)
2513 value
.push_back(char(x
% 127));
2516 for (unsigned int x
= 1; x
<= 100000; ++x
)
2518 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2522 memcached_free(mclone
);
2524 return TEST_SUCCESS
;
2528 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2530 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2532 memcached_return_t rc
;
2534 size_t value_length
;
2536 uint64_t number_value
;
2538 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2539 &value_length
, &flags
, &rc
);
2541 test_compare(MEMCACHED_NOTFOUND
, rc
);
2543 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2546 /* The binary protocol will set the key if it doesn't exist */
2547 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2549 test_compare(MEMCACHED_SUCCESS
, rc
);
2553 test_compare(MEMCACHED_NOTFOUND
, rc
);
2556 test_compare(MEMCACHED_SUCCESS
,
2557 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2559 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2563 test_compare(MEMCACHED_SUCCESS
,
2564 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2565 test_compare(2UL, number_value
);
2567 return TEST_SUCCESS
;
2571 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2572 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2574 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2576 char key
[] = "key34567890";
2578 char commandFirst
[]= "set key34567890 0 0 ";
2579 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2580 size_t commandLength
;
2582 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2584 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2586 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2588 char *overflow
= new (std::nothrow
) char[testSize
];
2589 test_true(overflow
);
2591 memset(overflow
, 'x', testSize
);
2592 test_compare(MEMCACHED_SUCCESS
,
2593 memcached_set(memc
, key
, strlen(key
),
2594 overflow
, testSize
, 0, 0));
2598 return TEST_SUCCESS
;
2603 Test values of many different sizes
2604 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2605 set key34567890 0 0 8169 \r\n
2606 is sent followed by buffer of size 8169, followed by 8169
2608 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2610 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2612 libtest::vchar_t value
;
2613 value
.reserve(18000);
2614 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2616 value
.push_back((char) (x
% 127));
2619 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2621 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2622 &value
[0], current_length
,
2623 (time_t)0, (uint32_t)0);
2624 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2626 size_t string_length
;
2628 char *string
= memcached_get(memc
, test_literal_param("foo"),
2629 &string_length
, &flags
, &rc
);
2631 test_compare(MEMCACHED_SUCCESS
, rc
);
2632 test_compare(string_length
, current_length
);
2634 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2635 test_memcmp(string
, &value
[0], string_length
);
2640 return TEST_SUCCESS
;
2644 Look for zero length value problems
2646 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2648 for (uint32_t x
= 0; x
< 2; x
++)
2650 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2652 (time_t)0, (uint32_t)0);
2654 test_compare(MEMCACHED_SUCCESS
, rc
);
2658 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2659 &length
, &flags
, &rc
);
2661 test_compare(MEMCACHED_SUCCESS
, rc
);
2666 value
= memcached_get(memc
, test_literal_param("mykey"),
2667 &length
, &flags
, &rc
);
2669 test_compare(MEMCACHED_SUCCESS
, rc
);
2675 return TEST_SUCCESS
;
2678 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2679 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2681 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2683 (time_t)0, UINT32_MAX
));
2688 memcached_return_t rc
;
2689 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2690 &length
, &flags
, &rc
);
2692 test_compare(MEMCACHED_SUCCESS
, rc
);
2695 test_compare(flags
, UINT32_MAX
);
2697 return TEST_SUCCESS
;
2700 #if !defined(__sun) && !defined(__OpenBSD__)
2701 /* Check the validity of chinese key*/
2702 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2704 const char *key
= "豆瓣";
2705 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2706 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2707 value
, strlen(value
),
2710 test_compare(MEMCACHED_SUCCESS
, rc
);
2714 char *value2
= memcached_get(memc
, key
, strlen(key
),
2715 &length
, &flags
, &rc
);
2717 test_compare(length
, strlen(value
));
2718 test_compare(MEMCACHED_SUCCESS
, rc
);
2719 test_memcmp(value
, value2
, length
);
2722 return TEST_SUCCESS
;
2730 test_return_t
user_supplied_bug19(memcached_st
*)
2732 memcached_return_t res
;
2734 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2736 const memcached_instance_st
* server
= memcached_server_by_key(memc
, "a", 1, &res
);
2739 memcached_free(memc
);
2741 return TEST_SUCCESS
;
2744 /* CAS test from Andei */
2745 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2747 const char *key
= "abc";
2748 size_t key_len
= strlen("abc");
2750 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2752 test_compare(MEMCACHED_SUCCESS
,
2754 test_literal_param("abc"),
2755 test_literal_param("foobar"),
2756 (time_t)0, (uint32_t)0));
2758 test_compare(MEMCACHED_SUCCESS
,
2759 memcached_mget(memc
, &key
, &key_len
, 1));
2761 memcached_result_st result_obj
;
2762 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2765 memcached_result_create(memc
, &result_obj
);
2766 memcached_return_t status
;
2767 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2770 test_compare(MEMCACHED_SUCCESS
, status
);
2772 memcached_result_free(result
);
2774 return TEST_SUCCESS
;
2777 /* Large mget() of missing keys with binary proto
2779 * If many binary quiet commands (such as getq's in an mget) fill the output
2780 * buffer and the server chooses not to respond, memcached_flush hangs. See
2781 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2784 /* sighandler_t function that always asserts false */
2785 static __attribute__((noreturn
)) void fail(int)
2791 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2796 return TEST_SKIPPED
;
2798 void (*oldalarm
)(int);
2800 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2801 test_true(memc_clone
);
2803 /* only binproto uses getq for mget */
2804 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2806 /* empty the cache to ensure misses (hence non-responses) */
2807 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2809 keys_st
keys(key_count
);
2811 oldalarm
= signal(SIGALRM
, fail
);
2814 test_compare_got(MEMCACHED_SUCCESS
,
2815 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2816 memcached_last_error_message(memc_clone
));
2819 signal(SIGALRM
, oldalarm
);
2821 memcached_return_t rc
;
2823 char return_key
[MEMCACHED_MAX_KEY
];
2824 size_t return_key_length
;
2826 size_t return_value_length
;
2827 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2828 &return_value_length
, &flags
, &rc
)))
2830 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2832 test_compare(MEMCACHED_NOTFOUND
, rc
);
2833 test_zero(return_value_length
);
2834 test_zero(return_key_length
);
2835 test_false(return_key
[0]);
2836 test_false(return_value
);
2838 memcached_free(memc_clone
);
2840 return TEST_SUCCESS
;
2844 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2846 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2848 /* should work as of r580 */
2849 test_compare(TEST_SUCCESS
,
2850 _user_supplied_bug21(memc
, 10));
2852 /* should fail as of r580 */
2853 test_compare(TEST_SUCCESS
,
2854 _user_supplied_bug21(memc
, 1000));
2856 return TEST_SUCCESS
;
2859 test_return_t
comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st
*)
2863 memcached_st
*memc
= &memc_
;
2865 ASSERT_EQ(memc
, MEMCACHED_SUCCESS
);
2866 test_compare(memc
, MEMCACHED_SUCCESS
);
2868 ASSERT_NEQ(memc
, MEMCACHED_FAILURE
);
2870 return TEST_SUCCESS
;
2873 test_return_t
ketama_TEST(memcached_st
*)
2875 test::Memc
memc("--server=10.0.1.1:11211 --server=10.0.1.2:11211");
2877 test_compare(MEMCACHED_SUCCESS
,
2878 memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2880 test_compare(memcached_behavior_get(&memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
), uint64_t(1));
2882 test_compare(memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
), MEMCACHED_SUCCESS
);
2884 test_compare(memcached_hash_t(memcached_behavior_get(&memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
)), MEMCACHED_HASH_MD5
);
2886 test_compare(memcached_behavior_set_distribution(&memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
), MEMCACHED_SUCCESS
);
2889 return TEST_SUCCESS
;
2892 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2894 memcached_st
*memc
= memcached_create(NULL
);
2898 test_compare(MEMCACHED_SUCCESS
,
2899 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2901 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2902 test_compare(value
, uint64_t(1));
2904 test_compare(MEMCACHED_SUCCESS
,
2905 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2907 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2908 test_true(value
== MEMCACHED_HASH_MD5
);
2911 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2913 memcached_server_st
*server_pool
;
2914 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");
2915 memcached_server_push(memc
, server_pool
);
2917 // @todo this needs to be refactored to actually test something.
2920 if ((fp
= fopen("ketama_keys.txt", "w")))
2924 printf("cannot write to file ketama_keys.txt");
2925 return TEST_FAILURE
;
2928 for (int x
= 0; x
< 10000; x
++)
2931 snprintf(key
, sizeof(key
), "%d", x
);
2933 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2934 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2935 in_port_t port
= memc
->hosts
[server_idx
].port
;
2936 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2937 const memcached_instance_st
* instance
=
2938 memcached_server_instance_by_position(memc
, host_index
);
2942 memcached_server_list_free(server_pool
);
2943 memcached_free(memc
);
2945 return TEST_SUCCESS
;
2949 test_return_t
result_static(memcached_st
*memc
)
2951 memcached_result_st result
;
2952 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
2953 test_false(result
.options
.is_allocated
);
2954 test_true(memcached_is_initialized(&result
));
2955 test_true(result_ptr
);
2956 test_true(result_ptr
== &result
);
2958 memcached_result_free(&result
);
2960 test_false(result
.options
.is_allocated
);
2961 test_false(memcached_is_initialized(&result
));
2963 return TEST_SUCCESS
;
2966 test_return_t
result_alloc(memcached_st
*memc
)
2968 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
2969 test_true(result_ptr
);
2970 test_true(result_ptr
->options
.is_allocated
);
2971 test_true(memcached_is_initialized(result_ptr
));
2972 memcached_result_free(result_ptr
);
2974 return TEST_SUCCESS
;
2978 test_return_t
add_host_test1(memcached_st
*memc
)
2980 memcached_return_t rc
;
2981 char servername
[]= "0.example.com";
2983 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2985 test_compare(1U, memcached_server_list_count(servers
));
2987 for (uint32_t x
= 2; x
< 20; x
++)
2989 char buffer
[SMALL_STRING_LEN
];
2991 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
2992 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2994 test_compare(MEMCACHED_SUCCESS
, rc
);
2995 test_compare(x
, memcached_server_list_count(servers
));
2998 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2999 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3001 memcached_server_list_free(servers
);
3003 return TEST_SUCCESS
;
3007 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3011 #ifdef HARD_MALLOC_TESTS
3012 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3020 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3024 #ifdef HARD_MALLOC_TESTS
3025 void *ret
= malloc(size
+ 8);
3028 ret
= (void*)((caddr_t
)ret
+ 8);
3031 void *ret
= malloc(size
);
3036 memset(ret
, 0xff, size
);
3043 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3045 #ifdef HARD_MALLOC_TESTS
3046 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3047 void *nmem
= realloc(real_ptr
, size
+ 8);
3052 ret
= (void*)((caddr_t
)nmem
+ 8);
3058 return realloc(mem
, size
);
3063 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3065 #ifdef HARD_MALLOC_TESTS
3066 void *mem
= my_malloc(ptr
, nelem
* size
);
3069 memset(mem
, 0, nelem
* size
);
3075 return calloc(nelem
, size
);
3079 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3081 memcached_return_t rc
;
3082 const char *key
= "mine";
3085 /* Make sure by default none exists */
3086 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3088 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3090 /* Test a clean set */
3091 test_compare(MEMCACHED_SUCCESS
,
3092 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3094 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3096 test_memcmp(value
, key
, strlen(key
));
3097 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3099 /* Test that we can turn it off */
3100 test_compare(MEMCACHED_SUCCESS
,
3101 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3103 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3105 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3107 /* Now setup for main test */
3108 test_compare(MEMCACHED_SUCCESS
,
3109 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3111 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3113 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3114 test_memcmp(value
, key
, strlen(key
));
3116 /* Set to Zero, and then Set to something too large */
3119 memset(long_key
, 0, 255);
3121 test_compare(MEMCACHED_SUCCESS
,
3122 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3124 ASSERT_NULL_(memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
), "Setting namespace to NULL did not work");
3126 /* Test a long key for failure */
3127 /* TODO, extend test to determine based on setting, what result should be */
3128 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3129 test_compare(MEMCACHED_SUCCESS
,
3130 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3132 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3133 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3134 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3135 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3137 /* Test for a bad prefix, but with a short key */
3138 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3139 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3141 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3142 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3145 return TEST_SUCCESS
;
3148 test_return_t
set_namespace(memcached_st
*memc
)
3150 memcached_return_t rc
;
3151 const char *key
= "mine";
3153 // Make sure we default to a null namespace
3154 char* value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3155 ASSERT_NULL_(value
, "memc had a value for namespace when none should exist");
3156 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3158 /* Test a clean set */
3159 test_compare(MEMCACHED_SUCCESS
,
3160 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3162 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3164 test_memcmp(value
, key
, strlen(key
));
3165 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3167 return TEST_SUCCESS
;
3170 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3172 test_return_if(pre_binary(memc
));
3173 test_return_if(set_namespace(memc
));
3175 return TEST_SUCCESS
;
3178 #ifdef MEMCACHED_ENABLE_DEPRECATED
3179 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3181 void *test_ptr
= NULL
;
3184 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
3185 cb_ptr
= *(void **)&malloc_cb
;
3186 memcached_return_t rc
;
3188 test_compare(MEMCACHED_SUCCESS
,
3189 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3190 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3191 test_compare(MEMCACHED_SUCCESS
, rc
);
3192 test_true(test_ptr
== cb_ptr
);
3196 memcached_realloc_fn realloc_cb
=
3197 (memcached_realloc_fn
)my_realloc
;
3198 cb_ptr
= *(void **)&realloc_cb
;
3199 memcached_return_t rc
;
3201 test_compare(MEMCACHED_SUCCESS
,
3202 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3203 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3204 test_compare(MEMCACHED_SUCCESS
, rc
);
3205 test_true(test_ptr
== cb_ptr
);
3209 memcached_free_fn free_cb
=
3210 (memcached_free_fn
)my_free
;
3211 cb_ptr
= *(void **)&free_cb
;
3212 memcached_return_t rc
;
3214 test_compare(MEMCACHED_SUCCESS
,
3215 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3216 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3217 test_compare(MEMCACHED_SUCCESS
, rc
);
3218 test_true(test_ptr
== cb_ptr
);
3221 return TEST_SUCCESS
;
3226 test_return_t
set_memory_alloc(memcached_st
*memc
)
3228 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3229 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3230 my_realloc
, my_calloc
, NULL
));
3232 test_compare(MEMCACHED_SUCCESS
,
3233 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3234 my_realloc
, my_calloc
, NULL
));
3236 memcached_malloc_fn mem_malloc
;
3237 memcached_free_fn mem_free
;
3238 memcached_realloc_fn mem_realloc
;
3239 memcached_calloc_fn mem_calloc
;
3240 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3241 &mem_realloc
, &mem_calloc
);
3243 test_true(mem_malloc
== my_malloc
);
3244 test_true(mem_realloc
== my_realloc
);
3245 test_true(mem_calloc
== my_calloc
);
3246 test_true(mem_free
== my_free
);
3248 return TEST_SUCCESS
;
3251 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3253 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
));
3254 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3257 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3262 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3264 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_CRC
)
3266 return TEST_SKIPPED
;
3269 return TEST_SUCCESS
;
3272 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3275 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
);
3276 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3281 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3283 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_HSIEH
)
3285 return TEST_SKIPPED
;
3288 return TEST_SUCCESS
;
3291 test_return_t
enable_cas(memcached_st
*memc
)
3293 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3295 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true);
3297 return TEST_SUCCESS
;
3300 return TEST_SKIPPED
;
3303 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3305 memcached_version(memc
);
3307 const memcached_instance_st
* instance
=
3308 memcached_server_instance_by_position(memc
, 0);
3310 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3311 or instance
->minor_version
> 2)
3313 return TEST_SUCCESS
;
3316 return TEST_SKIPPED
;
3319 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3321 const uint64_t timeout
= 100; // Not using, just checking that it sets
3323 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3325 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3327 return TEST_SUCCESS
;
3330 test_return_t
noreply_test(memcached_st
*memc
)
3332 test_compare(MEMCACHED_SUCCESS
,
3333 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3334 test_compare(MEMCACHED_SUCCESS
,
3335 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3336 test_compare(MEMCACHED_SUCCESS
,
3337 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3338 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3339 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3340 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3342 memcached_return_t ret
;
3343 for (int count
= 0; count
< 5; ++count
)
3345 for (size_t x
= 0; x
< 100; ++x
)
3347 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3348 int check_length
= snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3349 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3351 size_t len
= (size_t)check_length
;
3356 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3359 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3362 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3365 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3368 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3374 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3375 memcached_strerror(NULL
, ret
));
3379 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3380 ** API and is _ONLY_ done this way to verify that the library works the
3381 ** way it is supposed to do!!!!
3385 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3387 const memcached_instance_st
* instance
=
3388 memcached_server_instance_by_position(memc
, x
);
3389 no_msg
+=(int)(instance
->cursor_active
);
3392 test_true(no_msg
== 0);
3394 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3397 ** Now validate that all items was set properly!
3399 for (size_t x
= 0; x
< 100; ++x
)
3403 int check_length
= snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3405 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3407 size_t len
= (size_t)check_length
;
3410 char* value
=memcached_get(memc
, key
, strlen(key
),
3411 &length
, &flags
, &ret
);
3412 // For the moment we will just go to the next key
3413 if (MEMCACHED_TIMEOUT
== ret
)
3417 test_true(ret
== MEMCACHED_SUCCESS
and value
!= NULL
);
3420 case 0: /* FALLTHROUGH */
3421 case 1: /* FALLTHROUGH */
3423 test_true(strncmp(value
, key
, len
) == 0);
3424 test_true(len
== length
);
3427 test_true(length
== len
* 2);
3430 test_true(length
== len
* 3);
3440 /* Try setting an illegal cas value (should not return an error to
3441 * the caller (because we don't expect a return message from the server)
3443 const char* keys
[]= {"0"};
3444 size_t lengths
[]= {1};
3447 memcached_result_st results_obj
;
3448 memcached_result_st
*results
;
3449 test_compare(MEMCACHED_SUCCESS
,
3450 memcached_mget(memc
, keys
, lengths
, 1));
3452 results
= memcached_result_create(memc
, &results_obj
);
3454 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3456 test_compare(MEMCACHED_SUCCESS
, ret
);
3457 uint64_t cas
= memcached_result_cas(results
);
3458 memcached_result_free(&results_obj
);
3460 test_compare(MEMCACHED_SUCCESS
,
3461 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3464 * The item will have a new cas value, so try to set it again with the old
3465 * value. This should fail!
3467 test_compare(MEMCACHED_SUCCESS
,
3468 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3469 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3470 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3471 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3474 return TEST_SUCCESS
;
3477 test_return_t
analyzer_test(memcached_st
*memc
)
3479 memcached_analysis_st
*report
;
3480 memcached_return_t rc
;
3482 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3483 test_compare(MEMCACHED_SUCCESS
, rc
);
3484 test_true(memc_stat
);
3486 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3487 test_compare(MEMCACHED_SUCCESS
, rc
);
3491 memcached_stat_free(NULL
, memc_stat
);
3493 return TEST_SUCCESS
;
3496 test_return_t
util_version_test(memcached_st
*memc
)
3498 test_compare(memcached_version(memc
), MEMCACHED_SUCCESS
);
3499 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3501 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3503 // We expect failure
3506 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3507 fprintf(stderr
, "\nDumping Server Information\n\n");
3508 memcached_server_fn callbacks
[1];
3510 callbacks
[0]= dump_server_information
;
3511 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3512 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3514 test_true(if_successful
== false);
3516 const memcached_instance_st
* instance
=
3517 memcached_server_instance_by_position(memc
, 0);
3519 memcached_version(memc
);
3521 // We only use one binary when we test, so this should be just fine.
3522 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3523 test_true(if_successful
== true);
3525 if (instance
->micro_version
> 0)
3527 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3529 else if (instance
->minor_version
> 0)
3531 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3533 else if (instance
->major_version
> 0)
3535 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3538 test_true(if_successful
== true);
3540 if (instance
->micro_version
> 0)
3542 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3544 else if (instance
->minor_version
> 0)
3546 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3548 else if (instance
->major_version
> 0)
3550 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3553 test_true(if_successful
== false);
3555 return TEST_SUCCESS
;
3558 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3560 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3561 memcached_return_t rc
;
3562 const memcached_instance_st
* instance
=
3563 memcached_server_instance_by_position(memc
, 0);
3565 // Test both the version that returns a code, and the one that does not.
3566 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3567 memcached_server_port(instance
) -1, NULL
) == -1);
3569 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3570 memcached_server_port(instance
) -1, &rc
) == -1);
3571 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3573 return TEST_SUCCESS
;
3577 test_return_t
getpid_test(memcached_st
*memc
)
3579 memcached_return_t rc
;
3580 const memcached_instance_st
* instance
=
3581 memcached_server_instance_by_position(memc
, 0);
3583 // Test both the version that returns a code, and the one that does not.
3584 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3585 memcached_server_port(instance
), NULL
) > -1);
3587 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3588 memcached_server_port(instance
), &rc
) > -1);
3589 test_compare(MEMCACHED_SUCCESS
, rc
);
3591 return TEST_SUCCESS
;
3594 static memcached_return_t
ping_each_server(const memcached_st
*,
3595 const memcached_instance_st
* instance
,
3598 // Test both the version that returns a code, and the one that does not.
3599 memcached_return_t rc
;
3600 if (libmemcached_util_ping(memcached_server_name(instance
),
3601 memcached_server_port(instance
), &rc
) == false)
3603 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d %s", memcached_server_name(instance
),
3604 memcached_server_port(instance
), memcached_strerror(NULL
, rc
));
3607 if (libmemcached_util_ping(memcached_server_name(instance
),
3608 memcached_server_port(instance
), NULL
) == false)
3610 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d", memcached_server_name(instance
), memcached_server_port(instance
));
3613 return MEMCACHED_SUCCESS
;
3616 test_return_t
libmemcached_util_ping_TEST(memcached_st
*memc
)
3618 memcached_server_fn callbacks
[1]= { ping_each_server
};
3619 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
3621 return TEST_SUCCESS
;
3626 test_return_t
hash_sanity_test (memcached_st
*memc
)
3630 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3631 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3632 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3633 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3634 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3635 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3636 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3637 #ifdef HAVE_HSIEH_HASH
3638 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3640 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3641 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3642 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3644 return TEST_SUCCESS
;
3648 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3650 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3652 test_compare(MEMCACHED_SUCCESS
,
3653 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3654 (uint64_t)MEMCACHED_HASH_HSIEH
));
3656 return TEST_SUCCESS
;
3659 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3661 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3663 test_compare(MEMCACHED_SUCCESS
,
3664 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3666 return TEST_SUCCESS
;
3669 test_return_t
one_at_a_time_run (memcached_st
*)
3674 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3676 test_compare(one_at_a_time_values
[x
],
3677 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3680 return TEST_SUCCESS
;
3683 test_return_t
md5_run (memcached_st
*)
3688 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3690 test_compare(md5_values
[x
],
3691 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3694 return TEST_SUCCESS
;
3697 test_return_t
crc_run (memcached_st
*)
3702 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3704 test_compare(crc_values
[x
],
3705 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3708 return TEST_SUCCESS
;
3711 test_return_t
fnv1_64_run (memcached_st
*)
3713 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3718 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3720 test_compare(fnv1_64_values
[x
],
3721 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3724 return TEST_SUCCESS
;
3727 test_return_t
fnv1a_64_run (memcached_st
*)
3729 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3734 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3736 test_compare(fnv1a_64_values
[x
],
3737 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3740 return TEST_SUCCESS
;
3743 test_return_t
fnv1_32_run (memcached_st
*)
3748 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3750 test_compare(fnv1_32_values
[x
],
3751 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3754 return TEST_SUCCESS
;
3757 test_return_t
fnv1a_32_run (memcached_st
*)
3762 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3764 test_compare(fnv1a_32_values
[x
],
3765 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3768 return TEST_SUCCESS
;
3771 test_return_t
hsieh_run (memcached_st
*)
3773 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3778 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3780 test_compare(hsieh_values
[x
],
3781 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3784 return TEST_SUCCESS
;
3787 test_return_t
murmur_run (memcached_st
*)
3789 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3791 #ifdef WORDS_BIGENDIAN
3792 (void)murmur_values
;
3793 return TEST_SKIPPED
;
3798 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3800 test_compare(murmur_values
[x
],
3801 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3804 return TEST_SUCCESS
;
3808 test_return_t
murmur3_TEST(hashkit_st
*)
3810 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR3
));
3812 #ifdef WORDS_BIGENDIAN
3813 (void)murmur3_values
;
3814 return TEST_SKIPPED
;
3819 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3821 test_compare(murmur3_values
[x
],
3822 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR3
));
3825 return TEST_SUCCESS
;
3829 test_return_t
jenkins_run (memcached_st
*)
3834 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3836 test_compare(jenkins_values
[x
],
3837 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3840 return TEST_SUCCESS
;
3843 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3845 return libhashkit_md5(string
, string_length
);
3848 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3850 return libhashkit_crc32(string
, string_length
);
3853 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3859 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3861 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};
3862 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};
3864 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3866 hashkit_clone(&new_kit
, kit
);
3867 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3869 memcached_set_hashkit(memc
, &new_kit
);
3872 Verify Setting the hash.
3874 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3878 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3879 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3884 Now check memcached_st.
3886 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3890 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3891 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3894 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3896 memcached_set_hashkit(memc
, &new_kit
);
3899 Verify Setting the hash.
3901 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3905 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3906 test_true(crc_values
[x
] == hash_val
);
3909 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3913 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3914 test_compare(crc_hosts
[x
], hash_val
);
3917 memcached_free(memc
);
3919 return TEST_SUCCESS
;
3923 Test case adapted from John Gorman <johngorman2@gmail.com>
3925 We are testing the error condition when we connect to a server via memcached_get()
3926 but find that the server is not available.
3928 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3932 memcached_return rc
;
3935 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3937 // See if memcached is reachable.
3938 char *value
= memcached_get(tl_memc_h
,
3939 test_literal_param(__func__
),
3944 test_true(memcached_failed(rc
));
3946 memcached_free(tl_memc_h
);
3948 return TEST_SUCCESS
;
3952 We connect to a server which exists, but search for a key that does not exist.
3954 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3958 memcached_return rc
;
3960 // See if memcached is reachable.
3961 char *value
= memcached_get(memc
,
3962 test_literal_param(__func__
),
3967 test_compare(MEMCACHED_NOTFOUND
, rc
);
3969 return TEST_SUCCESS
;
3973 Test case adapted from John Gorman <johngorman2@gmail.com>
3975 We are testing the error condition when we connect to a server via memcached_get_by_key()
3976 but find that the server is not available.
3978 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
3982 memcached_return rc
;
3985 memcached_st
*tl_memc_h
= memcached_create(NULL
);
3986 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
3987 memcached_server_push(tl_memc_h
, servers
);
3988 memcached_server_list_free(servers
);
3990 // See if memcached is reachable.
3991 char *value
= memcached_get_by_key(tl_memc_h
,
3992 test_literal_param(__func__
), // Key
3993 test_literal_param(__func__
), // Value
3998 test_true(memcached_failed(rc
));
4000 memcached_free(tl_memc_h
);
4002 return TEST_SUCCESS
;
4006 We connect to a server which exists, but search for a key that does not exist.
4008 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4012 memcached_return rc
;
4014 // See if memcached is reachable.
4015 char *value
= memcached_get_by_key(memc
,
4016 test_literal_param(__func__
), // Key
4017 test_literal_param(__func__
), // Value
4022 test_compare(MEMCACHED_NOTFOUND
, rc
);
4024 return TEST_SUCCESS
;
4027 test_return_t
regression_bug_434484(memcached_st
*memc
)
4029 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4031 test_compare(MEMCACHED_NOTSTORED
,
4032 memcached_append(memc
,
4033 test_literal_param(__func__
), // Key
4034 test_literal_param(__func__
), // Value
4037 libtest::vchar_t data
;
4038 data
.resize(2048 * 1024);
4039 test_compare(MEMCACHED_E2BIG
,
4041 test_literal_param(__func__
), // Key
4042 &data
[0], data
.size(), 0, 0));
4044 return TEST_SUCCESS
;
4047 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4049 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4051 memcached_return_t rc
;
4053 memcached_execute_fn callbacks
[]= { &callback_counter
};
4056 * I only want to hit only _one_ server so I know the number of requests I'm
4057 * sending in the pipleine to the server. Let's try to do a multiget of
4058 * 1024 (that should satisfy most users don't you think?). Future versions
4059 * will include a mget_execute function call if you need a higher number.
4061 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4066 * Run two times.. the first time we should have 100% cache miss,
4067 * and the second time we should have 100% cache hits
4069 for (ptrdiff_t y
= 0; y
< 2; y
++)
4071 test_compare(MEMCACHED_SUCCESS
,
4072 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4074 // One the first run we should get a NOT_FOUND, but on the second some data
4075 // should be returned.
4076 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4077 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4081 /* The first iteration should give me a 100% cache miss. verify that*/
4082 char blob
[1024]= { 0 };
4084 test_false(counter
);
4086 for (size_t x
= 0; x
< keys
.size(); ++x
)
4088 rc
= memcached_add(memc
,
4089 keys
.key_at(x
), keys
.length_at(x
),
4090 blob
, sizeof(blob
), 0, 0);
4091 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4096 /* Verify that we received all of the key/value pairs */
4097 test_compare(counter
, keys
.size());
4101 memcached_free(memc
);
4103 return TEST_SUCCESS
;
4106 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4108 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
4110 return regression_bug_434843(memc
);
4113 test_return_t
regression_bug_421108(memcached_st
*memc
)
4115 memcached_return_t rc
;
4116 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4117 test_compare(MEMCACHED_SUCCESS
, rc
);
4119 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4120 test_compare(MEMCACHED_SUCCESS
, rc
);
4121 test_true(bytes_str
);
4122 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4124 test_compare(MEMCACHED_SUCCESS
, rc
);
4125 test_true(bytes_read_str
);
4127 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4128 "bytes_written", &rc
);
4129 test_compare(MEMCACHED_SUCCESS
, rc
);
4130 test_true(bytes_written_str
);
4132 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4133 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4134 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4136 test_true(bytes
!= bytes_read
);
4137 test_true(bytes
!= bytes_written
);
4139 /* Release allocated resources */
4141 free(bytes_read_str
);
4142 free(bytes_written_str
);
4143 memcached_stat_free(NULL
, memc_stat
);
4145 return TEST_SUCCESS
;
4149 * The test case isn't obvious so I should probably document why
4150 * it works the way it does. Bug 442914 was caused by a bug
4151 * in the logic in memcached_purge (it did not handle the case
4152 * where the number of bytes sent was equal to the watermark).
4153 * In this test case, create messages so that we hit that case
4154 * and then disable noreply mode and issue a new command to
4155 * verify that it isn't stuck. If we change the format for the
4156 * delete command or the watermarks, we need to update this
4159 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
4161 test_skip(original_memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
4163 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
4165 for (uint32_t x
= 0; x
< 250; ++x
)
4168 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
4169 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4170 char error_buffer
[2048]= { 0 };
4171 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
4172 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
4175 // Delete, and then delete again to look for not found
4178 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
4179 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4180 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4182 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
4183 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
4186 memcached_free(memc
);
4188 return TEST_SUCCESS
;
4191 test_return_t
regression_bug_447342(memcached_st
*memc
)
4193 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4195 return TEST_SKIPPED
;
4198 test_compare(MEMCACHED_SUCCESS
,
4199 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4203 for (size_t x
= 0; x
< keys
.size(); ++x
)
4205 test_compare(MEMCACHED_SUCCESS
,
4207 keys
.key_at(x
), keys
.length_at(x
), // Keys
4208 keys
.key_at(x
), keys
.length_at(x
), // Values
4213 ** We are using the quiet commands to store the replicas, so we need
4214 ** to ensure that all of them are processed before we can continue.
4215 ** In the test we go directly from storing the object to trying to
4216 ** receive the object from all of the different servers, so we
4217 ** could end up in a race condition (the memcached server hasn't yet
4218 ** processed the quiet command from the replication set when it process
4219 ** the request from the other client (created by the clone)). As a
4220 ** workaround for that we call memcached_quit to send the quit command
4221 ** to the server and wait for the response ;-) If you use the test code
4222 ** as an example for your own code, please note that you shouldn't need
4225 memcached_quit(memc
);
4227 /* Verify that all messages are stored, and we didn't stuff too much
4230 test_compare(MEMCACHED_SUCCESS
,
4231 memcached_mget(memc
,
4232 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4234 unsigned int counter
= 0;
4235 memcached_execute_fn callbacks
[]= { &callback_counter
};
4236 test_compare(MEMCACHED_SUCCESS
,
4237 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4239 /* Verify that we received all of the key/value pairs */
4240 test_compare(counter
, keys
.size());
4242 memcached_quit(memc
);
4244 * Don't do the following in your code. I am abusing the internal details
4245 * within the library, and this is not a supported interface.
4246 * This is to verify correct behavior in the library. Fake that two servers
4249 const memcached_instance_st
* instance_one
= memcached_server_instance_by_position(memc
, 0);
4250 const memcached_instance_st
* instance_two
= memcached_server_instance_by_position(memc
, 2);
4251 in_port_t port0
= instance_one
->port();
4252 in_port_t port2
= instance_two
->port();
4254 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4255 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4257 test_compare(MEMCACHED_SUCCESS
,
4258 memcached_mget(memc
,
4259 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4262 test_compare(MEMCACHED_SUCCESS
,
4263 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4264 test_compare(counter
, keys
.size());
4266 /* restore the memc handle */
4267 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4268 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4270 memcached_quit(memc
);
4272 /* Remove half of the objects */
4273 for (size_t x
= 0; x
< keys
.size(); ++x
)
4277 test_compare(MEMCACHED_SUCCESS
,
4278 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4282 memcached_quit(memc
);
4283 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4284 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4286 /* now retry the command, this time we should have cache misses */
4287 test_compare(MEMCACHED_SUCCESS
,
4288 memcached_mget(memc
,
4289 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4292 test_compare(MEMCACHED_SUCCESS
,
4293 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4294 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4296 /* restore the memc handle */
4297 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4298 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4300 return TEST_SUCCESS
;
4303 test_return_t
regression_bug_463297(memcached_st
*memc
)
4305 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4307 // Since we blocked timed delete, this test is no longer valid.
4309 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4310 test_true(memc_clone
);
4311 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4313 const memcached_instance_st
* instance
=
4314 memcached_server_instance_by_position(memc_clone
, 0);
4316 if (instance
->major_version
> 1 ||
4317 (instance
->major_version
== 1 &&
4318 instance
->minor_version
> 2))
4320 /* Binary protocol doesn't support deferred delete */
4321 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4322 test_true(bin_clone
);
4323 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4324 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4325 memcached_free(bin_clone
);
4327 memcached_quit(memc_clone
);
4329 /* If we know the server version, deferred delete should fail
4330 * with invalid arguments */
4331 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4333 /* If we don't know the server version, we should get a protocol error */
4334 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4336 /* but there is a bug in some of the memcached servers (1.4) that treats
4337 * the counter as noreply so it doesn't send the proper error message
4339 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4341 /* And buffered mode should be disabled and we should get protocol error */
4342 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4343 rc
= memcached_delete(memc
, "foo", 3, 1);
4344 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4346 /* Same goes for noreply... */
4347 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4348 rc
= memcached_delete(memc
, "foo", 3, 1);
4349 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4351 /* but a normal request should go through (and be buffered) */
4352 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4353 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4355 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4356 /* unbuffered noreply should be success */
4357 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4358 /* unbuffered with reply should be not found... */
4359 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4360 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4363 memcached_free(memc_clone
);
4366 return TEST_SUCCESS
;
4370 /* Test memcached_server_get_last_disconnect
4371 * For a working server set, shall be NULL
4372 * For a set of non existing server, shall not be NULL
4374 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4376 memcached_return_t rc
;
4377 const memcached_instance_st
* disconnected_server
;
4379 /* With the working set of server */
4380 const char *key
= "marmotte";
4381 const char *value
= "milka";
4383 memcached_reset_last_disconnected_server(memc
);
4384 test_false(memc
->last_disconnected_server
);
4385 rc
= memcached_set(memc
, key
, strlen(key
),
4386 value
, strlen(value
),
4387 (time_t)0, (uint32_t)0);
4388 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4390 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4391 test_false(disconnected_server
);
4393 /* With a non existing server */
4395 memcached_server_st
*servers
;
4397 const char *server_list
= "localhost:9";
4399 servers
= memcached_servers_parse(server_list
);
4401 mine
= memcached_create(NULL
);
4402 rc
= memcached_server_push(mine
, servers
);
4403 test_compare(MEMCACHED_SUCCESS
, rc
);
4404 memcached_server_list_free(servers
);
4407 rc
= memcached_set(mine
, key
, strlen(key
),
4408 value
, strlen(value
),
4409 (time_t)0, (uint32_t)0);
4410 test_true(memcached_failed(rc
));
4412 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4413 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4414 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4415 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4417 memcached_quit(mine
);
4418 memcached_free(mine
);
4420 return TEST_SUCCESS
;
4423 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4425 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4426 char buffer
[BUFSIZ
];
4428 test_compare(MEMCACHED_SUCCESS
,
4429 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4431 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4434 // We will just use the error strings as our keys
4435 uint32_t counter
= 100;
4438 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4440 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4441 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4442 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4444 const memcached_instance_st
* disconnected_server
= memcached_server_get_last_disconnect(memc
);
4445 test_true(disconnected_server
);
4446 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4447 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4451 memcached_reset_last_disconnected_server(memc
);
4456 memcached_free(memc
);
4458 return TEST_SUCCESS
;
4461 test_return_t
test_verbosity(memcached_st
*memc
)
4463 memcached_verbosity(memc
, 3);
4465 return TEST_SUCCESS
;
4469 static memcached_return_t
stat_printer(const memcached_instance_st
* server
,
4470 const char *key
, size_t key_length
,
4471 const char *value
, size_t value_length
,
4481 return MEMCACHED_SUCCESS
;
4484 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4486 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4487 test_compare(MEMCACHED_SUCCESS
, rc
);
4489 test_compare(MEMCACHED_SUCCESS
,
4490 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4492 test_compare(MEMCACHED_SUCCESS
,
4493 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4495 test_compare(MEMCACHED_SUCCESS
,
4496 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4498 return TEST_SUCCESS
;
4502 * This test ensures that the failure counter isn't incremented during
4503 * normal termination of the memcached instance.
4505 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4507 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4509 /* Ensure that we are connected to the server by setting a value */
4510 memcached_return_t rc
= memcached_set(memc
,
4511 test_literal_param(__func__
), // Key
4512 test_literal_param(__func__
), // Value
4513 time_t(0), uint32_t(0));
4514 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4517 const memcached_instance_st
* instance
= memcached_server_instance_by_position(memc
, 0);
4519 /* The test is to see that the memcached_quit doesn't increase the
4520 * the server failure conter, so let's ensure that it is zero
4521 * before sending quit
4523 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4525 memcached_quit(memc
);
4527 /* Verify that it memcached_quit didn't increment the failure counter
4528 * Please note that this isn't bullet proof, because an error could
4531 test_zero(instance
->server_failure_counter
);
4533 memcached_free(memc
);
4535 return TEST_SUCCESS
;
4539 * This tests ensures expected disconnections (for some behavior changes
4540 * for instance) do not wrongly increase failure counter
4542 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4544 /* Set value to force connection to the server */
4545 const char *key
= "marmotte";
4546 const char *value
= "milka";
4548 test_compare_hint(MEMCACHED_SUCCESS
,
4549 memcached_set(memc
, key
, strlen(key
),
4550 value
, strlen(value
),
4551 (time_t)0, (uint32_t)0),
4552 memcached_last_error_message(memc
));
4555 /* put failure limit to 1 */
4556 test_compare(MEMCACHED_SUCCESS
,
4557 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4559 /* Put a retry timeout to effectively activate failure_limit effect */
4560 test_compare(MEMCACHED_SUCCESS
,
4561 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4563 /* change behavior that triggers memcached_quit()*/
4564 test_compare(MEMCACHED_SUCCESS
,
4565 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4568 /* Check if we still are connected */
4570 size_t string_length
;
4571 memcached_return rc
;
4572 char *string
= memcached_get(memc
, key
, strlen(key
),
4573 &string_length
, &flags
, &rc
);
4575 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4579 return TEST_SUCCESS
;
4582 test_return_t
regression_996813_TEST(memcached_st
*)
4584 memcached_st
* memc
= memcached_create(NULL
);
4586 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
4587 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
4588 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4589 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4590 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1));
4591 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 300));
4592 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 30));
4594 // We will never connect to these servers
4595 in_port_t base_port
= 11211;
4596 for (size_t x
= 0; x
< 17; x
++)
4598 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", base_port
+x
));
4600 test_compare(6U, memcached_generate_hash(memc
, test_literal_param("SZ6hu0SHweFmpwpc0w2R")));
4601 test_compare(1U, memcached_generate_hash(memc
, test_literal_param("SQCK9eiCf53YxHWnYA.o")));
4602 test_compare(9U, memcached_generate_hash(memc
, test_literal_param("SUSDkGXuuZC9t9VhMwa.")));
4603 test_compare(0U, memcached_generate_hash(memc
, test_literal_param("SnnqnJARfaCNT679iAF_")));
4605 memcached_free(memc
);
4607 return TEST_SUCCESS
;
4612 * Test that ensures mget_execute does not end into recursive calls that finally fails
4614 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4618 return TEST_SKIPPED
; // My MAC can't handle this test
4621 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4624 * I only want to hit _one_ server so I know the number of requests I'm
4625 * sending in the pipeline.
4627 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4630 keys_st
keys(20480);
4632 /* First add all of the items.. */
4633 char blob
[1024]= { 0 };
4634 for (size_t x
= 0; x
< keys
.size(); ++x
)
4636 memcached_return rc
= memcached_set(memc
,
4637 keys
.key_at(x
), keys
.length_at(x
),
4638 blob
, sizeof(blob
), 0, 0);
4639 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4644 /* Try to get all of them with a large multiget */
4646 memcached_execute_function callbacks
[]= { &callback_counter
};
4647 memcached_return_t rc
= memcached_mget_execute(memc
,
4648 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4649 callbacks
, &counter
, 1);
4650 test_compare(MEMCACHED_SUCCESS
, rc
);
4652 char* the_value
= NULL
;
4653 char the_key
[MEMCACHED_MAX_KEY
];
4654 size_t the_key_length
;
4655 size_t the_value_length
;
4659 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4661 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4667 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4670 test_compare(MEMCACHED_END
, rc
);
4672 /* Verify that we got all of the items */
4673 test_compare(counter
, keys
.size());
4676 memcached_free(memc
);
4678 return TEST_SUCCESS
;
4681 test_return_t
regression_1021819_TEST(memcached_st
*original
)
4683 memcached_st
*memc
= memcached_clone(NULL
, original
);
4686 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 2000000), MEMCACHED_SUCCESS
);
4687 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 3000000), MEMCACHED_SUCCESS
);
4689 memcached_return_t rc
;
4692 test_literal_param(__func__
),
4695 test_compare(rc
, MEMCACHED_NOTFOUND
);
4697 memcached_free(memc
);
4699 return TEST_SUCCESS
;
4702 test_return_t
regression_bug_583031(memcached_st
*)
4704 memcached_st
*memc
= memcached_create(NULL
);
4706 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.251.4", 11211));
4708 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 3000);
4709 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4710 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4711 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4712 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4713 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4715 memcached_return_t rc
;
4719 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4723 test_compare(MEMCACHED_TIMEOUT
, memc
);
4725 memcached_free(memc
);
4727 return TEST_SUCCESS
;
4730 test_return_t
regression_bug_581030(memcached_st
*)
4733 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4734 test_false(local_stat
);
4736 memcached_stat_free(NULL
, NULL
);
4739 return TEST_SUCCESS
;
4742 #define regression_bug_655423_COUNT 6000
4743 test_return_t
regression_bug_655423(memcached_st
*memc
)
4745 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4746 memc
= NULL
; // Just to make sure it is not used
4751 return TEST_SKIPPED
;
4754 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4755 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4756 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4757 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4759 memset(payload
, int('x'), sizeof(payload
));
4761 keys_st
keys(regression_bug_655423_COUNT
);
4763 for (size_t x
= 0; x
< keys
.size(); x
++)
4765 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4768 payload
, sizeof(payload
), 0, 0));
4771 for (size_t x
= 0; x
< keys
.size(); x
++)
4773 size_t value_length
;
4774 memcached_return_t rc
;
4775 char *value
= memcached_get(clone
,
4778 &value_length
, NULL
, &rc
);
4780 if (rc
== MEMCACHED_NOTFOUND
)
4783 test_zero(value_length
);
4787 test_compare(MEMCACHED_SUCCESS
, rc
);
4789 test_compare(100LLU, value_length
);
4793 test_compare(MEMCACHED_SUCCESS
,
4794 memcached_mget(clone
,
4795 keys
.keys_ptr(), keys
.lengths_ptr(),
4799 memcached_result_st
*result
= NULL
;
4800 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4802 test_compare(size_t(100), memcached_result_length(result
));
4806 test_true(count
> 100); // If we don't get back atleast this, something is up
4808 memcached_free(clone
);
4810 return TEST_SUCCESS
;
4814 * Test that ensures that buffered set to not trigger problems during io_flush
4816 #define regression_bug_490520_COUNT 200480
4817 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4819 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4821 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4822 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4823 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4824 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4825 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4827 /* First add all of the items.. */
4828 char blob
[3333] = {0};
4829 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4832 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4834 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4835 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4838 memcached_free(memc
);
4840 return TEST_SUCCESS
;
4843 test_return_t
regression_1009493_TEST(memcached_st
*)
4845 memcached_st
* memc
= memcached_create(NULL
);
4847 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, true));
4849 memcached_st
* clone
= memcached_clone(NULL
, memc
);
4852 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
),
4853 memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
4855 memcached_free(memc
);
4856 memcached_free(clone
);
4858 return TEST_SUCCESS
;
4861 test_return_t
regression_994772_TEST(memcached_st
* memc
)
4863 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4865 test_compare(MEMCACHED_SUCCESS
,
4867 test_literal_param(__func__
), // Key
4868 test_literal_param(__func__
), // Value
4869 time_t(0), uint32_t(0)));
4871 const char *keys
[] = { __func__
};
4872 size_t key_length
[]= { strlen(__func__
) };
4873 test_compare(MEMCACHED_SUCCESS
,
4874 memcached_mget(memc
, keys
, key_length
, 1));
4876 memcached_return_t rc
;
4877 memcached_result_st
*results
= memcached_fetch_result(memc
, NULL
, &rc
);
4879 test_compare(MEMCACHED_SUCCESS
, rc
);
4881 test_strcmp(__func__
, memcached_result_value(results
));
4882 uint64_t cas_value
= memcached_result_cas(results
);
4883 test_true(cas_value
);
4885 char* take_value
= memcached_result_take_value(results
);
4886 test_strcmp(__func__
, take_value
);
4889 memcached_result_free(results
);
4891 // Bad cas value, sanity check
4892 test_true(cas_value
!= 9999);
4893 test_compare(MEMCACHED_END
,
4895 test_literal_param(__func__
), // Key
4896 test_literal_param(__FILE__
), // Value
4897 time_t(0), uint32_t(0), 9999));
4899 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
4900 "different", strlen("different"), // Key
4901 test_literal_param(__FILE__
), // Value
4902 time_t(0), uint32_t(0)));
4904 return TEST_SUCCESS
;
4907 test_return_t
regression_bug_854604(memcached_st
*)
4911 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4913 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4915 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4916 test_compare(buffer
[0], 0);
4918 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4919 test_true(strlen(buffer
));
4921 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4922 test_true(strlen(buffer
));
4924 return TEST_SUCCESS
;
4927 static void die_message(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4929 fprintf(stderr
, "Iteration #%u: ", it
);
4931 if (error
== MEMCACHED_ERRNO
)
4933 fprintf(stderr
, "system error %d from %s: %s\n",
4934 errno
, what
, strerror(errno
));
4938 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4939 memcached_strerror(mc
, error
));
4943 #define TEST_CONSTANT_CREATION 200
4945 test_return_t
regression_bug_(memcached_st
*memc
)
4947 const char *remote_server
;
4950 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4952 return TEST_SKIPPED
;
4955 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4957 memcached_st
* mc
= memcached_create(NULL
);
4958 memcached_return rc
;
4960 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4961 if (rc
!= MEMCACHED_SUCCESS
)
4963 die_message(mc
, rc
, "memcached_behavior_set", x
);
4966 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4967 if (rc
!= MEMCACHED_SUCCESS
)
4969 die_message(mc
, rc
, "memcached_behavior_set", x
);
4972 rc
= memcached_server_add(mc
, remote_server
, 0);
4973 if (rc
!= MEMCACHED_SUCCESS
)
4975 die_message(mc
, rc
, "memcached_server_add", x
);
4978 const char *set_key
= "akey";
4979 const size_t set_key_len
= strlen(set_key
);
4980 const char *set_value
= "a value";
4981 const size_t set_value_len
= strlen(set_value
);
4983 if (rc
== MEMCACHED_SUCCESS
)
4987 size_t get_value_len
;
4989 uint32_t get_value_flags
;
4991 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
4992 &get_value_flags
, &rc
);
4993 if (rc
!= MEMCACHED_SUCCESS
)
4995 die_message(mc
, rc
, "memcached_get", x
);
5001 (get_value_len
!= set_value_len
5002 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5004 fprintf(stderr
, "Values don't match?\n");
5005 rc
= MEMCACHED_FAILURE
;
5011 rc
= memcached_set(mc
,
5012 set_key
, set_key_len
,
5013 set_value
, set_value_len
,
5017 if (rc
!= MEMCACHED_SUCCESS
)
5019 die_message(mc
, rc
, "memcached_set", x
);
5026 if (rc
!= MEMCACHED_SUCCESS
)
5032 return TEST_SUCCESS
;
5035 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
5037 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
5040 const memcached_instance_st
* instance
= memcached_server_instance_by_position(memc
, 0);
5043 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
5044 memcached_server_port(instance
), NULL
)) > -1);
5047 test_compare(MEMCACHED_SUCCESS
,
5049 test_literal_param(__func__
), // Keys
5050 test_literal_param(__func__
), // Values
5052 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
5054 memcached_return_t ret
= memcached_set(memc
,
5055 test_literal_param(__func__
), // Keys
5056 test_literal_param(__func__
), // Values
5058 test_compare(ret
, memc
);
5059 test_compare(MEMCACHED_CONNECTION_FAILURE
, memc
);
5061 memcached_free(memc
);
5063 return TEST_SUCCESS
;