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 ASSERT_TRUE_(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, "Returned %s", memcached_strerror(NULL
, rc
));
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
)
2502 test::Memc
mclone(memc
);
2504 memcached_behavior_set(&mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2505 memcached_behavior_set(&mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2506 memcached_behavior_set(&mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2508 test_compare(-1, int32_t(memcached_behavior_get(&mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2510 libtest::vchar_t value
;
2512 for (unsigned int x
= 0; x
< 512; x
++)
2514 value
.push_back(char(x
% 127));
2517 for (unsigned int x
= 1; x
<= 100000; ++x
)
2519 memcached_return_t rc
= memcached_set(&mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2525 return TEST_SUCCESS
;
2529 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2531 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2533 memcached_return_t rc
;
2535 size_t value_length
;
2537 uint64_t number_value
;
2539 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2540 &value_length
, &flags
, &rc
);
2542 test_compare(MEMCACHED_NOTFOUND
, rc
);
2544 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2547 /* The binary protocol will set the key if it doesn't exist */
2548 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2550 test_compare(MEMCACHED_SUCCESS
, rc
);
2554 test_compare(MEMCACHED_NOTFOUND
, rc
);
2557 test_compare(MEMCACHED_SUCCESS
,
2558 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2560 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2564 test_compare(MEMCACHED_SUCCESS
,
2565 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2566 test_compare(2UL, number_value
);
2568 return TEST_SUCCESS
;
2572 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2573 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2575 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2577 char key
[] = "key34567890";
2579 char commandFirst
[]= "set key34567890 0 0 ";
2580 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2581 size_t commandLength
;
2583 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2585 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2587 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2589 char *overflow
= new (std::nothrow
) char[testSize
];
2590 test_true(overflow
);
2592 memset(overflow
, 'x', testSize
);
2593 test_compare(MEMCACHED_SUCCESS
,
2594 memcached_set(memc
, key
, strlen(key
),
2595 overflow
, testSize
, 0, 0));
2599 return TEST_SUCCESS
;
2604 Test values of many different sizes
2605 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2606 set key34567890 0 0 8169 \r\n
2607 is sent followed by buffer of size 8169, followed by 8169
2609 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2611 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2613 libtest::vchar_t value
;
2614 value
.reserve(18000);
2615 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2617 value
.push_back((char) (x
% 127));
2620 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2622 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2623 &value
[0], current_length
,
2624 (time_t)0, (uint32_t)0);
2625 ASSERT_TRUE_(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, "Instead got %s", memcached_strerror(NULL
, rc
));
2627 size_t string_length
;
2629 char *string
= memcached_get(memc
, test_literal_param("foo"),
2630 &string_length
, &flags
, &rc
);
2632 test_compare(MEMCACHED_SUCCESS
, rc
);
2633 test_compare(string_length
, current_length
);
2635 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2636 test_memcmp(string
, &value
[0], string_length
);
2641 return TEST_SUCCESS
;
2645 Look for zero length value problems
2647 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2649 for (uint32_t x
= 0; x
< 2; x
++)
2651 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2653 (time_t)0, (uint32_t)0);
2655 test_compare(MEMCACHED_SUCCESS
, rc
);
2659 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2660 &length
, &flags
, &rc
);
2662 test_compare(MEMCACHED_SUCCESS
, rc
);
2667 value
= memcached_get(memc
, test_literal_param("mykey"),
2668 &length
, &flags
, &rc
);
2670 test_compare(MEMCACHED_SUCCESS
, rc
);
2676 return TEST_SUCCESS
;
2679 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2680 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2682 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2684 (time_t)0, UINT32_MAX
));
2689 memcached_return_t rc
;
2690 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2691 &length
, &flags
, &rc
);
2693 test_compare(MEMCACHED_SUCCESS
, rc
);
2696 test_compare(flags
, UINT32_MAX
);
2698 return TEST_SUCCESS
;
2701 #if !defined(__sun) && !defined(__OpenBSD__)
2702 /* Check the validity of chinese key*/
2703 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2705 const char *key
= "豆瓣";
2706 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2707 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2708 value
, strlen(value
),
2711 test_compare(MEMCACHED_SUCCESS
, rc
);
2715 char *value2
= memcached_get(memc
, key
, strlen(key
),
2716 &length
, &flags
, &rc
);
2718 test_compare(length
, strlen(value
));
2719 test_compare(MEMCACHED_SUCCESS
, rc
);
2720 test_memcmp(value
, value2
, length
);
2723 return TEST_SUCCESS
;
2731 test_return_t
user_supplied_bug19(memcached_st
*)
2733 memcached_return_t res
;
2735 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2737 const memcached_instance_st
* server
= memcached_server_by_key(memc
, "a", 1, &res
);
2740 memcached_free(memc
);
2742 return TEST_SUCCESS
;
2745 /* CAS test from Andei */
2746 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2748 const char *key
= "abc";
2749 size_t key_len
= strlen("abc");
2751 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2753 test_compare(MEMCACHED_SUCCESS
,
2755 test_literal_param("abc"),
2756 test_literal_param("foobar"),
2757 (time_t)0, (uint32_t)0));
2759 test_compare(MEMCACHED_SUCCESS
,
2760 memcached_mget(memc
, &key
, &key_len
, 1));
2762 memcached_result_st result_obj
;
2763 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2766 memcached_result_create(memc
, &result_obj
);
2767 memcached_return_t status
;
2768 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2771 test_compare(MEMCACHED_SUCCESS
, status
);
2773 memcached_result_free(result
);
2775 return TEST_SUCCESS
;
2778 /* Large mget() of missing keys with binary proto
2780 * If many binary quiet commands (such as getq's in an mget) fill the output
2781 * buffer and the server chooses not to respond, memcached_flush hangs. See
2782 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2785 /* sighandler_t function that always asserts false */
2786 static __attribute__((noreturn
)) void fail(int)
2792 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2797 return TEST_SKIPPED
;
2799 void (*oldalarm
)(int);
2801 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2802 test_true(memc_clone
);
2804 /* only binproto uses getq for mget */
2805 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2807 /* empty the cache to ensure misses (hence non-responses) */
2808 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2810 keys_st
keys(key_count
);
2812 oldalarm
= signal(SIGALRM
, fail
);
2815 test_compare_got(MEMCACHED_SUCCESS
,
2816 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2817 memcached_last_error_message(memc_clone
));
2820 signal(SIGALRM
, oldalarm
);
2822 memcached_return_t rc
;
2824 char return_key
[MEMCACHED_MAX_KEY
];
2825 size_t return_key_length
;
2827 size_t return_value_length
;
2828 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2829 &return_value_length
, &flags
, &rc
)))
2831 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2833 test_compare(MEMCACHED_NOTFOUND
, rc
);
2834 test_zero(return_value_length
);
2835 test_zero(return_key_length
);
2836 test_false(return_key
[0]);
2837 test_false(return_value
);
2839 memcached_free(memc_clone
);
2841 return TEST_SUCCESS
;
2845 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2847 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2849 /* should work as of r580 */
2850 test_compare(TEST_SUCCESS
,
2851 _user_supplied_bug21(memc
, 10));
2853 /* should fail as of r580 */
2854 test_compare(TEST_SUCCESS
,
2855 _user_supplied_bug21(memc
, 1000));
2857 return TEST_SUCCESS
;
2860 test_return_t
comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st
*)
2864 memcached_st
*memc
= &memc_
;
2866 ASSERT_EQ(memc
, MEMCACHED_SUCCESS
);
2867 test_compare(memc
, MEMCACHED_SUCCESS
);
2869 ASSERT_NEQ(memc
, MEMCACHED_FAILURE
);
2871 return TEST_SUCCESS
;
2874 test_return_t
ketama_TEST(memcached_st
*)
2876 test::Memc
memc("--server=10.0.1.1:11211 --server=10.0.1.2:11211");
2878 test_compare(MEMCACHED_SUCCESS
,
2879 memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2881 test_compare(memcached_behavior_get(&memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
), uint64_t(1));
2883 test_compare(memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
), MEMCACHED_SUCCESS
);
2885 test_compare(memcached_hash_t(memcached_behavior_get(&memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
)), MEMCACHED_HASH_MD5
);
2887 test_compare(memcached_behavior_set_distribution(&memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
), MEMCACHED_SUCCESS
);
2890 return TEST_SUCCESS
;
2893 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2895 memcached_st
*memc
= memcached_create(NULL
);
2899 test_compare(MEMCACHED_SUCCESS
,
2900 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2902 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2903 test_compare(value
, uint64_t(1));
2905 test_compare(MEMCACHED_SUCCESS
,
2906 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2908 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2909 test_true(value
== MEMCACHED_HASH_MD5
);
2912 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2914 memcached_server_st
*server_pool
;
2915 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");
2916 memcached_server_push(memc
, server_pool
);
2918 // @todo this needs to be refactored to actually test something.
2921 if ((fp
= fopen("ketama_keys.txt", "w")))
2925 printf("cannot write to file ketama_keys.txt");
2926 return TEST_FAILURE
;
2929 for (int x
= 0; x
< 10000; x
++)
2932 snprintf(key
, sizeof(key
), "%d", x
);
2934 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2935 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2936 in_port_t port
= memc
->hosts
[server_idx
].port
;
2937 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2938 const memcached_instance_st
* instance
=
2939 memcached_server_instance_by_position(memc
, host_index
);
2943 memcached_server_list_free(server_pool
);
2944 memcached_free(memc
);
2946 return TEST_SUCCESS
;
2950 test_return_t
result_static(memcached_st
*memc
)
2952 memcached_result_st result
;
2953 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
2954 test_false(result
.options
.is_allocated
);
2955 test_true(memcached_is_initialized(&result
));
2956 test_true(result_ptr
);
2957 test_true(result_ptr
== &result
);
2959 memcached_result_free(&result
);
2961 test_false(result
.options
.is_allocated
);
2962 test_false(memcached_is_initialized(&result
));
2964 return TEST_SUCCESS
;
2967 test_return_t
result_alloc(memcached_st
*memc
)
2969 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
2970 test_true(result_ptr
);
2971 test_true(result_ptr
->options
.is_allocated
);
2972 test_true(memcached_is_initialized(result_ptr
));
2973 memcached_result_free(result_ptr
);
2975 return TEST_SUCCESS
;
2979 test_return_t
add_host_test1(memcached_st
*memc
)
2981 memcached_return_t rc
;
2982 char servername
[]= "0.example.com";
2984 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2986 test_compare(1U, memcached_server_list_count(servers
));
2988 for (uint32_t x
= 2; x
< 20; x
++)
2990 char buffer
[SMALL_STRING_LEN
];
2992 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
2993 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2995 test_compare(MEMCACHED_SUCCESS
, rc
);
2996 test_compare(x
, memcached_server_list_count(servers
));
2999 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3000 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3002 memcached_server_list_free(servers
);
3004 return TEST_SUCCESS
;
3008 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3012 #ifdef HARD_MALLOC_TESTS
3013 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3021 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3025 #ifdef HARD_MALLOC_TESTS
3026 void *ret
= malloc(size
+ 8);
3029 ret
= (void*)((caddr_t
)ret
+ 8);
3032 void *ret
= malloc(size
);
3037 memset(ret
, 0xff, size
);
3044 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3046 #ifdef HARD_MALLOC_TESTS
3047 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3048 void *nmem
= realloc(real_ptr
, size
+ 8);
3053 ret
= (void*)((caddr_t
)nmem
+ 8);
3059 return realloc(mem
, size
);
3064 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3066 #ifdef HARD_MALLOC_TESTS
3067 void *mem
= my_malloc(ptr
, nelem
* size
);
3070 memset(mem
, 0, nelem
* size
);
3076 return calloc(nelem
, size
);
3080 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3082 memcached_return_t rc
;
3083 const char *key
= "mine";
3086 /* Make sure by default none exists */
3087 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3089 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3091 /* Test a clean set */
3092 test_compare(MEMCACHED_SUCCESS
,
3093 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3095 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3097 test_memcmp(value
, key
, strlen(key
));
3098 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3100 /* Test that we can turn it off */
3101 test_compare(MEMCACHED_SUCCESS
,
3102 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3104 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3106 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3108 /* Now setup for main test */
3109 test_compare(MEMCACHED_SUCCESS
,
3110 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3112 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3114 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3115 test_memcmp(value
, key
, strlen(key
));
3117 /* Set to Zero, and then Set to something too large */
3120 memset(long_key
, 0, 255);
3122 test_compare(MEMCACHED_SUCCESS
,
3123 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3125 ASSERT_NULL_(memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
), "Setting namespace to NULL did not work");
3127 /* Test a long key for failure */
3128 /* TODO, extend test to determine based on setting, what result should be */
3129 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3130 test_compare(MEMCACHED_SUCCESS
,
3131 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3133 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3134 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3135 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3136 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3138 /* Test for a bad prefix, but with a short key */
3139 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3140 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3142 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3143 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3146 return TEST_SUCCESS
;
3149 test_return_t
set_namespace(memcached_st
*memc
)
3151 memcached_return_t rc
;
3152 const char *key
= "mine";
3154 // Make sure we default to a null namespace
3155 char* value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3156 ASSERT_NULL_(value
, "memc had a value for namespace when none should exist");
3157 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3159 /* Test a clean set */
3160 test_compare(MEMCACHED_SUCCESS
,
3161 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3163 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3165 test_memcmp(value
, key
, strlen(key
));
3166 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3168 return TEST_SUCCESS
;
3171 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3173 test_return_if(pre_binary(memc
));
3174 test_return_if(set_namespace(memc
));
3176 return TEST_SUCCESS
;
3179 #ifdef MEMCACHED_ENABLE_DEPRECATED
3180 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3182 void *test_ptr
= NULL
;
3185 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
3186 cb_ptr
= *(void **)&malloc_cb
;
3187 memcached_return_t rc
;
3189 test_compare(MEMCACHED_SUCCESS
,
3190 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3191 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3192 test_compare(MEMCACHED_SUCCESS
, rc
);
3193 test_true(test_ptr
== cb_ptr
);
3197 memcached_realloc_fn realloc_cb
=
3198 (memcached_realloc_fn
)my_realloc
;
3199 cb_ptr
= *(void **)&realloc_cb
;
3200 memcached_return_t rc
;
3202 test_compare(MEMCACHED_SUCCESS
,
3203 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3204 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3205 test_compare(MEMCACHED_SUCCESS
, rc
);
3206 test_true(test_ptr
== cb_ptr
);
3210 memcached_free_fn free_cb
=
3211 (memcached_free_fn
)my_free
;
3212 cb_ptr
= *(void **)&free_cb
;
3213 memcached_return_t rc
;
3215 test_compare(MEMCACHED_SUCCESS
,
3216 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3217 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3218 test_compare(MEMCACHED_SUCCESS
, rc
);
3219 test_true(test_ptr
== cb_ptr
);
3222 return TEST_SUCCESS
;
3227 test_return_t
set_memory_alloc(memcached_st
*memc
)
3229 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3230 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3231 my_realloc
, my_calloc
, NULL
));
3233 test_compare(MEMCACHED_SUCCESS
,
3234 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3235 my_realloc
, my_calloc
, NULL
));
3237 memcached_malloc_fn mem_malloc
;
3238 memcached_free_fn mem_free
;
3239 memcached_realloc_fn mem_realloc
;
3240 memcached_calloc_fn mem_calloc
;
3241 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3242 &mem_realloc
, &mem_calloc
);
3244 test_true(mem_malloc
== my_malloc
);
3245 test_true(mem_realloc
== my_realloc
);
3246 test_true(mem_calloc
== my_calloc
);
3247 test_true(mem_free
== my_free
);
3249 return TEST_SUCCESS
;
3252 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3254 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
));
3255 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3258 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3263 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3265 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_CRC
)
3267 return TEST_SKIPPED
;
3270 return TEST_SUCCESS
;
3273 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3276 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
);
3277 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3282 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3284 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_HSIEH
)
3286 return TEST_SKIPPED
;
3289 return TEST_SUCCESS
;
3292 test_return_t
enable_cas(memcached_st
*memc
)
3294 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3296 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true);
3298 return TEST_SUCCESS
;
3301 return TEST_SKIPPED
;
3304 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3306 memcached_version(memc
);
3308 const memcached_instance_st
* instance
=
3309 memcached_server_instance_by_position(memc
, 0);
3311 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3312 or instance
->minor_version
> 2)
3314 return TEST_SUCCESS
;
3317 return TEST_SKIPPED
;
3320 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3322 const uint64_t timeout
= 100; // Not using, just checking that it sets
3324 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3326 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3328 return TEST_SUCCESS
;
3331 test_return_t
noreply_test(memcached_st
*memc
)
3333 test_compare(MEMCACHED_SUCCESS
,
3334 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3335 test_compare(MEMCACHED_SUCCESS
,
3336 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3337 test_compare(MEMCACHED_SUCCESS
,
3338 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3339 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3340 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3341 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3343 memcached_return_t ret
;
3344 for (int count
= 0; count
< 5; ++count
)
3346 for (size_t x
= 0; x
< 100; ++x
)
3348 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3349 int check_length
= snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3350 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3352 size_t len
= (size_t)check_length
;
3357 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3360 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3363 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3366 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3369 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3375 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3376 memcached_strerror(NULL
, ret
));
3380 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3381 ** API and is _ONLY_ done this way to verify that the library works the
3382 ** way it is supposed to do!!!!
3386 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3388 const memcached_instance_st
* instance
=
3389 memcached_server_instance_by_position(memc
, x
);
3390 no_msg
+=(int)(instance
->cursor_active
);
3393 test_true(no_msg
== 0);
3395 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3398 ** Now validate that all items was set properly!
3400 for (size_t x
= 0; x
< 100; ++x
)
3404 int check_length
= snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3406 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3408 size_t len
= (size_t)check_length
;
3411 char* value
=memcached_get(memc
, key
, strlen(key
),
3412 &length
, &flags
, &ret
);
3413 // For the moment we will just go to the next key
3414 if (MEMCACHED_TIMEOUT
== ret
)
3418 test_true(ret
== MEMCACHED_SUCCESS
and value
!= NULL
);
3421 case 0: /* FALLTHROUGH */
3422 case 1: /* FALLTHROUGH */
3424 test_true(strncmp(value
, key
, len
) == 0);
3425 test_true(len
== length
);
3428 test_true(length
== len
* 2);
3431 test_true(length
== len
* 3);
3441 /* Try setting an illegal cas value (should not return an error to
3442 * the caller (because we don't expect a return message from the server)
3444 const char* keys
[]= {"0"};
3445 size_t lengths
[]= {1};
3448 memcached_result_st results_obj
;
3449 memcached_result_st
*results
;
3450 test_compare(MEMCACHED_SUCCESS
,
3451 memcached_mget(memc
, keys
, lengths
, 1));
3453 results
= memcached_result_create(memc
, &results_obj
);
3455 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3457 test_compare(MEMCACHED_SUCCESS
, ret
);
3458 uint64_t cas
= memcached_result_cas(results
);
3459 memcached_result_free(&results_obj
);
3461 test_compare(MEMCACHED_SUCCESS
,
3462 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3465 * The item will have a new cas value, so try to set it again with the old
3466 * value. This should fail!
3468 test_compare(MEMCACHED_SUCCESS
,
3469 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3470 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3471 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3472 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3475 return TEST_SUCCESS
;
3478 test_return_t
analyzer_test(memcached_st
*memc
)
3480 memcached_analysis_st
*report
;
3481 memcached_return_t rc
;
3483 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3484 test_compare(MEMCACHED_SUCCESS
, rc
);
3485 test_true(memc_stat
);
3487 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3488 test_compare(MEMCACHED_SUCCESS
, rc
);
3492 memcached_stat_free(NULL
, memc_stat
);
3494 return TEST_SUCCESS
;
3497 test_return_t
util_version_test(memcached_st
*memc
)
3499 test_compare(memcached_version(memc
), MEMCACHED_SUCCESS
);
3500 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3502 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3504 // We expect failure
3507 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3508 fprintf(stderr
, "\nDumping Server Information\n\n");
3509 memcached_server_fn callbacks
[1];
3511 callbacks
[0]= dump_server_information
;
3512 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3513 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3515 test_true(if_successful
== false);
3517 const memcached_instance_st
* instance
=
3518 memcached_server_instance_by_position(memc
, 0);
3520 memcached_version(memc
);
3522 // We only use one binary when we test, so this should be just fine.
3523 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3524 test_true(if_successful
== true);
3526 if (instance
->micro_version
> 0)
3528 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3530 else if (instance
->minor_version
> 0)
3532 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3534 else if (instance
->major_version
> 0)
3536 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3539 test_true(if_successful
== true);
3541 if (instance
->micro_version
> 0)
3543 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3545 else if (instance
->minor_version
> 0)
3547 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3549 else if (instance
->major_version
> 0)
3551 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3554 test_true(if_successful
== false);
3556 return TEST_SUCCESS
;
3559 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3561 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3562 memcached_return_t rc
;
3563 const memcached_instance_st
* instance
=
3564 memcached_server_instance_by_position(memc
, 0);
3566 // Test both the version that returns a code, and the one that does not.
3567 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3568 memcached_server_port(instance
) -1, NULL
) == -1);
3570 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3571 memcached_server_port(instance
) -1, &rc
) == -1);
3572 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3574 return TEST_SUCCESS
;
3578 test_return_t
getpid_test(memcached_st
*memc
)
3580 memcached_return_t rc
;
3581 const memcached_instance_st
* instance
=
3582 memcached_server_instance_by_position(memc
, 0);
3584 // Test both the version that returns a code, and the one that does not.
3585 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3586 memcached_server_port(instance
), NULL
) > -1);
3588 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3589 memcached_server_port(instance
), &rc
) > -1);
3590 test_compare(MEMCACHED_SUCCESS
, rc
);
3592 return TEST_SUCCESS
;
3595 static memcached_return_t
ping_each_server(const memcached_st
*,
3596 const memcached_instance_st
* instance
,
3599 // Test both the version that returns a code, and the one that does not.
3600 memcached_return_t rc
;
3601 if (libmemcached_util_ping(memcached_server_name(instance
),
3602 memcached_server_port(instance
), &rc
) == false)
3604 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d %s", memcached_server_name(instance
),
3605 memcached_server_port(instance
), memcached_strerror(NULL
, rc
));
3608 if (libmemcached_util_ping(memcached_server_name(instance
),
3609 memcached_server_port(instance
), NULL
) == false)
3611 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d", memcached_server_name(instance
), memcached_server_port(instance
));
3614 return MEMCACHED_SUCCESS
;
3617 test_return_t
libmemcached_util_ping_TEST(memcached_st
*memc
)
3619 memcached_server_fn callbacks
[1]= { ping_each_server
};
3620 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
3622 return TEST_SUCCESS
;
3627 test_return_t
hash_sanity_test (memcached_st
*memc
)
3631 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3632 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3633 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3634 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3635 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3636 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3637 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3638 #ifdef HAVE_HSIEH_HASH
3639 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3641 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3642 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3643 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3645 return TEST_SUCCESS
;
3649 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3651 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3653 test_compare(MEMCACHED_SUCCESS
,
3654 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3655 (uint64_t)MEMCACHED_HASH_HSIEH
));
3657 return TEST_SUCCESS
;
3660 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3662 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3664 test_compare(MEMCACHED_SUCCESS
,
3665 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3667 return TEST_SUCCESS
;
3670 test_return_t
one_at_a_time_run (memcached_st
*)
3675 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3677 test_compare(one_at_a_time_values
[x
],
3678 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3681 return TEST_SUCCESS
;
3684 test_return_t
md5_run (memcached_st
*)
3689 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3691 test_compare(md5_values
[x
],
3692 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3695 return TEST_SUCCESS
;
3698 test_return_t
crc_run (memcached_st
*)
3703 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3705 test_compare(crc_values
[x
],
3706 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3709 return TEST_SUCCESS
;
3712 test_return_t
fnv1_64_run (memcached_st
*)
3714 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3719 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3721 test_compare(fnv1_64_values
[x
],
3722 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3725 return TEST_SUCCESS
;
3728 test_return_t
fnv1a_64_run (memcached_st
*)
3730 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3735 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3737 test_compare(fnv1a_64_values
[x
],
3738 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3741 return TEST_SUCCESS
;
3744 test_return_t
fnv1_32_run (memcached_st
*)
3749 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3751 test_compare(fnv1_32_values
[x
],
3752 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3755 return TEST_SUCCESS
;
3758 test_return_t
fnv1a_32_run (memcached_st
*)
3763 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3765 test_compare(fnv1a_32_values
[x
],
3766 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3769 return TEST_SUCCESS
;
3772 test_return_t
hsieh_run (memcached_st
*)
3774 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3779 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3781 test_compare(hsieh_values
[x
],
3782 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3785 return TEST_SUCCESS
;
3788 test_return_t
murmur_run (memcached_st
*)
3790 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3792 #ifdef WORDS_BIGENDIAN
3793 (void)murmur_values
;
3794 return TEST_SKIPPED
;
3799 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3801 test_compare(murmur_values
[x
],
3802 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3805 return TEST_SUCCESS
;
3809 test_return_t
murmur3_TEST(hashkit_st
*)
3811 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR3
));
3813 #ifdef WORDS_BIGENDIAN
3814 (void)murmur3_values
;
3815 return TEST_SKIPPED
;
3820 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3822 test_compare(murmur3_values
[x
],
3823 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR3
));
3826 return TEST_SUCCESS
;
3830 test_return_t
jenkins_run (memcached_st
*)
3835 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3837 test_compare(jenkins_values
[x
],
3838 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3841 return TEST_SUCCESS
;
3844 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3846 return libhashkit_md5(string
, string_length
);
3849 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3851 return libhashkit_crc32(string
, string_length
);
3854 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3860 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3862 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};
3863 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};
3865 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3867 hashkit_clone(&new_kit
, kit
);
3868 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3870 memcached_set_hashkit(memc
, &new_kit
);
3873 Verify Setting the hash.
3875 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3879 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3880 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3885 Now check memcached_st.
3887 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3891 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3892 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3895 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3897 memcached_set_hashkit(memc
, &new_kit
);
3900 Verify Setting the hash.
3902 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3906 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3907 test_true(crc_values
[x
] == hash_val
);
3910 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3914 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3915 test_compare(crc_hosts
[x
], hash_val
);
3918 memcached_free(memc
);
3920 return TEST_SUCCESS
;
3924 Test case adapted from John Gorman <johngorman2@gmail.com>
3926 We are testing the error condition when we connect to a server via memcached_get()
3927 but find that the server is not available.
3929 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3933 memcached_return rc
;
3936 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3938 // See if memcached is reachable.
3939 char *value
= memcached_get(tl_memc_h
,
3940 test_literal_param(__func__
),
3945 test_true(memcached_failed(rc
));
3947 memcached_free(tl_memc_h
);
3949 return TEST_SUCCESS
;
3953 We connect to a server which exists, but search for a key that does not exist.
3955 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3959 memcached_return rc
;
3961 // See if memcached is reachable.
3962 char *value
= memcached_get(memc
,
3963 test_literal_param(__func__
),
3968 test_compare(MEMCACHED_NOTFOUND
, rc
);
3970 return TEST_SUCCESS
;
3974 Test case adapted from John Gorman <johngorman2@gmail.com>
3976 We are testing the error condition when we connect to a server via memcached_get_by_key()
3977 but find that the server is not available.
3979 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
3983 memcached_return rc
;
3986 memcached_st
*tl_memc_h
= memcached_create(NULL
);
3987 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
3988 memcached_server_push(tl_memc_h
, servers
);
3989 memcached_server_list_free(servers
);
3991 // See if memcached is reachable.
3992 char *value
= memcached_get_by_key(tl_memc_h
,
3993 test_literal_param(__func__
), // Key
3994 test_literal_param(__func__
), // Value
3999 test_true(memcached_failed(rc
));
4001 memcached_free(tl_memc_h
);
4003 return TEST_SUCCESS
;
4007 We connect to a server which exists, but search for a key that does not exist.
4009 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4013 memcached_return rc
;
4015 // See if memcached is reachable.
4016 char *value
= memcached_get_by_key(memc
,
4017 test_literal_param(__func__
), // Key
4018 test_literal_param(__func__
), // Value
4023 test_compare(MEMCACHED_NOTFOUND
, rc
);
4025 return TEST_SUCCESS
;
4028 test_return_t
regression_bug_434484(memcached_st
*memc
)
4030 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4032 test_compare(MEMCACHED_NOTSTORED
,
4033 memcached_append(memc
,
4034 test_literal_param(__func__
), // Key
4035 test_literal_param(__func__
), // Value
4038 libtest::vchar_t data
;
4039 data
.resize(2048 * 1024);
4040 test_compare(MEMCACHED_E2BIG
,
4042 test_literal_param(__func__
), // Key
4043 &data
[0], data
.size(), 0, 0));
4045 return TEST_SUCCESS
;
4048 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4050 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4052 memcached_return_t rc
;
4054 memcached_execute_fn callbacks
[]= { &callback_counter
};
4057 * I only want to hit only _one_ server so I know the number of requests I'm
4058 * sending in the pipleine to the server. Let's try to do a multiget of
4059 * 1024 (that should satisfy most users don't you think?). Future versions
4060 * will include a mget_execute function call if you need a higher number.
4062 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4067 * Run two times.. the first time we should have 100% cache miss,
4068 * and the second time we should have 100% cache hits
4070 for (ptrdiff_t y
= 0; y
< 2; y
++)
4072 test_compare(MEMCACHED_SUCCESS
,
4073 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4075 // One the first run we should get a NOT_FOUND, but on the second some data
4076 // should be returned.
4077 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4078 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4082 /* The first iteration should give me a 100% cache miss. verify that*/
4083 char blob
[1024]= { 0 };
4085 test_false(counter
);
4087 for (size_t x
= 0; x
< keys
.size(); ++x
)
4089 rc
= memcached_add(memc
,
4090 keys
.key_at(x
), keys
.length_at(x
),
4091 blob
, sizeof(blob
), 0, 0);
4092 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4097 /* Verify that we received all of the key/value pairs */
4098 test_compare(counter
, keys
.size());
4102 memcached_free(memc
);
4104 return TEST_SUCCESS
;
4107 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4109 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
4111 return regression_bug_434843(memc
);
4114 test_return_t
regression_bug_421108(memcached_st
*memc
)
4116 memcached_return_t rc
;
4117 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4118 test_compare(MEMCACHED_SUCCESS
, rc
);
4120 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4121 test_compare(MEMCACHED_SUCCESS
, rc
);
4122 test_true(bytes_str
);
4123 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4125 test_compare(MEMCACHED_SUCCESS
, rc
);
4126 test_true(bytes_read_str
);
4128 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4129 "bytes_written", &rc
);
4130 test_compare(MEMCACHED_SUCCESS
, rc
);
4131 test_true(bytes_written_str
);
4133 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4134 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4135 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4137 test_true(bytes
!= bytes_read
);
4138 test_true(bytes
!= bytes_written
);
4140 /* Release allocated resources */
4142 free(bytes_read_str
);
4143 free(bytes_written_str
);
4144 memcached_stat_free(NULL
, memc_stat
);
4146 return TEST_SUCCESS
;
4150 * The test case isn't obvious so I should probably document why
4151 * it works the way it does. Bug 442914 was caused by a bug
4152 * in the logic in memcached_purge (it did not handle the case
4153 * where the number of bytes sent was equal to the watermark).
4154 * In this test case, create messages so that we hit that case
4155 * and then disable noreply mode and issue a new command to
4156 * verify that it isn't stuck. If we change the format for the
4157 * delete command or the watermarks, we need to update this
4160 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
4162 test_skip(original_memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
4164 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
4166 for (uint32_t x
= 0; x
< 250; ++x
)
4169 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
4170 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4171 char error_buffer
[2048]= { 0 };
4172 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
4173 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
4176 // Delete, and then delete again to look for not found
4179 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
4180 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4181 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4183 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
4184 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
4187 memcached_free(memc
);
4189 return TEST_SUCCESS
;
4192 test_return_t
regression_bug_447342(memcached_st
*memc
)
4194 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4196 return TEST_SKIPPED
;
4199 test_compare(MEMCACHED_SUCCESS
,
4200 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4204 for (size_t x
= 0; x
< keys
.size(); ++x
)
4206 test_compare(MEMCACHED_SUCCESS
,
4208 keys
.key_at(x
), keys
.length_at(x
), // Keys
4209 keys
.key_at(x
), keys
.length_at(x
), // Values
4214 ** We are using the quiet commands to store the replicas, so we need
4215 ** to ensure that all of them are processed before we can continue.
4216 ** In the test we go directly from storing the object to trying to
4217 ** receive the object from all of the different servers, so we
4218 ** could end up in a race condition (the memcached server hasn't yet
4219 ** processed the quiet command from the replication set when it process
4220 ** the request from the other client (created by the clone)). As a
4221 ** workaround for that we call memcached_quit to send the quit command
4222 ** to the server and wait for the response ;-) If you use the test code
4223 ** as an example for your own code, please note that you shouldn't need
4226 memcached_quit(memc
);
4228 /* Verify that all messages are stored, and we didn't stuff too much
4231 test_compare(MEMCACHED_SUCCESS
,
4232 memcached_mget(memc
,
4233 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4235 unsigned int counter
= 0;
4236 memcached_execute_fn callbacks
[]= { &callback_counter
};
4237 test_compare(MEMCACHED_SUCCESS
,
4238 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4240 /* Verify that we received all of the key/value pairs */
4241 test_compare(counter
, keys
.size());
4243 memcached_quit(memc
);
4245 * Don't do the following in your code. I am abusing the internal details
4246 * within the library, and this is not a supported interface.
4247 * This is to verify correct behavior in the library. Fake that two servers
4250 const memcached_instance_st
* instance_one
= memcached_server_instance_by_position(memc
, 0);
4251 const memcached_instance_st
* instance_two
= memcached_server_instance_by_position(memc
, 2);
4252 in_port_t port0
= instance_one
->port();
4253 in_port_t port2
= instance_two
->port();
4255 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4256 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4258 test_compare(MEMCACHED_SUCCESS
,
4259 memcached_mget(memc
,
4260 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4263 test_compare(MEMCACHED_SUCCESS
,
4264 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4265 test_compare(counter
, keys
.size());
4267 /* restore the memc handle */
4268 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4269 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4271 memcached_quit(memc
);
4273 /* Remove half of the objects */
4274 for (size_t x
= 0; x
< keys
.size(); ++x
)
4278 test_compare(MEMCACHED_SUCCESS
,
4279 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4283 memcached_quit(memc
);
4284 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4285 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4287 /* now retry the command, this time we should have cache misses */
4288 test_compare(MEMCACHED_SUCCESS
,
4289 memcached_mget(memc
,
4290 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4293 test_compare(MEMCACHED_SUCCESS
,
4294 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4295 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4297 /* restore the memc handle */
4298 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4299 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4301 return TEST_SUCCESS
;
4304 test_return_t
regression_bug_463297(memcached_st
*memc
)
4306 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4308 // Since we blocked timed delete, this test is no longer valid.
4310 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4311 test_true(memc_clone
);
4312 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4314 const memcached_instance_st
* instance
=
4315 memcached_server_instance_by_position(memc_clone
, 0);
4317 if (instance
->major_version
> 1 ||
4318 (instance
->major_version
== 1 &&
4319 instance
->minor_version
> 2))
4321 /* Binary protocol doesn't support deferred delete */
4322 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4323 test_true(bin_clone
);
4324 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4325 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4326 memcached_free(bin_clone
);
4328 memcached_quit(memc_clone
);
4330 /* If we know the server version, deferred delete should fail
4331 * with invalid arguments */
4332 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4334 /* If we don't know the server version, we should get a protocol error */
4335 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4337 /* but there is a bug in some of the memcached servers (1.4) that treats
4338 * the counter as noreply so it doesn't send the proper error message
4340 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4342 /* And buffered mode should be disabled and we should get protocol error */
4343 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4344 rc
= memcached_delete(memc
, "foo", 3, 1);
4345 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4347 /* Same goes for noreply... */
4348 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4349 rc
= memcached_delete(memc
, "foo", 3, 1);
4350 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4352 /* but a normal request should go through (and be buffered) */
4353 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4354 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4356 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4357 /* unbuffered noreply should be success */
4358 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4359 /* unbuffered with reply should be not found... */
4360 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4361 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4364 memcached_free(memc_clone
);
4367 return TEST_SUCCESS
;
4371 /* Test memcached_server_get_last_disconnect
4372 * For a working server set, shall be NULL
4373 * For a set of non existing server, shall not be NULL
4375 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4377 memcached_return_t rc
;
4378 const memcached_instance_st
* disconnected_server
;
4380 /* With the working set of server */
4381 const char *key
= "marmotte";
4382 const char *value
= "milka";
4384 memcached_reset_last_disconnected_server(memc
);
4385 test_false(memc
->last_disconnected_server
);
4386 rc
= memcached_set(memc
, key
, strlen(key
),
4387 value
, strlen(value
),
4388 (time_t)0, (uint32_t)0);
4389 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4391 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4392 test_false(disconnected_server
);
4394 /* With a non existing server */
4396 memcached_server_st
*servers
;
4398 const char *server_list
= "localhost:9";
4400 servers
= memcached_servers_parse(server_list
);
4402 mine
= memcached_create(NULL
);
4403 rc
= memcached_server_push(mine
, servers
);
4404 test_compare(MEMCACHED_SUCCESS
, rc
);
4405 memcached_server_list_free(servers
);
4408 rc
= memcached_set(mine
, key
, strlen(key
),
4409 value
, strlen(value
),
4410 (time_t)0, (uint32_t)0);
4411 test_true(memcached_failed(rc
));
4413 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4414 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4415 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4416 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4418 memcached_quit(mine
);
4419 memcached_free(mine
);
4421 return TEST_SUCCESS
;
4424 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4426 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4427 char buffer
[BUFSIZ
];
4429 test_compare(MEMCACHED_SUCCESS
,
4430 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4432 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4435 // We will just use the error strings as our keys
4436 uint32_t counter
= 100;
4439 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4441 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4442 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4443 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4445 const memcached_instance_st
* disconnected_server
= memcached_server_get_last_disconnect(memc
);
4446 test_true(disconnected_server
);
4447 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4448 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4452 memcached_reset_last_disconnected_server(memc
);
4457 memcached_free(memc
);
4459 return TEST_SUCCESS
;
4462 test_return_t
test_verbosity(memcached_st
*memc
)
4464 memcached_verbosity(memc
, 3);
4466 return TEST_SUCCESS
;
4470 static memcached_return_t
stat_printer(const memcached_instance_st
* server
,
4471 const char *key
, size_t key_length
,
4472 const char *value
, size_t value_length
,
4482 return MEMCACHED_SUCCESS
;
4485 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4487 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4488 test_compare(MEMCACHED_SUCCESS
, rc
);
4490 test_compare(MEMCACHED_SUCCESS
,
4491 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4493 test_compare(MEMCACHED_SUCCESS
,
4494 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4496 test_compare(MEMCACHED_SUCCESS
,
4497 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4499 return TEST_SUCCESS
;
4503 * This test ensures that the failure counter isn't incremented during
4504 * normal termination of the memcached instance.
4506 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4508 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4510 /* Ensure that we are connected to the server by setting a value */
4511 memcached_return_t rc
= memcached_set(memc
,
4512 test_literal_param(__func__
), // Key
4513 test_literal_param(__func__
), // Value
4514 time_t(0), uint32_t(0));
4515 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4518 const memcached_instance_st
* instance
= memcached_server_instance_by_position(memc
, 0);
4520 /* The test is to see that the memcached_quit doesn't increase the
4521 * the server failure conter, so let's ensure that it is zero
4522 * before sending quit
4524 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4526 memcached_quit(memc
);
4528 /* Verify that it memcached_quit didn't increment the failure counter
4529 * Please note that this isn't bullet proof, because an error could
4532 test_zero(instance
->server_failure_counter
);
4534 memcached_free(memc
);
4536 return TEST_SUCCESS
;
4540 * This tests ensures expected disconnections (for some behavior changes
4541 * for instance) do not wrongly increase failure counter
4543 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4545 /* Set value to force connection to the server */
4546 const char *key
= "marmotte";
4547 const char *value
= "milka";
4549 test_compare_hint(MEMCACHED_SUCCESS
,
4550 memcached_set(memc
, key
, strlen(key
),
4551 value
, strlen(value
),
4552 (time_t)0, (uint32_t)0),
4553 memcached_last_error_message(memc
));
4556 /* put failure limit to 1 */
4557 test_compare(MEMCACHED_SUCCESS
,
4558 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4560 /* Put a retry timeout to effectively activate failure_limit effect */
4561 test_compare(MEMCACHED_SUCCESS
,
4562 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
4564 /* change behavior that triggers memcached_quit()*/
4565 test_compare(MEMCACHED_SUCCESS
,
4566 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4569 /* Check if we still are connected */
4571 size_t string_length
;
4572 memcached_return rc
;
4573 char *string
= memcached_get(memc
, key
, strlen(key
),
4574 &string_length
, &flags
, &rc
);
4576 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4580 return TEST_SUCCESS
;
4583 test_return_t
regression_996813_TEST(memcached_st
*)
4585 memcached_st
* memc
= memcached_create(NULL
);
4587 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
4588 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
4589 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4590 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4591 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1));
4592 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 300));
4593 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 30));
4595 // We will never connect to these servers
4596 in_port_t base_port
= 11211;
4597 for (size_t x
= 0; x
< 17; x
++)
4599 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", base_port
+x
));
4601 test_compare(6U, memcached_generate_hash(memc
, test_literal_param("SZ6hu0SHweFmpwpc0w2R")));
4602 test_compare(1U, memcached_generate_hash(memc
, test_literal_param("SQCK9eiCf53YxHWnYA.o")));
4603 test_compare(9U, memcached_generate_hash(memc
, test_literal_param("SUSDkGXuuZC9t9VhMwa.")));
4604 test_compare(0U, memcached_generate_hash(memc
, test_literal_param("SnnqnJARfaCNT679iAF_")));
4606 memcached_free(memc
);
4608 return TEST_SUCCESS
;
4613 * Test that ensures mget_execute does not end into recursive calls that finally fails
4615 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4619 return TEST_SKIPPED
; // My MAC can't handle this test
4622 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4625 * I only want to hit _one_ server so I know the number of requests I'm
4626 * sending in the pipeline.
4628 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4631 keys_st
keys(20480);
4633 /* First add all of the items.. */
4634 char blob
[1024]= { 0 };
4635 for (size_t x
= 0; x
< keys
.size(); ++x
)
4637 memcached_return rc
= memcached_set(memc
,
4638 keys
.key_at(x
), keys
.length_at(x
),
4639 blob
, sizeof(blob
), 0, 0);
4640 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4645 /* Try to get all of them with a large multiget */
4647 memcached_execute_function callbacks
[]= { &callback_counter
};
4648 memcached_return_t rc
= memcached_mget_execute(memc
,
4649 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4650 callbacks
, &counter
, 1);
4651 test_compare(MEMCACHED_SUCCESS
, rc
);
4653 char* the_value
= NULL
;
4654 char the_key
[MEMCACHED_MAX_KEY
];
4655 size_t the_key_length
;
4656 size_t the_value_length
;
4660 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4662 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4668 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4671 test_compare(MEMCACHED_END
, rc
);
4673 /* Verify that we got all of the items */
4674 test_compare(counter
, keys
.size());
4677 memcached_free(memc
);
4679 return TEST_SUCCESS
;
4682 test_return_t
regression_1021819_TEST(memcached_st
*original
)
4684 memcached_st
*memc
= memcached_clone(NULL
, original
);
4687 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 2000000), MEMCACHED_SUCCESS
);
4688 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 3000000), MEMCACHED_SUCCESS
);
4690 memcached_return_t rc
;
4693 test_literal_param(__func__
),
4696 test_compare(rc
, MEMCACHED_NOTFOUND
);
4698 memcached_free(memc
);
4700 return TEST_SUCCESS
;
4703 test_return_t
regression_bug_583031(memcached_st
*)
4705 memcached_st
*memc
= memcached_create(NULL
);
4707 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.251.4", 11211));
4709 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 3000);
4710 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4711 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4712 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4713 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4714 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4716 memcached_return_t rc
;
4720 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4724 test_compare(MEMCACHED_TIMEOUT
, memc
);
4726 memcached_free(memc
);
4728 return TEST_SUCCESS
;
4731 test_return_t
regression_bug_581030(memcached_st
*)
4734 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4735 test_false(local_stat
);
4737 memcached_stat_free(NULL
, NULL
);
4740 return TEST_SUCCESS
;
4743 #define regression_bug_655423_COUNT 6000
4744 test_return_t
regression_bug_655423(memcached_st
*memc
)
4746 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4747 memc
= NULL
; // Just to make sure it is not used
4752 return TEST_SKIPPED
;
4755 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4756 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4757 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4758 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4760 memset(payload
, int('x'), sizeof(payload
));
4762 keys_st
keys(regression_bug_655423_COUNT
);
4764 for (size_t x
= 0; x
< keys
.size(); x
++)
4766 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4769 payload
, sizeof(payload
), 0, 0));
4772 for (size_t x
= 0; x
< keys
.size(); x
++)
4774 size_t value_length
;
4775 memcached_return_t rc
;
4776 char *value
= memcached_get(clone
,
4779 &value_length
, NULL
, &rc
);
4781 if (rc
== MEMCACHED_NOTFOUND
)
4784 test_zero(value_length
);
4788 test_compare(MEMCACHED_SUCCESS
, rc
);
4790 test_compare(100LLU, value_length
);
4794 test_compare(MEMCACHED_SUCCESS
,
4795 memcached_mget(clone
,
4796 keys
.keys_ptr(), keys
.lengths_ptr(),
4800 memcached_result_st
*result
= NULL
;
4801 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4803 test_compare(size_t(100), memcached_result_length(result
));
4807 test_true(count
> 100); // If we don't get back atleast this, something is up
4809 memcached_free(clone
);
4811 return TEST_SUCCESS
;
4815 * Test that ensures that buffered set to not trigger problems during io_flush
4817 #define regression_bug_490520_COUNT 200480
4818 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4820 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4822 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4823 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4824 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4825 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4826 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4828 /* First add all of the items.. */
4829 char blob
[3333] = {0};
4830 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4833 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4835 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4836 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4839 memcached_free(memc
);
4841 return TEST_SUCCESS
;
4844 test_return_t
regression_bug_1251482(memcached_st
*)
4846 test::Memc
memc("--server=localhost:0");
4848 memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 0);
4850 for (size_t x
= 4; x
; --x
)
4852 size_t value_length
;
4853 memcached_return_t rc
;
4854 char *value
= memcached_get(&memc
,
4855 test_literal_param(__func__
),
4856 &value_length
, NULL
, &rc
);
4859 test_compare(0LLU, value_length
);
4860 test_compare(MEMCACHED_CONNECTION_FAILURE
, rc
);
4863 return TEST_SUCCESS
;
4866 test_return_t
regression_1009493_TEST(memcached_st
*)
4868 memcached_st
* memc
= memcached_create(NULL
);
4870 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, true));
4872 memcached_st
* clone
= memcached_clone(NULL
, memc
);
4875 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
),
4876 memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
4878 memcached_free(memc
);
4879 memcached_free(clone
);
4881 return TEST_SUCCESS
;
4884 test_return_t
regression_994772_TEST(memcached_st
* memc
)
4886 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4888 test_compare(MEMCACHED_SUCCESS
,
4890 test_literal_param(__func__
), // Key
4891 test_literal_param(__func__
), // Value
4892 time_t(0), uint32_t(0)));
4894 const char *keys
[] = { __func__
};
4895 size_t key_length
[]= { strlen(__func__
) };
4896 test_compare(MEMCACHED_SUCCESS
,
4897 memcached_mget(memc
, keys
, key_length
, 1));
4899 memcached_return_t rc
;
4900 memcached_result_st
*results
= memcached_fetch_result(memc
, NULL
, &rc
);
4902 test_compare(MEMCACHED_SUCCESS
, rc
);
4904 test_strcmp(__func__
, memcached_result_value(results
));
4905 uint64_t cas_value
= memcached_result_cas(results
);
4906 test_true(cas_value
);
4908 char* take_value
= memcached_result_take_value(results
);
4909 test_strcmp(__func__
, take_value
);
4912 memcached_result_free(results
);
4914 // Bad cas value, sanity check
4915 test_true(cas_value
!= 9999);
4916 test_compare(MEMCACHED_END
,
4918 test_literal_param(__func__
), // Key
4919 test_literal_param(__FILE__
), // Value
4920 time_t(0), uint32_t(0), 9999));
4922 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
4923 "different", strlen("different"), // Key
4924 test_literal_param(__FILE__
), // Value
4925 time_t(0), uint32_t(0)));
4927 return TEST_SUCCESS
;
4930 test_return_t
regression_bug_854604(memcached_st
*)
4934 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4936 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4938 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4939 test_compare(buffer
[0], 0);
4941 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4942 test_true(strlen(buffer
));
4944 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4945 test_true(strlen(buffer
));
4947 return TEST_SUCCESS
;
4950 static void die_message(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4952 fprintf(stderr
, "Iteration #%u: ", it
);
4954 if (error
== MEMCACHED_ERRNO
)
4956 fprintf(stderr
, "system error %d from %s: %s\n",
4957 errno
, what
, strerror(errno
));
4961 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4962 memcached_strerror(mc
, error
));
4966 #define TEST_CONSTANT_CREATION 200
4968 test_return_t
regression_bug_(memcached_st
*memc
)
4970 const char *remote_server
;
4973 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4975 return TEST_SKIPPED
;
4978 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4980 memcached_st
* mc
= memcached_create(NULL
);
4981 memcached_return rc
;
4983 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4984 if (rc
!= MEMCACHED_SUCCESS
)
4986 die_message(mc
, rc
, "memcached_behavior_set", x
);
4989 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4990 if (rc
!= MEMCACHED_SUCCESS
)
4992 die_message(mc
, rc
, "memcached_behavior_set", x
);
4995 rc
= memcached_server_add(mc
, remote_server
, 0);
4996 if (rc
!= MEMCACHED_SUCCESS
)
4998 die_message(mc
, rc
, "memcached_server_add", x
);
5001 const char *set_key
= "akey";
5002 const size_t set_key_len
= strlen(set_key
);
5003 const char *set_value
= "a value";
5004 const size_t set_value_len
= strlen(set_value
);
5006 if (rc
== MEMCACHED_SUCCESS
)
5010 size_t get_value_len
;
5012 uint32_t get_value_flags
;
5014 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5015 &get_value_flags
, &rc
);
5016 if (rc
!= MEMCACHED_SUCCESS
)
5018 die_message(mc
, rc
, "memcached_get", x
);
5024 (get_value_len
!= set_value_len
5025 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5027 fprintf(stderr
, "Values don't match?\n");
5028 rc
= MEMCACHED_FAILURE
;
5034 rc
= memcached_set(mc
,
5035 set_key
, set_key_len
,
5036 set_value
, set_value_len
,
5040 if (rc
!= MEMCACHED_SUCCESS
)
5042 die_message(mc
, rc
, "memcached_set", x
);
5049 if (rc
!= MEMCACHED_SUCCESS
)
5055 return TEST_SUCCESS
;
5058 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
5060 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
5063 const memcached_instance_st
* instance
= memcached_server_instance_by_position(memc
, 0);
5066 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
5067 memcached_server_port(instance
), NULL
)) > -1);
5070 test_compare(MEMCACHED_SUCCESS
,
5072 test_literal_param(__func__
), // Keys
5073 test_literal_param(__func__
), // Values
5075 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
5077 memcached_return_t ret
= memcached_set(memc
,
5078 test_literal_param(__func__
), // Keys
5079 test_literal_param(__func__
), // Values
5081 test_compare(ret
, memc
);
5082 test_compare(MEMCACHED_CONNECTION_FAILURE
, memc
);
5084 memcached_free(memc
);
5086 return TEST_SUCCESS
;