1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 #include <mem_config.h>
39 #include <libtest/test.hpp>
41 #if defined(HAVE_LIBUUID) && HAVE_LIBUUID
42 # include <uuid/uuid.h>
49 #include <libmemcached-1.0/memcached.h>
50 #include "libmemcached/is.h"
51 #include "libmemcached/server_instance.h"
53 #include <libhashkit-1.0/hashkit.h>
55 #include <libtest/memcached.hpp>
60 #include <semaphore.h>
64 #include <sys/types.h>
69 #include <libtest/server.h>
71 #include "clients/generator.h"
73 #define SMALL_STRING_LEN 1024
75 #include <libtest/test.hpp>
77 using namespace libtest
;
79 #include <libmemcachedutil-1.0/util.h>
81 #include "tests/hash_results.h"
83 #include "tests/libmemcached-1.0/callback_counter.h"
84 #include "tests/libmemcached-1.0/fetch_all_results.h"
85 #include "tests/libmemcached-1.0/mem_functions.h"
86 #include "tests/libmemcached-1.0/setup_and_teardowns.h"
87 #include "tests/print.h"
88 #include "tests/debug.h"
89 #include "tests/memc.hpp"
91 #define UUID_STRING_MAXLENGTH 36
93 #include "tests/keys.hpp"
95 #include "libmemcached/instance.hpp"
97 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
100 If no options are given, copy over at least the binary flag.
102 char options_buffer
[1024]= { 0 };
105 if (memcached_is_binary(original_memc
))
107 snprintf(options_buffer
, sizeof(options_buffer
), "--BINARY");
112 * I only want to hit _one_ server so I know the number of requests I'm
113 * sending in the pipeline.
115 const memcached_instance_st
* instance
= memcached_server_instance_by_position(original_memc
, 0);
117 char server_string
[1024];
118 int server_string_length
;
119 if (instance
->type
== MEMCACHED_CONNECTION_UNIX_SOCKET
)
123 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\" %s",
124 memcached_server_name(instance
), options
);
128 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\"",
129 memcached_server_name(instance
));
136 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
137 memcached_server_name(instance
), int(memcached_server_port(instance
)),
142 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
143 memcached_server_name(instance
), int(memcached_server_port(instance
)));
147 if (server_string_length
<= 0)
152 char errror_buffer
[1024];
153 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, errror_buffer
, sizeof(errror_buffer
))))
155 Error
<< "Failed to parse (" << server_string
<< ") " << errror_buffer
;
159 return memcached(server_string
, server_string_length
);
163 test_return_t
init_test(memcached_st
*not_used
)
168 (void)memcached_create(&memc
);
169 memcached_free(&memc
);
174 #define TEST_PORT_COUNT 7
175 in_port_t test_ports
[TEST_PORT_COUNT
];
177 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
178 const memcached_instance_st
* server
,
182 size_t bigger
= *((size_t *)(context
));
184 fatal_assert(bigger
<= memcached_server_port(server
));
185 *((size_t *)(context
))= memcached_server_port(server
);
187 return MEMCACHED_SUCCESS
;
190 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
191 const memcached_instance_st
* instance
,
195 FILE *stream
= (FILE *)context
;
198 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
199 memcached_server_name(instance
),
200 memcached_server_port(instance
),
201 instance
->major_version
,
202 instance
->minor_version
,
203 instance
->micro_version
);
205 return MEMCACHED_SUCCESS
;
208 test_return_t
server_sort_test(memcached_st
*ptr
)
210 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
212 memcached_return_t rc
;
213 memcached_server_fn callbacks
[1];
214 memcached_st
*local_memc
;
217 local_memc
= memcached_create(NULL
);
218 test_true(local_memc
);
219 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
221 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
223 test_ports
[x
]= (in_port_t
)random() % 64000;
224 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
225 test_compare(memcached_server_count(local_memc
), x
+1);
227 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
229 test_compare(MEMCACHED_SUCCESS
, rc
);
232 callbacks
[0]= server_display_function
;
233 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
236 memcached_free(local_memc
);
241 test_return_t
server_sort2_test(memcached_st
*ptr
)
243 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
244 memcached_server_fn callbacks
[1];
245 memcached_st
*local_memc
;
246 const memcached_instance_st
* instance
;
249 local_memc
= memcached_create(NULL
);
250 test_true(local_memc
);
251 test_compare(MEMCACHED_SUCCESS
,
252 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
254 test_compare(MEMCACHED_SUCCESS
,
255 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
256 instance
= memcached_server_instance_by_position(local_memc
, 0);
257 test_compare(in_port_t(43043), memcached_server_port(instance
));
259 test_compare(MEMCACHED_SUCCESS
,
260 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
262 instance
= memcached_server_instance_by_position(local_memc
, 0);
263 test_compare(in_port_t(43042), memcached_server_port(instance
));
265 instance
= memcached_server_instance_by_position(local_memc
, 1);
266 test_compare(in_port_t(43043), memcached_server_port(instance
));
268 callbacks
[0]= server_display_function
;
269 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
272 memcached_free(local_memc
);
277 test_return_t
memcached_server_remove_test(memcached_st
*)
279 const char *server_string
= "--server=localhost:4444 --server=localhost:4445 --server=localhost:4446 --server=localhost:4447 --server=localhost --server=memcache1.memcache.bk.sapo.pt:11211 --server=memcache1.memcache.bk.sapo.pt:11212 --server=memcache1.memcache.bk.sapo.pt:11213 --server=memcache1.memcache.bk.sapo.pt:11214 --server=memcache2.memcache.bk.sapo.pt:11211 --server=memcache2.memcache.bk.sapo.pt:11212 --server=memcache2.memcache.bk.sapo.pt:11213 --server=memcache2.memcache.bk.sapo.pt:11214";
282 test_compare(MEMCACHED_SUCCESS
,
283 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
284 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
287 memcached_server_fn callbacks
[1];
288 callbacks
[0]= server_print_callback
;
289 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
291 memcached_free(memc
);
296 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
297 const memcached_instance_st
* server
,
301 uint32_t x
= *((uint32_t *)(context
));
303 if (! (test_ports
[x
] == memcached_server_port(server
)))
305 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)memcached_server_port(server
));
306 return MEMCACHED_FAILURE
;
309 *((uint32_t *)(context
))= ++x
;
311 return MEMCACHED_SUCCESS
;
314 test_return_t
server_unsort_test(memcached_st
*ptr
)
316 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
317 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
318 memcached_server_fn callbacks
[1];
319 memcached_st
*local_memc
;
322 local_memc
= memcached_create(NULL
);
323 test_true(local_memc
);
325 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
327 test_ports
[x
]= (in_port_t
)(random() % 64000);
328 test_compare(MEMCACHED_SUCCESS
,
329 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
330 test_compare(memcached_server_count(local_memc
), x
+1);
332 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
336 callbacks
[0]= server_display_unsort_function
;
337 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
339 /* Now we sort old data! */
340 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
341 callbacks
[0]= server_display_function
;
342 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
345 memcached_free(local_memc
);
350 test_return_t
allocation_test(memcached_st
*not_used
)
354 memc
= memcached_create(NULL
);
356 memcached_free(memc
);
361 test_return_t
clone_test(memcached_st
*memc
)
365 memcached_st
*memc_clone
;
366 memc_clone
= memcached_clone(NULL
, NULL
);
367 test_true(memc_clone
);
368 memcached_free(memc_clone
);
371 /* Can we init from null? */
373 memcached_st
*memc_clone
;
374 memc_clone
= memcached_clone(NULL
, memc
);
375 test_true(memc_clone
);
378 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
379 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
380 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
381 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
384 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
385 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
386 test_true(memc_clone
->distribution
== memc
->distribution
);
387 { // Test all of the flags
388 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
389 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
390 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
391 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
392 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
393 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
394 test_true(memc_clone
->ketama
.weighted_
== memc
->ketama
.weighted_
);
395 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
396 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
397 test_true(memc_clone
->flags
.reply
== memc
->flags
.reply
);
398 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
399 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
400 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
402 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
403 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
404 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
405 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
406 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
407 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
408 test_true(memc_clone
->on_clone
== memc
->on_clone
);
409 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
410 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
411 test_true(memc_clone
->recv_size
== memc
->recv_size
);
412 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
413 test_true(memc_clone
->send_size
== memc
->send_size
);
414 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
415 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
416 test_true(memc_clone
->user_data
== memc
->user_data
);
418 memcached_free(memc_clone
);
421 /* Can we init from struct? */
423 memcached_st declared_clone
;
424 memcached_st
*memc_clone
;
425 memset(&declared_clone
, 0 , sizeof(memcached_st
));
426 memc_clone
= memcached_clone(&declared_clone
, NULL
);
427 test_true(memc_clone
);
428 memcached_free(memc_clone
);
431 /* Can we init from struct? */
433 memcached_st declared_clone
;
434 memcached_st
*memc_clone
;
435 memset(&declared_clone
, 0 , sizeof(memcached_st
));
436 memc_clone
= memcached_clone(&declared_clone
, memc
);
437 test_true(memc_clone
);
438 memcached_free(memc_clone
);
444 test_return_t
userdata_test(memcached_st
*memc
)
447 test_false(memcached_set_user_data(memc
, foo
));
448 test_true(memcached_get_user_data(memc
) == foo
);
449 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
454 test_return_t
connection_test(memcached_st
*memc
)
456 test_compare(MEMCACHED_SUCCESS
,
457 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
462 test_return_t
libmemcached_string_behavior_test(memcached_st
*)
464 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
466 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
468 test_compare(37, int(MEMCACHED_BEHAVIOR_MAX
));
473 test_return_t
libmemcached_string_distribution_test(memcached_st
*)
475 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
477 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
479 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
484 test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
486 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
487 982370485U, 1263635348U, 4242906218U, 3829656100U,
488 1891735253U, 334139633U, 2257084983U, 3351789013U,
489 13199785U, 2542027183U, 1097051614U, 199566778U,
490 2748246961U, 2465192557U, 1664094137U, 2405439045U,
491 1842224848U, 692413798U, 3479807801U, 919913813U,
492 4269430871U, 610793021U, 527273862U, 1437122909U,
493 2300930706U, 2943759320U, 674306647U, 2400528935U,
494 54481931U, 4186304426U, 1741088401U, 2979625118U,
495 4159057246U, 3425930182U, 2593724503U, 1868899624U,
496 1769812374U, 2302537950U, 1110330676U, 3365377466U,
497 1336171666U, 3021258493U, 2334992265U, 3861994737U,
498 3582734124U, 3365377466U };
500 // You have updated the memcache_error messages but not updated docs/tests.
501 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
504 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
505 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
506 MEMCACHED_HASH_JENKINS
);
507 if (values
[rc
] != hash_val
)
509 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
510 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
512 test_compare(values
[rc
], hash_val
);
514 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
519 test_return_t
set_test(memcached_st
*memc
)
521 memcached_return_t rc
= memcached_set(memc
,
522 test_literal_param("foo"),
523 test_literal_param("when we sanitize"),
524 time_t(0), (uint32_t)0);
525 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
530 test_return_t
append_test(memcached_st
*memc
)
532 memcached_return_t rc
;
533 const char *in_value
= "we";
537 test_compare(MEMCACHED_SUCCESS
,
538 memcached_flush(memc
, 0));
540 test_compare(MEMCACHED_SUCCESS
,
542 test_literal_param(__func__
),
543 in_value
, strlen(in_value
),
544 time_t(0), uint32_t(0)));
546 test_compare(MEMCACHED_SUCCESS
,
547 memcached_append(memc
,
548 test_literal_param(__func__
),
549 " the", strlen(" the"),
550 time_t(0), uint32_t(0)));
552 test_compare(MEMCACHED_SUCCESS
,
553 memcached_append(memc
,
554 test_literal_param(__func__
),
555 " people", strlen(" people"),
556 time_t(0), uint32_t(0)));
558 char *out_value
= memcached_get(memc
,
559 test_literal_param(__func__
),
560 &value_length
, &flags
, &rc
);
561 test_memcmp(out_value
, "we the people", strlen("we the people"));
562 test_compare(strlen("we the people"), value_length
);
563 test_compare(MEMCACHED_SUCCESS
, rc
);
569 test_return_t
append_binary_test(memcached_st
*memc
)
571 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
573 test_compare(MEMCACHED_SUCCESS
,
574 memcached_flush(memc
, 0));
576 test_compare(MEMCACHED_SUCCESS
,
578 test_literal_param(__func__
),
580 time_t(0), uint32_t(0)));
583 for (uint32_t x
= 0; store_list
[x
] ; x
++)
585 test_compare(MEMCACHED_SUCCESS
,
586 memcached_append(memc
,
587 test_literal_param(__func__
),
588 (char *)&store_list
[x
], sizeof(uint32_t),
589 time_t(0), uint32_t(0)));
595 memcached_return_t rc
;
596 uint32_t *value
= (uint32_t *)memcached_get(memc
,
597 test_literal_param(__func__
),
598 &value_length
, &flags
, &rc
);
599 test_compare(value_length
, sizeof(uint32_t) * count
);
600 test_compare(MEMCACHED_SUCCESS
, rc
);
602 for (uint32_t counter
= uint32_t(count
), *ptr
= value
; counter
; counter
--)
604 test_compare(*ptr
, store_list
[count
- counter
]);
612 test_return_t
memcached_mget_mixed_memcached_get_TEST(memcached_st
*memc
)
616 for (libtest::vchar_ptr_t::iterator iter
= keys
.begin();
620 test_compare_hint(MEMCACHED_SUCCESS
,
624 time_t(0), uint32_t(0)),
625 memcached_last_error_message(memc
));
628 for (ptrdiff_t loop
= 0; loop
< 20; loop
++)
632 test_compare(MEMCACHED_SUCCESS
,
633 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
635 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
638 size_t result_count
= 0;
639 memcached_return_t rc
;
640 while (memcached_fetch_result(memc
, results
, &rc
))
644 test_true(keys
.size() >= result_count
);
648 int which_key
= random() % int(keys
.size());
651 memcached_return_t rc
;
652 char *out_value
= memcached_get(memc
, keys
.key_at(which_key
), keys
.length_at(which_key
),
653 &value_length
, &flags
, &rc
);
654 if (rc
== MEMCACHED_NOTFOUND
)
655 { } // It is possible that the value has been purged.
658 test_compare(MEMCACHED_SUCCESS
, rc
);
660 test_null(out_value
);
661 test_zero(value_length
);
669 test_return_t
cas2_test(memcached_st
*memc
)
671 const char *keys
[]= {"fudge", "son", "food"};
672 size_t key_length
[]= {5, 3, 4};
673 const char *value
= "we the people";
674 size_t value_length
= strlen("we the people");
676 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
678 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
680 for (uint32_t x
= 0; x
< 3; x
++)
682 test_compare(MEMCACHED_SUCCESS
,
683 memcached_set(memc
, keys
[x
], key_length
[x
],
684 keys
[x
], key_length
[x
],
685 time_t(50), uint32_t(9)));
688 test_compare(MEMCACHED_SUCCESS
,
689 memcached_mget(memc
, keys
, key_length
, 3));
691 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
694 memcached_return_t rc
;
695 results
= memcached_fetch_result(memc
, results
, &rc
);
697 test_true(results
->item_cas
);
698 test_compare(MEMCACHED_SUCCESS
, rc
);
699 test_true(memcached_result_cas(results
));
701 test_memcmp(value
, "we the people", strlen("we the people"));
702 test_compare(strlen("we the people"), value_length
);
703 test_compare(MEMCACHED_SUCCESS
, rc
);
705 memcached_result_free(results
);
710 test_return_t
cas_test(memcached_st
*memc
)
712 const char* keys
[2] = { __func__
, NULL
};
713 size_t keylengths
[2] = { strlen(__func__
), 0 };
715 memcached_result_st results_obj
;
717 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
719 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
721 test_compare(MEMCACHED_SUCCESS
,
723 test_literal_param(__func__
),
724 test_literal_param("we the people"),
725 (time_t)0, (uint32_t)0));
727 test_compare(MEMCACHED_SUCCESS
,
728 memcached_mget(memc
, keys
, keylengths
, 1));
730 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
733 memcached_return_t rc
;
734 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
736 test_compare(MEMCACHED_SUCCESS
, rc
);
737 test_true(memcached_result_cas(results
));
738 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
739 test_compare(test_literal_param_size("we the people"),
740 strlen(memcached_result_value(results
)));
742 uint64_t cas
= memcached_result_cas(results
);
745 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
746 test_true(rc
== MEMCACHED_END
);
747 test_true(results
== NULL
);
750 test_compare(MEMCACHED_SUCCESS
,
752 test_literal_param(__func__
),
753 test_literal_param("change the value"),
757 * The item will have a new cas value, so try to set it again with the old
758 * value. This should fail!
760 test_compare(MEMCACHED_DATA_EXISTS
,
762 test_literal_param(__func__
),
763 test_literal_param("change the value"),
766 memcached_result_free(&results_obj
);
772 test_return_t
prepend_test(memcached_st
*memc
)
774 const char *key
= "fig";
775 const char *value
= "people";
777 test_compare(MEMCACHED_SUCCESS
,
778 memcached_flush(memc
, 0));
780 test_compare(MEMCACHED_SUCCESS
,
781 memcached_set(memc
, key
, strlen(key
),
782 value
, strlen(value
),
783 time_t(0), uint32_t(0)));
785 test_compare(MEMCACHED_SUCCESS
,
786 memcached_prepend(memc
, key
, strlen(key
),
787 "the ", strlen("the "),
788 time_t(0), uint32_t(0)));
790 test_compare(MEMCACHED_SUCCESS
,
791 memcached_prepend(memc
, key
, strlen(key
),
792 "we ", strlen("we "),
793 time_t(0), uint32_t(0)));
797 memcached_return_t rc
;
798 char *out_value
= memcached_get(memc
, key
, strlen(key
),
799 &value_length
, &flags
, &rc
);
800 test_memcmp(out_value
, "we the people", strlen("we the people"));
801 test_compare(strlen("we the people"), value_length
);
802 test_compare(MEMCACHED_SUCCESS
, rc
);
809 Set the value, then quit to make sure it is flushed.
810 Come back in and test that add fails.
812 test_return_t
memcached_add_SUCCESS_TEST(memcached_st
*memc
)
814 memcached_return_t rc
;
815 test_null(memcached_get(memc
, test_literal_param(__func__
), NULL
, NULL
, &rc
));
816 test_compare(MEMCACHED_NOTFOUND
, rc
);
818 test_compare(MEMCACHED_SUCCESS
,
820 test_literal_param(__func__
),
821 test_literal_param("try something else"),
822 time_t(0), uint32_t(0)));
827 test_return_t
regression_1067242_TEST(memcached_st
*memc
)
829 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
830 test_literal_param(__func__
),
831 test_literal_param("-2"),
834 memcached_return_t rc
;
836 test_true((value
= memcached_get(memc
, test_literal_param(__func__
), NULL
, NULL
, &rc
)));
837 test_compare(MEMCACHED_SUCCESS
, rc
);
840 for (size_t x
= 0; x
< 10; x
++)
843 test_compare(MEMCACHED_CLIENT_ERROR
,
844 memcached_increment(memc
,
845 test_literal_param(__func__
), 1, &new_number
));
846 test_compare(MEMCACHED_CLIENT_ERROR
, memcached_last_error(memc
));
847 test_true((value
= memcached_get(memc
, test_literal_param(__func__
), NULL
, NULL
, &rc
)));
848 test_compare(MEMCACHED_SUCCESS
, rc
);
856 Set the value, then quit to make sure it is flushed.
857 Come back in and test that add fails.
859 test_return_t
add_test(memcached_st
*memc
)
861 test_compare(return_value_based_on_buffering(memc
),
863 test_literal_param(__func__
),
864 test_literal_param("when we sanitize"),
865 time_t(0), uint32_t(0)));
867 memcached_quit(memc
);
871 memcached_return_t rc
;
872 char *check_value
= memcached_get(memc
,
873 test_literal_param(__func__
),
874 &value_length
, &flags
, &rc
);
875 test_memcmp(check_value
, "when we sanitize", strlen("when we sanitize"));
876 test_compare(test_literal_param_size("when we sanitize"), value_length
);
877 test_compare(MEMCACHED_SUCCESS
, rc
);
880 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
882 test_literal_param(__func__
),
883 test_literal_param("try something else"),
884 time_t(0), uint32_t(0)));
890 ** There was a problem of leaking filedescriptors in the initial release
891 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
892 ** systems it seems that the kernel is slow on reclaiming the resources
893 ** because the connects starts to time out (the test doesn't do much
894 ** anyway, so just loop 10 iterations)
896 test_return_t
add_wrapper(memcached_st
*memc
)
898 unsigned int max
= 10000;
906 for (uint32_t x
= 0; x
< max
; x
++)
914 test_return_t
replace_test(memcached_st
*memc
)
916 test_compare(return_value_based_on_buffering(memc
),
918 test_literal_param(__func__
),
919 test_literal_param("when we sanitize"),
920 time_t(0), uint32_t(0)));
922 test_compare(MEMCACHED_SUCCESS
,
923 memcached_replace(memc
,
924 test_literal_param(__func__
),
925 test_literal_param("first we insert some data"),
926 time_t(0), uint32_t(0)));
931 test_return_t
delete_test(memcached_st
*memc
)
933 test_compare(return_value_based_on_buffering(memc
),
935 test_literal_param(__func__
),
936 test_literal_param("when we sanitize"),
937 time_t(0), uint32_t(0)));
939 test_compare(return_value_based_on_buffering(memc
),
940 memcached_delete(memc
,
941 test_literal_param(__func__
),
947 test_return_t
flush_test(memcached_st
*memc
)
949 uint64_t query_id
= memcached_query_id(memc
);
950 test_compare(MEMCACHED_SUCCESS
,
951 memcached_flush(memc
, 0));
952 test_compare(query_id
+1, memcached_query_id(memc
));
957 static memcached_return_t
server_function(const memcached_st
*,
958 const memcached_instance_st
*,
962 return MEMCACHED_SUCCESS
;
965 test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
968 strncpy(context
, "foo bad", sizeof(context
));
969 memcached_server_fn callbacks
[1];
971 callbacks
[0]= server_function
;
972 memcached_server_cursor(memc
, callbacks
, context
, 1);
976 test_return_t
bad_key_test(memcached_st
*memc
)
978 memcached_return_t rc
;
979 const char *key
= "foo bad";
982 uint64_t query_id
= memcached_query_id(memc
);
984 // Just skip if we are in binary mode.
985 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
987 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
989 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
990 test_true(memc_clone
);
992 query_id
= memcached_query_id(memc_clone
);
993 test_compare(MEMCACHED_SUCCESS
,
994 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
995 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
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 const memcached_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 static test_return_t
__increment_with_initial_test(memcached_st
*memc
, uint64_t initial
)
1299 uint64_t new_number
;
1301 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1303 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
1305 test_compare(MEMCACHED_SUCCESS
,
1306 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1307 test_compare(new_number
, initial
);
1309 test_compare(MEMCACHED_SUCCESS
,
1310 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1311 test_compare(new_number
, (initial
+1));
1315 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
1316 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1319 return TEST_SUCCESS
;
1322 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1324 return __increment_with_initial_test(memc
, 0);
1327 test_return_t
increment_with_initial_999_test(memcached_st
*memc
)
1329 return __increment_with_initial_test(memc
, 999);
1332 test_return_t
decrement_test(memcached_st
*memc
)
1334 test_compare(return_value_based_on_buffering(memc
),
1336 test_literal_param(__func__
),
1337 test_literal_param("3"),
1338 time_t(0), uint32_t(0)));
1340 // Make sure we flush the value we just set
1341 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1343 uint64_t new_number
;
1344 test_compare(MEMCACHED_SUCCESS
,
1345 memcached_decrement(memc
,
1346 test_literal_param(__func__
),
1348 test_compare(uint64_t(2), new_number
);
1350 test_compare(MEMCACHED_SUCCESS
,
1351 memcached_decrement(memc
,
1352 test_literal_param(__func__
),
1354 test_compare(uint64_t(1), new_number
);
1356 return TEST_SUCCESS
;
1359 static test_return_t
__decrement_with_initial_test(memcached_st
*memc
, uint64_t initial
)
1361 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1363 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1365 uint64_t new_number
;
1366 test_compare(MEMCACHED_SUCCESS
,
1367 memcached_decrement_with_initial(memc
,
1368 test_literal_param(__func__
),
1371 test_compare(new_number
, initial
);
1373 test_compare(MEMCACHED_SUCCESS
,
1374 memcached_decrement_with_initial(memc
,
1375 test_literal_param(__func__
),
1378 test_compare(new_number
, (initial
- 1));
1380 return TEST_SUCCESS
;
1383 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1385 return __decrement_with_initial_test(memc
, 3);
1388 test_return_t
decrement_with_initial_999_test(memcached_st
*memc
)
1390 return __decrement_with_initial_test(memc
, 999);
1393 test_return_t
increment_by_key_test(memcached_st
*memc
)
1395 const char *master_key
= "foo";
1396 const char *key
= "number";
1397 const char *value
= "0";
1399 test_compare(return_value_based_on_buffering(memc
),
1400 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1402 value
, strlen(value
),
1403 time_t(0), uint32_t(0)));
1405 // Make sure we flush the value we just set
1406 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1408 uint64_t new_number
;
1409 test_compare(MEMCACHED_SUCCESS
,
1410 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1411 key
, strlen(key
), 1, &new_number
));
1412 test_compare(uint64_t(1), new_number
);
1414 test_compare(MEMCACHED_SUCCESS
,
1415 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1416 key
, strlen(key
), 1, &new_number
));
1417 test_compare(uint64_t(2), new_number
);
1419 return TEST_SUCCESS
;
1422 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1424 uint64_t new_number
;
1425 const char *master_key
= "foo";
1426 const char *key
= "number";
1427 uint64_t initial
= 0;
1429 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
1431 test_compare(MEMCACHED_SUCCESS
,
1432 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1434 1, initial
, 0, &new_number
));
1435 test_compare(new_number
, initial
);
1437 test_compare(MEMCACHED_SUCCESS
,
1438 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1440 1, initial
, 0, &new_number
));
1441 test_compare(new_number
, (initial
+1));
1445 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
1446 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1448 1, initial
, 0, &new_number
));
1451 return TEST_SUCCESS
;
1454 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1456 uint64_t new_number
;
1457 const char *value
= "3";
1459 test_compare(return_value_based_on_buffering(memc
),
1460 memcached_set_by_key(memc
,
1461 test_literal_param("foo"),
1462 test_literal_param("number"),
1463 value
, strlen(value
),
1464 (time_t)0, (uint32_t)0));
1466 test_compare(MEMCACHED_SUCCESS
,
1467 memcached_decrement_by_key(memc
,
1468 test_literal_param("foo"),
1469 test_literal_param("number"),
1471 test_compare(uint64_t(2), new_number
);
1473 test_compare(MEMCACHED_SUCCESS
,
1474 memcached_decrement_by_key(memc
,
1475 test_literal_param("foo"),
1476 test_literal_param("number"),
1478 test_compare(uint64_t(1), new_number
);
1480 return TEST_SUCCESS
;
1483 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1485 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1487 uint64_t new_number
;
1488 uint64_t initial
= 3;
1490 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
1492 test_compare(MEMCACHED_SUCCESS
,
1493 memcached_decrement_with_initial_by_key(memc
,
1494 test_literal_param("foo"),
1495 test_literal_param("number"),
1496 1, initial
, 0, &new_number
));
1497 test_compare(new_number
, initial
);
1499 test_compare(MEMCACHED_SUCCESS
,
1500 memcached_decrement_with_initial_by_key(memc
,
1501 test_literal_param("foo"),
1502 test_literal_param("number"),
1503 1, initial
, 0, &new_number
));
1504 test_compare(new_number
, (initial
- 1));
1508 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
1509 memcached_decrement_with_initial_by_key(memc
,
1510 test_literal_param("foo"),
1511 test_literal_param("number"),
1512 1, initial
, 0, &new_number
));
1515 return TEST_SUCCESS
;
1517 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1519 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1521 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1523 test_compare(return_value_based_on_buffering(memc
),
1525 test_literal_param("number"),
1526 test_literal_param("0"),
1527 (time_t)0, (uint32_t)0));
1529 uint64_t new_number
;
1530 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1531 test_literal_param("number"),
1533 test_compare(uint64_t(1), new_number
);
1535 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1536 test_literal_param("number"),
1538 test_compare(uint64_t(2), new_number
);
1540 return TEST_SUCCESS
;
1543 test_return_t
quit_test(memcached_st
*memc
)
1545 const char *value
= "sanford and sun";
1547 test_compare(return_value_based_on_buffering(memc
),
1549 test_literal_param(__func__
),
1550 value
, strlen(value
),
1551 time_t(10), uint32_t(3)));
1552 memcached_quit(memc
);
1554 test_compare(return_value_based_on_buffering(memc
),
1556 test_literal_param(__func__
),
1557 value
, strlen(value
),
1558 time_t(50), uint32_t(9)));
1560 return TEST_SUCCESS
;
1563 test_return_t
mget_result_test(memcached_st
*memc
)
1565 const char *keys
[]= {"fudge", "son", "food"};
1566 size_t key_length
[]= {5, 3, 4};
1568 memcached_result_st results_obj
;
1569 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1571 test_true(&results_obj
== results
);
1573 /* We need to empty the server before continueing test */
1574 test_compare(MEMCACHED_SUCCESS
,
1575 memcached_flush(memc
, 0));
1577 test_compare(MEMCACHED_SUCCESS
,
1578 memcached_mget(memc
, keys
, key_length
, 3));
1580 memcached_return_t rc
;
1581 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1586 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1587 test_false(results
);
1588 test_compare(MEMCACHED_NOTFOUND
, rc
);
1590 for (uint32_t x
= 0; x
< 3; x
++)
1592 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1593 keys
[x
], key_length
[x
],
1594 (time_t)50, (uint32_t)9);
1595 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1598 test_compare(MEMCACHED_SUCCESS
,
1599 memcached_mget(memc
, keys
, key_length
, 3));
1601 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1604 test_true(&results_obj
== results
);
1605 test_compare(MEMCACHED_SUCCESS
, rc
);
1606 test_memcmp(memcached_result_key_value(results
),
1607 memcached_result_value(results
),
1608 memcached_result_length(results
));
1609 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1612 memcached_result_free(&results_obj
);
1614 return TEST_SUCCESS
;
1617 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1619 const char *keys
[]= {"fudge", "son", "food"};
1620 size_t key_length
[]= {5, 3, 4};
1622 memcached_result_st
*results
;
1624 /* We need to empty the server before continueing test */
1625 test_compare(MEMCACHED_SUCCESS
,
1626 memcached_flush(memc
, 0));
1628 test_compare(MEMCACHED_SUCCESS
,
1629 memcached_mget(memc
, keys
, key_length
, 3));
1631 memcached_return_t rc
;
1632 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1636 test_false(results
);
1637 test_compare(MEMCACHED_NOTFOUND
, rc
);
1639 for (uint32_t x
= 0; x
< 3; x
++)
1641 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1642 keys
[x
], key_length
[x
],
1643 (time_t)50, (uint32_t)9);
1644 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1647 test_compare(MEMCACHED_SUCCESS
,
1648 memcached_mget(memc
, keys
, key_length
, 3));
1651 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1654 test_compare(MEMCACHED_SUCCESS
, rc
);
1655 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1656 test_memcmp(memcached_result_key_value(results
),
1657 memcached_result_value(results
),
1658 memcached_result_length(results
));
1659 memcached_result_free(results
);
1663 return TEST_SUCCESS
;
1666 test_return_t
mget_result_function(memcached_st
*memc
)
1668 const char *keys
[]= {"fudge", "son", "food"};
1669 size_t key_length
[]= {5, 3, 4};
1671 memcached_execute_fn callbacks
[1];
1673 for (uint32_t x
= 0; x
< 3; x
++)
1675 test_compare(return_value_based_on_buffering(memc
),
1676 memcached_set(memc
, keys
[x
], key_length
[x
],
1677 keys
[x
], key_length
[x
],
1678 time_t(50), uint32_t(9)));
1680 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1681 memcached_quit(memc
);
1683 test_compare(MEMCACHED_SUCCESS
,
1684 memcached_mget(memc
, keys
, key_length
, 3));
1686 callbacks
[0]= &callback_counter
;
1689 test_compare(MEMCACHED_SUCCESS
,
1690 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1692 test_compare(size_t(3), counter
);
1694 return TEST_SUCCESS
;
1697 test_return_t
mget_test(memcached_st
*memc
)
1699 const char *keys
[]= {"fudge", "son", "food"};
1700 size_t key_length
[]= {5, 3, 4};
1702 char return_key
[MEMCACHED_MAX_KEY
];
1703 size_t return_key_length
;
1705 size_t return_value_length
;
1707 test_compare(MEMCACHED_SUCCESS
,
1708 memcached_mget(memc
, keys
, key_length
, 3));
1711 memcached_return_t rc
;
1712 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1713 &return_value_length
, &flags
, &rc
)))
1715 test_true(return_value
);
1717 test_false(return_value
);
1718 test_zero(return_value_length
);
1719 test_compare(MEMCACHED_NOTFOUND
, rc
);
1721 for (uint32_t x
= 0; x
< 3; x
++)
1723 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1724 keys
[x
], key_length
[x
],
1725 (time_t)50, (uint32_t)9);
1726 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1728 test_compare(MEMCACHED_SUCCESS
,
1729 memcached_mget(memc
, keys
, key_length
, 3));
1732 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1733 &return_value_length
, &flags
, &rc
)))
1735 test_true(return_value
);
1736 test_compare(MEMCACHED_SUCCESS
, rc
);
1737 if (not memc
->_namespace
)
1739 test_compare(return_key_length
, return_value_length
);
1740 test_memcmp(return_value
, return_key
, return_value_length
);
1746 return TEST_SUCCESS
;
1749 test_return_t
mget_execute(memcached_st
*original_memc
)
1751 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1753 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1756 keys_st
keys(20480);
1758 /* First add all of the items.. */
1759 char blob
[1024] = {0};
1761 for (size_t x
= 0; x
< keys
.size(); ++x
)
1763 uint64_t query_id
= memcached_query_id(memc
);
1764 memcached_return_t rc
= memcached_add(memc
,
1765 keys
.key_at(x
), keys
.length_at(x
),
1768 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1769 test_compare(query_id
+1, memcached_query_id(memc
));
1772 /* Try to get all of them with a large multiget */
1774 memcached_execute_fn callbacks
[]= { &callback_counter
};
1775 test_compare(MEMCACHED_SUCCESS
,
1776 memcached_mget_execute(memc
,
1777 keys
.keys_ptr(), keys
.lengths_ptr(),
1778 keys
.size(), callbacks
, &counter
, 1));
1781 uint64_t query_id
= memcached_query_id(memc
);
1782 test_compare(MEMCACHED_SUCCESS
,
1783 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1784 test_compare(query_id
, memcached_query_id(memc
));
1786 /* Verify that we got all of the items */
1787 test_compare(keys
.size(), counter
);
1790 memcached_free(memc
);
1792 return TEST_SUCCESS
;
1795 test_return_t
MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST(memcached_st
*original_memc
)
1797 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1799 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1802 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 8));
1804 keys_st
keys(20480);
1806 /* First add all of the items.. */
1807 char blob
[1024] = {0};
1809 for (size_t x
= 0; x
< keys
.size(); ++x
)
1811 uint64_t query_id
= memcached_query_id(memc
);
1812 memcached_return_t rc
= memcached_add(memc
,
1813 keys
.key_at(x
), keys
.length_at(x
),
1816 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1817 test_compare(query_id
+1, memcached_query_id(memc
));
1820 /* Try to get all of them with a large multiget */
1822 memcached_execute_fn callbacks
[]= { &callback_counter
};
1823 test_compare(MEMCACHED_SUCCESS
,
1824 memcached_mget_execute(memc
,
1825 keys
.keys_ptr(), keys
.lengths_ptr(),
1826 keys
.size(), callbacks
, &counter
, 1));
1829 uint64_t query_id
= memcached_query_id(memc
);
1830 test_compare(MEMCACHED_SUCCESS
,
1831 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1832 test_compare(query_id
, memcached_query_id(memc
));
1834 /* Verify that we got all of the items */
1835 test_compare(keys
.size(), counter
);
1838 memcached_free(memc
);
1840 return TEST_SUCCESS
;
1843 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1844 static pairs_st
*global_pairs
= NULL
;
1846 test_return_t
key_setup(memcached_st
*memc
)
1848 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1850 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1852 return TEST_SUCCESS
;
1855 test_return_t
key_teardown(memcached_st
*)
1857 pairs_free(global_pairs
);
1860 return TEST_SUCCESS
;
1863 test_return_t
block_add_regression(memcached_st
*memc
)
1865 /* First add all of the items.. */
1866 for (ptrdiff_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1868 libtest::vchar_t blob
;
1869 libtest::vchar::make(blob
, 1024);
1871 memcached_return_t rc
= memcached_add_by_key(memc
,
1872 test_literal_param("bob"),
1873 global_pairs
[x
].key
, global_pairs
[x
].key_length
,
1874 &blob
[0], blob
.size(),
1875 time_t(0), uint32_t(0));
1876 if (rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
)
1878 Error
<< memcached_last_error_message(memc
);
1879 return TEST_SKIPPED
;
1881 test_compare(*memc
, MEMCACHED_SUCCESS
);
1882 test_compare(rc
, MEMCACHED_SUCCESS
);
1885 return TEST_SUCCESS
;
1888 test_return_t
binary_add_regression(memcached_st
*memc
)
1890 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1891 return block_add_regression(memc
);
1894 test_return_t
get_stats_keys(memcached_st
*memc
)
1898 memcached_stat_st memc_stat
;
1899 memcached_return_t rc
;
1901 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1902 test_compare(MEMCACHED_SUCCESS
, rc
);
1903 for (ptr
= stat_list
; *ptr
; ptr
++)
1908 return TEST_SUCCESS
;
1911 test_return_t
version_string_test(memcached_st
*)
1913 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1915 return TEST_SUCCESS
;
1918 test_return_t
get_stats(memcached_st
*memc
)
1920 memcached_return_t rc
;
1922 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1923 test_compare(MEMCACHED_SUCCESS
, rc
);
1924 test_true(memc_stat
);
1926 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1928 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1929 test_compare(MEMCACHED_SUCCESS
, rc
);
1930 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1935 memcached_stat_free(NULL
, memc_stat
);
1937 return TEST_SUCCESS
;
1940 test_return_t
add_host_test(memcached_st
*memc
)
1942 char servername
[]= "0.example.com";
1944 memcached_return_t rc
;
1945 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1946 test_compare(1U, memcached_server_list_count(servers
));
1948 for (unsigned int x
= 2; x
< 20; x
++)
1950 char buffer
[SMALL_STRING_LEN
];
1952 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1953 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1955 test_compare(MEMCACHED_SUCCESS
, rc
);
1956 test_compare(x
, memcached_server_list_count(servers
));
1959 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1960 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1962 memcached_server_list_free(servers
);
1964 return TEST_SUCCESS
;
1967 test_return_t
regression_1048945_TEST(memcached_st
*)
1969 memcached_return status
;
1971 memcached_server_st
* list
= memcached_server_list_append_with_weight(NULL
, "a", 11211, 0, &status
);
1972 test_compare(status
, MEMCACHED_SUCCESS
);
1974 list
= memcached_server_list_append_with_weight(list
, "b", 11211, 0, &status
);
1975 test_compare(status
, MEMCACHED_SUCCESS
);
1977 list
= memcached_server_list_append_with_weight(list
, "c", 11211, 0, &status
);
1978 test_compare(status
, MEMCACHED_SUCCESS
);
1980 memcached_st
* memc
= memcached_create(NULL
);
1982 status
= memcached_server_push(memc
, list
);
1983 memcached_server_list_free(list
);
1984 test_compare(status
, MEMCACHED_SUCCESS
);
1986 const memcached_instance_st
* server
= memcached_server_by_key(memc
, test_literal_param(__func__
), &status
);
1988 test_compare(status
, MEMCACHED_SUCCESS
);
1990 memcached_free(memc
);
1992 return TEST_SUCCESS
;
1995 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1997 memcached_return_t rc
;
1999 const char *key
= "not_found";
2000 size_t key_length
= test_literal_param_size("not_found");
2002 test_compare(MEMCACHED_SUCCESS
,
2003 memcached_mget(memc
, &key
, &key_length
, 1));
2005 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
2007 test_compare(MEMCACHED_NOTFOUND
, rc
);
2009 memcached_result_free(result
);
2011 return TEST_SUCCESS
;
2014 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
2016 return MEMCACHED_SUCCESS
;
2019 static memcached_return_t
cleanup_test_callback(memcached_st
*)
2021 return MEMCACHED_SUCCESS
;
2024 test_return_t
callback_test(memcached_st
*memc
)
2026 /* Test User Data */
2030 memcached_return_t rc
;
2032 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
2033 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
2034 test_true(*test_ptr
== x
);
2037 /* Test Clone Callback */
2039 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2040 void *clone_cb_ptr
= *(void **)&clone_cb
;
2041 void *temp_function
= NULL
;
2043 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
2044 memcached_return_t rc
;
2045 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2046 test_true(temp_function
== clone_cb_ptr
);
2047 test_compare(MEMCACHED_SUCCESS
, rc
);
2050 /* Test Cleanup Callback */
2052 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2053 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2054 void *temp_function
= NULL
;
2055 memcached_return_t rc
;
2057 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2058 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2059 test_true(temp_function
== cleanup_cb_ptr
);
2062 return TEST_SUCCESS
;
2065 /* We don't test the behavior itself, we test the switches */
2066 test_return_t
behavior_test(memcached_st
*memc
)
2068 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2069 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2071 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2072 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2074 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2075 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2077 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2078 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2080 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2081 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2083 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2084 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2086 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2087 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2089 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2091 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2093 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2094 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2095 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2097 return TEST_SUCCESS
;
2100 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2102 test_compare(MEMCACHED_DEPRECATED
,
2103 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2105 // Platform dependent
2107 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2111 return TEST_SUCCESS
;
2115 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2117 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2118 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2120 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2122 if (memcached_success(rc
))
2131 return TEST_SUCCESS
;
2135 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2137 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2138 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2140 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2142 if (memcached_success(rc
))
2151 return TEST_SUCCESS
;
2154 /* Make sure we behave properly if server list has no values */
2155 test_return_t
user_supplied_bug4(memcached_st
*memc
)
2157 const char *keys
[]= {"fudge", "son", "food"};
2158 size_t key_length
[]= {5, 3, 4};
2160 /* Here we free everything before running a bunch of mget tests */
2161 memcached_servers_reset(memc
);
2164 /* We need to empty the server before continueing test */
2165 test_compare(MEMCACHED_NO_SERVERS
,
2166 memcached_flush(memc
, 0));
2168 test_compare(MEMCACHED_NO_SERVERS
,
2169 memcached_mget(memc
, keys
, key_length
, 3));
2172 unsigned int keys_returned
;
2173 memcached_return_t rc
;
2174 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2175 test_compare(MEMCACHED_NOTFOUND
, rc
);
2176 test_zero(keys_returned
);
2179 for (uint32_t x
= 0; x
< 3; x
++)
2181 test_compare(MEMCACHED_NO_SERVERS
,
2182 memcached_set(memc
, keys
[x
], key_length
[x
],
2183 keys
[x
], key_length
[x
],
2184 (time_t)50, (uint32_t)9));
2187 test_compare(MEMCACHED_NO_SERVERS
,
2188 memcached_mget(memc
, keys
, key_length
, 3));
2192 char return_key
[MEMCACHED_MAX_KEY
];
2193 memcached_return_t rc
;
2194 size_t return_key_length
;
2195 size_t return_value_length
;
2198 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2199 &return_value_length
, &flags
, &rc
)))
2201 test_true(return_value
);
2202 test_compare(MEMCACHED_SUCCESS
, rc
);
2203 test_true(return_key_length
== return_value_length
);
2204 test_memcmp(return_value
, return_key
, return_value_length
);
2210 return TEST_SUCCESS
;
2213 #define VALUE_SIZE_BUG5 1048064
2214 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2216 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2217 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2219 size_t value_length
;
2221 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2223 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2225 insert_data
[x
]= (signed char)rand();
2228 test_compare(MEMCACHED_SUCCESS
,
2229 memcached_flush(memc
, 0));
2231 memcached_return_t rc
;
2232 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2233 test_compare(MEMCACHED_SUCCESS
,
2234 memcached_mget(memc
, keys
, key_length
, 4));
2237 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2238 test_compare(MEMCACHED_NOTFOUND
, rc
);
2241 for (uint32_t x
= 0; x
< 4; x
++)
2243 test_compare(MEMCACHED_SUCCESS
,
2244 memcached_set(memc
, keys
[x
], key_length
[x
],
2245 insert_data
, VALUE_SIZE_BUG5
,
2246 (time_t)0, (uint32_t)0));
2249 for (uint32_t x
= 0; x
< 10; x
++)
2251 value
= memcached_get(memc
, keys
[0], key_length
[0],
2252 &value_length
, &flags
, &rc
);
2253 test_compare(rc
, MEMCACHED_SUCCESS
);
2257 test_compare(MEMCACHED_SUCCESS
,
2258 memcached_mget(memc
, keys
, key_length
, 4));
2260 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2261 test_compare(4U, count
);
2263 delete [] insert_data
;
2265 return TEST_SUCCESS
;
2268 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2270 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2271 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2272 char return_key
[MEMCACHED_MAX_KEY
];
2273 size_t return_key_length
;
2275 size_t value_length
;
2277 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2279 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2281 insert_data
[x
]= (signed char)rand();
2284 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2286 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2288 // We will now confirm that memcached_mget() returns success, but we will
2289 // then check to make sure that no actual keys are returned.
2290 test_compare(MEMCACHED_SUCCESS
,
2291 memcached_mget(memc
, keys
, key_length
, 4));
2293 memcached_return_t rc
;
2295 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2296 &value_length
, &flags
, &rc
)))
2301 test_compare(MEMCACHED_NOTFOUND
, rc
);
2303 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2305 test_compare(MEMCACHED_SUCCESS
,
2306 memcached_set(memc
, keys
[x
], key_length
[x
],
2307 insert_data
, VALUE_SIZE_BUG5
,
2308 (time_t)0, (uint32_t)0));
2310 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2312 for (uint32_t x
= 0; x
< 2; x
++)
2314 value
= memcached_get(memc
, keys
[0], key_length
[0],
2315 &value_length
, &flags
, &rc
);
2319 test_compare(MEMCACHED_SUCCESS
,
2320 memcached_mget(memc
, keys
, key_length
, 4));
2321 /* We test for purge of partial complete fetches */
2322 for (count
= 3; count
; count
--)
2324 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2325 &value_length
, &flags
, &rc
);
2326 test_compare(MEMCACHED_SUCCESS
, rc
);
2327 test_memcmp(value
, insert_data
, value_length
);
2328 test_true(value_length
);
2332 delete [] insert_data
;
2334 return TEST_SUCCESS
;
2337 test_return_t
user_supplied_bug8(memcached_st
*)
2339 memcached_return_t rc
;
2341 memcached_st
*memc_clone
;
2343 memcached_server_st
*servers
;
2344 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";
2346 servers
= memcached_servers_parse(server_list
);
2349 mine
= memcached_create(NULL
);
2350 rc
= memcached_server_push(mine
, servers
);
2351 test_compare(MEMCACHED_SUCCESS
, rc
);
2352 memcached_server_list_free(servers
);
2355 memc_clone
= memcached_clone(NULL
, mine
);
2357 memcached_quit(mine
);
2358 memcached_quit(memc_clone
);
2361 memcached_free(mine
);
2362 memcached_free(memc_clone
);
2364 return TEST_SUCCESS
;
2367 /* Test flag store/retrieve */
2368 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2370 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2371 test_true(insert_data
);
2373 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2375 insert_data
[x
]= (signed char)rand();
2378 memcached_flush(memc
, 0);
2380 const char *keys
= "036790384900";
2381 size_t key_length
= strlen(keys
);
2382 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2383 insert_data
, VALUE_SIZE_BUG5
,
2386 memcached_return_t rc
;
2387 size_t value_length
;
2389 char *value
= memcached_get(memc
, keys
, key_length
,
2390 &value_length
, &flags
, &rc
);
2391 test_compare(245U, flags
);
2395 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2397 char return_key
[MEMCACHED_MAX_KEY
];
2398 size_t return_key_length
;
2400 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2401 &value_length
, &flags
, &rc
);
2402 test_compare(uint32_t(245), flags
);
2405 delete [] insert_data
;
2408 return TEST_SUCCESS
;
2411 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2413 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2414 size_t key_length
[3];
2418 char return_key
[MEMCACHED_MAX_KEY
];
2419 size_t return_key_length
;
2421 size_t return_value_length
;
2424 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2425 key_length
[1]= strlen("fudge&*@#");
2426 key_length
[2]= strlen("for^#@&$not");
2429 for (unsigned int x
= 0; x
< 3; x
++)
2431 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2432 keys
[x
], key_length
[x
],
2433 (time_t)50, (uint32_t)9);
2434 test_compare(MEMCACHED_SUCCESS
, rc
);
2437 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2438 test_compare(MEMCACHED_SUCCESS
, rc
);
2440 /* We need to empty the server before continueing test */
2441 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2442 &return_value_length
, &flags
, &rc
)) != NULL
)
2444 test_true(return_value
);
2448 test_compare(3U, count
);
2450 return TEST_SUCCESS
;
2453 /* We are testing with aggressive timeout to get failures */
2454 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2456 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
2458 size_t value_length
= 512;
2459 unsigned int set
= 1;
2460 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2462 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2463 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2464 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2466 libtest::vchar_t value
;
2467 value
.reserve(value_length
);
2468 for (uint32_t x
= 0; x
< value_length
; 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
,
2476 test_literal_param("foo"),
2477 &value
[0], value
.size(),
2480 test_true((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2481 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
));
2483 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2489 memcached_free(mclone
);
2491 return TEST_SUCCESS
;
2495 We are looking failures in the async protocol
2497 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2499 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2501 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2502 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2503 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2505 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2508 libtest::vchar_t value
;
2510 for (unsigned int x
= 0; x
< 512; x
++)
2512 value
.push_back(char(x
% 127));
2515 for (unsigned int x
= 1; x
<= 100000; ++x
)
2517 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2521 memcached_free(mclone
);
2523 return TEST_SUCCESS
;
2527 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2529 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2531 memcached_return_t rc
;
2533 size_t value_length
;
2535 uint64_t number_value
;
2537 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2538 &value_length
, &flags
, &rc
);
2540 test_compare(MEMCACHED_NOTFOUND
, rc
);
2542 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2545 /* The binary protocol will set the key if it doesn't exist */
2546 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2548 test_compare(MEMCACHED_SUCCESS
, rc
);
2552 test_compare(MEMCACHED_NOTFOUND
, rc
);
2555 test_compare(MEMCACHED_SUCCESS
,
2556 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2558 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2562 test_compare(MEMCACHED_SUCCESS
,
2563 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2564 test_compare(2UL, number_value
);
2566 return TEST_SUCCESS
;
2570 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2571 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2573 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2575 char key
[] = "key34567890";
2577 char commandFirst
[]= "set key34567890 0 0 ";
2578 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2579 size_t commandLength
;
2581 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2583 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2585 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2587 char *overflow
= new (std::nothrow
) char[testSize
];
2588 test_true(overflow
);
2590 memset(overflow
, 'x', testSize
);
2591 test_compare(MEMCACHED_SUCCESS
,
2592 memcached_set(memc
, key
, strlen(key
),
2593 overflow
, testSize
, 0, 0));
2597 return TEST_SUCCESS
;
2602 Test values of many different sizes
2603 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2604 set key34567890 0 0 8169 \r\n
2605 is sent followed by buffer of size 8169, followed by 8169
2607 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2609 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2611 libtest::vchar_t value
;
2612 value
.reserve(18000);
2613 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2615 value
.push_back((char) (x
% 127));
2618 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2620 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2621 &value
[0], current_length
,
2622 (time_t)0, (uint32_t)0);
2623 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2625 size_t string_length
;
2627 char *string
= memcached_get(memc
, test_literal_param("foo"),
2628 &string_length
, &flags
, &rc
);
2630 test_compare(MEMCACHED_SUCCESS
, rc
);
2631 test_compare(string_length
, current_length
);
2633 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2634 test_memcmp(string
, &value
[0], string_length
);
2639 return TEST_SUCCESS
;
2643 Look for zero length value problems
2645 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2647 for (uint32_t x
= 0; x
< 2; x
++)
2649 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2651 (time_t)0, (uint32_t)0);
2653 test_compare(MEMCACHED_SUCCESS
, rc
);
2657 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2658 &length
, &flags
, &rc
);
2660 test_compare(MEMCACHED_SUCCESS
, rc
);
2665 value
= memcached_get(memc
, test_literal_param("mykey"),
2666 &length
, &flags
, &rc
);
2668 test_compare(MEMCACHED_SUCCESS
, rc
);
2674 return TEST_SUCCESS
;
2677 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2678 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2680 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2682 (time_t)0, UINT32_MAX
));
2687 memcached_return_t rc
;
2688 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2689 &length
, &flags
, &rc
);
2691 test_compare(MEMCACHED_SUCCESS
, rc
);
2694 test_compare(flags
, UINT32_MAX
);
2696 return TEST_SUCCESS
;
2699 #if !defined(__sun) && !defined(__OpenBSD__)
2700 /* Check the validity of chinese key*/
2701 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2703 const char *key
= "豆瓣";
2704 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2705 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2706 value
, strlen(value
),
2709 test_compare(MEMCACHED_SUCCESS
, rc
);
2713 char *value2
= memcached_get(memc
, key
, strlen(key
),
2714 &length
, &flags
, &rc
);
2716 test_compare(length
, strlen(value
));
2717 test_compare(MEMCACHED_SUCCESS
, rc
);
2718 test_memcmp(value
, value2
, length
);
2721 return TEST_SUCCESS
;
2729 test_return_t
user_supplied_bug19(memcached_st
*)
2731 memcached_return_t res
;
2733 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2735 const memcached_instance_st
* server
= memcached_server_by_key(memc
, "a", 1, &res
);
2738 memcached_free(memc
);
2740 return TEST_SUCCESS
;
2743 /* CAS test from Andei */
2744 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2746 const char *key
= "abc";
2747 size_t key_len
= strlen("abc");
2749 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2751 test_compare(MEMCACHED_SUCCESS
,
2753 test_literal_param("abc"),
2754 test_literal_param("foobar"),
2755 (time_t)0, (uint32_t)0));
2757 test_compare(MEMCACHED_SUCCESS
,
2758 memcached_mget(memc
, &key
, &key_len
, 1));
2760 memcached_result_st result_obj
;
2761 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2764 memcached_result_create(memc
, &result_obj
);
2765 memcached_return_t status
;
2766 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2769 test_compare(MEMCACHED_SUCCESS
, status
);
2771 memcached_result_free(result
);
2773 return TEST_SUCCESS
;
2776 /* Large mget() of missing keys with binary proto
2778 * If many binary quiet commands (such as getq's in an mget) fill the output
2779 * buffer and the server chooses not to respond, memcached_flush hangs. See
2780 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2783 /* sighandler_t function that always asserts false */
2784 static __attribute__((noreturn
)) void fail(int)
2790 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2795 return TEST_SKIPPED
;
2797 void (*oldalarm
)(int);
2799 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2800 test_true(memc_clone
);
2802 /* only binproto uses getq for mget */
2803 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2805 /* empty the cache to ensure misses (hence non-responses) */
2806 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2808 keys_st
keys(key_count
);
2810 oldalarm
= signal(SIGALRM
, fail
);
2813 test_compare_got(MEMCACHED_SUCCESS
,
2814 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2815 memcached_last_error_message(memc_clone
));
2818 signal(SIGALRM
, oldalarm
);
2820 memcached_return_t rc
;
2822 char return_key
[MEMCACHED_MAX_KEY
];
2823 size_t return_key_length
;
2825 size_t return_value_length
;
2826 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2827 &return_value_length
, &flags
, &rc
)))
2829 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2831 test_compare(MEMCACHED_NOTFOUND
, rc
);
2832 test_zero(return_value_length
);
2833 test_zero(return_key_length
);
2834 test_false(return_key
[0]);
2835 test_false(return_value
);
2837 memcached_free(memc_clone
);
2839 return TEST_SUCCESS
;
2843 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2845 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2847 /* should work as of r580 */
2848 test_compare(TEST_SUCCESS
,
2849 _user_supplied_bug21(memc
, 10));
2851 /* should fail as of r580 */
2852 test_compare(TEST_SUCCESS
,
2853 _user_supplied_bug21(memc
, 1000));
2855 return TEST_SUCCESS
;
2858 test_return_t
comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st
*)
2862 memcached_st
*memc
= &memc_
;
2864 ASSERT_EQ(memc
, MEMCACHED_SUCCESS
);
2865 test_compare(memc
, MEMCACHED_SUCCESS
);
2867 ASSERT_NEQ(memc
, MEMCACHED_FAILURE
);
2869 return TEST_SUCCESS
;
2872 test_return_t
ketama_TEST(memcached_st
*)
2874 test::Memc
memc("--server=10.0.1.1:11211 --server=10.0.1.2:11211");
2876 test_compare(MEMCACHED_SUCCESS
,
2877 memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2879 test_compare(memcached_behavior_get(&memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
), uint64_t(1));
2881 test_compare(memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
), MEMCACHED_SUCCESS
);
2883 test_compare(memcached_hash_t(memcached_behavior_get(&memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
)), MEMCACHED_HASH_MD5
);
2885 test_compare(memcached_behavior_set_distribution(&memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
), MEMCACHED_SUCCESS
);
2888 return TEST_SUCCESS
;
2891 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2893 memcached_st
*memc
= memcached_create(NULL
);
2897 test_compare(MEMCACHED_SUCCESS
,
2898 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2900 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2901 test_compare(value
, uint64_t(1));
2903 test_compare(MEMCACHED_SUCCESS
,
2904 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2906 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2907 test_true(value
== MEMCACHED_HASH_MD5
);
2910 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2912 memcached_server_st
*server_pool
;
2913 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");
2914 memcached_server_push(memc
, server_pool
);
2916 // @todo this needs to be refactored to actually test something.
2919 if ((fp
= fopen("ketama_keys.txt", "w")))
2923 printf("cannot write to file ketama_keys.txt");
2924 return TEST_FAILURE
;
2927 for (int x
= 0; x
< 10000; x
++)
2930 snprintf(key
, sizeof(key
), "%d", x
);
2932 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2933 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2934 in_port_t port
= memc
->hosts
[server_idx
].port
;
2935 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2936 const memcached_instance_st
* instance
=
2937 memcached_server_instance_by_position(memc
, host_index
);
2941 memcached_server_list_free(server_pool
);
2942 memcached_free(memc
);
2944 return TEST_SUCCESS
;
2948 test_return_t
result_static(memcached_st
*memc
)
2950 memcached_result_st result
;
2951 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
2952 test_false(result
.options
.is_allocated
);
2953 test_true(memcached_is_initialized(&result
));
2954 test_true(result_ptr
);
2955 test_true(result_ptr
== &result
);
2957 memcached_result_free(&result
);
2959 test_false(result
.options
.is_allocated
);
2960 test_false(memcached_is_initialized(&result
));
2962 return TEST_SUCCESS
;
2965 test_return_t
result_alloc(memcached_st
*memc
)
2967 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
2968 test_true(result_ptr
);
2969 test_true(result_ptr
->options
.is_allocated
);
2970 test_true(memcached_is_initialized(result_ptr
));
2971 memcached_result_free(result_ptr
);
2973 return TEST_SUCCESS
;
2977 test_return_t
add_host_test1(memcached_st
*memc
)
2979 memcached_return_t rc
;
2980 char servername
[]= "0.example.com";
2982 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2984 test_compare(1U, memcached_server_list_count(servers
));
2986 for (uint32_t x
= 2; x
< 20; x
++)
2988 char buffer
[SMALL_STRING_LEN
];
2990 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
2991 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2993 test_compare(MEMCACHED_SUCCESS
, rc
);
2994 test_compare(x
, memcached_server_list_count(servers
));
2997 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2998 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3000 memcached_server_list_free(servers
);
3002 return TEST_SUCCESS
;
3006 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3010 #ifdef HARD_MALLOC_TESTS
3011 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3019 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3023 #ifdef HARD_MALLOC_TESTS
3024 void *ret
= malloc(size
+ 8);
3027 ret
= (void*)((caddr_t
)ret
+ 8);
3030 void *ret
= malloc(size
);
3035 memset(ret
, 0xff, size
);
3042 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3044 #ifdef HARD_MALLOC_TESTS
3045 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3046 void *nmem
= realloc(real_ptr
, size
+ 8);
3051 ret
= (void*)((caddr_t
)nmem
+ 8);
3057 return realloc(mem
, size
);
3062 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3064 #ifdef HARD_MALLOC_TESTS
3065 void *mem
= my_malloc(ptr
, nelem
* size
);
3068 memset(mem
, 0, nelem
* size
);
3074 return calloc(nelem
, size
);
3078 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3080 memcached_return_t rc
;
3081 const char *key
= "mine";
3084 /* Make sure be default none exists */
3085 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3087 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3089 /* Test a clean set */
3090 test_compare(MEMCACHED_SUCCESS
,
3091 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3093 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3095 test_memcmp(value
, key
, 4);
3096 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3098 /* Test that we can turn it off */
3099 test_compare(MEMCACHED_SUCCESS
,
3100 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3102 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3104 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3106 /* Now setup for main test */
3107 test_compare(MEMCACHED_SUCCESS
,
3108 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3110 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3112 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3113 test_memcmp(value
, key
, 4);
3115 /* Set to Zero, and then Set to something too large */
3118 memset(long_key
, 0, 255);
3120 test_compare(MEMCACHED_SUCCESS
,
3121 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3123 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3125 test_compare(MEMCACHED_SUCCESS
, rc
);
3127 /* Test a long key for failure */
3128 /* TODO, extend test to determine based on setting, what result should be */
3129 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3130 test_compare(MEMCACHED_SUCCESS
,
3131 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3133 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3134 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3135 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3136 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3138 /* Test for a bad prefix, but with a short key */
3139 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3140 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3142 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3143 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3146 return TEST_SUCCESS
;
3149 test_return_t
set_namespace(memcached_st
*memc
)
3151 memcached_return_t rc
;
3152 const char *key
= "mine";
3155 // Make sure we default to a null namespace
3156 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3158 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3160 /* Test a clean set */
3161 test_compare(MEMCACHED_SUCCESS
,
3162 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3164 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3166 test_memcmp(value
, key
, 4);
3167 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3169 return TEST_SUCCESS
;
3172 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3174 test_return_if(pre_binary(memc
));
3175 test_return_if(set_namespace(memc
));
3177 return TEST_SUCCESS
;
3180 #ifdef MEMCACHED_ENABLE_DEPRECATED
3181 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3183 void *test_ptr
= NULL
;
3186 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
3187 cb_ptr
= *(void **)&malloc_cb
;
3188 memcached_return_t rc
;
3190 test_compare(MEMCACHED_SUCCESS
,
3191 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3192 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3193 test_compare(MEMCACHED_SUCCESS
, rc
);
3194 test_true(test_ptr
== cb_ptr
);
3198 memcached_realloc_fn realloc_cb
=
3199 (memcached_realloc_fn
)my_realloc
;
3200 cb_ptr
= *(void **)&realloc_cb
;
3201 memcached_return_t rc
;
3203 test_compare(MEMCACHED_SUCCESS
,
3204 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3205 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3206 test_compare(MEMCACHED_SUCCESS
, rc
);
3207 test_true(test_ptr
== cb_ptr
);
3211 memcached_free_fn free_cb
=
3212 (memcached_free_fn
)my_free
;
3213 cb_ptr
= *(void **)&free_cb
;
3214 memcached_return_t rc
;
3216 test_compare(MEMCACHED_SUCCESS
,
3217 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3218 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3219 test_compare(MEMCACHED_SUCCESS
, rc
);
3220 test_true(test_ptr
== cb_ptr
);
3223 return TEST_SUCCESS
;
3228 test_return_t
set_memory_alloc(memcached_st
*memc
)
3230 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3231 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3232 my_realloc
, my_calloc
, NULL
));
3234 test_compare(MEMCACHED_SUCCESS
,
3235 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3236 my_realloc
, my_calloc
, NULL
));
3238 memcached_malloc_fn mem_malloc
;
3239 memcached_free_fn mem_free
;
3240 memcached_realloc_fn mem_realloc
;
3241 memcached_calloc_fn mem_calloc
;
3242 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3243 &mem_realloc
, &mem_calloc
);
3245 test_true(mem_malloc
== my_malloc
);
3246 test_true(mem_realloc
== my_realloc
);
3247 test_true(mem_calloc
== my_calloc
);
3248 test_true(mem_free
== my_free
);
3250 return TEST_SUCCESS
;
3253 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3255 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
));
3256 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3259 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3264 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3266 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_CRC
)
3268 return TEST_SKIPPED
;
3271 return TEST_SUCCESS
;
3274 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3277 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
);
3278 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3283 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3285 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_HSIEH
)
3287 return TEST_SKIPPED
;
3290 return TEST_SUCCESS
;
3293 test_return_t
enable_cas(memcached_st
*memc
)
3295 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3297 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true);
3299 return TEST_SUCCESS
;
3302 return TEST_SKIPPED
;
3305 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3307 memcached_version(memc
);
3309 const memcached_instance_st
* instance
=
3310 memcached_server_instance_by_position(memc
, 0);
3312 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3313 or instance
->minor_version
> 2)
3315 return TEST_SUCCESS
;
3318 return TEST_SKIPPED
;
3321 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3323 const uint64_t timeout
= 100; // Not using, just checking that it sets
3325 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3327 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3329 return TEST_SUCCESS
;
3332 test_return_t
noreply_test(memcached_st
*memc
)
3334 test_compare(MEMCACHED_SUCCESS
,
3335 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3336 test_compare(MEMCACHED_SUCCESS
,
3337 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3338 test_compare(MEMCACHED_SUCCESS
,
3339 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3340 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3341 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3342 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3344 memcached_return_t ret
;
3345 for (int count
= 0; count
< 5; ++count
)
3347 for (size_t x
= 0; x
< 100; ++x
)
3349 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3350 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
;
3358 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3361 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3364 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3367 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3370 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3376 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3377 memcached_strerror(NULL
, ret
));
3381 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3382 ** API and is _ONLY_ done this way to verify that the library works the
3383 ** way it is supposed to do!!!!
3387 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3389 const memcached_instance_st
* instance
=
3390 memcached_server_instance_by_position(memc
, x
);
3391 no_msg
+=(int)(instance
->cursor_active
);
3394 test_true(no_msg
== 0);
3396 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3399 ** Now validate that all items was set properly!
3401 for (size_t x
= 0; x
< 100; ++x
)
3405 int check_length
= snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3407 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3409 size_t len
= (size_t)check_length
;
3412 char* value
=memcached_get(memc
, key
, strlen(key
),
3413 &length
, &flags
, &ret
);
3414 // For the moment we will just go to the next key
3415 if (MEMCACHED_TIMEOUT
== ret
)
3419 test_true(ret
== MEMCACHED_SUCCESS
and value
!= NULL
);
3422 case 0: /* FALLTHROUGH */
3423 case 1: /* FALLTHROUGH */
3425 test_true(strncmp(value
, key
, len
) == 0);
3426 test_true(len
== length
);
3429 test_true(length
== len
* 2);
3432 test_true(length
== len
* 3);
3442 /* Try setting an illegal cas value (should not return an error to
3443 * the caller (because we don't expect a return message from the server)
3445 const char* keys
[]= {"0"};
3446 size_t lengths
[]= {1};
3449 memcached_result_st results_obj
;
3450 memcached_result_st
*results
;
3451 test_compare(MEMCACHED_SUCCESS
,
3452 memcached_mget(memc
, keys
, lengths
, 1));
3454 results
= memcached_result_create(memc
, &results_obj
);
3456 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3458 test_compare(MEMCACHED_SUCCESS
, ret
);
3459 uint64_t cas
= memcached_result_cas(results
);
3460 memcached_result_free(&results_obj
);
3462 test_compare(MEMCACHED_SUCCESS
,
3463 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3466 * The item will have a new cas value, so try to set it again with the old
3467 * value. This should fail!
3469 test_compare(MEMCACHED_SUCCESS
,
3470 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3471 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3472 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3473 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3476 return TEST_SUCCESS
;
3479 test_return_t
analyzer_test(memcached_st
*memc
)
3481 memcached_analysis_st
*report
;
3482 memcached_return_t rc
;
3484 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3485 test_compare(MEMCACHED_SUCCESS
, rc
);
3486 test_true(memc_stat
);
3488 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3489 test_compare(MEMCACHED_SUCCESS
, rc
);
3493 memcached_stat_free(NULL
, memc_stat
);
3495 return TEST_SUCCESS
;
3498 test_return_t
util_version_test(memcached_st
*memc
)
3500 test_compare(memcached_version(memc
), MEMCACHED_SUCCESS
);
3501 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3503 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3505 // We expect failure
3508 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3509 fprintf(stderr
, "\nDumping Server Information\n\n");
3510 memcached_server_fn callbacks
[1];
3512 callbacks
[0]= dump_server_information
;
3513 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3514 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3516 test_true(if_successful
== false);
3518 const memcached_instance_st
* instance
=
3519 memcached_server_instance_by_position(memc
, 0);
3521 memcached_version(memc
);
3523 // We only use one binary when we test, so this should be just fine.
3524 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3525 test_true(if_successful
== true);
3527 if (instance
->micro_version
> 0)
3529 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3531 else if (instance
->minor_version
> 0)
3533 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3535 else if (instance
->major_version
> 0)
3537 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3540 test_true(if_successful
== true);
3542 if (instance
->micro_version
> 0)
3544 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3546 else if (instance
->minor_version
> 0)
3548 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3550 else if (instance
->major_version
> 0)
3552 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3555 test_true(if_successful
== false);
3557 return TEST_SUCCESS
;
3560 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3562 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3563 memcached_return_t rc
;
3564 const memcached_instance_st
* instance
=
3565 memcached_server_instance_by_position(memc
, 0);
3567 // Test both the version that returns a code, and the one that does not.
3568 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3569 memcached_server_port(instance
) -1, NULL
) == -1);
3571 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3572 memcached_server_port(instance
) -1, &rc
) == -1);
3573 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3575 return TEST_SUCCESS
;
3579 test_return_t
getpid_test(memcached_st
*memc
)
3581 memcached_return_t rc
;
3582 const memcached_instance_st
* instance
=
3583 memcached_server_instance_by_position(memc
, 0);
3585 // Test both the version that returns a code, and the one that does not.
3586 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3587 memcached_server_port(instance
), NULL
) > -1);
3589 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3590 memcached_server_port(instance
), &rc
) > -1);
3591 test_compare(MEMCACHED_SUCCESS
, rc
);
3593 return TEST_SUCCESS
;
3596 static memcached_return_t
ping_each_server(const memcached_st
*,
3597 const memcached_instance_st
* instance
,
3600 // Test both the version that returns a code, and the one that does not.
3601 memcached_return_t rc
;
3602 if (libmemcached_util_ping(memcached_server_name(instance
),
3603 memcached_server_port(instance
), &rc
) == false)
3605 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d %s", memcached_server_name(instance
),
3606 memcached_server_port(instance
), memcached_strerror(NULL
, rc
));
3609 if (libmemcached_util_ping(memcached_server_name(instance
),
3610 memcached_server_port(instance
), NULL
) == false)
3612 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d", memcached_server_name(instance
), memcached_server_port(instance
));
3615 return MEMCACHED_SUCCESS
;
3618 test_return_t
libmemcached_util_ping_TEST(memcached_st
*memc
)
3620 memcached_server_fn callbacks
[1]= { ping_each_server
};
3621 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
3623 return TEST_SUCCESS
;
3628 test_return_t
hash_sanity_test (memcached_st
*memc
)
3632 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3633 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3634 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3635 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3636 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3637 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3638 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3639 #ifdef HAVE_HSIEH_HASH
3640 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3642 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3643 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3644 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3646 return TEST_SUCCESS
;
3650 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3652 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3654 test_compare(MEMCACHED_SUCCESS
,
3655 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3656 (uint64_t)MEMCACHED_HASH_HSIEH
));
3658 return TEST_SUCCESS
;
3661 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3663 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3665 test_compare(MEMCACHED_SUCCESS
,
3666 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3668 return TEST_SUCCESS
;
3671 test_return_t
one_at_a_time_run (memcached_st
*)
3676 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3678 test_compare(one_at_a_time_values
[x
],
3679 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3682 return TEST_SUCCESS
;
3685 test_return_t
md5_run (memcached_st
*)
3690 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3692 test_compare(md5_values
[x
],
3693 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3696 return TEST_SUCCESS
;
3699 test_return_t
crc_run (memcached_st
*)
3704 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3706 test_compare(crc_values
[x
],
3707 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3710 return TEST_SUCCESS
;
3713 test_return_t
fnv1_64_run (memcached_st
*)
3715 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3720 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3722 test_compare(fnv1_64_values
[x
],
3723 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3726 return TEST_SUCCESS
;
3729 test_return_t
fnv1a_64_run (memcached_st
*)
3731 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3736 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3738 test_compare(fnv1a_64_values
[x
],
3739 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3742 return TEST_SUCCESS
;
3745 test_return_t
fnv1_32_run (memcached_st
*)
3750 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3752 test_compare(fnv1_32_values
[x
],
3753 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3756 return TEST_SUCCESS
;
3759 test_return_t
fnv1a_32_run (memcached_st
*)
3764 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3766 test_compare(fnv1a_32_values
[x
],
3767 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3770 return TEST_SUCCESS
;
3773 test_return_t
hsieh_run (memcached_st
*)
3775 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3780 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3782 test_compare(hsieh_values
[x
],
3783 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3786 return TEST_SUCCESS
;
3789 test_return_t
murmur_run (memcached_st
*)
3791 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3793 #ifdef WORDS_BIGENDIAN
3794 (void)murmur_values
;
3795 return TEST_SKIPPED
;
3800 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3802 test_compare(murmur_values
[x
],
3803 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3806 return TEST_SUCCESS
;
3810 test_return_t
murmur3_TEST(hashkit_st
*)
3812 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR3
));
3814 #ifdef WORDS_BIGENDIAN
3815 (void)murmur3_values
;
3816 return TEST_SKIPPED
;
3821 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3823 test_compare(murmur3_values
[x
],
3824 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR3
));
3827 return TEST_SUCCESS
;
3831 test_return_t
jenkins_run (memcached_st
*)
3836 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3838 test_compare(jenkins_values
[x
],
3839 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3842 return TEST_SUCCESS
;
3845 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3847 return libhashkit_md5(string
, string_length
);
3850 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3852 return libhashkit_crc32(string
, string_length
);
3855 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3861 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3863 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};
3864 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};
3866 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3868 hashkit_clone(&new_kit
, kit
);
3869 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3871 memcached_set_hashkit(memc
, &new_kit
);
3874 Verify Setting the hash.
3876 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3880 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3881 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3886 Now check memcached_st.
3888 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3892 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3893 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3896 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3898 memcached_set_hashkit(memc
, &new_kit
);
3901 Verify Setting the hash.
3903 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3907 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3908 test_true(crc_values
[x
] == hash_val
);
3911 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3915 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3916 test_compare(crc_hosts
[x
], hash_val
);
3919 memcached_free(memc
);
3921 return TEST_SUCCESS
;
3925 Test case adapted from John Gorman <johngorman2@gmail.com>
3927 We are testing the error condition when we connect to a server via memcached_get()
3928 but find that the server is not available.
3930 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3934 memcached_return rc
;
3937 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3939 // See if memcached is reachable.
3940 char *value
= memcached_get(tl_memc_h
,
3941 test_literal_param(__func__
),
3946 test_true(memcached_failed(rc
));
3948 memcached_free(tl_memc_h
);
3950 return TEST_SUCCESS
;
3954 We connect to a server which exists, but search for a key that does not exist.
3956 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3960 memcached_return rc
;
3962 // See if memcached is reachable.
3963 char *value
= memcached_get(memc
,
3964 test_literal_param(__func__
),
3969 test_compare(MEMCACHED_NOTFOUND
, rc
);
3971 return TEST_SUCCESS
;
3975 Test case adapted from John Gorman <johngorman2@gmail.com>
3977 We are testing the error condition when we connect to a server via memcached_get_by_key()
3978 but find that the server is not available.
3980 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
3984 memcached_return rc
;
3987 memcached_st
*tl_memc_h
= memcached_create(NULL
);
3988 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
3989 memcached_server_push(tl_memc_h
, servers
);
3990 memcached_server_list_free(servers
);
3992 // See if memcached is reachable.
3993 char *value
= memcached_get_by_key(tl_memc_h
,
3994 test_literal_param(__func__
), // Key
3995 test_literal_param(__func__
), // Value
4000 test_true(memcached_failed(rc
));
4002 memcached_free(tl_memc_h
);
4004 return TEST_SUCCESS
;
4008 We connect to a server which exists, but search for a key that does not exist.
4010 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4014 memcached_return rc
;
4016 // See if memcached is reachable.
4017 char *value
= memcached_get_by_key(memc
,
4018 test_literal_param(__func__
), // Key
4019 test_literal_param(__func__
), // Value
4024 test_compare(MEMCACHED_NOTFOUND
, rc
);
4026 return TEST_SUCCESS
;
4029 test_return_t
regression_bug_434484(memcached_st
*memc
)
4031 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4033 test_compare(MEMCACHED_NOTSTORED
,
4034 memcached_append(memc
,
4035 test_literal_param(__func__
), // Key
4036 test_literal_param(__func__
), // Value
4039 libtest::vchar_t data
;
4040 data
.resize(2048 * 1024);
4041 test_compare(MEMCACHED_E2BIG
,
4043 test_literal_param(__func__
), // Key
4044 &data
[0], data
.size(), 0, 0));
4046 return TEST_SUCCESS
;
4049 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4051 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4053 memcached_return_t rc
;
4055 memcached_execute_fn callbacks
[]= { &callback_counter
};
4058 * I only want to hit only _one_ server so I know the number of requests I'm
4059 * sending in the pipleine to the server. Let's try to do a multiget of
4060 * 1024 (that should satisfy most users don't you think?). Future versions
4061 * will include a mget_execute function call if you need a higher number.
4063 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4068 * Run two times.. the first time we should have 100% cache miss,
4069 * and the second time we should have 100% cache hits
4071 for (ptrdiff_t y
= 0; y
< 2; y
++)
4073 test_compare(MEMCACHED_SUCCESS
,
4074 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4076 // One the first run we should get a NOT_FOUND, but on the second some data
4077 // should be returned.
4078 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4079 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4083 /* The first iteration should give me a 100% cache miss. verify that*/
4084 char blob
[1024]= { 0 };
4086 test_false(counter
);
4088 for (size_t x
= 0; x
< keys
.size(); ++x
)
4090 rc
= memcached_add(memc
,
4091 keys
.key_at(x
), keys
.length_at(x
),
4092 blob
, sizeof(blob
), 0, 0);
4093 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4098 /* Verify that we received all of the key/value pairs */
4099 test_compare(counter
, keys
.size());
4103 memcached_free(memc
);
4105 return TEST_SUCCESS
;
4108 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4110 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
4112 return regression_bug_434843(memc
);
4115 test_return_t
regression_bug_421108(memcached_st
*memc
)
4117 memcached_return_t rc
;
4118 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4119 test_compare(MEMCACHED_SUCCESS
, rc
);
4121 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4122 test_compare(MEMCACHED_SUCCESS
, rc
);
4123 test_true(bytes_str
);
4124 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4126 test_compare(MEMCACHED_SUCCESS
, rc
);
4127 test_true(bytes_read_str
);
4129 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4130 "bytes_written", &rc
);
4131 test_compare(MEMCACHED_SUCCESS
, rc
);
4132 test_true(bytes_written_str
);
4134 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4135 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4136 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4138 test_true(bytes
!= bytes_read
);
4139 test_true(bytes
!= bytes_written
);
4141 /* Release allocated resources */
4143 free(bytes_read_str
);
4144 free(bytes_written_str
);
4145 memcached_stat_free(NULL
, memc_stat
);
4147 return TEST_SUCCESS
;
4151 * The test case isn't obvious so I should probably document why
4152 * it works the way it does. Bug 442914 was caused by a bug
4153 * in the logic in memcached_purge (it did not handle the case
4154 * where the number of bytes sent was equal to the watermark).
4155 * In this test case, create messages so that we hit that case
4156 * and then disable noreply mode and issue a new command to
4157 * verify that it isn't stuck. If we change the format for the
4158 * delete command or the watermarks, we need to update this
4161 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
4163 test_skip(original_memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
4165 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
4167 for (uint32_t x
= 0; x
< 250; ++x
)
4170 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
4171 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4172 char error_buffer
[2048]= { 0 };
4173 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
4174 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
4177 // Delete, and then delete again to look for not found
4180 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
4181 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4182 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4184 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
4185 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
4188 memcached_free(memc
);
4190 return TEST_SUCCESS
;
4193 test_return_t
regression_bug_447342(memcached_st
*memc
)
4195 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4197 return TEST_SKIPPED
;
4200 test_compare(MEMCACHED_SUCCESS
,
4201 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4205 for (size_t x
= 0; x
< keys
.size(); ++x
)
4207 test_compare(MEMCACHED_SUCCESS
,
4209 keys
.key_at(x
), keys
.length_at(x
), // Keys
4210 keys
.key_at(x
), keys
.length_at(x
), // Values
4215 ** We are using the quiet commands to store the replicas, so we need
4216 ** to ensure that all of them are processed before we can continue.
4217 ** In the test we go directly from storing the object to trying to
4218 ** receive the object from all of the different servers, so we
4219 ** could end up in a race condition (the memcached server hasn't yet
4220 ** processed the quiet command from the replication set when it process
4221 ** the request from the other client (created by the clone)). As a
4222 ** workaround for that we call memcached_quit to send the quit command
4223 ** to the server and wait for the response ;-) If you use the test code
4224 ** as an example for your own code, please note that you shouldn't need
4227 memcached_quit(memc
);
4229 /* Verify that all messages are stored, and we didn't stuff too much
4232 test_compare(MEMCACHED_SUCCESS
,
4233 memcached_mget(memc
,
4234 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4236 unsigned int counter
= 0;
4237 memcached_execute_fn callbacks
[]= { &callback_counter
};
4238 test_compare(MEMCACHED_SUCCESS
,
4239 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4241 /* Verify that we received all of the key/value pairs */
4242 test_compare(counter
, keys
.size());
4244 memcached_quit(memc
);
4246 * Don't do the following in your code. I am abusing the internal details
4247 * within the library, and this is not a supported interface.
4248 * This is to verify correct behavior in the library. Fake that two servers
4251 const memcached_instance_st
* instance_one
= memcached_server_instance_by_position(memc
, 0);
4252 const memcached_instance_st
* instance_two
= memcached_server_instance_by_position(memc
, 2);
4253 in_port_t port0
= instance_one
->port();
4254 in_port_t port2
= instance_two
->port();
4256 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4257 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4259 test_compare(MEMCACHED_SUCCESS
,
4260 memcached_mget(memc
,
4261 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4264 test_compare(MEMCACHED_SUCCESS
,
4265 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4266 test_compare(counter
, keys
.size());
4268 /* restore the memc handle */
4269 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4270 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4272 memcached_quit(memc
);
4274 /* Remove half of the objects */
4275 for (size_t x
= 0; x
< keys
.size(); ++x
)
4279 test_compare(MEMCACHED_SUCCESS
,
4280 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4284 memcached_quit(memc
);
4285 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4286 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4288 /* now retry the command, this time we should have cache misses */
4289 test_compare(MEMCACHED_SUCCESS
,
4290 memcached_mget(memc
,
4291 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4294 test_compare(MEMCACHED_SUCCESS
,
4295 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4296 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4298 /* restore the memc handle */
4299 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4300 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4302 return TEST_SUCCESS
;
4305 test_return_t
regression_bug_463297(memcached_st
*memc
)
4307 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4309 // Since we blocked timed delete, this test is no longer valid.
4311 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4312 test_true(memc_clone
);
4313 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4315 const memcached_instance_st
* instance
=
4316 memcached_server_instance_by_position(memc_clone
, 0);
4318 if (instance
->major_version
> 1 ||
4319 (instance
->major_version
== 1 &&
4320 instance
->minor_version
> 2))
4322 /* Binary protocol doesn't support deferred delete */
4323 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4324 test_true(bin_clone
);
4325 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4326 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4327 memcached_free(bin_clone
);
4329 memcached_quit(memc_clone
);
4331 /* If we know the server version, deferred delete should fail
4332 * with invalid arguments */
4333 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4335 /* If we don't know the server version, we should get a protocol error */
4336 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4338 /* but there is a bug in some of the memcached servers (1.4) that treats
4339 * the counter as noreply so it doesn't send the proper error message
4341 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4343 /* And buffered mode should be disabled and we should get protocol error */
4344 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4345 rc
= memcached_delete(memc
, "foo", 3, 1);
4346 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4348 /* Same goes for noreply... */
4349 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4350 rc
= memcached_delete(memc
, "foo", 3, 1);
4351 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4353 /* but a normal request should go through (and be buffered) */
4354 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4355 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4357 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4358 /* unbuffered noreply should be success */
4359 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4360 /* unbuffered with reply should be not found... */
4361 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4362 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4365 memcached_free(memc_clone
);
4368 return TEST_SUCCESS
;
4372 /* Test memcached_server_get_last_disconnect
4373 * For a working server set, shall be NULL
4374 * For a set of non existing server, shall not be NULL
4376 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4378 memcached_return_t rc
;
4379 const memcached_instance_st
* disconnected_server
;
4381 /* With the working set of server */
4382 const char *key
= "marmotte";
4383 const char *value
= "milka";
4385 memcached_reset_last_disconnected_server(memc
);
4386 test_false(memc
->last_disconnected_server
);
4387 rc
= memcached_set(memc
, key
, strlen(key
),
4388 value
, strlen(value
),
4389 (time_t)0, (uint32_t)0);
4390 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4392 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4393 test_false(disconnected_server
);
4395 /* With a non existing server */
4397 memcached_server_st
*servers
;
4399 const char *server_list
= "localhost:9";
4401 servers
= memcached_servers_parse(server_list
);
4403 mine
= memcached_create(NULL
);
4404 rc
= memcached_server_push(mine
, servers
);
4405 test_compare(MEMCACHED_SUCCESS
, rc
);
4406 memcached_server_list_free(servers
);
4409 rc
= memcached_set(mine
, key
, strlen(key
),
4410 value
, strlen(value
),
4411 (time_t)0, (uint32_t)0);
4412 test_true(memcached_failed(rc
));
4414 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4415 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4416 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4417 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4419 memcached_quit(mine
);
4420 memcached_free(mine
);
4422 return TEST_SUCCESS
;
4425 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4427 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4428 char buffer
[BUFSIZ
];
4430 test_compare(MEMCACHED_SUCCESS
,
4431 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4433 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4436 // We will just use the error strings as our keys
4437 uint32_t counter
= 100;
4440 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4442 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4443 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4444 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4446 const memcached_instance_st
* disconnected_server
= memcached_server_get_last_disconnect(memc
);
4447 test_true(disconnected_server
);
4448 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4449 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4453 memcached_reset_last_disconnected_server(memc
);
4458 memcached_free(memc
);
4460 return TEST_SUCCESS
;
4463 test_return_t
test_verbosity(memcached_st
*memc
)
4465 memcached_verbosity(memc
, 3);
4467 return TEST_SUCCESS
;
4471 static memcached_return_t
stat_printer(const memcached_instance_st
* server
,
4472 const char *key
, size_t key_length
,
4473 const char *value
, size_t value_length
,
4483 return MEMCACHED_SUCCESS
;
4486 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4488 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4489 test_compare(MEMCACHED_SUCCESS
, rc
);
4491 test_compare(MEMCACHED_SUCCESS
,
4492 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4494 test_compare(MEMCACHED_SUCCESS
,
4495 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4497 test_compare(MEMCACHED_SUCCESS
,
4498 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4500 return TEST_SUCCESS
;
4504 * This test ensures that the failure counter isn't incremented during
4505 * normal termination of the memcached instance.
4507 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4509 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4511 /* Ensure that we are connected to the server by setting a value */
4512 memcached_return_t rc
= memcached_set(memc
,
4513 test_literal_param(__func__
), // Key
4514 test_literal_param(__func__
), // Value
4515 time_t(0), uint32_t(0));
4516 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4519 const memcached_instance_st
* instance
= memcached_server_instance_by_position(memc
, 0);
4521 /* The test is to see that the memcached_quit doesn't increase the
4522 * the server failure conter, so let's ensure that it is zero
4523 * before sending quit
4525 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4527 memcached_quit(memc
);
4529 /* Verify that it memcached_quit didn't increment the failure counter
4530 * Please note that this isn't bullet proof, because an error could
4533 test_zero(instance
->server_failure_counter
);
4535 memcached_free(memc
);
4537 return TEST_SUCCESS
;
4541 * This tests ensures expected disconnections (for some behavior changes
4542 * for instance) do not wrongly increase failure counter
4544 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4546 /* Set value to force connection to the server */
4547 const char *key
= "marmotte";
4548 const char *value
= "milka";
4550 test_compare_hint(MEMCACHED_SUCCESS
,
4551 memcached_set(memc
, key
, strlen(key
),
4552 value
, strlen(value
),
4553 (time_t)0, (uint32_t)0),
4554 memcached_last_error_message(memc
));
4557 /* put failure limit to 1 */
4558 test_compare(MEMCACHED_SUCCESS
,
4559 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4561 /* Put a retry timeout to effectively activate failure_limit effect */
4562 test_compare(MEMCACHED_SUCCESS
,
4563 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4565 /* change behavior that triggers memcached_quit()*/
4566 test_compare(MEMCACHED_SUCCESS
,
4567 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4570 /* Check if we still are connected */
4572 size_t string_length
;
4573 memcached_return rc
;
4574 char *string
= memcached_get(memc
, key
, strlen(key
),
4575 &string_length
, &flags
, &rc
);
4577 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4581 return TEST_SUCCESS
;
4584 test_return_t
regression_996813_TEST(memcached_st
*)
4586 memcached_st
* memc
= memcached_create(NULL
);
4588 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
4589 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
4590 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4591 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4592 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1));
4593 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 300));
4594 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 30));
4596 // We will never connect to these servers
4597 in_port_t base_port
= 11211;
4598 for (size_t x
= 0; x
< 17; x
++)
4600 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", base_port
+x
));
4602 test_compare(6U, memcached_generate_hash(memc
, test_literal_param("SZ6hu0SHweFmpwpc0w2R")));
4603 test_compare(1U, memcached_generate_hash(memc
, test_literal_param("SQCK9eiCf53YxHWnYA.o")));
4604 test_compare(9U, memcached_generate_hash(memc
, test_literal_param("SUSDkGXuuZC9t9VhMwa.")));
4605 test_compare(0U, memcached_generate_hash(memc
, test_literal_param("SnnqnJARfaCNT679iAF_")));
4607 memcached_free(memc
);
4609 return TEST_SUCCESS
;
4614 * Test that ensures mget_execute does not end into recursive calls that finally fails
4616 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4620 return TEST_SKIPPED
; // My MAC can't handle this test
4623 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4626 * I only want to hit _one_ server so I know the number of requests I'm
4627 * sending in the pipeline.
4629 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4632 keys_st
keys(20480);
4634 /* First add all of the items.. */
4635 char blob
[1024]= { 0 };
4636 for (size_t x
= 0; x
< keys
.size(); ++x
)
4638 memcached_return rc
= memcached_set(memc
,
4639 keys
.key_at(x
), keys
.length_at(x
),
4640 blob
, sizeof(blob
), 0, 0);
4641 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4646 /* Try to get all of them with a large multiget */
4648 memcached_execute_function callbacks
[]= { &callback_counter
};
4649 memcached_return_t rc
= memcached_mget_execute(memc
,
4650 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4651 callbacks
, &counter
, 1);
4652 test_compare(MEMCACHED_SUCCESS
, rc
);
4654 char* the_value
= NULL
;
4655 char the_key
[MEMCACHED_MAX_KEY
];
4656 size_t the_key_length
;
4657 size_t the_value_length
;
4661 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4663 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4669 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4672 test_compare(MEMCACHED_END
, rc
);
4674 /* Verify that we got all of the items */
4675 test_compare(counter
, keys
.size());
4678 memcached_free(memc
);
4680 return TEST_SUCCESS
;
4683 test_return_t
regression_1021819_TEST(memcached_st
*original
)
4685 memcached_st
*memc
= memcached_clone(NULL
, original
);
4688 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 2000000), MEMCACHED_SUCCESS
);
4689 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 3000000), MEMCACHED_SUCCESS
);
4691 memcached_return_t rc
;
4694 test_literal_param(__func__
),
4697 test_compare(rc
, MEMCACHED_NOTFOUND
);
4699 memcached_free(memc
);
4701 return TEST_SUCCESS
;
4704 test_return_t
regression_bug_583031(memcached_st
*)
4706 memcached_st
*memc
= memcached_create(NULL
);
4708 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.251.4", 11211));
4710 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 3000);
4711 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4712 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4713 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4714 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4715 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4717 memcached_return_t rc
;
4721 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4725 test_compare(MEMCACHED_TIMEOUT
, memc
);
4727 memcached_free(memc
);
4729 return TEST_SUCCESS
;
4732 test_return_t
regression_bug_581030(memcached_st
*)
4735 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4736 test_false(local_stat
);
4738 memcached_stat_free(NULL
, NULL
);
4741 return TEST_SUCCESS
;
4744 #define regression_bug_655423_COUNT 6000
4745 test_return_t
regression_bug_655423(memcached_st
*memc
)
4747 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4748 memc
= NULL
; // Just to make sure it is not used
4753 return TEST_SKIPPED
;
4756 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4757 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4758 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4759 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4761 memset(payload
, int('x'), sizeof(payload
));
4763 keys_st
keys(regression_bug_655423_COUNT
);
4765 for (size_t x
= 0; x
< keys
.size(); x
++)
4767 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4770 payload
, sizeof(payload
), 0, 0));
4773 for (size_t x
= 0; x
< keys
.size(); x
++)
4775 size_t value_length
;
4776 memcached_return_t rc
;
4777 char *value
= memcached_get(clone
,
4780 &value_length
, NULL
, &rc
);
4782 if (rc
== MEMCACHED_NOTFOUND
)
4785 test_zero(value_length
);
4789 test_compare(MEMCACHED_SUCCESS
, rc
);
4791 test_compare(100LLU, value_length
);
4795 test_compare(MEMCACHED_SUCCESS
,
4796 memcached_mget(clone
,
4797 keys
.keys_ptr(), keys
.lengths_ptr(),
4801 memcached_result_st
*result
= NULL
;
4802 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4804 test_compare(size_t(100), memcached_result_length(result
));
4808 test_true(count
> 100); // If we don't get back atleast this, something is up
4810 memcached_free(clone
);
4812 return TEST_SUCCESS
;
4816 * Test that ensures that buffered set to not trigger problems during io_flush
4818 #define regression_bug_490520_COUNT 200480
4819 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4821 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4823 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4824 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4825 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4826 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4827 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4829 /* First add all of the items.. */
4830 char blob
[3333] = {0};
4831 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4834 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4836 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4837 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4840 memcached_free(memc
);
4842 return TEST_SUCCESS
;
4845 test_return_t
regression_1009493_TEST(memcached_st
*)
4847 memcached_st
* memc
= memcached_create(NULL
);
4849 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, true));
4851 memcached_st
* clone
= memcached_clone(NULL
, memc
);
4854 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
),
4855 memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
4857 memcached_free(memc
);
4858 memcached_free(clone
);
4860 return TEST_SUCCESS
;
4863 test_return_t
regression_994772_TEST(memcached_st
* memc
)
4865 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4867 test_compare(MEMCACHED_SUCCESS
,
4869 test_literal_param(__func__
), // Key
4870 test_literal_param(__func__
), // Value
4871 time_t(0), uint32_t(0)));
4873 const char *keys
[] = { __func__
};
4874 size_t key_length
[]= { strlen(__func__
) };
4875 test_compare(MEMCACHED_SUCCESS
,
4876 memcached_mget(memc
, keys
, key_length
, 1));
4878 memcached_return_t rc
;
4879 memcached_result_st
*results
= memcached_fetch_result(memc
, NULL
, &rc
);
4881 test_compare(MEMCACHED_SUCCESS
, rc
);
4883 test_strcmp(__func__
, memcached_result_value(results
));
4884 uint64_t cas_value
= memcached_result_cas(results
);
4885 test_true(cas_value
);
4887 char* take_value
= memcached_result_take_value(results
);
4888 test_strcmp(__func__
, take_value
);
4891 memcached_result_free(results
);
4893 // Bad cas value, sanity check
4894 test_true(cas_value
!= 9999);
4895 test_compare(MEMCACHED_END
,
4897 test_literal_param(__func__
), // Key
4898 test_literal_param(__FILE__
), // Value
4899 time_t(0), uint32_t(0), 9999));
4901 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
4902 "different", strlen("different"), // Key
4903 test_literal_param(__FILE__
), // Value
4904 time_t(0), uint32_t(0)));
4906 return TEST_SUCCESS
;
4909 test_return_t
regression_bug_854604(memcached_st
*)
4913 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4915 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4917 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4918 test_compare(buffer
[0], 0);
4920 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4921 test_true(strlen(buffer
));
4923 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4924 test_true(strlen(buffer
));
4926 return TEST_SUCCESS
;
4929 static void die_message(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4931 fprintf(stderr
, "Iteration #%u: ", it
);
4933 if (error
== MEMCACHED_ERRNO
)
4935 fprintf(stderr
, "system error %d from %s: %s\n",
4936 errno
, what
, strerror(errno
));
4940 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4941 memcached_strerror(mc
, error
));
4945 #define TEST_CONSTANT_CREATION 200
4947 test_return_t
regression_bug_(memcached_st
*memc
)
4949 const char *remote_server
;
4952 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4954 return TEST_SKIPPED
;
4957 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4959 memcached_st
* mc
= memcached_create(NULL
);
4960 memcached_return rc
;
4962 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4963 if (rc
!= MEMCACHED_SUCCESS
)
4965 die_message(mc
, rc
, "memcached_behavior_set", x
);
4968 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4969 if (rc
!= MEMCACHED_SUCCESS
)
4971 die_message(mc
, rc
, "memcached_behavior_set", x
);
4974 rc
= memcached_server_add(mc
, remote_server
, 0);
4975 if (rc
!= MEMCACHED_SUCCESS
)
4977 die_message(mc
, rc
, "memcached_server_add", x
);
4980 const char *set_key
= "akey";
4981 const size_t set_key_len
= strlen(set_key
);
4982 const char *set_value
= "a value";
4983 const size_t set_value_len
= strlen(set_value
);
4985 if (rc
== MEMCACHED_SUCCESS
)
4989 size_t get_value_len
;
4991 uint32_t get_value_flags
;
4993 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
4994 &get_value_flags
, &rc
);
4995 if (rc
!= MEMCACHED_SUCCESS
)
4997 die_message(mc
, rc
, "memcached_get", x
);
5003 (get_value_len
!= set_value_len
5004 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5006 fprintf(stderr
, "Values don't match?\n");
5007 rc
= MEMCACHED_FAILURE
;
5013 rc
= memcached_set(mc
,
5014 set_key
, set_key_len
,
5015 set_value
, set_value_len
,
5019 if (rc
!= MEMCACHED_SUCCESS
)
5021 die_message(mc
, rc
, "memcached_set", x
);
5028 if (rc
!= MEMCACHED_SUCCESS
)
5034 return TEST_SUCCESS
;
5037 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
5039 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
5042 const memcached_instance_st
* instance
= memcached_server_instance_by_position(memc
, 0);
5045 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
5046 memcached_server_port(instance
), NULL
)) > -1);
5049 test_compare(MEMCACHED_SUCCESS
,
5051 test_literal_param(__func__
), // Keys
5052 test_literal_param(__func__
), // Values
5054 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
5056 memcached_return_t ret
= memcached_set(memc
,
5057 test_literal_param(__func__
), // Keys
5058 test_literal_param(__func__
), // Values
5060 test_compare(ret
, memc
);
5061 test_compare(MEMCACHED_CONNECTION_FAILURE
, memc
);
5063 memcached_free(memc
);
5065 return TEST_SUCCESS
;