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 memcached_server_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 memcached_server_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 memcached_server_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 memcached_server_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 memcached_server_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 memcached_server_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()
997 /* All keys are valid in the binary protocol (except for length) */
998 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == false)
1000 uint64_t before_query_id
= memcached_query_id(memc_clone
);
1002 size_t string_length
;
1003 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1004 &string_length
, &flags
, &rc
);
1005 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1006 test_zero(string_length
);
1009 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
1011 query_id
= memcached_query_id(memc_clone
);
1012 test_compare(MEMCACHED_SUCCESS
,
1013 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
1014 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
1016 size_t string_length
;
1017 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1018 &string_length
, &flags
, &rc
);
1019 test_compare(MEMCACHED_NOTFOUND
, rc
);
1020 test_zero(string_length
);
1024 /* Test multi key for bad keys */
1025 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
1026 size_t key_lengths
[] = { 7, 7, 7 };
1027 query_id
= memcached_query_id(memc_clone
);
1028 test_compare(MEMCACHED_SUCCESS
,
1029 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1030 test_compare(query_id
, memcached_query_id(memc_clone
));
1032 query_id
= memcached_query_id(memc_clone
);
1033 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
1034 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
1035 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1037 query_id
= memcached_query_id(memc_clone
);
1038 // Grouping keys are not required to follow normal key behaviors
1039 test_compare(MEMCACHED_SUCCESS
,
1040 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
1041 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1043 /* The following test should be moved to the end of this function when the
1044 memcached server is updated to allow max size length of the keys in the
1047 test_compare(MEMCACHED_SUCCESS
,
1048 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
1050 libtest::vchar_t longkey
;
1052 libtest::vchar_t::iterator it
= longkey
.begin();
1053 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
1056 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
1058 size_t string_length
;
1060 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
1061 test_compare(MEMCACHED_NOTFOUND
, rc
);
1062 test_zero(string_length
);
1064 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
1065 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1066 test_zero(string_length
);
1070 /* Make sure zero length keys are marked as bad */
1072 test_compare(MEMCACHED_SUCCESS
,
1073 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1074 size_t string_length
;
1075 char *string
= memcached_get(memc_clone
, key
, 0,
1076 &string_length
, &flags
, &rc
);
1077 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1078 test_zero(string_length
);
1082 memcached_free(memc_clone
);
1084 return TEST_SUCCESS
;
1087 #define READ_THROUGH_VALUE "set for me"
1088 static memcached_return_t
read_through_trigger(memcached_st
*, // memc
1090 size_t, // key_length,
1091 memcached_result_st
*result
)
1093 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
1096 #ifndef __INTEL_COMPILER
1097 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1100 test_return_t
read_through(memcached_st
*memc
)
1102 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1104 size_t string_length
;
1106 memcached_return_t rc
;
1107 char *string
= memcached_get(memc
,
1108 test_literal_param(__func__
),
1109 &string_length
, &flags
, &rc
);
1111 test_compare(MEMCACHED_NOTFOUND
, rc
);
1112 test_false(string_length
);
1115 test_compare(MEMCACHED_SUCCESS
,
1116 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1118 string
= memcached_get(memc
,
1119 test_literal_param(__func__
),
1120 &string_length
, &flags
, &rc
);
1122 test_compare(MEMCACHED_SUCCESS
, rc
);
1123 test_compare(sizeof(READ_THROUGH_VALUE
) -1, string_length
);
1124 test_compare(0, string
[sizeof(READ_THROUGH_VALUE
) -1]);
1125 test_strcmp(READ_THROUGH_VALUE
, string
);
1128 string
= memcached_get(memc
,
1129 test_literal_param(__func__
),
1130 &string_length
, &flags
, &rc
);
1132 test_compare(MEMCACHED_SUCCESS
, rc
);
1134 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1135 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1136 test_strcmp(READ_THROUGH_VALUE
, string
);
1139 return TEST_SUCCESS
;
1142 test_return_t
set_test2(memcached_st
*memc
)
1144 for (uint32_t x
= 0; x
< 10; x
++)
1146 test_compare(return_value_based_on_buffering(memc
),
1148 test_literal_param("foo"),
1149 test_literal_param("train in the brain"),
1150 time_t(0), uint32_t(0)));
1153 return TEST_SUCCESS
;
1156 test_return_t
set_test3(memcached_st
*memc
)
1158 size_t value_length
= 8191;
1160 libtest::vchar_t value
;
1161 value
.reserve(value_length
);
1162 for (uint32_t x
= 0; x
< value_length
; x
++)
1164 value
.push_back(char(x
% 127));
1167 /* The dump test relies on there being at least 32 items in memcached */
1168 for (uint32_t x
= 0; x
< 32; x
++)
1172 snprintf(key
, sizeof(key
), "foo%u", x
);
1174 uint64_t query_id
= memcached_query_id(memc
);
1175 test_compare(return_value_based_on_buffering(memc
),
1176 memcached_set(memc
, key
, strlen(key
),
1177 &value
[0], value
.size(),
1178 time_t(0), uint32_t(0)));
1179 test_compare(query_id
+1, memcached_query_id(memc
));
1182 return TEST_SUCCESS
;
1185 test_return_t
mget_end(memcached_st
*memc
)
1187 const char *keys
[]= { "foo", "foo2" };
1188 size_t lengths
[]= { 3, 4 };
1189 const char *values
[]= { "fjord", "41" };
1192 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1194 test_compare(MEMCACHED_SUCCESS
,
1196 keys
[x
], lengths
[x
],
1197 values
[x
], strlen(values
[x
]),
1198 time_t(0), uint32_t(0)));
1202 size_t string_length
;
1205 // retrieve both via mget
1206 test_compare(MEMCACHED_SUCCESS
,
1207 memcached_mget(memc
,
1209 test_array_length(keys
)));
1211 char key
[MEMCACHED_MAX_KEY
];
1213 memcached_return_t rc
;
1215 // this should get both
1216 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1218 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1220 test_compare(MEMCACHED_SUCCESS
, rc
);
1222 if (key_length
== 4)
1227 test_compare(string_length
, strlen(values
[val
]));
1228 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1232 // this should indicate end
1233 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1234 test_compare(MEMCACHED_END
, rc
);
1238 test_compare(MEMCACHED_SUCCESS
,
1239 memcached_mget(memc
, keys
, lengths
, 1));
1241 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1242 test_compare(key_length
, lengths
[0]);
1243 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1244 test_compare(string_length
, strlen(values
[0]));
1245 test_true(strncmp(values
[0], string
, string_length
) == 0);
1246 test_compare(MEMCACHED_SUCCESS
, rc
);
1249 // this should indicate end
1250 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1251 test_compare(MEMCACHED_END
, rc
);
1254 return TEST_SUCCESS
;
1257 /* Do not copy the style of this code, I just access hosts to testthis function */
1258 test_return_t
stats_servername_test(memcached_st
*memc
)
1260 memcached_stat_st memc_stat
;
1261 memcached_server_instance_st instance
=
1262 memcached_server_instance_by_position(memc
, 0);
1264 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1266 return TEST_SKIPPED
;
1269 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1270 memcached_server_name(instance
),
1271 memcached_server_port(instance
)));
1273 return TEST_SUCCESS
;
1276 test_return_t
increment_test(memcached_st
*memc
)
1278 uint64_t new_number
;
1280 test_compare(MEMCACHED_SUCCESS
,
1282 test_literal_param("number"),
1283 test_literal_param("0"),
1284 (time_t)0, (uint32_t)0));
1286 test_compare(MEMCACHED_SUCCESS
,
1287 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1288 test_compare(uint64_t(1), new_number
);
1290 test_compare(MEMCACHED_SUCCESS
,
1291 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1292 test_compare(uint64_t(2), new_number
);
1294 return TEST_SUCCESS
;
1297 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1299 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1301 uint64_t new_number
;
1302 uint64_t initial
= 0;
1304 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
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));
1314 return TEST_SUCCESS
;
1317 test_return_t
decrement_test(memcached_st
*memc
)
1319 test_compare(return_value_based_on_buffering(memc
),
1321 test_literal_param(__func__
),
1322 test_literal_param("3"),
1323 time_t(0), uint32_t(0)));
1325 // Make sure we flush the value we just set
1326 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1328 uint64_t new_number
;
1329 test_compare(MEMCACHED_SUCCESS
,
1330 memcached_decrement(memc
,
1331 test_literal_param(__func__
),
1333 test_compare(uint64_t(2), new_number
);
1335 test_compare(MEMCACHED_SUCCESS
,
1336 memcached_decrement(memc
,
1337 test_literal_param(__func__
),
1339 test_compare(uint64_t(1), new_number
);
1341 return TEST_SUCCESS
;
1344 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1346 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1348 uint64_t initial
= 3;
1350 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1352 uint64_t new_number
;
1353 test_compare(MEMCACHED_SUCCESS
,
1354 memcached_decrement_with_initial(memc
,
1355 test_literal_param(__func__
),
1358 test_compare(new_number
, initial
);
1360 test_compare(MEMCACHED_SUCCESS
,
1361 memcached_decrement_with_initial(memc
,
1362 test_literal_param(__func__
),
1365 test_compare(new_number
, (initial
- 1));
1367 return TEST_SUCCESS
;
1370 test_return_t
increment_by_key_test(memcached_st
*memc
)
1372 const char *master_key
= "foo";
1373 const char *key
= "number";
1374 const char *value
= "0";
1376 test_compare(return_value_based_on_buffering(memc
),
1377 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1379 value
, strlen(value
),
1380 time_t(0), uint32_t(0)));
1382 // Make sure we flush the value we just set
1383 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1385 uint64_t new_number
;
1386 test_compare(MEMCACHED_SUCCESS
,
1387 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1388 key
, strlen(key
), 1, &new_number
));
1389 test_compare(uint64_t(1), new_number
);
1391 test_compare(MEMCACHED_SUCCESS
,
1392 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1393 key
, strlen(key
), 1, &new_number
));
1394 test_compare(uint64_t(2), new_number
);
1396 return TEST_SUCCESS
;
1399 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1401 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1403 uint64_t new_number
;
1404 const char *master_key
= "foo";
1405 const char *key
= "number";
1406 uint64_t initial
= 0;
1408 test_compare(MEMCACHED_SUCCESS
,
1409 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1411 1, initial
, 0, &new_number
));
1412 test_compare(new_number
, initial
);
1414 test_compare(MEMCACHED_SUCCESS
,
1415 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1417 1, initial
, 0, &new_number
));
1418 test_compare(new_number
, (initial
+1));
1420 return TEST_SUCCESS
;
1423 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1425 uint64_t new_number
;
1426 const char *value
= "3";
1428 test_compare(return_value_based_on_buffering(memc
),
1429 memcached_set_by_key(memc
,
1430 test_literal_param("foo"),
1431 test_literal_param("number"),
1432 value
, strlen(value
),
1433 (time_t)0, (uint32_t)0));
1435 test_compare(MEMCACHED_SUCCESS
,
1436 memcached_decrement_by_key(memc
,
1437 test_literal_param("foo"),
1438 test_literal_param("number"),
1440 test_compare(uint64_t(2), new_number
);
1442 test_compare(MEMCACHED_SUCCESS
,
1443 memcached_decrement_by_key(memc
,
1444 test_literal_param("foo"),
1445 test_literal_param("number"),
1447 test_compare(uint64_t(1), new_number
);
1449 return TEST_SUCCESS
;
1452 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1454 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1456 uint64_t new_number
;
1457 uint64_t initial
= 3;
1459 test_compare(MEMCACHED_SUCCESS
,
1460 memcached_decrement_with_initial_by_key(memc
,
1461 test_literal_param("foo"),
1462 test_literal_param("number"),
1463 1, initial
, 0, &new_number
));
1464 test_compare(new_number
, initial
);
1466 test_compare(MEMCACHED_SUCCESS
,
1467 memcached_decrement_with_initial_by_key(memc
,
1468 test_literal_param("foo"),
1469 test_literal_param("number"),
1470 1, initial
, 0, &new_number
));
1471 test_compare(new_number
, (initial
- 1));
1473 return TEST_SUCCESS
;
1475 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1477 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1479 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1481 test_compare(return_value_based_on_buffering(memc
),
1483 test_literal_param("number"),
1484 test_literal_param("0"),
1485 (time_t)0, (uint32_t)0));
1487 uint64_t new_number
;
1488 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1489 test_literal_param("number"),
1491 test_compare(uint64_t(1), new_number
);
1493 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1494 test_literal_param("number"),
1496 test_compare(uint64_t(2), new_number
);
1498 return TEST_SUCCESS
;
1501 test_return_t
quit_test(memcached_st
*memc
)
1503 const char *value
= "sanford and sun";
1505 test_compare(return_value_based_on_buffering(memc
),
1507 test_literal_param(__func__
),
1508 value
, strlen(value
),
1509 time_t(10), uint32_t(3)));
1510 memcached_quit(memc
);
1512 test_compare(return_value_based_on_buffering(memc
),
1514 test_literal_param(__func__
),
1515 value
, strlen(value
),
1516 time_t(50), uint32_t(9)));
1518 return TEST_SUCCESS
;
1521 test_return_t
mget_result_test(memcached_st
*memc
)
1523 const char *keys
[]= {"fudge", "son", "food"};
1524 size_t key_length
[]= {5, 3, 4};
1526 memcached_result_st results_obj
;
1527 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1529 test_true(&results_obj
== results
);
1531 /* We need to empty the server before continueing test */
1532 test_compare(MEMCACHED_SUCCESS
,
1533 memcached_flush(memc
, 0));
1535 test_compare(MEMCACHED_SUCCESS
,
1536 memcached_mget(memc
, keys
, key_length
, 3));
1538 memcached_return_t rc
;
1539 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1544 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1545 test_false(results
);
1546 test_compare(MEMCACHED_NOTFOUND
, rc
);
1548 for (uint32_t x
= 0; x
< 3; x
++)
1550 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1551 keys
[x
], key_length
[x
],
1552 (time_t)50, (uint32_t)9);
1553 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1556 test_compare(MEMCACHED_SUCCESS
,
1557 memcached_mget(memc
, keys
, key_length
, 3));
1559 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1562 test_true(&results_obj
== results
);
1563 test_compare(MEMCACHED_SUCCESS
, rc
);
1564 test_memcmp(memcached_result_key_value(results
),
1565 memcached_result_value(results
),
1566 memcached_result_length(results
));
1567 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1570 memcached_result_free(&results_obj
);
1572 return TEST_SUCCESS
;
1575 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1577 const char *keys
[]= {"fudge", "son", "food"};
1578 size_t key_length
[]= {5, 3, 4};
1580 memcached_result_st
*results
;
1582 /* We need to empty the server before continueing test */
1583 test_compare(MEMCACHED_SUCCESS
,
1584 memcached_flush(memc
, 0));
1586 test_compare(MEMCACHED_SUCCESS
,
1587 memcached_mget(memc
, keys
, key_length
, 3));
1589 memcached_return_t rc
;
1590 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1594 test_false(results
);
1595 test_compare(MEMCACHED_NOTFOUND
, rc
);
1597 for (uint32_t x
= 0; x
< 3; x
++)
1599 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1600 keys
[x
], key_length
[x
],
1601 (time_t)50, (uint32_t)9);
1602 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1605 test_compare(MEMCACHED_SUCCESS
,
1606 memcached_mget(memc
, keys
, key_length
, 3));
1609 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1612 test_compare(MEMCACHED_SUCCESS
, rc
);
1613 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1614 test_memcmp(memcached_result_key_value(results
),
1615 memcached_result_value(results
),
1616 memcached_result_length(results
));
1617 memcached_result_free(results
);
1621 return TEST_SUCCESS
;
1624 test_return_t
mget_result_function(memcached_st
*memc
)
1626 const char *keys
[]= {"fudge", "son", "food"};
1627 size_t key_length
[]= {5, 3, 4};
1629 memcached_execute_fn callbacks
[1];
1631 for (uint32_t x
= 0; x
< 3; x
++)
1633 test_compare(return_value_based_on_buffering(memc
),
1634 memcached_set(memc
, keys
[x
], key_length
[x
],
1635 keys
[x
], key_length
[x
],
1636 time_t(50), uint32_t(9)));
1638 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1639 memcached_quit(memc
);
1641 test_compare(MEMCACHED_SUCCESS
,
1642 memcached_mget(memc
, keys
, key_length
, 3));
1644 callbacks
[0]= &callback_counter
;
1647 test_compare(MEMCACHED_SUCCESS
,
1648 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1650 test_compare(size_t(3), counter
);
1652 return TEST_SUCCESS
;
1655 test_return_t
mget_test(memcached_st
*memc
)
1657 const char *keys
[]= {"fudge", "son", "food"};
1658 size_t key_length
[]= {5, 3, 4};
1660 char return_key
[MEMCACHED_MAX_KEY
];
1661 size_t return_key_length
;
1663 size_t return_value_length
;
1665 test_compare(MEMCACHED_SUCCESS
,
1666 memcached_mget(memc
, keys
, key_length
, 3));
1669 memcached_return_t rc
;
1670 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1671 &return_value_length
, &flags
, &rc
)))
1673 test_true(return_value
);
1675 test_false(return_value
);
1676 test_zero(return_value_length
);
1677 test_compare(MEMCACHED_NOTFOUND
, rc
);
1679 for (uint32_t x
= 0; x
< 3; x
++)
1681 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1682 keys
[x
], key_length
[x
],
1683 (time_t)50, (uint32_t)9);
1684 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1686 test_compare(MEMCACHED_SUCCESS
,
1687 memcached_mget(memc
, keys
, key_length
, 3));
1690 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1691 &return_value_length
, &flags
, &rc
)))
1693 test_true(return_value
);
1694 test_compare(MEMCACHED_SUCCESS
, rc
);
1695 if (not memc
->_namespace
)
1697 test_compare(return_key_length
, return_value_length
);
1698 test_memcmp(return_value
, return_key
, return_value_length
);
1704 return TEST_SUCCESS
;
1707 test_return_t
mget_execute(memcached_st
*original_memc
)
1709 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1711 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1714 keys_st
keys(20480);
1716 /* First add all of the items.. */
1717 char blob
[1024] = {0};
1719 for (size_t x
= 0; x
< keys
.size(); ++x
)
1721 uint64_t query_id
= memcached_query_id(memc
);
1722 memcached_return_t rc
= memcached_add(memc
,
1723 keys
.key_at(x
), keys
.length_at(x
),
1726 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1727 test_compare(query_id
+1, memcached_query_id(memc
));
1730 /* Try to get all of them with a large multiget */
1732 memcached_execute_fn callbacks
[]= { &callback_counter
};
1733 test_compare(MEMCACHED_SUCCESS
,
1734 memcached_mget_execute(memc
,
1735 keys
.keys_ptr(), keys
.lengths_ptr(),
1736 keys
.size(), callbacks
, &counter
, 1));
1739 uint64_t query_id
= memcached_query_id(memc
);
1740 test_compare(MEMCACHED_SUCCESS
,
1741 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1742 test_compare(query_id
, memcached_query_id(memc
));
1744 /* Verify that we got all of the items */
1745 test_compare(keys
.size(), counter
);
1748 memcached_free(memc
);
1750 return TEST_SUCCESS
;
1753 test_return_t
MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST(memcached_st
*original_memc
)
1755 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1757 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1760 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 8));
1762 keys_st
keys(20480);
1764 /* First add all of the items.. */
1765 char blob
[1024] = {0};
1767 for (size_t x
= 0; x
< keys
.size(); ++x
)
1769 uint64_t query_id
= memcached_query_id(memc
);
1770 memcached_return_t rc
= memcached_add(memc
,
1771 keys
.key_at(x
), keys
.length_at(x
),
1774 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1775 test_compare(query_id
+1, memcached_query_id(memc
));
1778 /* Try to get all of them with a large multiget */
1780 memcached_execute_fn callbacks
[]= { &callback_counter
};
1781 test_compare(MEMCACHED_SUCCESS
,
1782 memcached_mget_execute(memc
,
1783 keys
.keys_ptr(), keys
.lengths_ptr(),
1784 keys
.size(), callbacks
, &counter
, 1));
1787 uint64_t query_id
= memcached_query_id(memc
);
1788 test_compare(MEMCACHED_SUCCESS
,
1789 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1790 test_compare(query_id
, memcached_query_id(memc
));
1792 /* Verify that we got all of the items */
1793 test_compare(keys
.size(), counter
);
1796 memcached_free(memc
);
1798 return TEST_SUCCESS
;
1801 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1802 static pairs_st
*global_pairs
= NULL
;
1804 test_return_t
key_setup(memcached_st
*memc
)
1806 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1808 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1810 return TEST_SUCCESS
;
1813 test_return_t
key_teardown(memcached_st
*)
1815 pairs_free(global_pairs
);
1818 return TEST_SUCCESS
;
1821 test_return_t
block_add_regression(memcached_st
*memc
)
1823 /* First add all of the items.. */
1824 for (ptrdiff_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1826 libtest::vchar_t blob
;
1827 libtest::vchar::make(blob
, 1024);
1829 memcached_return_t rc
= memcached_add_by_key(memc
,
1830 test_literal_param("bob"),
1831 global_pairs
[x
].key
, global_pairs
[x
].key_length
,
1832 &blob
[0], blob
.size(),
1833 time_t(0), uint32_t(0));
1834 if (rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
)
1836 Error
<< memcached_last_error_message(memc
);
1837 return TEST_SKIPPED
;
1839 test_compare(*memc
, MEMCACHED_SUCCESS
);
1840 test_compare(rc
, MEMCACHED_SUCCESS
);
1843 return TEST_SUCCESS
;
1846 test_return_t
binary_add_regression(memcached_st
*memc
)
1848 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1849 return block_add_regression(memc
);
1852 test_return_t
get_stats_keys(memcached_st
*memc
)
1856 memcached_stat_st memc_stat
;
1857 memcached_return_t rc
;
1859 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1860 test_compare(MEMCACHED_SUCCESS
, rc
);
1861 for (ptr
= stat_list
; *ptr
; ptr
++)
1866 return TEST_SUCCESS
;
1869 test_return_t
version_string_test(memcached_st
*)
1871 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1873 return TEST_SUCCESS
;
1876 test_return_t
get_stats(memcached_st
*memc
)
1878 memcached_return_t rc
;
1880 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1881 test_compare(MEMCACHED_SUCCESS
, rc
);
1882 test_true(memc_stat
);
1884 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1886 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1887 test_compare(MEMCACHED_SUCCESS
, rc
);
1888 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1893 memcached_stat_free(NULL
, memc_stat
);
1895 return TEST_SUCCESS
;
1898 test_return_t
add_host_test(memcached_st
*memc
)
1900 char servername
[]= "0.example.com";
1902 memcached_return_t rc
;
1903 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1904 test_compare(1U, memcached_server_list_count(servers
));
1906 for (unsigned int x
= 2; x
< 20; x
++)
1908 char buffer
[SMALL_STRING_LEN
];
1910 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1911 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1913 test_compare(MEMCACHED_SUCCESS
, rc
);
1914 test_compare(x
, memcached_server_list_count(servers
));
1917 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1918 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1920 memcached_server_list_free(servers
);
1922 return TEST_SUCCESS
;
1925 test_return_t
regression_1048945_TEST(memcached_st
*)
1927 memcached_return status
;
1929 memcached_server_st
* list
= memcached_server_list_append_with_weight(NULL
, "a", 11211, 0, &status
);
1930 test_compare(status
, MEMCACHED_SUCCESS
);
1932 list
= memcached_server_list_append_with_weight(list
, "b", 11211, 0, &status
);
1933 test_compare(status
, MEMCACHED_SUCCESS
);
1935 list
= memcached_server_list_append_with_weight(list
, "c", 11211, 0, &status
);
1936 test_compare(status
, MEMCACHED_SUCCESS
);
1938 memcached_st
* memc
= memcached_create(NULL
);
1940 status
= memcached_server_push(memc
, list
);
1941 memcached_server_list_free(list
);
1942 test_compare(status
, MEMCACHED_SUCCESS
);
1944 memcached_server_instance_st server
= memcached_server_by_key(memc
, test_literal_param(__func__
), &status
);
1946 test_compare(status
, MEMCACHED_SUCCESS
);
1948 memcached_free(memc
);
1950 return TEST_SUCCESS
;
1953 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1955 memcached_return_t rc
;
1957 const char *key
= "not_found";
1958 size_t key_length
= test_literal_param_size("not_found");
1960 test_compare(MEMCACHED_SUCCESS
,
1961 memcached_mget(memc
, &key
, &key_length
, 1));
1963 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1965 test_compare(MEMCACHED_NOTFOUND
, rc
);
1967 memcached_result_free(result
);
1969 return TEST_SUCCESS
;
1972 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1974 return MEMCACHED_SUCCESS
;
1977 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1979 return MEMCACHED_SUCCESS
;
1982 test_return_t
callback_test(memcached_st
*memc
)
1984 /* Test User Data */
1988 memcached_return_t rc
;
1990 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1991 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1992 test_true(*test_ptr
== x
);
1995 /* Test Clone Callback */
1997 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1998 void *clone_cb_ptr
= *(void **)&clone_cb
;
1999 void *temp_function
= NULL
;
2001 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
2002 memcached_return_t rc
;
2003 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2004 test_true(temp_function
== clone_cb_ptr
);
2005 test_compare(MEMCACHED_SUCCESS
, rc
);
2008 /* Test Cleanup Callback */
2010 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2011 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2012 void *temp_function
= NULL
;
2013 memcached_return_t rc
;
2015 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2016 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2017 test_true(temp_function
== cleanup_cb_ptr
);
2020 return TEST_SUCCESS
;
2023 /* We don't test the behavior itself, we test the switches */
2024 test_return_t
behavior_test(memcached_st
*memc
)
2026 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2027 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2029 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2030 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2032 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2033 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2035 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2036 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2038 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2039 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2041 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2042 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2044 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2045 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2047 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2049 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2051 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2052 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2053 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2055 return TEST_SUCCESS
;
2058 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2060 test_compare(MEMCACHED_DEPRECATED
,
2061 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2063 // Platform dependent
2065 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2069 return TEST_SUCCESS
;
2073 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2075 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2076 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2078 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2080 if (memcached_success(rc
))
2089 return TEST_SUCCESS
;
2093 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2095 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2096 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2098 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2100 if (memcached_success(rc
))
2109 return TEST_SUCCESS
;
2112 /* Make sure we behave properly if server list has no values */
2113 test_return_t
user_supplied_bug4(memcached_st
*memc
)
2115 const char *keys
[]= {"fudge", "son", "food"};
2116 size_t key_length
[]= {5, 3, 4};
2118 /* Here we free everything before running a bunch of mget tests */
2119 memcached_servers_reset(memc
);
2122 /* We need to empty the server before continueing test */
2123 test_compare(MEMCACHED_NO_SERVERS
,
2124 memcached_flush(memc
, 0));
2126 test_compare(MEMCACHED_NO_SERVERS
,
2127 memcached_mget(memc
, keys
, key_length
, 3));
2130 unsigned int keys_returned
;
2131 memcached_return_t rc
;
2132 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2133 test_compare(MEMCACHED_NOTFOUND
, rc
);
2134 test_zero(keys_returned
);
2137 for (uint32_t x
= 0; x
< 3; x
++)
2139 test_compare(MEMCACHED_NO_SERVERS
,
2140 memcached_set(memc
, keys
[x
], key_length
[x
],
2141 keys
[x
], key_length
[x
],
2142 (time_t)50, (uint32_t)9));
2145 test_compare(MEMCACHED_NO_SERVERS
,
2146 memcached_mget(memc
, keys
, key_length
, 3));
2150 char return_key
[MEMCACHED_MAX_KEY
];
2151 memcached_return_t rc
;
2152 size_t return_key_length
;
2153 size_t return_value_length
;
2156 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2157 &return_value_length
, &flags
, &rc
)))
2159 test_true(return_value
);
2160 test_compare(MEMCACHED_SUCCESS
, rc
);
2161 test_true(return_key_length
== return_value_length
);
2162 test_memcmp(return_value
, return_key
, return_value_length
);
2168 return TEST_SUCCESS
;
2171 #define VALUE_SIZE_BUG5 1048064
2172 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2174 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2175 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2177 size_t value_length
;
2179 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2181 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2183 insert_data
[x
]= (signed char)rand();
2186 test_compare(MEMCACHED_SUCCESS
,
2187 memcached_flush(memc
, 0));
2189 memcached_return_t rc
;
2190 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2191 test_compare(MEMCACHED_SUCCESS
,
2192 memcached_mget(memc
, keys
, key_length
, 4));
2195 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2196 test_compare(MEMCACHED_NOTFOUND
, rc
);
2199 for (uint32_t x
= 0; x
< 4; x
++)
2201 test_compare(MEMCACHED_SUCCESS
,
2202 memcached_set(memc
, keys
[x
], key_length
[x
],
2203 insert_data
, VALUE_SIZE_BUG5
,
2204 (time_t)0, (uint32_t)0));
2207 for (uint32_t x
= 0; x
< 10; x
++)
2209 value
= memcached_get(memc
, keys
[0], key_length
[0],
2210 &value_length
, &flags
, &rc
);
2211 test_compare(rc
, MEMCACHED_SUCCESS
);
2215 test_compare(MEMCACHED_SUCCESS
,
2216 memcached_mget(memc
, keys
, key_length
, 4));
2218 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2219 test_compare(4U, count
);
2221 delete [] insert_data
;
2223 return TEST_SUCCESS
;
2226 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2228 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2229 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2230 char return_key
[MEMCACHED_MAX_KEY
];
2231 size_t return_key_length
;
2233 size_t value_length
;
2235 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2237 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2239 insert_data
[x
]= (signed char)rand();
2242 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2244 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2246 // We will now confirm that memcached_mget() returns success, but we will
2247 // then check to make sure that no actual keys are returned.
2248 test_compare(MEMCACHED_SUCCESS
,
2249 memcached_mget(memc
, keys
, key_length
, 4));
2251 memcached_return_t rc
;
2253 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2254 &value_length
, &flags
, &rc
)))
2259 test_compare(MEMCACHED_NOTFOUND
, rc
);
2261 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2263 test_compare(MEMCACHED_SUCCESS
,
2264 memcached_set(memc
, keys
[x
], key_length
[x
],
2265 insert_data
, VALUE_SIZE_BUG5
,
2266 (time_t)0, (uint32_t)0));
2268 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2270 for (uint32_t x
= 0; x
< 2; x
++)
2272 value
= memcached_get(memc
, keys
[0], key_length
[0],
2273 &value_length
, &flags
, &rc
);
2277 test_compare(MEMCACHED_SUCCESS
,
2278 memcached_mget(memc
, keys
, key_length
, 4));
2279 /* We test for purge of partial complete fetches */
2280 for (count
= 3; count
; count
--)
2282 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2283 &value_length
, &flags
, &rc
);
2284 test_compare(MEMCACHED_SUCCESS
, rc
);
2285 test_memcmp(value
, insert_data
, value_length
);
2286 test_true(value_length
);
2290 delete [] insert_data
;
2292 return TEST_SUCCESS
;
2295 test_return_t
user_supplied_bug8(memcached_st
*)
2297 memcached_return_t rc
;
2299 memcached_st
*memc_clone
;
2301 memcached_server_st
*servers
;
2302 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";
2304 servers
= memcached_servers_parse(server_list
);
2307 mine
= memcached_create(NULL
);
2308 rc
= memcached_server_push(mine
, servers
);
2309 test_compare(MEMCACHED_SUCCESS
, rc
);
2310 memcached_server_list_free(servers
);
2313 memc_clone
= memcached_clone(NULL
, mine
);
2315 memcached_quit(mine
);
2316 memcached_quit(memc_clone
);
2319 memcached_free(mine
);
2320 memcached_free(memc_clone
);
2322 return TEST_SUCCESS
;
2325 /* Test flag store/retrieve */
2326 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2328 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2329 test_true(insert_data
);
2331 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2333 insert_data
[x
]= (signed char)rand();
2336 memcached_flush(memc
, 0);
2338 const char *keys
= "036790384900";
2339 size_t key_length
= strlen(keys
);
2340 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2341 insert_data
, VALUE_SIZE_BUG5
,
2344 memcached_return_t rc
;
2345 size_t value_length
;
2347 char *value
= memcached_get(memc
, keys
, key_length
,
2348 &value_length
, &flags
, &rc
);
2349 test_compare(245U, flags
);
2353 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2355 char return_key
[MEMCACHED_MAX_KEY
];
2356 size_t return_key_length
;
2358 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2359 &value_length
, &flags
, &rc
);
2360 test_compare(uint32_t(245), flags
);
2363 delete [] insert_data
;
2366 return TEST_SUCCESS
;
2369 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2371 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2372 size_t key_length
[3];
2376 char return_key
[MEMCACHED_MAX_KEY
];
2377 size_t return_key_length
;
2379 size_t return_value_length
;
2382 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2383 key_length
[1]= strlen("fudge&*@#");
2384 key_length
[2]= strlen("for^#@&$not");
2387 for (unsigned int x
= 0; x
< 3; x
++)
2389 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2390 keys
[x
], key_length
[x
],
2391 (time_t)50, (uint32_t)9);
2392 test_compare(MEMCACHED_SUCCESS
, rc
);
2395 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2396 test_compare(MEMCACHED_SUCCESS
, rc
);
2398 /* We need to empty the server before continueing test */
2399 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2400 &return_value_length
, &flags
, &rc
)) != NULL
)
2402 test_true(return_value
);
2406 test_compare(3U, count
);
2408 return TEST_SUCCESS
;
2411 /* We are testing with aggressive timeout to get failures */
2412 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2414 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
2416 size_t value_length
= 512;
2417 unsigned int set
= 1;
2418 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2420 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2421 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2422 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2424 libtest::vchar_t value
;
2425 value
.reserve(value_length
);
2426 for (uint32_t x
= 0; x
< value_length
; x
++)
2428 value
.push_back(char(x
% 127));
2431 for (unsigned int x
= 1; x
<= 100000; ++x
)
2433 memcached_return_t rc
= memcached_set(mclone
,
2434 test_literal_param("foo"),
2435 &value
[0], value
.size(),
2438 test_true((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2439 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
));
2441 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2447 memcached_free(mclone
);
2449 return TEST_SUCCESS
;
2453 We are looking failures in the async protocol
2455 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2457 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2459 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2460 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2461 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2463 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2466 libtest::vchar_t value
;
2468 for (unsigned int x
= 0; x
< 512; x
++)
2470 value
.push_back(char(x
% 127));
2473 for (unsigned int x
= 1; x
<= 100000; ++x
)
2475 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2479 memcached_free(mclone
);
2481 return TEST_SUCCESS
;
2485 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2487 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2489 memcached_return_t rc
;
2491 size_t value_length
;
2493 uint64_t number_value
;
2495 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2496 &value_length
, &flags
, &rc
);
2498 test_compare(MEMCACHED_NOTFOUND
, rc
);
2500 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2503 /* The binary protocol will set the key if it doesn't exist */
2504 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2506 test_compare(MEMCACHED_SUCCESS
, rc
);
2510 test_compare(MEMCACHED_NOTFOUND
, rc
);
2513 test_compare(MEMCACHED_SUCCESS
,
2514 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2516 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2520 test_compare(MEMCACHED_SUCCESS
,
2521 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2522 test_compare(2UL, number_value
);
2524 return TEST_SUCCESS
;
2528 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2529 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2531 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2533 char key
[] = "key34567890";
2535 char commandFirst
[]= "set key34567890 0 0 ";
2536 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2537 size_t commandLength
;
2539 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2541 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2543 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2545 char *overflow
= new (std::nothrow
) char[testSize
];
2546 test_true(overflow
);
2548 memset(overflow
, 'x', testSize
);
2549 test_compare(MEMCACHED_SUCCESS
,
2550 memcached_set(memc
, key
, strlen(key
),
2551 overflow
, testSize
, 0, 0));
2555 return TEST_SUCCESS
;
2560 Test values of many different sizes
2561 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2562 set key34567890 0 0 8169 \r\n
2563 is sent followed by buffer of size 8169, followed by 8169
2565 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2567 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2569 libtest::vchar_t value
;
2570 value
.reserve(18000);
2571 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2573 value
.push_back((char) (x
% 127));
2576 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2578 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2579 &value
[0], current_length
,
2580 (time_t)0, (uint32_t)0);
2581 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2583 size_t string_length
;
2585 char *string
= memcached_get(memc
, test_literal_param("foo"),
2586 &string_length
, &flags
, &rc
);
2588 test_compare(MEMCACHED_SUCCESS
, rc
);
2589 test_compare(string_length
, current_length
);
2591 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2592 test_memcmp(string
, &value
[0], string_length
);
2597 return TEST_SUCCESS
;
2601 Look for zero length value problems
2603 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2605 for (uint32_t x
= 0; x
< 2; x
++)
2607 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2609 (time_t)0, (uint32_t)0);
2611 test_compare(MEMCACHED_SUCCESS
, rc
);
2615 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2616 &length
, &flags
, &rc
);
2618 test_compare(MEMCACHED_SUCCESS
, rc
);
2623 value
= memcached_get(memc
, test_literal_param("mykey"),
2624 &length
, &flags
, &rc
);
2626 test_compare(MEMCACHED_SUCCESS
, rc
);
2632 return TEST_SUCCESS
;
2635 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2636 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2638 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2640 (time_t)0, UINT32_MAX
));
2645 memcached_return_t rc
;
2646 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2647 &length
, &flags
, &rc
);
2649 test_compare(MEMCACHED_SUCCESS
, rc
);
2652 test_compare(flags
, UINT32_MAX
);
2654 return TEST_SUCCESS
;
2657 #if !defined(__sun) && !defined(__OpenBSD__)
2658 /* Check the validity of chinese key*/
2659 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2661 const char *key
= "豆瓣";
2662 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2663 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2664 value
, strlen(value
),
2667 test_compare(MEMCACHED_SUCCESS
, rc
);
2671 char *value2
= memcached_get(memc
, key
, strlen(key
),
2672 &length
, &flags
, &rc
);
2674 test_compare(length
, strlen(value
));
2675 test_compare(MEMCACHED_SUCCESS
, rc
);
2676 test_memcmp(value
, value2
, length
);
2679 return TEST_SUCCESS
;
2687 test_return_t
user_supplied_bug19(memcached_st
*)
2689 memcached_return_t res
;
2691 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2693 memcached_server_instance_st server
= memcached_server_by_key(memc
, "a", 1, &res
);
2696 memcached_free(memc
);
2698 return TEST_SUCCESS
;
2701 /* CAS test from Andei */
2702 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2704 const char *key
= "abc";
2705 size_t key_len
= strlen("abc");
2707 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2709 test_compare(MEMCACHED_SUCCESS
,
2711 test_literal_param("abc"),
2712 test_literal_param("foobar"),
2713 (time_t)0, (uint32_t)0));
2715 test_compare(MEMCACHED_SUCCESS
,
2716 memcached_mget(memc
, &key
, &key_len
, 1));
2718 memcached_result_st result_obj
;
2719 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2722 memcached_result_create(memc
, &result_obj
);
2723 memcached_return_t status
;
2724 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2727 test_compare(MEMCACHED_SUCCESS
, status
);
2729 memcached_result_free(result
);
2731 return TEST_SUCCESS
;
2734 /* Large mget() of missing keys with binary proto
2736 * If many binary quiet commands (such as getq's in an mget) fill the output
2737 * buffer and the server chooses not to respond, memcached_flush hangs. See
2738 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2741 /* sighandler_t function that always asserts false */
2742 static __attribute__((noreturn
)) void fail(int)
2748 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2753 return TEST_SKIPPED
;
2755 void (*oldalarm
)(int);
2757 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2758 test_true(memc_clone
);
2760 /* only binproto uses getq for mget */
2761 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2763 /* empty the cache to ensure misses (hence non-responses) */
2764 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2766 keys_st
keys(key_count
);
2768 oldalarm
= signal(SIGALRM
, fail
);
2771 test_compare_got(MEMCACHED_SUCCESS
,
2772 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2773 memcached_last_error_message(memc_clone
));
2776 signal(SIGALRM
, oldalarm
);
2778 memcached_return_t rc
;
2780 char return_key
[MEMCACHED_MAX_KEY
];
2781 size_t return_key_length
;
2783 size_t return_value_length
;
2784 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2785 &return_value_length
, &flags
, &rc
)))
2787 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2789 test_compare(MEMCACHED_NOTFOUND
, rc
);
2790 test_zero(return_value_length
);
2791 test_zero(return_key_length
);
2792 test_false(return_key
[0]);
2793 test_false(return_value
);
2795 memcached_free(memc_clone
);
2797 return TEST_SUCCESS
;
2801 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2803 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2805 /* should work as of r580 */
2806 test_compare(TEST_SUCCESS
,
2807 _user_supplied_bug21(memc
, 10));
2809 /* should fail as of r580 */
2810 test_compare(TEST_SUCCESS
,
2811 _user_supplied_bug21(memc
, 1000));
2813 return TEST_SUCCESS
;
2816 test_return_t
ketama_TEST(memcached_st
*)
2818 test::Memc
memc("--server=10.0.1.1:11211 --server=10.0.1.2:11211");
2820 test_compare(MEMCACHED_SUCCESS
,
2821 memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2823 test_compare(memcached_behavior_get(&memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
), uint64_t(1));
2825 test_compare(memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
), MEMCACHED_SUCCESS
);
2827 test_compare(memcached_behavior_get(&memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
), MEMCACHED_HASH_MD5
);
2829 test_compare(memcached_behavior_set_distribution(&memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
), MEMCACHED_SUCCESS
);
2832 return TEST_SUCCESS
;
2835 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2837 memcached_st
*memc
= memcached_create(NULL
);
2841 test_compare(MEMCACHED_SUCCESS
,
2842 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2844 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2845 test_compare(value
, uint64_t(1));
2847 test_compare(MEMCACHED_SUCCESS
,
2848 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2850 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2851 test_true(value
== MEMCACHED_HASH_MD5
);
2854 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2856 memcached_server_st
*server_pool
;
2857 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");
2858 memcached_server_push(memc
, server_pool
);
2860 // @todo this needs to be refactored to actually test something.
2863 if ((fp
= fopen("ketama_keys.txt", "w")))
2867 printf("cannot write to file ketama_keys.txt");
2868 return TEST_FAILURE
;
2871 for (int x
= 0; x
< 10000; x
++)
2874 snprintf(key
, sizeof(key
), "%d", x
);
2876 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2877 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2878 in_port_t port
= memc
->hosts
[server_idx
].port
;
2879 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2880 memcached_server_instance_st instance
=
2881 memcached_server_instance_by_position(memc
, host_index
);
2885 memcached_server_list_free(server_pool
);
2886 memcached_free(memc
);
2888 return TEST_SUCCESS
;
2892 test_return_t
result_static(memcached_st
*memc
)
2894 memcached_result_st result
;
2895 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
2896 test_false(result
.options
.is_allocated
);
2897 test_true(memcached_is_initialized(&result
));
2898 test_true(result_ptr
);
2899 test_true(result_ptr
== &result
);
2901 memcached_result_free(&result
);
2903 test_false(result
.options
.is_allocated
);
2904 test_false(memcached_is_initialized(&result
));
2906 return TEST_SUCCESS
;
2909 test_return_t
result_alloc(memcached_st
*memc
)
2911 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
2912 test_true(result_ptr
);
2913 test_true(result_ptr
->options
.is_allocated
);
2914 test_true(memcached_is_initialized(result_ptr
));
2915 memcached_result_free(result_ptr
);
2917 return TEST_SUCCESS
;
2921 test_return_t
add_host_test1(memcached_st
*memc
)
2923 memcached_return_t rc
;
2924 char servername
[]= "0.example.com";
2926 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2928 test_compare(1U, memcached_server_list_count(servers
));
2930 for (uint32_t x
= 2; x
< 20; x
++)
2932 char buffer
[SMALL_STRING_LEN
];
2934 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
2935 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2937 test_compare(MEMCACHED_SUCCESS
, rc
);
2938 test_compare(x
, memcached_server_list_count(servers
));
2941 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2942 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2944 memcached_server_list_free(servers
);
2946 return TEST_SUCCESS
;
2950 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
2954 #ifdef HARD_MALLOC_TESTS
2955 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
2963 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
2967 #ifdef HARD_MALLOC_TESTS
2968 void *ret
= malloc(size
+ 8);
2971 ret
= (void*)((caddr_t
)ret
+ 8);
2974 void *ret
= malloc(size
);
2979 memset(ret
, 0xff, size
);
2986 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
2988 #ifdef HARD_MALLOC_TESTS
2989 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
2990 void *nmem
= realloc(real_ptr
, size
+ 8);
2995 ret
= (void*)((caddr_t
)nmem
+ 8);
3001 return realloc(mem
, size
);
3006 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3008 #ifdef HARD_MALLOC_TESTS
3009 void *mem
= my_malloc(ptr
, nelem
* size
);
3012 memset(mem
, 0, nelem
* size
);
3018 return calloc(nelem
, size
);
3022 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3024 memcached_return_t rc
;
3025 const char *key
= "mine";
3028 /* Make sure be default none exists */
3029 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3031 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3033 /* Test a clean set */
3034 test_compare(MEMCACHED_SUCCESS
,
3035 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3037 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3039 test_memcmp(value
, key
, 4);
3040 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3042 /* Test that we can turn it off */
3043 test_compare(MEMCACHED_SUCCESS
,
3044 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3046 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3048 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3050 /* Now setup for main test */
3051 test_compare(MEMCACHED_SUCCESS
,
3052 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3054 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3056 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3057 test_memcmp(value
, key
, 4);
3059 /* Set to Zero, and then Set to something too large */
3062 memset(long_key
, 0, 255);
3064 test_compare(MEMCACHED_SUCCESS
,
3065 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3067 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3069 test_compare(MEMCACHED_SUCCESS
, rc
);
3071 /* Test a long key for failure */
3072 /* TODO, extend test to determine based on setting, what result should be */
3073 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3074 test_compare(MEMCACHED_SUCCESS
,
3075 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3077 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3078 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3079 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3080 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3082 /* Test for a bad prefix, but with a short key */
3083 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3084 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3086 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3087 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3090 return TEST_SUCCESS
;
3093 test_return_t
set_namespace(memcached_st
*memc
)
3095 memcached_return_t rc
;
3096 const char *key
= "mine";
3099 // Make sure we default to a null namespace
3100 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3102 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3104 /* Test a clean set */
3105 test_compare(MEMCACHED_SUCCESS
,
3106 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3108 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3110 test_memcmp(value
, key
, 4);
3111 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3113 return TEST_SUCCESS
;
3116 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3118 test_return_if(pre_binary(memc
));
3119 test_return_if(set_namespace(memc
));
3121 return TEST_SUCCESS
;
3124 #ifdef MEMCACHED_ENABLE_DEPRECATED
3125 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3127 void *test_ptr
= NULL
;
3130 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
3131 cb_ptr
= *(void **)&malloc_cb
;
3132 memcached_return_t rc
;
3134 test_compare(MEMCACHED_SUCCESS
,
3135 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3136 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3137 test_compare(MEMCACHED_SUCCESS
, rc
);
3138 test_true(test_ptr
== cb_ptr
);
3142 memcached_realloc_fn realloc_cb
=
3143 (memcached_realloc_fn
)my_realloc
;
3144 cb_ptr
= *(void **)&realloc_cb
;
3145 memcached_return_t rc
;
3147 test_compare(MEMCACHED_SUCCESS
,
3148 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3149 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3150 test_compare(MEMCACHED_SUCCESS
, rc
);
3151 test_true(test_ptr
== cb_ptr
);
3155 memcached_free_fn free_cb
=
3156 (memcached_free_fn
)my_free
;
3157 cb_ptr
= *(void **)&free_cb
;
3158 memcached_return_t rc
;
3160 test_compare(MEMCACHED_SUCCESS
,
3161 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3162 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3163 test_compare(MEMCACHED_SUCCESS
, rc
);
3164 test_true(test_ptr
== cb_ptr
);
3167 return TEST_SUCCESS
;
3172 test_return_t
set_memory_alloc(memcached_st
*memc
)
3174 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3175 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3176 my_realloc
, my_calloc
, NULL
));
3178 test_compare(MEMCACHED_SUCCESS
,
3179 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3180 my_realloc
, my_calloc
, NULL
));
3182 memcached_malloc_fn mem_malloc
;
3183 memcached_free_fn mem_free
;
3184 memcached_realloc_fn mem_realloc
;
3185 memcached_calloc_fn mem_calloc
;
3186 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3187 &mem_realloc
, &mem_calloc
);
3189 test_true(mem_malloc
== my_malloc
);
3190 test_true(mem_realloc
== my_realloc
);
3191 test_true(mem_calloc
== my_calloc
);
3192 test_true(mem_free
== my_free
);
3194 return TEST_SUCCESS
;
3197 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3199 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
));
3200 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3203 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3208 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3210 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_CRC
)
3212 return TEST_SKIPPED
;
3215 return TEST_SUCCESS
;
3218 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3221 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
);
3222 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3227 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3229 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_HSIEH
)
3231 return TEST_SKIPPED
;
3234 return TEST_SUCCESS
;
3237 test_return_t
enable_cas(memcached_st
*memc
)
3239 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3241 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true);
3243 return TEST_SUCCESS
;
3246 return TEST_SKIPPED
;
3249 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3251 memcached_version(memc
);
3253 memcached_server_instance_st instance
=
3254 memcached_server_instance_by_position(memc
, 0);
3256 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3257 or instance
->minor_version
> 2)
3259 return TEST_SUCCESS
;
3262 return TEST_SKIPPED
;
3265 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3267 const uint64_t timeout
= 100; // Not using, just checking that it sets
3269 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3271 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3273 return TEST_SUCCESS
;
3276 test_return_t
noreply_test(memcached_st
*memc
)
3278 test_compare(MEMCACHED_SUCCESS
,
3279 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3280 test_compare(MEMCACHED_SUCCESS
,
3281 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3282 test_compare(MEMCACHED_SUCCESS
,
3283 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3284 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3285 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3286 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3288 memcached_return_t ret
;
3289 for (int count
= 0; count
< 5; ++count
)
3291 for (size_t x
= 0; x
< 100; ++x
)
3293 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3294 int check_length
= snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3295 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3297 size_t len
= (size_t)check_length
;
3302 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3305 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3308 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3311 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3314 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3320 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3321 memcached_strerror(NULL
, ret
));
3325 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3326 ** API and is _ONLY_ done this way to verify that the library works the
3327 ** way it is supposed to do!!!!
3331 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3333 memcached_server_instance_st instance
=
3334 memcached_server_instance_by_position(memc
, x
);
3335 no_msg
+=(int)(instance
->cursor_active
);
3338 test_true(no_msg
== 0);
3340 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3343 ** Now validate that all items was set properly!
3345 for (size_t x
= 0; x
< 100; ++x
)
3349 int check_length
= snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3351 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3353 size_t len
= (size_t)check_length
;
3356 char* value
=memcached_get(memc
, key
, strlen(key
),
3357 &length
, &flags
, &ret
);
3358 // For the moment we will just go to the next key
3359 if (MEMCACHED_TIMEOUT
== ret
)
3363 test_true(ret
== MEMCACHED_SUCCESS
and value
!= NULL
);
3366 case 0: /* FALLTHROUGH */
3367 case 1: /* FALLTHROUGH */
3369 test_true(strncmp(value
, key
, len
) == 0);
3370 test_true(len
== length
);
3373 test_true(length
== len
* 2);
3376 test_true(length
== len
* 3);
3386 /* Try setting an illegal cas value (should not return an error to
3387 * the caller (because we don't expect a return message from the server)
3389 const char* keys
[]= {"0"};
3390 size_t lengths
[]= {1};
3393 memcached_result_st results_obj
;
3394 memcached_result_st
*results
;
3395 test_compare(MEMCACHED_SUCCESS
,
3396 memcached_mget(memc
, keys
, lengths
, 1));
3398 results
= memcached_result_create(memc
, &results_obj
);
3400 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3402 test_compare(MEMCACHED_SUCCESS
, ret
);
3403 uint64_t cas
= memcached_result_cas(results
);
3404 memcached_result_free(&results_obj
);
3406 test_compare(MEMCACHED_SUCCESS
,
3407 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3410 * The item will have a new cas value, so try to set it again with the old
3411 * value. This should fail!
3413 test_compare(MEMCACHED_SUCCESS
,
3414 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3415 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3416 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3417 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3420 return TEST_SUCCESS
;
3423 test_return_t
analyzer_test(memcached_st
*memc
)
3425 memcached_analysis_st
*report
;
3426 memcached_return_t rc
;
3428 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3429 test_compare(MEMCACHED_SUCCESS
, rc
);
3430 test_true(memc_stat
);
3432 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3433 test_compare(MEMCACHED_SUCCESS
, rc
);
3437 memcached_stat_free(NULL
, memc_stat
);
3439 return TEST_SUCCESS
;
3442 test_return_t
util_version_test(memcached_st
*memc
)
3444 test_compare(memcached_version(memc
), MEMCACHED_SUCCESS
);
3445 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3447 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3449 // We expect failure
3452 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3453 fprintf(stderr
, "\nDumping Server Information\n\n");
3454 memcached_server_fn callbacks
[1];
3456 callbacks
[0]= dump_server_information
;
3457 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3458 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3460 test_true(if_successful
== false);
3462 memcached_server_instance_st instance
=
3463 memcached_server_instance_by_position(memc
, 0);
3465 memcached_version(memc
);
3467 // We only use one binary when we test, so this should be just fine.
3468 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3469 test_true(if_successful
== true);
3471 if (instance
->micro_version
> 0)
3473 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3475 else if (instance
->minor_version
> 0)
3477 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3479 else if (instance
->major_version
> 0)
3481 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3484 test_true(if_successful
== true);
3486 if (instance
->micro_version
> 0)
3488 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3490 else if (instance
->minor_version
> 0)
3492 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3494 else if (instance
->major_version
> 0)
3496 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3499 test_true(if_successful
== false);
3501 return TEST_SUCCESS
;
3504 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3506 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3507 memcached_return_t rc
;
3508 memcached_server_instance_st instance
=
3509 memcached_server_instance_by_position(memc
, 0);
3511 // Test both the version that returns a code, and the one that does not.
3512 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3513 memcached_server_port(instance
) -1, NULL
) == -1);
3515 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3516 memcached_server_port(instance
) -1, &rc
) == -1);
3517 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3519 return TEST_SUCCESS
;
3523 test_return_t
getpid_test(memcached_st
*memc
)
3525 memcached_return_t rc
;
3526 memcached_server_instance_st instance
=
3527 memcached_server_instance_by_position(memc
, 0);
3529 // Test both the version that returns a code, and the one that does not.
3530 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3531 memcached_server_port(instance
), NULL
) > -1);
3533 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3534 memcached_server_port(instance
), &rc
) > -1);
3535 test_compare(MEMCACHED_SUCCESS
, rc
);
3537 return TEST_SUCCESS
;
3540 static memcached_return_t
ping_each_server(const memcached_st
*,
3541 memcached_server_instance_st instance
,
3544 // Test both the version that returns a code, and the one that does not.
3545 memcached_return_t rc
;
3546 if (libmemcached_util_ping(memcached_server_name(instance
),
3547 memcached_server_port(instance
), &rc
) == false)
3549 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d %s", memcached_server_name(instance
),
3550 memcached_server_port(instance
), memcached_strerror(NULL
, rc
));
3553 if (libmemcached_util_ping(memcached_server_name(instance
),
3554 memcached_server_port(instance
), NULL
) == false)
3556 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d", memcached_server_name(instance
), memcached_server_port(instance
));
3559 return MEMCACHED_SUCCESS
;
3562 test_return_t
libmemcached_util_ping_TEST(memcached_st
*memc
)
3564 memcached_server_fn callbacks
[1]= { ping_each_server
};
3565 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
3567 return TEST_SUCCESS
;
3572 test_return_t
hash_sanity_test (memcached_st
*memc
)
3576 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3577 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3578 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3579 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3580 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3581 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3582 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3583 #ifdef HAVE_HSIEH_HASH
3584 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3586 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3587 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3588 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3590 return TEST_SUCCESS
;
3594 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3596 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3598 test_compare(MEMCACHED_SUCCESS
,
3599 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3600 (uint64_t)MEMCACHED_HASH_HSIEH
));
3602 return TEST_SUCCESS
;
3605 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3607 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3609 test_compare(MEMCACHED_SUCCESS
,
3610 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3612 return TEST_SUCCESS
;
3615 test_return_t
one_at_a_time_run (memcached_st
*)
3620 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3622 test_compare(one_at_a_time_values
[x
],
3623 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3626 return TEST_SUCCESS
;
3629 test_return_t
md5_run (memcached_st
*)
3634 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3636 test_compare(md5_values
[x
],
3637 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3640 return TEST_SUCCESS
;
3643 test_return_t
crc_run (memcached_st
*)
3648 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3650 test_compare(crc_values
[x
],
3651 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3654 return TEST_SUCCESS
;
3657 test_return_t
fnv1_64_run (memcached_st
*)
3659 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3664 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3666 test_compare(fnv1_64_values
[x
],
3667 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3670 return TEST_SUCCESS
;
3673 test_return_t
fnv1a_64_run (memcached_st
*)
3675 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3680 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3682 test_compare(fnv1a_64_values
[x
],
3683 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3686 return TEST_SUCCESS
;
3689 test_return_t
fnv1_32_run (memcached_st
*)
3694 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3696 test_compare(fnv1_32_values
[x
],
3697 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3700 return TEST_SUCCESS
;
3703 test_return_t
fnv1a_32_run (memcached_st
*)
3708 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3710 test_compare(fnv1a_32_values
[x
],
3711 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3714 return TEST_SUCCESS
;
3717 test_return_t
hsieh_run (memcached_st
*)
3719 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3724 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3726 test_compare(hsieh_values
[x
],
3727 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3730 return TEST_SUCCESS
;
3733 test_return_t
murmur_run (memcached_st
*)
3735 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3737 #ifdef WORDS_BIGENDIAN
3738 (void)murmur_values
;
3739 return TEST_SKIPPED
;
3744 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3746 test_compare(murmur_values
[x
],
3747 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3750 return TEST_SUCCESS
;
3754 test_return_t
murmur3_TEST(hashkit_st
*)
3756 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR3
));
3758 #ifdef WORDS_BIGENDIAN
3759 (void)murmur3_values
;
3760 return TEST_SKIPPED
;
3765 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3767 test_compare(murmur3_values
[x
],
3768 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR3
));
3771 return TEST_SUCCESS
;
3775 test_return_t
jenkins_run (memcached_st
*)
3780 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3782 test_compare(jenkins_values
[x
],
3783 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3786 return TEST_SUCCESS
;
3789 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3791 return libhashkit_md5(string
, string_length
);
3794 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3796 return libhashkit_crc32(string
, string_length
);
3799 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3805 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3807 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};
3808 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};
3810 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3812 hashkit_clone(&new_kit
, kit
);
3813 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3815 memcached_set_hashkit(memc
, &new_kit
);
3818 Verify Setting the hash.
3820 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3824 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3825 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3830 Now check memcached_st.
3832 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3836 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3837 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3840 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3842 memcached_set_hashkit(memc
, &new_kit
);
3845 Verify Setting the hash.
3847 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3851 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3852 test_true(crc_values
[x
] == hash_val
);
3855 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3859 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3860 test_compare(crc_hosts
[x
], hash_val
);
3863 memcached_free(memc
);
3865 return TEST_SUCCESS
;
3869 Test case adapted from John Gorman <johngorman2@gmail.com>
3871 We are testing the error condition when we connect to a server via memcached_get()
3872 but find that the server is not available.
3874 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3878 memcached_return rc
;
3881 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3883 // See if memcached is reachable.
3884 char *value
= memcached_get(tl_memc_h
,
3885 test_literal_param(__func__
),
3890 test_true(memcached_failed(rc
));
3892 memcached_free(tl_memc_h
);
3894 return TEST_SUCCESS
;
3898 We connect to a server which exists, but search for a key that does not exist.
3900 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3904 memcached_return rc
;
3906 // See if memcached is reachable.
3907 char *value
= memcached_get(memc
,
3908 test_literal_param(__func__
),
3913 test_compare(MEMCACHED_NOTFOUND
, rc
);
3915 return TEST_SUCCESS
;
3919 Test case adapted from John Gorman <johngorman2@gmail.com>
3921 We are testing the error condition when we connect to a server via memcached_get_by_key()
3922 but find that the server is not available.
3924 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
3928 memcached_return rc
;
3931 memcached_st
*tl_memc_h
= memcached_create(NULL
);
3932 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
3933 memcached_server_push(tl_memc_h
, servers
);
3934 memcached_server_list_free(servers
);
3936 // See if memcached is reachable.
3937 char *value
= memcached_get_by_key(tl_memc_h
,
3938 test_literal_param(__func__
), // Key
3939 test_literal_param(__func__
), // Value
3944 test_true(memcached_failed(rc
));
3946 memcached_free(tl_memc_h
);
3948 return TEST_SUCCESS
;
3952 We connect to a server which exists, but search for a key that does not exist.
3954 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3958 memcached_return rc
;
3960 // See if memcached is reachable.
3961 char *value
= memcached_get_by_key(memc
,
3962 test_literal_param(__func__
), // Key
3963 test_literal_param(__func__
), // Value
3968 test_compare(MEMCACHED_NOTFOUND
, rc
);
3970 return TEST_SUCCESS
;
3973 test_return_t
regression_bug_434484(memcached_st
*memc
)
3975 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3977 test_compare(MEMCACHED_NOTSTORED
,
3978 memcached_append(memc
,
3979 test_literal_param(__func__
), // Key
3980 test_literal_param(__func__
), // Value
3983 libtest::vchar_t data
;
3984 data
.resize(2048 * 1024);
3985 test_compare(MEMCACHED_E2BIG
,
3987 test_literal_param(__func__
), // Key
3988 &data
[0], data
.size(), 0, 0));
3990 return TEST_SUCCESS
;
3993 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
3995 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
3997 memcached_return_t rc
;
3999 memcached_execute_fn callbacks
[]= { &callback_counter
};
4002 * I only want to hit only _one_ server so I know the number of requests I'm
4003 * sending in the pipleine to the server. Let's try to do a multiget of
4004 * 1024 (that should satisfy most users don't you think?). Future versions
4005 * will include a mget_execute function call if you need a higher number.
4007 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4012 * Run two times.. the first time we should have 100% cache miss,
4013 * and the second time we should have 100% cache hits
4015 for (ptrdiff_t y
= 0; y
< 2; y
++)
4017 test_compare(MEMCACHED_SUCCESS
,
4018 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4020 // One the first run we should get a NOT_FOUND, but on the second some data
4021 // should be returned.
4022 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4023 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4027 /* The first iteration should give me a 100% cache miss. verify that*/
4028 char blob
[1024]= { 0 };
4030 test_false(counter
);
4032 for (size_t x
= 0; x
< keys
.size(); ++x
)
4034 rc
= memcached_add(memc
,
4035 keys
.key_at(x
), keys
.length_at(x
),
4036 blob
, sizeof(blob
), 0, 0);
4037 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4042 /* Verify that we received all of the key/value pairs */
4043 test_compare(counter
, keys
.size());
4047 memcached_free(memc
);
4049 return TEST_SUCCESS
;
4052 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4054 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
4056 return regression_bug_434843(memc
);
4059 test_return_t
regression_bug_421108(memcached_st
*memc
)
4061 memcached_return_t rc
;
4062 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4063 test_compare(MEMCACHED_SUCCESS
, rc
);
4065 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4066 test_compare(MEMCACHED_SUCCESS
, rc
);
4067 test_true(bytes_str
);
4068 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4070 test_compare(MEMCACHED_SUCCESS
, rc
);
4071 test_true(bytes_read_str
);
4073 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4074 "bytes_written", &rc
);
4075 test_compare(MEMCACHED_SUCCESS
, rc
);
4076 test_true(bytes_written_str
);
4078 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4079 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4080 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4082 test_true(bytes
!= bytes_read
);
4083 test_true(bytes
!= bytes_written
);
4085 /* Release allocated resources */
4087 free(bytes_read_str
);
4088 free(bytes_written_str
);
4089 memcached_stat_free(NULL
, memc_stat
);
4091 return TEST_SUCCESS
;
4095 * The test case isn't obvious so I should probably document why
4096 * it works the way it does. Bug 442914 was caused by a bug
4097 * in the logic in memcached_purge (it did not handle the case
4098 * where the number of bytes sent was equal to the watermark).
4099 * In this test case, create messages so that we hit that case
4100 * and then disable noreply mode and issue a new command to
4101 * verify that it isn't stuck. If we change the format for the
4102 * delete command or the watermarks, we need to update this
4105 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
4107 test_skip(original_memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
4109 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
4111 for (uint32_t x
= 0; x
< 250; ++x
)
4114 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
4115 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4116 char error_buffer
[2048]= { 0 };
4117 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
4118 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
4121 // Delete, and then delete again to look for not found
4124 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
4125 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4126 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4128 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
4129 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
4132 memcached_free(memc
);
4134 return TEST_SUCCESS
;
4137 test_return_t
regression_bug_447342(memcached_st
*memc
)
4139 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4141 return TEST_SKIPPED
;
4144 test_compare(MEMCACHED_SUCCESS
,
4145 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4149 for (size_t x
= 0; x
< keys
.size(); ++x
)
4151 test_compare(MEMCACHED_SUCCESS
,
4153 keys
.key_at(x
), keys
.length_at(x
), // Keys
4154 keys
.key_at(x
), keys
.length_at(x
), // Values
4159 ** We are using the quiet commands to store the replicas, so we need
4160 ** to ensure that all of them are processed before we can continue.
4161 ** In the test we go directly from storing the object to trying to
4162 ** receive the object from all of the different servers, so we
4163 ** could end up in a race condition (the memcached server hasn't yet
4164 ** processed the quiet command from the replication set when it process
4165 ** the request from the other client (created by the clone)). As a
4166 ** workaround for that we call memcached_quit to send the quit command
4167 ** to the server and wait for the response ;-) If you use the test code
4168 ** as an example for your own code, please note that you shouldn't need
4171 memcached_quit(memc
);
4173 /* Verify that all messages are stored, and we didn't stuff too much
4176 test_compare(MEMCACHED_SUCCESS
,
4177 memcached_mget(memc
,
4178 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4180 unsigned int counter
= 0;
4181 memcached_execute_fn callbacks
[]= { &callback_counter
};
4182 test_compare(MEMCACHED_SUCCESS
,
4183 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4185 /* Verify that we received all of the key/value pairs */
4186 test_compare(counter
, keys
.size());
4188 memcached_quit(memc
);
4190 * Don't do the following in your code. I am abusing the internal details
4191 * within the library, and this is not a supported interface.
4192 * This is to verify correct behavior in the library. Fake that two servers
4195 memcached_server_instance_st instance_one
= memcached_server_instance_by_position(memc
, 0);
4196 memcached_server_instance_st instance_two
= memcached_server_instance_by_position(memc
, 2);
4197 in_port_t port0
= instance_one
->port();
4198 in_port_t port2
= instance_two
->port();
4200 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4201 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4203 test_compare(MEMCACHED_SUCCESS
,
4204 memcached_mget(memc
,
4205 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4208 test_compare(MEMCACHED_SUCCESS
,
4209 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4210 test_compare(counter
, keys
.size());
4212 /* restore the memc handle */
4213 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4214 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4216 memcached_quit(memc
);
4218 /* Remove half of the objects */
4219 for (size_t x
= 0; x
< keys
.size(); ++x
)
4223 test_compare(MEMCACHED_SUCCESS
,
4224 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4228 memcached_quit(memc
);
4229 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4230 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4232 /* now retry the command, this time we should have cache misses */
4233 test_compare(MEMCACHED_SUCCESS
,
4234 memcached_mget(memc
,
4235 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4238 test_compare(MEMCACHED_SUCCESS
,
4239 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4240 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4242 /* restore the memc handle */
4243 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4244 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4246 return TEST_SUCCESS
;
4249 test_return_t
regression_bug_463297(memcached_st
*memc
)
4251 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4253 // Since we blocked timed delete, this test is no longer valid.
4255 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4256 test_true(memc_clone
);
4257 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4259 memcached_server_instance_st instance
=
4260 memcached_server_instance_by_position(memc_clone
, 0);
4262 if (instance
->major_version
> 1 ||
4263 (instance
->major_version
== 1 &&
4264 instance
->minor_version
> 2))
4266 /* Binary protocol doesn't support deferred delete */
4267 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4268 test_true(bin_clone
);
4269 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4270 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4271 memcached_free(bin_clone
);
4273 memcached_quit(memc_clone
);
4275 /* If we know the server version, deferred delete should fail
4276 * with invalid arguments */
4277 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4279 /* If we don't know the server version, we should get a protocol error */
4280 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4282 /* but there is a bug in some of the memcached servers (1.4) that treats
4283 * the counter as noreply so it doesn't send the proper error message
4285 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4287 /* And buffered mode should be disabled and we should get protocol error */
4288 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4289 rc
= memcached_delete(memc
, "foo", 3, 1);
4290 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4292 /* Same goes for noreply... */
4293 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4294 rc
= memcached_delete(memc
, "foo", 3, 1);
4295 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4297 /* but a normal request should go through (and be buffered) */
4298 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4299 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4301 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4302 /* unbuffered noreply should be success */
4303 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4304 /* unbuffered with reply should be not found... */
4305 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4306 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4309 memcached_free(memc_clone
);
4312 return TEST_SUCCESS
;
4316 /* Test memcached_server_get_last_disconnect
4317 * For a working server set, shall be NULL
4318 * For a set of non existing server, shall not be NULL
4320 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4322 memcached_return_t rc
;
4323 memcached_server_instance_st disconnected_server
;
4325 /* With the working set of server */
4326 const char *key
= "marmotte";
4327 const char *value
= "milka";
4329 memcached_reset_last_disconnected_server(memc
);
4330 test_false(memc
->last_disconnected_server
);
4331 rc
= memcached_set(memc
, key
, strlen(key
),
4332 value
, strlen(value
),
4333 (time_t)0, (uint32_t)0);
4334 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4336 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4337 test_false(disconnected_server
);
4339 /* With a non existing server */
4341 memcached_server_st
*servers
;
4343 const char *server_list
= "localhost:9";
4345 servers
= memcached_servers_parse(server_list
);
4347 mine
= memcached_create(NULL
);
4348 rc
= memcached_server_push(mine
, servers
);
4349 test_compare(MEMCACHED_SUCCESS
, rc
);
4350 memcached_server_list_free(servers
);
4353 rc
= memcached_set(mine
, key
, strlen(key
),
4354 value
, strlen(value
),
4355 (time_t)0, (uint32_t)0);
4356 test_true(memcached_failed(rc
));
4358 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4359 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4360 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4361 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4363 memcached_quit(mine
);
4364 memcached_free(mine
);
4366 return TEST_SUCCESS
;
4369 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4371 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4372 char buffer
[BUFSIZ
];
4374 test_compare(MEMCACHED_SUCCESS
,
4375 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4377 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4380 // We will just use the error strings as our keys
4381 uint32_t counter
= 100;
4384 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4386 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4387 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4388 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4390 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
4391 test_true(disconnected_server
);
4392 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4393 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4397 memcached_reset_last_disconnected_server(memc
);
4402 memcached_free(memc
);
4404 return TEST_SUCCESS
;
4407 test_return_t
test_verbosity(memcached_st
*memc
)
4409 memcached_verbosity(memc
, 3);
4411 return TEST_SUCCESS
;
4415 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
4416 const char *key
, size_t key_length
,
4417 const char *value
, size_t value_length
,
4427 return MEMCACHED_SUCCESS
;
4430 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4432 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4433 test_compare(MEMCACHED_SUCCESS
, rc
);
4435 test_compare(MEMCACHED_SUCCESS
,
4436 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4438 test_compare(MEMCACHED_SUCCESS
,
4439 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4441 test_compare(MEMCACHED_SUCCESS
,
4442 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4444 return TEST_SUCCESS
;
4448 * This test ensures that the failure counter isn't incremented during
4449 * normal termination of the memcached instance.
4451 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4453 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4455 /* Ensure that we are connected to the server by setting a value */
4456 memcached_return_t rc
= memcached_set(memc
,
4457 test_literal_param(__func__
), // Key
4458 test_literal_param(__func__
), // Value
4459 time_t(0), uint32_t(0));
4460 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4463 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4465 /* The test is to see that the memcached_quit doesn't increase the
4466 * the server failure conter, so let's ensure that it is zero
4467 * before sending quit
4469 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4471 memcached_quit(memc
);
4473 /* Verify that it memcached_quit didn't increment the failure counter
4474 * Please note that this isn't bullet proof, because an error could
4477 test_zero(instance
->server_failure_counter
);
4479 memcached_free(memc
);
4481 return TEST_SUCCESS
;
4485 * This tests ensures expected disconnections (for some behavior changes
4486 * for instance) do not wrongly increase failure counter
4488 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4490 /* Set value to force connection to the server */
4491 const char *key
= "marmotte";
4492 const char *value
= "milka";
4494 test_compare_hint(MEMCACHED_SUCCESS
,
4495 memcached_set(memc
, key
, strlen(key
),
4496 value
, strlen(value
),
4497 (time_t)0, (uint32_t)0),
4498 memcached_last_error_message(memc
));
4501 /* put failure limit to 1 */
4502 test_compare(MEMCACHED_SUCCESS
,
4503 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4505 /* Put a retry timeout to effectively activate failure_limit effect */
4506 test_compare(MEMCACHED_SUCCESS
,
4507 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4509 /* change behavior that triggers memcached_quit()*/
4510 test_compare(MEMCACHED_SUCCESS
,
4511 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4514 /* Check if we still are connected */
4516 size_t string_length
;
4517 memcached_return rc
;
4518 char *string
= memcached_get(memc
, key
, strlen(key
),
4519 &string_length
, &flags
, &rc
);
4521 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4525 return TEST_SUCCESS
;
4528 test_return_t
regression_996813_TEST(memcached_st
*)
4530 memcached_st
* memc
= memcached_create(NULL
);
4532 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
4533 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
4534 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4535 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4536 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1));
4537 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 300));
4538 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 30));
4540 // We will never connect to these servers
4541 in_port_t base_port
= 11211;
4542 for (size_t x
= 0; x
< 17; x
++)
4544 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", base_port
+x
));
4546 test_compare(6U, memcached_generate_hash(memc
, test_literal_param("SZ6hu0SHweFmpwpc0w2R")));
4547 test_compare(1U, memcached_generate_hash(memc
, test_literal_param("SQCK9eiCf53YxHWnYA.o")));
4548 test_compare(9U, memcached_generate_hash(memc
, test_literal_param("SUSDkGXuuZC9t9VhMwa.")));
4549 test_compare(0U, memcached_generate_hash(memc
, test_literal_param("SnnqnJARfaCNT679iAF_")));
4551 memcached_free(memc
);
4553 return TEST_SUCCESS
;
4558 * Test that ensures mget_execute does not end into recursive calls that finally fails
4560 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4564 return TEST_SKIPPED
; // My MAC can't handle this test
4567 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4570 * I only want to hit _one_ server so I know the number of requests I'm
4571 * sending in the pipeline.
4573 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4576 keys_st
keys(20480);
4578 /* First add all of the items.. */
4579 char blob
[1024]= { 0 };
4580 for (size_t x
= 0; x
< keys
.size(); ++x
)
4582 memcached_return rc
= memcached_set(memc
,
4583 keys
.key_at(x
), keys
.length_at(x
),
4584 blob
, sizeof(blob
), 0, 0);
4585 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4590 /* Try to get all of them with a large multiget */
4592 memcached_execute_function callbacks
[]= { &callback_counter
};
4593 memcached_return_t rc
= memcached_mget_execute(memc
,
4594 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4595 callbacks
, &counter
, 1);
4596 test_compare(MEMCACHED_SUCCESS
, rc
);
4598 char* the_value
= NULL
;
4599 char the_key
[MEMCACHED_MAX_KEY
];
4600 size_t the_key_length
;
4601 size_t the_value_length
;
4605 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4607 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4613 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4616 test_compare(MEMCACHED_END
, rc
);
4618 /* Verify that we got all of the items */
4619 test_compare(counter
, keys
.size());
4622 memcached_free(memc
);
4624 return TEST_SUCCESS
;
4627 test_return_t
regression_1021819_TEST(memcached_st
*original
)
4629 memcached_st
*memc
= memcached_clone(NULL
, original
);
4632 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 2000000), MEMCACHED_SUCCESS
);
4633 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 3000000), MEMCACHED_SUCCESS
);
4635 memcached_return_t rc
;
4638 test_literal_param(__func__
),
4641 test_compare(rc
, MEMCACHED_NOTFOUND
);
4643 memcached_free(memc
);
4645 return TEST_SUCCESS
;
4648 test_return_t
regression_bug_583031(memcached_st
*)
4650 memcached_st
*memc
= memcached_create(NULL
);
4652 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.251.4", 11211));
4654 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 3000);
4655 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4656 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4657 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4658 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4659 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4661 memcached_return_t rc
;
4665 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4669 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_error(memc
));
4671 memcached_free(memc
);
4673 return TEST_SUCCESS
;
4676 test_return_t
regression_bug_581030(memcached_st
*)
4679 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4680 test_false(local_stat
);
4682 memcached_stat_free(NULL
, NULL
);
4685 return TEST_SUCCESS
;
4688 #define regression_bug_655423_COUNT 6000
4689 test_return_t
regression_bug_655423(memcached_st
*memc
)
4691 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4692 memc
= NULL
; // Just to make sure it is not used
4697 return TEST_SKIPPED
;
4700 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4701 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4702 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4703 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4705 memset(payload
, int('x'), sizeof(payload
));
4707 keys_st
keys(regression_bug_655423_COUNT
);
4709 for (size_t x
= 0; x
< keys
.size(); x
++)
4711 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4714 payload
, sizeof(payload
), 0, 0));
4717 for (size_t x
= 0; x
< keys
.size(); x
++)
4719 size_t value_length
;
4720 memcached_return_t rc
;
4721 char *value
= memcached_get(clone
,
4724 &value_length
, NULL
, &rc
);
4726 if (rc
== MEMCACHED_NOTFOUND
)
4729 test_zero(value_length
);
4733 test_compare(MEMCACHED_SUCCESS
, rc
);
4735 test_compare(100LLU, value_length
);
4739 test_compare(MEMCACHED_SUCCESS
,
4740 memcached_mget(clone
,
4741 keys
.keys_ptr(), keys
.lengths_ptr(),
4745 memcached_result_st
*result
= NULL
;
4746 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4748 test_compare(size_t(100), memcached_result_length(result
));
4752 test_true(count
> 100); // If we don't get back atleast this, something is up
4754 memcached_free(clone
);
4756 return TEST_SUCCESS
;
4760 * Test that ensures that buffered set to not trigger problems during io_flush
4762 #define regression_bug_490520_COUNT 200480
4763 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4765 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4767 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4768 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4769 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4770 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4771 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4773 /* First add all of the items.. */
4774 char blob
[3333] = {0};
4775 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4778 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4780 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4781 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4784 memcached_free(memc
);
4786 return TEST_SUCCESS
;
4789 test_return_t
regression_1009493_TEST(memcached_st
*)
4791 memcached_st
* memc
= memcached_create(NULL
);
4793 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, true));
4795 memcached_st
* clone
= memcached_clone(NULL
, memc
);
4798 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
),
4799 memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
4801 memcached_free(memc
);
4802 memcached_free(clone
);
4804 return TEST_SUCCESS
;
4807 test_return_t
regression_994772_TEST(memcached_st
* memc
)
4809 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4811 test_compare(MEMCACHED_SUCCESS
,
4813 test_literal_param(__func__
), // Key
4814 test_literal_param(__func__
), // Value
4815 time_t(0), uint32_t(0)));
4817 const char *keys
[] = { __func__
};
4818 size_t key_length
[]= { strlen(__func__
) };
4819 test_compare(MEMCACHED_SUCCESS
,
4820 memcached_mget(memc
, keys
, key_length
, 1));
4822 memcached_return_t rc
;
4823 memcached_result_st
*results
= memcached_fetch_result(memc
, NULL
, &rc
);
4825 test_compare(MEMCACHED_SUCCESS
, rc
);
4827 test_strcmp(__func__
, memcached_result_value(results
));
4828 uint64_t cas_value
= memcached_result_cas(results
);
4829 test_true(cas_value
);
4831 char* take_value
= memcached_result_take_value(results
);
4832 test_strcmp(__func__
, take_value
);
4835 memcached_result_free(results
);
4837 // Bad cas value, sanity check
4838 test_true(cas_value
!= 9999);
4839 test_compare(MEMCACHED_END
,
4841 test_literal_param(__func__
), // Key
4842 test_literal_param(__FILE__
), // Value
4843 time_t(0), uint32_t(0), 9999));
4845 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
4846 "different", strlen("different"), // Key
4847 test_literal_param(__FILE__
), // Value
4848 time_t(0), uint32_t(0)));
4850 return TEST_SUCCESS
;
4853 test_return_t
regression_bug_854604(memcached_st
*)
4857 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4859 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4861 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4862 test_compare(buffer
[0], 0);
4864 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4865 test_true(strlen(buffer
));
4867 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4868 test_true(strlen(buffer
));
4870 return TEST_SUCCESS
;
4873 static void die_message(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4875 fprintf(stderr
, "Iteration #%u: ", it
);
4877 if (error
== MEMCACHED_ERRNO
)
4879 fprintf(stderr
, "system error %d from %s: %s\n",
4880 errno
, what
, strerror(errno
));
4884 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4885 memcached_strerror(mc
, error
));
4889 #define TEST_CONSTANT_CREATION 200
4891 test_return_t
regression_bug_(memcached_st
*memc
)
4893 const char *remote_server
;
4896 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4898 return TEST_SKIPPED
;
4901 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4903 memcached_st
* mc
= memcached_create(NULL
);
4904 memcached_return rc
;
4906 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4907 if (rc
!= MEMCACHED_SUCCESS
)
4909 die_message(mc
, rc
, "memcached_behavior_set", x
);
4912 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4913 if (rc
!= MEMCACHED_SUCCESS
)
4915 die_message(mc
, rc
, "memcached_behavior_set", x
);
4918 rc
= memcached_server_add(mc
, remote_server
, 0);
4919 if (rc
!= MEMCACHED_SUCCESS
)
4921 die_message(mc
, rc
, "memcached_server_add", x
);
4924 const char *set_key
= "akey";
4925 const size_t set_key_len
= strlen(set_key
);
4926 const char *set_value
= "a value";
4927 const size_t set_value_len
= strlen(set_value
);
4929 if (rc
== MEMCACHED_SUCCESS
)
4933 size_t get_value_len
;
4935 uint32_t get_value_flags
;
4937 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
4938 &get_value_flags
, &rc
);
4939 if (rc
!= MEMCACHED_SUCCESS
)
4941 die_message(mc
, rc
, "memcached_get", x
);
4947 (get_value_len
!= set_value_len
4948 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
4950 fprintf(stderr
, "Values don't match?\n");
4951 rc
= MEMCACHED_FAILURE
;
4957 rc
= memcached_set(mc
,
4958 set_key
, set_key_len
,
4959 set_value
, set_value_len
,
4963 if (rc
!= MEMCACHED_SUCCESS
)
4965 die_message(mc
, rc
, "memcached_set", x
);
4972 if (rc
!= MEMCACHED_SUCCESS
)
4978 return TEST_SUCCESS
;
4981 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
4983 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
4986 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4989 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
4990 memcached_server_port(instance
), NULL
)) > -1);
4993 test_compare(MEMCACHED_SUCCESS
,
4995 test_literal_param(__func__
), // Keys
4996 test_literal_param(__func__
), // Values
4998 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
5000 memcached_return_t ret
= memcached_set(memc
,
5001 test_literal_param(__func__
), // Keys
5002 test_literal_param(__func__
), // Values
5004 test_compare(ret
, MEMCACHED_CONNECTION_FAILURE
);
5006 memcached_free(memc
);
5008 return TEST_SUCCESS
;