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 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1299 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1301 uint64_t new_number
;
1302 uint64_t initial
= 0;
1304 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1306 test_compare(MEMCACHED_SUCCESS
,
1307 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1308 test_compare(new_number
, initial
);
1310 test_compare(MEMCACHED_SUCCESS
,
1311 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1312 test_compare(new_number
, (initial
+1));
1314 return TEST_SUCCESS
;
1317 test_return_t
decrement_test(memcached_st
*memc
)
1319 test_compare(return_value_based_on_buffering(memc
),
1321 test_literal_param(__func__
),
1322 test_literal_param("3"),
1323 time_t(0), uint32_t(0)));
1325 // Make sure we flush the value we just set
1326 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1328 uint64_t new_number
;
1329 test_compare(MEMCACHED_SUCCESS
,
1330 memcached_decrement(memc
,
1331 test_literal_param(__func__
),
1333 test_compare(uint64_t(2), new_number
);
1335 test_compare(MEMCACHED_SUCCESS
,
1336 memcached_decrement(memc
,
1337 test_literal_param(__func__
),
1339 test_compare(uint64_t(1), new_number
);
1341 return TEST_SUCCESS
;
1344 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1346 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1348 uint64_t initial
= 3;
1350 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1352 uint64_t new_number
;
1353 test_compare(MEMCACHED_SUCCESS
,
1354 memcached_decrement_with_initial(memc
,
1355 test_literal_param(__func__
),
1358 test_compare(new_number
, initial
);
1360 test_compare(MEMCACHED_SUCCESS
,
1361 memcached_decrement_with_initial(memc
,
1362 test_literal_param(__func__
),
1365 test_compare(new_number
, (initial
- 1));
1367 return TEST_SUCCESS
;
1370 test_return_t
increment_by_key_test(memcached_st
*memc
)
1372 const char *master_key
= "foo";
1373 const char *key
= "number";
1374 const char *value
= "0";
1376 test_compare(return_value_based_on_buffering(memc
),
1377 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1379 value
, strlen(value
),
1380 time_t(0), uint32_t(0)));
1382 // Make sure we flush the value we just set
1383 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1385 uint64_t new_number
;
1386 test_compare(MEMCACHED_SUCCESS
,
1387 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1388 key
, strlen(key
), 1, &new_number
));
1389 test_compare(uint64_t(1), new_number
);
1391 test_compare(MEMCACHED_SUCCESS
,
1392 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1393 key
, strlen(key
), 1, &new_number
));
1394 test_compare(uint64_t(2), new_number
);
1396 return TEST_SUCCESS
;
1399 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1401 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1403 uint64_t new_number
;
1404 const char *master_key
= "foo";
1405 const char *key
= "number";
1406 uint64_t initial
= 0;
1408 test_compare(MEMCACHED_SUCCESS
,
1409 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1411 1, initial
, 0, &new_number
));
1412 test_compare(new_number
, initial
);
1414 test_compare(MEMCACHED_SUCCESS
,
1415 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1417 1, initial
, 0, &new_number
));
1418 test_compare(new_number
, (initial
+1));
1420 return TEST_SUCCESS
;
1423 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1425 uint64_t new_number
;
1426 const char *value
= "3";
1428 test_compare(return_value_based_on_buffering(memc
),
1429 memcached_set_by_key(memc
,
1430 test_literal_param("foo"),
1431 test_literal_param("number"),
1432 value
, strlen(value
),
1433 (time_t)0, (uint32_t)0));
1435 test_compare(MEMCACHED_SUCCESS
,
1436 memcached_decrement_by_key(memc
,
1437 test_literal_param("foo"),
1438 test_literal_param("number"),
1440 test_compare(uint64_t(2), new_number
);
1442 test_compare(MEMCACHED_SUCCESS
,
1443 memcached_decrement_by_key(memc
,
1444 test_literal_param("foo"),
1445 test_literal_param("number"),
1447 test_compare(uint64_t(1), new_number
);
1449 return TEST_SUCCESS
;
1452 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1454 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1456 uint64_t new_number
;
1457 uint64_t initial
= 3;
1459 test_compare(MEMCACHED_SUCCESS
,
1460 memcached_decrement_with_initial_by_key(memc
,
1461 test_literal_param("foo"),
1462 test_literal_param("number"),
1463 1, initial
, 0, &new_number
));
1464 test_compare(new_number
, initial
);
1466 test_compare(MEMCACHED_SUCCESS
,
1467 memcached_decrement_with_initial_by_key(memc
,
1468 test_literal_param("foo"),
1469 test_literal_param("number"),
1470 1, initial
, 0, &new_number
));
1471 test_compare(new_number
, (initial
- 1));
1473 return TEST_SUCCESS
;
1475 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1477 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1479 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1481 test_compare(return_value_based_on_buffering(memc
),
1483 test_literal_param("number"),
1484 test_literal_param("0"),
1485 (time_t)0, (uint32_t)0));
1487 uint64_t new_number
;
1488 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1489 test_literal_param("number"),
1491 test_compare(uint64_t(1), new_number
);
1493 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1494 test_literal_param("number"),
1496 test_compare(uint64_t(2), new_number
);
1498 return TEST_SUCCESS
;
1501 test_return_t
quit_test(memcached_st
*memc
)
1503 const char *value
= "sanford and sun";
1505 test_compare(return_value_based_on_buffering(memc
),
1507 test_literal_param(__func__
),
1508 value
, strlen(value
),
1509 time_t(10), uint32_t(3)));
1510 memcached_quit(memc
);
1512 test_compare(return_value_based_on_buffering(memc
),
1514 test_literal_param(__func__
),
1515 value
, strlen(value
),
1516 time_t(50), uint32_t(9)));
1518 return TEST_SUCCESS
;
1521 test_return_t
mget_result_test(memcached_st
*memc
)
1523 const char *keys
[]= {"fudge", "son", "food"};
1524 size_t key_length
[]= {5, 3, 4};
1526 memcached_result_st results_obj
;
1527 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1529 test_true(&results_obj
== results
);
1531 /* We need to empty the server before continueing test */
1532 test_compare(MEMCACHED_SUCCESS
,
1533 memcached_flush(memc
, 0));
1535 test_compare(MEMCACHED_SUCCESS
,
1536 memcached_mget(memc
, keys
, key_length
, 3));
1538 memcached_return_t rc
;
1539 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1544 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1545 test_false(results
);
1546 test_compare(MEMCACHED_NOTFOUND
, rc
);
1548 for (uint32_t x
= 0; x
< 3; x
++)
1550 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1551 keys
[x
], key_length
[x
],
1552 (time_t)50, (uint32_t)9);
1553 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1556 test_compare(MEMCACHED_SUCCESS
,
1557 memcached_mget(memc
, keys
, key_length
, 3));
1559 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1562 test_true(&results_obj
== results
);
1563 test_compare(MEMCACHED_SUCCESS
, rc
);
1564 test_memcmp(memcached_result_key_value(results
),
1565 memcached_result_value(results
),
1566 memcached_result_length(results
));
1567 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1570 memcached_result_free(&results_obj
);
1572 return TEST_SUCCESS
;
1575 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1577 const char *keys
[]= {"fudge", "son", "food"};
1578 size_t key_length
[]= {5, 3, 4};
1580 memcached_result_st
*results
;
1582 /* We need to empty the server before continueing test */
1583 test_compare(MEMCACHED_SUCCESS
,
1584 memcached_flush(memc
, 0));
1586 test_compare(MEMCACHED_SUCCESS
,
1587 memcached_mget(memc
, keys
, key_length
, 3));
1589 memcached_return_t rc
;
1590 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1594 test_false(results
);
1595 test_compare(MEMCACHED_NOTFOUND
, rc
);
1597 for (uint32_t x
= 0; x
< 3; x
++)
1599 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1600 keys
[x
], key_length
[x
],
1601 (time_t)50, (uint32_t)9);
1602 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1605 test_compare(MEMCACHED_SUCCESS
,
1606 memcached_mget(memc
, keys
, key_length
, 3));
1609 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1612 test_compare(MEMCACHED_SUCCESS
, rc
);
1613 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1614 test_memcmp(memcached_result_key_value(results
),
1615 memcached_result_value(results
),
1616 memcached_result_length(results
));
1617 memcached_result_free(results
);
1621 return TEST_SUCCESS
;
1624 test_return_t
mget_result_function(memcached_st
*memc
)
1626 const char *keys
[]= {"fudge", "son", "food"};
1627 size_t key_length
[]= {5, 3, 4};
1629 memcached_execute_fn callbacks
[1];
1631 for (uint32_t x
= 0; x
< 3; x
++)
1633 test_compare(return_value_based_on_buffering(memc
),
1634 memcached_set(memc
, keys
[x
], key_length
[x
],
1635 keys
[x
], key_length
[x
],
1636 time_t(50), uint32_t(9)));
1638 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1639 memcached_quit(memc
);
1641 test_compare(MEMCACHED_SUCCESS
,
1642 memcached_mget(memc
, keys
, key_length
, 3));
1644 callbacks
[0]= &callback_counter
;
1647 test_compare(MEMCACHED_SUCCESS
,
1648 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1650 test_compare(size_t(3), counter
);
1652 return TEST_SUCCESS
;
1655 test_return_t
mget_test(memcached_st
*memc
)
1657 const char *keys
[]= {"fudge", "son", "food"};
1658 size_t key_length
[]= {5, 3, 4};
1660 char return_key
[MEMCACHED_MAX_KEY
];
1661 size_t return_key_length
;
1663 size_t return_value_length
;
1665 test_compare(MEMCACHED_SUCCESS
,
1666 memcached_mget(memc
, keys
, key_length
, 3));
1669 memcached_return_t rc
;
1670 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1671 &return_value_length
, &flags
, &rc
)))
1673 test_true(return_value
);
1675 test_false(return_value
);
1676 test_zero(return_value_length
);
1677 test_compare(MEMCACHED_NOTFOUND
, rc
);
1679 for (uint32_t x
= 0; x
< 3; x
++)
1681 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1682 keys
[x
], key_length
[x
],
1683 (time_t)50, (uint32_t)9);
1684 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1686 test_compare(MEMCACHED_SUCCESS
,
1687 memcached_mget(memc
, keys
, key_length
, 3));
1690 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1691 &return_value_length
, &flags
, &rc
)))
1693 test_true(return_value
);
1694 test_compare(MEMCACHED_SUCCESS
, rc
);
1695 if (not memc
->_namespace
)
1697 test_compare(return_key_length
, return_value_length
);
1698 test_memcmp(return_value
, return_key
, return_value_length
);
1704 return TEST_SUCCESS
;
1707 test_return_t
mget_execute(memcached_st
*original_memc
)
1709 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1711 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1714 keys_st
keys(20480);
1716 /* First add all of the items.. */
1717 char blob
[1024] = {0};
1719 for (size_t x
= 0; x
< keys
.size(); ++x
)
1721 uint64_t query_id
= memcached_query_id(memc
);
1722 memcached_return_t rc
= memcached_add(memc
,
1723 keys
.key_at(x
), keys
.length_at(x
),
1726 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1727 test_compare(query_id
+1, memcached_query_id(memc
));
1730 /* Try to get all of them with a large multiget */
1732 memcached_execute_fn callbacks
[]= { &callback_counter
};
1733 test_compare(MEMCACHED_SUCCESS
,
1734 memcached_mget_execute(memc
,
1735 keys
.keys_ptr(), keys
.lengths_ptr(),
1736 keys
.size(), callbacks
, &counter
, 1));
1739 uint64_t query_id
= memcached_query_id(memc
);
1740 test_compare(MEMCACHED_SUCCESS
,
1741 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1742 test_compare(query_id
, memcached_query_id(memc
));
1744 /* Verify that we got all of the items */
1745 test_compare(keys
.size(), counter
);
1748 memcached_free(memc
);
1750 return TEST_SUCCESS
;
1753 test_return_t
MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST(memcached_st
*original_memc
)
1755 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1757 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1760 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 8));
1762 keys_st
keys(20480);
1764 /* First add all of the items.. */
1765 char blob
[1024] = {0};
1767 for (size_t x
= 0; x
< keys
.size(); ++x
)
1769 uint64_t query_id
= memcached_query_id(memc
);
1770 memcached_return_t rc
= memcached_add(memc
,
1771 keys
.key_at(x
), keys
.length_at(x
),
1774 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1775 test_compare(query_id
+1, memcached_query_id(memc
));
1778 /* Try to get all of them with a large multiget */
1780 memcached_execute_fn callbacks
[]= { &callback_counter
};
1781 test_compare(MEMCACHED_SUCCESS
,
1782 memcached_mget_execute(memc
,
1783 keys
.keys_ptr(), keys
.lengths_ptr(),
1784 keys
.size(), callbacks
, &counter
, 1));
1787 uint64_t query_id
= memcached_query_id(memc
);
1788 test_compare(MEMCACHED_SUCCESS
,
1789 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1790 test_compare(query_id
, memcached_query_id(memc
));
1792 /* Verify that we got all of the items */
1793 test_compare(keys
.size(), counter
);
1796 memcached_free(memc
);
1798 return TEST_SUCCESS
;
1801 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1802 static pairs_st
*global_pairs
= NULL
;
1804 test_return_t
key_setup(memcached_st
*memc
)
1806 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1808 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1810 return TEST_SUCCESS
;
1813 test_return_t
key_teardown(memcached_st
*)
1815 pairs_free(global_pairs
);
1818 return TEST_SUCCESS
;
1821 test_return_t
block_add_regression(memcached_st
*memc
)
1823 /* First add all of the items.. */
1824 for (ptrdiff_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1826 libtest::vchar_t blob
;
1827 libtest::vchar::make(blob
, 1024);
1829 memcached_return_t rc
= memcached_add_by_key(memc
,
1830 test_literal_param("bob"),
1831 global_pairs
[x
].key
, global_pairs
[x
].key_length
,
1832 &blob
[0], blob
.size(),
1833 time_t(0), uint32_t(0));
1834 if (rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
)
1836 Error
<< memcached_last_error_message(memc
);
1837 return TEST_SKIPPED
;
1839 test_compare(*memc
, MEMCACHED_SUCCESS
);
1840 test_compare(rc
, MEMCACHED_SUCCESS
);
1843 return TEST_SUCCESS
;
1846 test_return_t
binary_add_regression(memcached_st
*memc
)
1848 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1849 return block_add_regression(memc
);
1852 test_return_t
get_stats_keys(memcached_st
*memc
)
1856 memcached_stat_st memc_stat
;
1857 memcached_return_t rc
;
1859 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1860 test_compare(MEMCACHED_SUCCESS
, rc
);
1861 for (ptr
= stat_list
; *ptr
; ptr
++)
1866 return TEST_SUCCESS
;
1869 test_return_t
version_string_test(memcached_st
*)
1871 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1873 return TEST_SUCCESS
;
1876 test_return_t
get_stats(memcached_st
*memc
)
1878 memcached_return_t rc
;
1880 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1881 test_compare(MEMCACHED_SUCCESS
, rc
);
1882 test_true(memc_stat
);
1884 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1886 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1887 test_compare(MEMCACHED_SUCCESS
, rc
);
1888 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1893 memcached_stat_free(NULL
, memc_stat
);
1895 return TEST_SUCCESS
;
1898 test_return_t
add_host_test(memcached_st
*memc
)
1900 char servername
[]= "0.example.com";
1902 memcached_return_t rc
;
1903 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1904 test_compare(1U, memcached_server_list_count(servers
));
1906 for (unsigned int x
= 2; x
< 20; x
++)
1908 char buffer
[SMALL_STRING_LEN
];
1910 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1911 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1913 test_compare(MEMCACHED_SUCCESS
, rc
);
1914 test_compare(x
, memcached_server_list_count(servers
));
1917 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1918 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1920 memcached_server_list_free(servers
);
1922 return TEST_SUCCESS
;
1925 test_return_t
regression_1048945_TEST(memcached_st
*)
1927 memcached_return status
;
1929 memcached_server_st
* list
= memcached_server_list_append_with_weight(NULL
, "a", 11211, 0, &status
);
1930 test_compare(status
, MEMCACHED_SUCCESS
);
1932 list
= memcached_server_list_append_with_weight(list
, "b", 11211, 0, &status
);
1933 test_compare(status
, MEMCACHED_SUCCESS
);
1935 list
= memcached_server_list_append_with_weight(list
, "c", 11211, 0, &status
);
1936 test_compare(status
, MEMCACHED_SUCCESS
);
1938 memcached_st
* memc
= memcached_create(NULL
);
1940 status
= memcached_server_push(memc
, list
);
1941 memcached_server_list_free(list
);
1942 test_compare(status
, MEMCACHED_SUCCESS
);
1944 const memcached_instance_st
* server
= memcached_server_by_key(memc
, test_literal_param(__func__
), &status
);
1946 test_compare(status
, MEMCACHED_SUCCESS
);
1948 memcached_free(memc
);
1950 return TEST_SUCCESS
;
1953 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1955 memcached_return_t rc
;
1957 const char *key
= "not_found";
1958 size_t key_length
= test_literal_param_size("not_found");
1960 test_compare(MEMCACHED_SUCCESS
,
1961 memcached_mget(memc
, &key
, &key_length
, 1));
1963 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1965 test_compare(MEMCACHED_NOTFOUND
, rc
);
1967 memcached_result_free(result
);
1969 return TEST_SUCCESS
;
1972 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1974 return MEMCACHED_SUCCESS
;
1977 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1979 return MEMCACHED_SUCCESS
;
1982 test_return_t
callback_test(memcached_st
*memc
)
1984 /* Test User Data */
1988 memcached_return_t rc
;
1990 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1991 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1992 test_true(*test_ptr
== x
);
1995 /* Test Clone Callback */
1997 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1998 void *clone_cb_ptr
= *(void **)&clone_cb
;
1999 void *temp_function
= NULL
;
2001 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
2002 memcached_return_t rc
;
2003 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2004 test_true(temp_function
== clone_cb_ptr
);
2005 test_compare(MEMCACHED_SUCCESS
, rc
);
2008 /* Test Cleanup Callback */
2010 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2011 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2012 void *temp_function
= NULL
;
2013 memcached_return_t rc
;
2015 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2016 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2017 test_true(temp_function
== cleanup_cb_ptr
);
2020 return TEST_SUCCESS
;
2023 /* We don't test the behavior itself, we test the switches */
2024 test_return_t
behavior_test(memcached_st
*memc
)
2026 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2027 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2029 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2030 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2032 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2033 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2035 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2036 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2038 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2039 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2041 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2042 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2044 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2045 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2047 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2049 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2051 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2052 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2053 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2055 return TEST_SUCCESS
;
2058 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2060 test_compare(MEMCACHED_DEPRECATED
,
2061 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2063 // Platform dependent
2065 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2069 return TEST_SUCCESS
;
2073 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2075 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2076 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2078 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2080 if (memcached_success(rc
))
2089 return TEST_SUCCESS
;
2093 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2095 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2096 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2098 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2100 if (memcached_success(rc
))
2109 return TEST_SUCCESS
;
2112 /* Make sure we behave properly if server list has no values */
2113 test_return_t
user_supplied_bug4(memcached_st
*memc
)
2115 const char *keys
[]= {"fudge", "son", "food"};
2116 size_t key_length
[]= {5, 3, 4};
2118 /* Here we free everything before running a bunch of mget tests */
2119 memcached_servers_reset(memc
);
2122 /* We need to empty the server before continueing test */
2123 test_compare(MEMCACHED_NO_SERVERS
,
2124 memcached_flush(memc
, 0));
2126 test_compare(MEMCACHED_NO_SERVERS
,
2127 memcached_mget(memc
, keys
, key_length
, 3));
2130 unsigned int keys_returned
;
2131 memcached_return_t rc
;
2132 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2133 test_compare(MEMCACHED_NOTFOUND
, rc
);
2134 test_zero(keys_returned
);
2137 for (uint32_t x
= 0; x
< 3; x
++)
2139 test_compare(MEMCACHED_NO_SERVERS
,
2140 memcached_set(memc
, keys
[x
], key_length
[x
],
2141 keys
[x
], key_length
[x
],
2142 (time_t)50, (uint32_t)9));
2145 test_compare(MEMCACHED_NO_SERVERS
,
2146 memcached_mget(memc
, keys
, key_length
, 3));
2150 char return_key
[MEMCACHED_MAX_KEY
];
2151 memcached_return_t rc
;
2152 size_t return_key_length
;
2153 size_t return_value_length
;
2156 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2157 &return_value_length
, &flags
, &rc
)))
2159 test_true(return_value
);
2160 test_compare(MEMCACHED_SUCCESS
, rc
);
2161 test_true(return_key_length
== return_value_length
);
2162 test_memcmp(return_value
, return_key
, return_value_length
);
2168 return TEST_SUCCESS
;
2171 #define VALUE_SIZE_BUG5 1048064
2172 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2174 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2175 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2177 size_t value_length
;
2179 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2181 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2183 insert_data
[x
]= (signed char)rand();
2186 test_compare(MEMCACHED_SUCCESS
,
2187 memcached_flush(memc
, 0));
2189 memcached_return_t rc
;
2190 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2191 test_compare(MEMCACHED_SUCCESS
,
2192 memcached_mget(memc
, keys
, key_length
, 4));
2195 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2196 test_compare(MEMCACHED_NOTFOUND
, rc
);
2199 for (uint32_t x
= 0; x
< 4; x
++)
2201 test_compare(MEMCACHED_SUCCESS
,
2202 memcached_set(memc
, keys
[x
], key_length
[x
],
2203 insert_data
, VALUE_SIZE_BUG5
,
2204 (time_t)0, (uint32_t)0));
2207 for (uint32_t x
= 0; x
< 10; x
++)
2209 value
= memcached_get(memc
, keys
[0], key_length
[0],
2210 &value_length
, &flags
, &rc
);
2211 test_compare(rc
, MEMCACHED_SUCCESS
);
2215 test_compare(MEMCACHED_SUCCESS
,
2216 memcached_mget(memc
, keys
, key_length
, 4));
2218 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2219 test_compare(4U, count
);
2221 delete [] insert_data
;
2223 return TEST_SUCCESS
;
2226 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2228 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2229 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2230 char return_key
[MEMCACHED_MAX_KEY
];
2231 size_t return_key_length
;
2233 size_t value_length
;
2235 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2237 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2239 insert_data
[x
]= (signed char)rand();
2242 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2244 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2246 // We will now confirm that memcached_mget() returns success, but we will
2247 // then check to make sure that no actual keys are returned.
2248 test_compare(MEMCACHED_SUCCESS
,
2249 memcached_mget(memc
, keys
, key_length
, 4));
2251 memcached_return_t rc
;
2253 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2254 &value_length
, &flags
, &rc
)))
2259 test_compare(MEMCACHED_NOTFOUND
, rc
);
2261 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2263 test_compare(MEMCACHED_SUCCESS
,
2264 memcached_set(memc
, keys
[x
], key_length
[x
],
2265 insert_data
, VALUE_SIZE_BUG5
,
2266 (time_t)0, (uint32_t)0));
2268 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2270 for (uint32_t x
= 0; x
< 2; x
++)
2272 value
= memcached_get(memc
, keys
[0], key_length
[0],
2273 &value_length
, &flags
, &rc
);
2277 test_compare(MEMCACHED_SUCCESS
,
2278 memcached_mget(memc
, keys
, key_length
, 4));
2279 /* We test for purge of partial complete fetches */
2280 for (count
= 3; count
; count
--)
2282 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2283 &value_length
, &flags
, &rc
);
2284 test_compare(MEMCACHED_SUCCESS
, rc
);
2285 test_memcmp(value
, insert_data
, value_length
);
2286 test_true(value_length
);
2290 delete [] insert_data
;
2292 return TEST_SUCCESS
;
2295 test_return_t
user_supplied_bug8(memcached_st
*)
2297 memcached_return_t rc
;
2299 memcached_st
*memc_clone
;
2301 memcached_server_st
*servers
;
2302 const char *server_list
= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
2304 servers
= memcached_servers_parse(server_list
);
2307 mine
= memcached_create(NULL
);
2308 rc
= memcached_server_push(mine
, servers
);
2309 test_compare(MEMCACHED_SUCCESS
, rc
);
2310 memcached_server_list_free(servers
);
2313 memc_clone
= memcached_clone(NULL
, mine
);
2315 memcached_quit(mine
);
2316 memcached_quit(memc_clone
);
2319 memcached_free(mine
);
2320 memcached_free(memc_clone
);
2322 return TEST_SUCCESS
;
2325 /* Test flag store/retrieve */
2326 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2328 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2329 test_true(insert_data
);
2331 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2333 insert_data
[x
]= (signed char)rand();
2336 memcached_flush(memc
, 0);
2338 const char *keys
= "036790384900";
2339 size_t key_length
= strlen(keys
);
2340 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2341 insert_data
, VALUE_SIZE_BUG5
,
2344 memcached_return_t rc
;
2345 size_t value_length
;
2347 char *value
= memcached_get(memc
, keys
, key_length
,
2348 &value_length
, &flags
, &rc
);
2349 test_compare(245U, flags
);
2353 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2355 char return_key
[MEMCACHED_MAX_KEY
];
2356 size_t return_key_length
;
2358 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2359 &value_length
, &flags
, &rc
);
2360 test_compare(uint32_t(245), flags
);
2363 delete [] insert_data
;
2366 return TEST_SUCCESS
;
2369 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2371 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2372 size_t key_length
[3];
2376 char return_key
[MEMCACHED_MAX_KEY
];
2377 size_t return_key_length
;
2379 size_t return_value_length
;
2382 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2383 key_length
[1]= strlen("fudge&*@#");
2384 key_length
[2]= strlen("for^#@&$not");
2387 for (unsigned int x
= 0; x
< 3; x
++)
2389 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2390 keys
[x
], key_length
[x
],
2391 (time_t)50, (uint32_t)9);
2392 test_compare(MEMCACHED_SUCCESS
, rc
);
2395 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2396 test_compare(MEMCACHED_SUCCESS
, rc
);
2398 /* We need to empty the server before continueing test */
2399 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2400 &return_value_length
, &flags
, &rc
)) != NULL
)
2402 test_true(return_value
);
2406 test_compare(3U, count
);
2408 return TEST_SUCCESS
;
2411 /* We are testing with aggressive timeout to get failures */
2412 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2414 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
2416 size_t value_length
= 512;
2417 unsigned int set
= 1;
2418 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2420 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2421 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2422 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2424 libtest::vchar_t value
;
2425 value
.reserve(value_length
);
2426 for (uint32_t x
= 0; x
< value_length
; x
++)
2428 value
.push_back(char(x
% 127));
2431 for (unsigned int x
= 1; x
<= 100000; ++x
)
2433 memcached_return_t rc
= memcached_set(mclone
,
2434 test_literal_param("foo"),
2435 &value
[0], value
.size(),
2438 test_true((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2439 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
));
2441 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2447 memcached_free(mclone
);
2449 return TEST_SUCCESS
;
2453 We are looking failures in the async protocol
2455 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2457 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2459 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2460 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2461 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2463 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2466 libtest::vchar_t value
;
2468 for (unsigned int x
= 0; x
< 512; x
++)
2470 value
.push_back(char(x
% 127));
2473 for (unsigned int x
= 1; x
<= 100000; ++x
)
2475 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2479 memcached_free(mclone
);
2481 return TEST_SUCCESS
;
2485 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2487 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2489 memcached_return_t rc
;
2491 size_t value_length
;
2493 uint64_t number_value
;
2495 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2496 &value_length
, &flags
, &rc
);
2498 test_compare(MEMCACHED_NOTFOUND
, rc
);
2500 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2503 /* The binary protocol will set the key if it doesn't exist */
2504 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2506 test_compare(MEMCACHED_SUCCESS
, rc
);
2510 test_compare(MEMCACHED_NOTFOUND
, rc
);
2513 test_compare(MEMCACHED_SUCCESS
,
2514 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2516 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2520 test_compare(MEMCACHED_SUCCESS
,
2521 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2522 test_compare(2UL, number_value
);
2524 return TEST_SUCCESS
;
2528 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2529 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2531 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2533 char key
[] = "key34567890";
2535 char commandFirst
[]= "set key34567890 0 0 ";
2536 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2537 size_t commandLength
;
2539 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2541 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2543 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2545 char *overflow
= new (std::nothrow
) char[testSize
];
2546 test_true(overflow
);
2548 memset(overflow
, 'x', testSize
);
2549 test_compare(MEMCACHED_SUCCESS
,
2550 memcached_set(memc
, key
, strlen(key
),
2551 overflow
, testSize
, 0, 0));
2555 return TEST_SUCCESS
;
2560 Test values of many different sizes
2561 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2562 set key34567890 0 0 8169 \r\n
2563 is sent followed by buffer of size 8169, followed by 8169
2565 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2567 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2569 libtest::vchar_t value
;
2570 value
.reserve(18000);
2571 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2573 value
.push_back((char) (x
% 127));
2576 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2578 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2579 &value
[0], current_length
,
2580 (time_t)0, (uint32_t)0);
2581 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2583 size_t string_length
;
2585 char *string
= memcached_get(memc
, test_literal_param("foo"),
2586 &string_length
, &flags
, &rc
);
2588 test_compare(MEMCACHED_SUCCESS
, rc
);
2589 test_compare(string_length
, current_length
);
2591 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2592 test_memcmp(string
, &value
[0], string_length
);
2597 return TEST_SUCCESS
;
2601 Look for zero length value problems
2603 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2605 for (uint32_t x
= 0; x
< 2; x
++)
2607 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2609 (time_t)0, (uint32_t)0);
2611 test_compare(MEMCACHED_SUCCESS
, rc
);
2615 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2616 &length
, &flags
, &rc
);
2618 test_compare(MEMCACHED_SUCCESS
, rc
);
2623 value
= memcached_get(memc
, test_literal_param("mykey"),
2624 &length
, &flags
, &rc
);
2626 test_compare(MEMCACHED_SUCCESS
, rc
);
2632 return TEST_SUCCESS
;
2635 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2636 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2638 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2640 (time_t)0, UINT32_MAX
));
2645 memcached_return_t rc
;
2646 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2647 &length
, &flags
, &rc
);
2649 test_compare(MEMCACHED_SUCCESS
, rc
);
2652 test_compare(flags
, UINT32_MAX
);
2654 return TEST_SUCCESS
;
2657 #if !defined(__sun) && !defined(__OpenBSD__)
2658 /* Check the validity of chinese key*/
2659 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2661 const char *key
= "豆瓣";
2662 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2663 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2664 value
, strlen(value
),
2667 test_compare(MEMCACHED_SUCCESS
, rc
);
2671 char *value2
= memcached_get(memc
, key
, strlen(key
),
2672 &length
, &flags
, &rc
);
2674 test_compare(length
, strlen(value
));
2675 test_compare(MEMCACHED_SUCCESS
, rc
);
2676 test_memcmp(value
, value2
, length
);
2679 return TEST_SUCCESS
;
2687 test_return_t
user_supplied_bug19(memcached_st
*)
2689 memcached_return_t res
;
2691 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2693 const memcached_instance_st
* server
= memcached_server_by_key(memc
, "a", 1, &res
);
2696 memcached_free(memc
);
2698 return TEST_SUCCESS
;
2701 /* CAS test from Andei */
2702 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2704 const char *key
= "abc";
2705 size_t key_len
= strlen("abc");
2707 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2709 test_compare(MEMCACHED_SUCCESS
,
2711 test_literal_param("abc"),
2712 test_literal_param("foobar"),
2713 (time_t)0, (uint32_t)0));
2715 test_compare(MEMCACHED_SUCCESS
,
2716 memcached_mget(memc
, &key
, &key_len
, 1));
2718 memcached_result_st result_obj
;
2719 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2722 memcached_result_create(memc
, &result_obj
);
2723 memcached_return_t status
;
2724 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2727 test_compare(MEMCACHED_SUCCESS
, status
);
2729 memcached_result_free(result
);
2731 return TEST_SUCCESS
;
2734 /* Large mget() of missing keys with binary proto
2736 * If many binary quiet commands (such as getq's in an mget) fill the output
2737 * buffer and the server chooses not to respond, memcached_flush hangs. See
2738 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2741 /* sighandler_t function that always asserts false */
2742 static __attribute__((noreturn
)) void fail(int)
2748 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2753 return TEST_SKIPPED
;
2755 void (*oldalarm
)(int);
2757 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2758 test_true(memc_clone
);
2760 /* only binproto uses getq for mget */
2761 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2763 /* empty the cache to ensure misses (hence non-responses) */
2764 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2766 keys_st
keys(key_count
);
2768 oldalarm
= signal(SIGALRM
, fail
);
2771 test_compare_got(MEMCACHED_SUCCESS
,
2772 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2773 memcached_last_error_message(memc_clone
));
2776 signal(SIGALRM
, oldalarm
);
2778 memcached_return_t rc
;
2780 char return_key
[MEMCACHED_MAX_KEY
];
2781 size_t return_key_length
;
2783 size_t return_value_length
;
2784 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2785 &return_value_length
, &flags
, &rc
)))
2787 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2789 test_compare(MEMCACHED_NOTFOUND
, rc
);
2790 test_zero(return_value_length
);
2791 test_zero(return_key_length
);
2792 test_false(return_key
[0]);
2793 test_false(return_value
);
2795 memcached_free(memc_clone
);
2797 return TEST_SUCCESS
;
2801 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2803 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2805 /* should work as of r580 */
2806 test_compare(TEST_SUCCESS
,
2807 _user_supplied_bug21(memc
, 10));
2809 /* should fail as of r580 */
2810 test_compare(TEST_SUCCESS
,
2811 _user_supplied_bug21(memc
, 1000));
2813 return TEST_SUCCESS
;
2816 test_return_t
comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st
*)
2820 memcached_st
*memc
= &memc_
;
2822 ASSERT_EQ(memc
, MEMCACHED_SUCCESS
);
2823 test_compare(memc
, MEMCACHED_SUCCESS
);
2825 ASSERT_NEQ(memc
, MEMCACHED_FAILURE
);
2827 return TEST_SUCCESS
;
2830 test_return_t
ketama_TEST(memcached_st
*)
2832 test::Memc
memc("--server=10.0.1.1:11211 --server=10.0.1.2:11211");
2834 test_compare(MEMCACHED_SUCCESS
,
2835 memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2837 test_compare(memcached_behavior_get(&memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
), uint64_t(1));
2839 test_compare(memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
), MEMCACHED_SUCCESS
);
2841 test_compare(memcached_behavior_get(&memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
), MEMCACHED_HASH_MD5
);
2843 test_compare(memcached_behavior_set_distribution(&memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
), MEMCACHED_SUCCESS
);
2846 return TEST_SUCCESS
;
2849 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2851 memcached_st
*memc
= memcached_create(NULL
);
2855 test_compare(MEMCACHED_SUCCESS
,
2856 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2858 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2859 test_compare(value
, uint64_t(1));
2861 test_compare(MEMCACHED_SUCCESS
,
2862 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2864 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2865 test_true(value
== MEMCACHED_HASH_MD5
);
2868 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2870 memcached_server_st
*server_pool
;
2871 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");
2872 memcached_server_push(memc
, server_pool
);
2874 // @todo this needs to be refactored to actually test something.
2877 if ((fp
= fopen("ketama_keys.txt", "w")))
2881 printf("cannot write to file ketama_keys.txt");
2882 return TEST_FAILURE
;
2885 for (int x
= 0; x
< 10000; x
++)
2888 snprintf(key
, sizeof(key
), "%d", x
);
2890 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2891 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2892 in_port_t port
= memc
->hosts
[server_idx
].port
;
2893 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2894 const memcached_instance_st
* instance
=
2895 memcached_server_instance_by_position(memc
, host_index
);
2899 memcached_server_list_free(server_pool
);
2900 memcached_free(memc
);
2902 return TEST_SUCCESS
;
2906 test_return_t
result_static(memcached_st
*memc
)
2908 memcached_result_st result
;
2909 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
2910 test_false(result
.options
.is_allocated
);
2911 test_true(memcached_is_initialized(&result
));
2912 test_true(result_ptr
);
2913 test_true(result_ptr
== &result
);
2915 memcached_result_free(&result
);
2917 test_false(result
.options
.is_allocated
);
2918 test_false(memcached_is_initialized(&result
));
2920 return TEST_SUCCESS
;
2923 test_return_t
result_alloc(memcached_st
*memc
)
2925 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
2926 test_true(result_ptr
);
2927 test_true(result_ptr
->options
.is_allocated
);
2928 test_true(memcached_is_initialized(result_ptr
));
2929 memcached_result_free(result_ptr
);
2931 return TEST_SUCCESS
;
2935 test_return_t
add_host_test1(memcached_st
*memc
)
2937 memcached_return_t rc
;
2938 char servername
[]= "0.example.com";
2940 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2942 test_compare(1U, memcached_server_list_count(servers
));
2944 for (uint32_t x
= 2; x
< 20; x
++)
2946 char buffer
[SMALL_STRING_LEN
];
2948 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
2949 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2951 test_compare(MEMCACHED_SUCCESS
, rc
);
2952 test_compare(x
, memcached_server_list_count(servers
));
2955 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2956 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2958 memcached_server_list_free(servers
);
2960 return TEST_SUCCESS
;
2964 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
2968 #ifdef HARD_MALLOC_TESTS
2969 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
2977 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
2981 #ifdef HARD_MALLOC_TESTS
2982 void *ret
= malloc(size
+ 8);
2985 ret
= (void*)((caddr_t
)ret
+ 8);
2988 void *ret
= malloc(size
);
2993 memset(ret
, 0xff, size
);
3000 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3002 #ifdef HARD_MALLOC_TESTS
3003 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3004 void *nmem
= realloc(real_ptr
, size
+ 8);
3009 ret
= (void*)((caddr_t
)nmem
+ 8);
3015 return realloc(mem
, size
);
3020 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3022 #ifdef HARD_MALLOC_TESTS
3023 void *mem
= my_malloc(ptr
, nelem
* size
);
3026 memset(mem
, 0, nelem
* size
);
3032 return calloc(nelem
, size
);
3036 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3038 memcached_return_t rc
;
3039 const char *key
= "mine";
3042 /* Make sure be default none exists */
3043 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3045 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3047 /* Test a clean set */
3048 test_compare(MEMCACHED_SUCCESS
,
3049 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3051 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3053 test_memcmp(value
, key
, 4);
3054 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3056 /* Test that we can turn it off */
3057 test_compare(MEMCACHED_SUCCESS
,
3058 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3060 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3062 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3064 /* Now setup for main test */
3065 test_compare(MEMCACHED_SUCCESS
,
3066 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3068 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3070 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3071 test_memcmp(value
, key
, 4);
3073 /* Set to Zero, and then Set to something too large */
3076 memset(long_key
, 0, 255);
3078 test_compare(MEMCACHED_SUCCESS
,
3079 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3081 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3083 test_compare(MEMCACHED_SUCCESS
, rc
);
3085 /* Test a long key for failure */
3086 /* TODO, extend test to determine based on setting, what result should be */
3087 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3088 test_compare(MEMCACHED_SUCCESS
,
3089 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3091 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3092 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3093 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3094 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3096 /* Test for a bad prefix, but with a short key */
3097 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3098 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3100 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3101 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3104 return TEST_SUCCESS
;
3107 test_return_t
set_namespace(memcached_st
*memc
)
3109 memcached_return_t rc
;
3110 const char *key
= "mine";
3113 // Make sure we default to a null namespace
3114 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3116 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3118 /* Test a clean set */
3119 test_compare(MEMCACHED_SUCCESS
,
3120 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3122 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3124 test_memcmp(value
, key
, 4);
3125 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3127 return TEST_SUCCESS
;
3130 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3132 test_return_if(pre_binary(memc
));
3133 test_return_if(set_namespace(memc
));
3135 return TEST_SUCCESS
;
3138 #ifdef MEMCACHED_ENABLE_DEPRECATED
3139 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3141 void *test_ptr
= NULL
;
3144 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
3145 cb_ptr
= *(void **)&malloc_cb
;
3146 memcached_return_t rc
;
3148 test_compare(MEMCACHED_SUCCESS
,
3149 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3150 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3151 test_compare(MEMCACHED_SUCCESS
, rc
);
3152 test_true(test_ptr
== cb_ptr
);
3156 memcached_realloc_fn realloc_cb
=
3157 (memcached_realloc_fn
)my_realloc
;
3158 cb_ptr
= *(void **)&realloc_cb
;
3159 memcached_return_t rc
;
3161 test_compare(MEMCACHED_SUCCESS
,
3162 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3163 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3164 test_compare(MEMCACHED_SUCCESS
, rc
);
3165 test_true(test_ptr
== cb_ptr
);
3169 memcached_free_fn free_cb
=
3170 (memcached_free_fn
)my_free
;
3171 cb_ptr
= *(void **)&free_cb
;
3172 memcached_return_t rc
;
3174 test_compare(MEMCACHED_SUCCESS
,
3175 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3176 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3177 test_compare(MEMCACHED_SUCCESS
, rc
);
3178 test_true(test_ptr
== cb_ptr
);
3181 return TEST_SUCCESS
;
3186 test_return_t
set_memory_alloc(memcached_st
*memc
)
3188 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3189 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3190 my_realloc
, my_calloc
, NULL
));
3192 test_compare(MEMCACHED_SUCCESS
,
3193 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3194 my_realloc
, my_calloc
, NULL
));
3196 memcached_malloc_fn mem_malloc
;
3197 memcached_free_fn mem_free
;
3198 memcached_realloc_fn mem_realloc
;
3199 memcached_calloc_fn mem_calloc
;
3200 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3201 &mem_realloc
, &mem_calloc
);
3203 test_true(mem_malloc
== my_malloc
);
3204 test_true(mem_realloc
== my_realloc
);
3205 test_true(mem_calloc
== my_calloc
);
3206 test_true(mem_free
== my_free
);
3208 return TEST_SUCCESS
;
3211 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3213 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
));
3214 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3217 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3222 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3224 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_CRC
)
3226 return TEST_SKIPPED
;
3229 return TEST_SUCCESS
;
3232 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3235 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
);
3236 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3241 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3243 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_HSIEH
)
3245 return TEST_SKIPPED
;
3248 return TEST_SUCCESS
;
3251 test_return_t
enable_cas(memcached_st
*memc
)
3253 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3255 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true);
3257 return TEST_SUCCESS
;
3260 return TEST_SKIPPED
;
3263 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3265 memcached_version(memc
);
3267 const memcached_instance_st
* instance
=
3268 memcached_server_instance_by_position(memc
, 0);
3270 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3271 or instance
->minor_version
> 2)
3273 return TEST_SUCCESS
;
3276 return TEST_SKIPPED
;
3279 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3281 const uint64_t timeout
= 100; // Not using, just checking that it sets
3283 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3285 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3287 return TEST_SUCCESS
;
3290 test_return_t
noreply_test(memcached_st
*memc
)
3292 test_compare(MEMCACHED_SUCCESS
,
3293 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3294 test_compare(MEMCACHED_SUCCESS
,
3295 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3296 test_compare(MEMCACHED_SUCCESS
,
3297 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3298 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3299 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3300 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3302 memcached_return_t ret
;
3303 for (int count
= 0; count
< 5; ++count
)
3305 for (size_t x
= 0; x
< 100; ++x
)
3307 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3308 int check_length
= snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3309 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3311 size_t len
= (size_t)check_length
;
3316 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3319 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3322 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3325 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3328 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3334 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3335 memcached_strerror(NULL
, ret
));
3339 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3340 ** API and is _ONLY_ done this way to verify that the library works the
3341 ** way it is supposed to do!!!!
3345 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3347 const memcached_instance_st
* instance
=
3348 memcached_server_instance_by_position(memc
, x
);
3349 no_msg
+=(int)(instance
->cursor_active
);
3352 test_true(no_msg
== 0);
3354 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3357 ** Now validate that all items was set properly!
3359 for (size_t x
= 0; x
< 100; ++x
)
3363 int check_length
= snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3365 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3367 size_t len
= (size_t)check_length
;
3370 char* value
=memcached_get(memc
, key
, strlen(key
),
3371 &length
, &flags
, &ret
);
3372 // For the moment we will just go to the next key
3373 if (MEMCACHED_TIMEOUT
== ret
)
3377 test_true(ret
== MEMCACHED_SUCCESS
and value
!= NULL
);
3380 case 0: /* FALLTHROUGH */
3381 case 1: /* FALLTHROUGH */
3383 test_true(strncmp(value
, key
, len
) == 0);
3384 test_true(len
== length
);
3387 test_true(length
== len
* 2);
3390 test_true(length
== len
* 3);
3400 /* Try setting an illegal cas value (should not return an error to
3401 * the caller (because we don't expect a return message from the server)
3403 const char* keys
[]= {"0"};
3404 size_t lengths
[]= {1};
3407 memcached_result_st results_obj
;
3408 memcached_result_st
*results
;
3409 test_compare(MEMCACHED_SUCCESS
,
3410 memcached_mget(memc
, keys
, lengths
, 1));
3412 results
= memcached_result_create(memc
, &results_obj
);
3414 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3416 test_compare(MEMCACHED_SUCCESS
, ret
);
3417 uint64_t cas
= memcached_result_cas(results
);
3418 memcached_result_free(&results_obj
);
3420 test_compare(MEMCACHED_SUCCESS
,
3421 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3424 * The item will have a new cas value, so try to set it again with the old
3425 * value. This should fail!
3427 test_compare(MEMCACHED_SUCCESS
,
3428 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3429 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3430 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3431 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3434 return TEST_SUCCESS
;
3437 test_return_t
analyzer_test(memcached_st
*memc
)
3439 memcached_analysis_st
*report
;
3440 memcached_return_t rc
;
3442 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3443 test_compare(MEMCACHED_SUCCESS
, rc
);
3444 test_true(memc_stat
);
3446 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3447 test_compare(MEMCACHED_SUCCESS
, rc
);
3451 memcached_stat_free(NULL
, memc_stat
);
3453 return TEST_SUCCESS
;
3456 test_return_t
util_version_test(memcached_st
*memc
)
3458 test_compare(memcached_version(memc
), MEMCACHED_SUCCESS
);
3459 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3461 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3463 // We expect failure
3466 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3467 fprintf(stderr
, "\nDumping Server Information\n\n");
3468 memcached_server_fn callbacks
[1];
3470 callbacks
[0]= dump_server_information
;
3471 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3472 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3474 test_true(if_successful
== false);
3476 const memcached_instance_st
* instance
=
3477 memcached_server_instance_by_position(memc
, 0);
3479 memcached_version(memc
);
3481 // We only use one binary when we test, so this should be just fine.
3482 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3483 test_true(if_successful
== true);
3485 if (instance
->micro_version
> 0)
3487 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3489 else if (instance
->minor_version
> 0)
3491 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3493 else if (instance
->major_version
> 0)
3495 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3498 test_true(if_successful
== true);
3500 if (instance
->micro_version
> 0)
3502 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3504 else if (instance
->minor_version
> 0)
3506 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3508 else if (instance
->major_version
> 0)
3510 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3513 test_true(if_successful
== false);
3515 return TEST_SUCCESS
;
3518 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3520 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3521 memcached_return_t rc
;
3522 const memcached_instance_st
* instance
=
3523 memcached_server_instance_by_position(memc
, 0);
3525 // Test both the version that returns a code, and the one that does not.
3526 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3527 memcached_server_port(instance
) -1, NULL
) == -1);
3529 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3530 memcached_server_port(instance
) -1, &rc
) == -1);
3531 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3533 return TEST_SUCCESS
;
3537 test_return_t
getpid_test(memcached_st
*memc
)
3539 memcached_return_t rc
;
3540 const memcached_instance_st
* instance
=
3541 memcached_server_instance_by_position(memc
, 0);
3543 // Test both the version that returns a code, and the one that does not.
3544 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3545 memcached_server_port(instance
), NULL
) > -1);
3547 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3548 memcached_server_port(instance
), &rc
) > -1);
3549 test_compare(MEMCACHED_SUCCESS
, rc
);
3551 return TEST_SUCCESS
;
3554 static memcached_return_t
ping_each_server(const memcached_st
*,
3555 const memcached_instance_st
* instance
,
3558 // Test both the version that returns a code, and the one that does not.
3559 memcached_return_t rc
;
3560 if (libmemcached_util_ping(memcached_server_name(instance
),
3561 memcached_server_port(instance
), &rc
) == false)
3563 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d %s", memcached_server_name(instance
),
3564 memcached_server_port(instance
), memcached_strerror(NULL
, rc
));
3567 if (libmemcached_util_ping(memcached_server_name(instance
),
3568 memcached_server_port(instance
), NULL
) == false)
3570 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d", memcached_server_name(instance
), memcached_server_port(instance
));
3573 return MEMCACHED_SUCCESS
;
3576 test_return_t
libmemcached_util_ping_TEST(memcached_st
*memc
)
3578 memcached_server_fn callbacks
[1]= { ping_each_server
};
3579 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
3581 return TEST_SUCCESS
;
3586 test_return_t
hash_sanity_test (memcached_st
*memc
)
3590 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3591 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3592 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3593 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3594 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3595 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3596 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3597 #ifdef HAVE_HSIEH_HASH
3598 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3600 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3601 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3602 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3604 return TEST_SUCCESS
;
3608 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3610 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3612 test_compare(MEMCACHED_SUCCESS
,
3613 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3614 (uint64_t)MEMCACHED_HASH_HSIEH
));
3616 return TEST_SUCCESS
;
3619 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3621 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3623 test_compare(MEMCACHED_SUCCESS
,
3624 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3626 return TEST_SUCCESS
;
3629 test_return_t
one_at_a_time_run (memcached_st
*)
3634 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3636 test_compare(one_at_a_time_values
[x
],
3637 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3640 return TEST_SUCCESS
;
3643 test_return_t
md5_run (memcached_st
*)
3648 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3650 test_compare(md5_values
[x
],
3651 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3654 return TEST_SUCCESS
;
3657 test_return_t
crc_run (memcached_st
*)
3662 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3664 test_compare(crc_values
[x
],
3665 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3668 return TEST_SUCCESS
;
3671 test_return_t
fnv1_64_run (memcached_st
*)
3673 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3678 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3680 test_compare(fnv1_64_values
[x
],
3681 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3684 return TEST_SUCCESS
;
3687 test_return_t
fnv1a_64_run (memcached_st
*)
3689 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3694 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3696 test_compare(fnv1a_64_values
[x
],
3697 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3700 return TEST_SUCCESS
;
3703 test_return_t
fnv1_32_run (memcached_st
*)
3708 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3710 test_compare(fnv1_32_values
[x
],
3711 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3714 return TEST_SUCCESS
;
3717 test_return_t
fnv1a_32_run (memcached_st
*)
3722 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3724 test_compare(fnv1a_32_values
[x
],
3725 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3728 return TEST_SUCCESS
;
3731 test_return_t
hsieh_run (memcached_st
*)
3733 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3738 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3740 test_compare(hsieh_values
[x
],
3741 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3744 return TEST_SUCCESS
;
3747 test_return_t
murmur_run (memcached_st
*)
3749 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3751 #ifdef WORDS_BIGENDIAN
3752 (void)murmur_values
;
3753 return TEST_SKIPPED
;
3758 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3760 test_compare(murmur_values
[x
],
3761 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3764 return TEST_SUCCESS
;
3768 test_return_t
murmur3_TEST(hashkit_st
*)
3770 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR3
));
3772 #ifdef WORDS_BIGENDIAN
3773 (void)murmur3_values
;
3774 return TEST_SKIPPED
;
3779 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3781 test_compare(murmur3_values
[x
],
3782 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR3
));
3785 return TEST_SUCCESS
;
3789 test_return_t
jenkins_run (memcached_st
*)
3794 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3796 test_compare(jenkins_values
[x
],
3797 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3800 return TEST_SUCCESS
;
3803 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3805 return libhashkit_md5(string
, string_length
);
3808 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3810 return libhashkit_crc32(string
, string_length
);
3813 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3819 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3821 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};
3822 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};
3824 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3826 hashkit_clone(&new_kit
, kit
);
3827 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3829 memcached_set_hashkit(memc
, &new_kit
);
3832 Verify Setting the hash.
3834 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3838 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3839 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3844 Now check memcached_st.
3846 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3850 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3851 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3854 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3856 memcached_set_hashkit(memc
, &new_kit
);
3859 Verify Setting the hash.
3861 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3865 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3866 test_true(crc_values
[x
] == hash_val
);
3869 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3873 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3874 test_compare(crc_hosts
[x
], hash_val
);
3877 memcached_free(memc
);
3879 return TEST_SUCCESS
;
3883 Test case adapted from John Gorman <johngorman2@gmail.com>
3885 We are testing the error condition when we connect to a server via memcached_get()
3886 but find that the server is not available.
3888 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3892 memcached_return rc
;
3895 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3897 // See if memcached is reachable.
3898 char *value
= memcached_get(tl_memc_h
,
3899 test_literal_param(__func__
),
3904 test_true(memcached_failed(rc
));
3906 memcached_free(tl_memc_h
);
3908 return TEST_SUCCESS
;
3912 We connect to a server which exists, but search for a key that does not exist.
3914 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3918 memcached_return rc
;
3920 // See if memcached is reachable.
3921 char *value
= memcached_get(memc
,
3922 test_literal_param(__func__
),
3927 test_compare(MEMCACHED_NOTFOUND
, rc
);
3929 return TEST_SUCCESS
;
3933 Test case adapted from John Gorman <johngorman2@gmail.com>
3935 We are testing the error condition when we connect to a server via memcached_get_by_key()
3936 but find that the server is not available.
3938 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
3942 memcached_return rc
;
3945 memcached_st
*tl_memc_h
= memcached_create(NULL
);
3946 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
3947 memcached_server_push(tl_memc_h
, servers
);
3948 memcached_server_list_free(servers
);
3950 // See if memcached is reachable.
3951 char *value
= memcached_get_by_key(tl_memc_h
,
3952 test_literal_param(__func__
), // Key
3953 test_literal_param(__func__
), // Value
3958 test_true(memcached_failed(rc
));
3960 memcached_free(tl_memc_h
);
3962 return TEST_SUCCESS
;
3966 We connect to a server which exists, but search for a key that does not exist.
3968 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3972 memcached_return rc
;
3974 // See if memcached is reachable.
3975 char *value
= memcached_get_by_key(memc
,
3976 test_literal_param(__func__
), // Key
3977 test_literal_param(__func__
), // Value
3982 test_compare(MEMCACHED_NOTFOUND
, rc
);
3984 return TEST_SUCCESS
;
3987 test_return_t
regression_bug_434484(memcached_st
*memc
)
3989 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3991 test_compare(MEMCACHED_NOTSTORED
,
3992 memcached_append(memc
,
3993 test_literal_param(__func__
), // Key
3994 test_literal_param(__func__
), // Value
3997 libtest::vchar_t data
;
3998 data
.resize(2048 * 1024);
3999 test_compare(MEMCACHED_E2BIG
,
4001 test_literal_param(__func__
), // Key
4002 &data
[0], data
.size(), 0, 0));
4004 return TEST_SUCCESS
;
4007 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4009 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4011 memcached_return_t rc
;
4013 memcached_execute_fn callbacks
[]= { &callback_counter
};
4016 * I only want to hit only _one_ server so I know the number of requests I'm
4017 * sending in the pipleine to the server. Let's try to do a multiget of
4018 * 1024 (that should satisfy most users don't you think?). Future versions
4019 * will include a mget_execute function call if you need a higher number.
4021 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4026 * Run two times.. the first time we should have 100% cache miss,
4027 * and the second time we should have 100% cache hits
4029 for (ptrdiff_t y
= 0; y
< 2; y
++)
4031 test_compare(MEMCACHED_SUCCESS
,
4032 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4034 // One the first run we should get a NOT_FOUND, but on the second some data
4035 // should be returned.
4036 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4037 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4041 /* The first iteration should give me a 100% cache miss. verify that*/
4042 char blob
[1024]= { 0 };
4044 test_false(counter
);
4046 for (size_t x
= 0; x
< keys
.size(); ++x
)
4048 rc
= memcached_add(memc
,
4049 keys
.key_at(x
), keys
.length_at(x
),
4050 blob
, sizeof(blob
), 0, 0);
4051 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4056 /* Verify that we received all of the key/value pairs */
4057 test_compare(counter
, keys
.size());
4061 memcached_free(memc
);
4063 return TEST_SUCCESS
;
4066 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4068 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
4070 return regression_bug_434843(memc
);
4073 test_return_t
regression_bug_421108(memcached_st
*memc
)
4075 memcached_return_t rc
;
4076 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4077 test_compare(MEMCACHED_SUCCESS
, rc
);
4079 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4080 test_compare(MEMCACHED_SUCCESS
, rc
);
4081 test_true(bytes_str
);
4082 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4084 test_compare(MEMCACHED_SUCCESS
, rc
);
4085 test_true(bytes_read_str
);
4087 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4088 "bytes_written", &rc
);
4089 test_compare(MEMCACHED_SUCCESS
, rc
);
4090 test_true(bytes_written_str
);
4092 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4093 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4094 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4096 test_true(bytes
!= bytes_read
);
4097 test_true(bytes
!= bytes_written
);
4099 /* Release allocated resources */
4101 free(bytes_read_str
);
4102 free(bytes_written_str
);
4103 memcached_stat_free(NULL
, memc_stat
);
4105 return TEST_SUCCESS
;
4109 * The test case isn't obvious so I should probably document why
4110 * it works the way it does. Bug 442914 was caused by a bug
4111 * in the logic in memcached_purge (it did not handle the case
4112 * where the number of bytes sent was equal to the watermark).
4113 * In this test case, create messages so that we hit that case
4114 * and then disable noreply mode and issue a new command to
4115 * verify that it isn't stuck. If we change the format for the
4116 * delete command or the watermarks, we need to update this
4119 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
4121 test_skip(original_memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
4123 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
4125 for (uint32_t x
= 0; x
< 250; ++x
)
4128 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
4129 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4130 char error_buffer
[2048]= { 0 };
4131 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
4132 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
4135 // Delete, and then delete again to look for not found
4138 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
4139 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4140 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4142 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
4143 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
4146 memcached_free(memc
);
4148 return TEST_SUCCESS
;
4151 test_return_t
regression_bug_447342(memcached_st
*memc
)
4153 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4155 return TEST_SKIPPED
;
4158 test_compare(MEMCACHED_SUCCESS
,
4159 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4163 for (size_t x
= 0; x
< keys
.size(); ++x
)
4165 test_compare(MEMCACHED_SUCCESS
,
4167 keys
.key_at(x
), keys
.length_at(x
), // Keys
4168 keys
.key_at(x
), keys
.length_at(x
), // Values
4173 ** We are using the quiet commands to store the replicas, so we need
4174 ** to ensure that all of them are processed before we can continue.
4175 ** In the test we go directly from storing the object to trying to
4176 ** receive the object from all of the different servers, so we
4177 ** could end up in a race condition (the memcached server hasn't yet
4178 ** processed the quiet command from the replication set when it process
4179 ** the request from the other client (created by the clone)). As a
4180 ** workaround for that we call memcached_quit to send the quit command
4181 ** to the server and wait for the response ;-) If you use the test code
4182 ** as an example for your own code, please note that you shouldn't need
4185 memcached_quit(memc
);
4187 /* Verify that all messages are stored, and we didn't stuff too much
4190 test_compare(MEMCACHED_SUCCESS
,
4191 memcached_mget(memc
,
4192 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4194 unsigned int counter
= 0;
4195 memcached_execute_fn callbacks
[]= { &callback_counter
};
4196 test_compare(MEMCACHED_SUCCESS
,
4197 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4199 /* Verify that we received all of the key/value pairs */
4200 test_compare(counter
, keys
.size());
4202 memcached_quit(memc
);
4204 * Don't do the following in your code. I am abusing the internal details
4205 * within the library, and this is not a supported interface.
4206 * This is to verify correct behavior in the library. Fake that two servers
4209 const memcached_instance_st
* instance_one
= memcached_server_instance_by_position(memc
, 0);
4210 const memcached_instance_st
* instance_two
= memcached_server_instance_by_position(memc
, 2);
4211 in_port_t port0
= instance_one
->port();
4212 in_port_t port2
= instance_two
->port();
4214 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4215 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4217 test_compare(MEMCACHED_SUCCESS
,
4218 memcached_mget(memc
,
4219 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4222 test_compare(MEMCACHED_SUCCESS
,
4223 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4224 test_compare(counter
, keys
.size());
4226 /* restore the memc handle */
4227 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4228 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4230 memcached_quit(memc
);
4232 /* Remove half of the objects */
4233 for (size_t x
= 0; x
< keys
.size(); ++x
)
4237 test_compare(MEMCACHED_SUCCESS
,
4238 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4242 memcached_quit(memc
);
4243 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4244 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4246 /* now retry the command, this time we should have cache misses */
4247 test_compare(MEMCACHED_SUCCESS
,
4248 memcached_mget(memc
,
4249 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4252 test_compare(MEMCACHED_SUCCESS
,
4253 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4254 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4256 /* restore the memc handle */
4257 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4258 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4260 return TEST_SUCCESS
;
4263 test_return_t
regression_bug_463297(memcached_st
*memc
)
4265 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4267 // Since we blocked timed delete, this test is no longer valid.
4269 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4270 test_true(memc_clone
);
4271 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4273 const memcached_instance_st
* instance
=
4274 memcached_server_instance_by_position(memc_clone
, 0);
4276 if (instance
->major_version
> 1 ||
4277 (instance
->major_version
== 1 &&
4278 instance
->minor_version
> 2))
4280 /* Binary protocol doesn't support deferred delete */
4281 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4282 test_true(bin_clone
);
4283 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4284 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4285 memcached_free(bin_clone
);
4287 memcached_quit(memc_clone
);
4289 /* If we know the server version, deferred delete should fail
4290 * with invalid arguments */
4291 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4293 /* If we don't know the server version, we should get a protocol error */
4294 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4296 /* but there is a bug in some of the memcached servers (1.4) that treats
4297 * the counter as noreply so it doesn't send the proper error message
4299 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4301 /* And buffered mode should be disabled and we should get protocol error */
4302 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4303 rc
= memcached_delete(memc
, "foo", 3, 1);
4304 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4306 /* Same goes for noreply... */
4307 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4308 rc
= memcached_delete(memc
, "foo", 3, 1);
4309 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4311 /* but a normal request should go through (and be buffered) */
4312 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4313 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4315 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4316 /* unbuffered noreply should be success */
4317 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4318 /* unbuffered with reply should be not found... */
4319 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4320 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4323 memcached_free(memc_clone
);
4326 return TEST_SUCCESS
;
4330 /* Test memcached_server_get_last_disconnect
4331 * For a working server set, shall be NULL
4332 * For a set of non existing server, shall not be NULL
4334 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4336 memcached_return_t rc
;
4337 const memcached_instance_st
* disconnected_server
;
4339 /* With the working set of server */
4340 const char *key
= "marmotte";
4341 const char *value
= "milka";
4343 memcached_reset_last_disconnected_server(memc
);
4344 test_false(memc
->last_disconnected_server
);
4345 rc
= memcached_set(memc
, key
, strlen(key
),
4346 value
, strlen(value
),
4347 (time_t)0, (uint32_t)0);
4348 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4350 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4351 test_false(disconnected_server
);
4353 /* With a non existing server */
4355 memcached_server_st
*servers
;
4357 const char *server_list
= "localhost:9";
4359 servers
= memcached_servers_parse(server_list
);
4361 mine
= memcached_create(NULL
);
4362 rc
= memcached_server_push(mine
, servers
);
4363 test_compare(MEMCACHED_SUCCESS
, rc
);
4364 memcached_server_list_free(servers
);
4367 rc
= memcached_set(mine
, key
, strlen(key
),
4368 value
, strlen(value
),
4369 (time_t)0, (uint32_t)0);
4370 test_true(memcached_failed(rc
));
4372 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4373 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4374 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4375 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4377 memcached_quit(mine
);
4378 memcached_free(mine
);
4380 return TEST_SUCCESS
;
4383 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4385 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4386 char buffer
[BUFSIZ
];
4388 test_compare(MEMCACHED_SUCCESS
,
4389 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4391 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4394 // We will just use the error strings as our keys
4395 uint32_t counter
= 100;
4398 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4400 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4401 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4402 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4404 const memcached_instance_st
* disconnected_server
= memcached_server_get_last_disconnect(memc
);
4405 test_true(disconnected_server
);
4406 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4407 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4411 memcached_reset_last_disconnected_server(memc
);
4416 memcached_free(memc
);
4418 return TEST_SUCCESS
;
4421 test_return_t
test_verbosity(memcached_st
*memc
)
4423 memcached_verbosity(memc
, 3);
4425 return TEST_SUCCESS
;
4429 static memcached_return_t
stat_printer(const memcached_instance_st
* server
,
4430 const char *key
, size_t key_length
,
4431 const char *value
, size_t value_length
,
4441 return MEMCACHED_SUCCESS
;
4444 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4446 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4447 test_compare(MEMCACHED_SUCCESS
, rc
);
4449 test_compare(MEMCACHED_SUCCESS
,
4450 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4452 test_compare(MEMCACHED_SUCCESS
,
4453 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4455 test_compare(MEMCACHED_SUCCESS
,
4456 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4458 return TEST_SUCCESS
;
4462 * This test ensures that the failure counter isn't incremented during
4463 * normal termination of the memcached instance.
4465 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4467 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4469 /* Ensure that we are connected to the server by setting a value */
4470 memcached_return_t rc
= memcached_set(memc
,
4471 test_literal_param(__func__
), // Key
4472 test_literal_param(__func__
), // Value
4473 time_t(0), uint32_t(0));
4474 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4477 const memcached_instance_st
* instance
= memcached_server_instance_by_position(memc
, 0);
4479 /* The test is to see that the memcached_quit doesn't increase the
4480 * the server failure conter, so let's ensure that it is zero
4481 * before sending quit
4483 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4485 memcached_quit(memc
);
4487 /* Verify that it memcached_quit didn't increment the failure counter
4488 * Please note that this isn't bullet proof, because an error could
4491 test_zero(instance
->server_failure_counter
);
4493 memcached_free(memc
);
4495 return TEST_SUCCESS
;
4499 * This tests ensures expected disconnections (for some behavior changes
4500 * for instance) do not wrongly increase failure counter
4502 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4504 /* Set value to force connection to the server */
4505 const char *key
= "marmotte";
4506 const char *value
= "milka";
4508 test_compare_hint(MEMCACHED_SUCCESS
,
4509 memcached_set(memc
, key
, strlen(key
),
4510 value
, strlen(value
),
4511 (time_t)0, (uint32_t)0),
4512 memcached_last_error_message(memc
));
4515 /* put failure limit to 1 */
4516 test_compare(MEMCACHED_SUCCESS
,
4517 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4519 /* Put a retry timeout to effectively activate failure_limit effect */
4520 test_compare(MEMCACHED_SUCCESS
,
4521 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4523 /* change behavior that triggers memcached_quit()*/
4524 test_compare(MEMCACHED_SUCCESS
,
4525 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4528 /* Check if we still are connected */
4530 size_t string_length
;
4531 memcached_return rc
;
4532 char *string
= memcached_get(memc
, key
, strlen(key
),
4533 &string_length
, &flags
, &rc
);
4535 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4539 return TEST_SUCCESS
;
4542 test_return_t
regression_996813_TEST(memcached_st
*)
4544 memcached_st
* memc
= memcached_create(NULL
);
4546 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
4547 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
4548 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4549 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4550 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1));
4551 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 300));
4552 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 30));
4554 // We will never connect to these servers
4555 in_port_t base_port
= 11211;
4556 for (size_t x
= 0; x
< 17; x
++)
4558 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", base_port
+x
));
4560 test_compare(6U, memcached_generate_hash(memc
, test_literal_param("SZ6hu0SHweFmpwpc0w2R")));
4561 test_compare(1U, memcached_generate_hash(memc
, test_literal_param("SQCK9eiCf53YxHWnYA.o")));
4562 test_compare(9U, memcached_generate_hash(memc
, test_literal_param("SUSDkGXuuZC9t9VhMwa.")));
4563 test_compare(0U, memcached_generate_hash(memc
, test_literal_param("SnnqnJARfaCNT679iAF_")));
4565 memcached_free(memc
);
4567 return TEST_SUCCESS
;
4572 * Test that ensures mget_execute does not end into recursive calls that finally fails
4574 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4578 return TEST_SKIPPED
; // My MAC can't handle this test
4581 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4584 * I only want to hit _one_ server so I know the number of requests I'm
4585 * sending in the pipeline.
4587 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4590 keys_st
keys(20480);
4592 /* First add all of the items.. */
4593 char blob
[1024]= { 0 };
4594 for (size_t x
= 0; x
< keys
.size(); ++x
)
4596 memcached_return rc
= memcached_set(memc
,
4597 keys
.key_at(x
), keys
.length_at(x
),
4598 blob
, sizeof(blob
), 0, 0);
4599 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4604 /* Try to get all of them with a large multiget */
4606 memcached_execute_function callbacks
[]= { &callback_counter
};
4607 memcached_return_t rc
= memcached_mget_execute(memc
,
4608 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4609 callbacks
, &counter
, 1);
4610 test_compare(MEMCACHED_SUCCESS
, rc
);
4612 char* the_value
= NULL
;
4613 char the_key
[MEMCACHED_MAX_KEY
];
4614 size_t the_key_length
;
4615 size_t the_value_length
;
4619 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4621 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4627 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4630 test_compare(MEMCACHED_END
, rc
);
4632 /* Verify that we got all of the items */
4633 test_compare(counter
, keys
.size());
4636 memcached_free(memc
);
4638 return TEST_SUCCESS
;
4641 test_return_t
regression_1021819_TEST(memcached_st
*original
)
4643 memcached_st
*memc
= memcached_clone(NULL
, original
);
4646 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 2000000), MEMCACHED_SUCCESS
);
4647 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 3000000), MEMCACHED_SUCCESS
);
4649 memcached_return_t rc
;
4652 test_literal_param(__func__
),
4655 test_compare(rc
, MEMCACHED_NOTFOUND
);
4657 memcached_free(memc
);
4659 return TEST_SUCCESS
;
4662 test_return_t
regression_bug_583031(memcached_st
*)
4664 memcached_st
*memc
= memcached_create(NULL
);
4666 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.251.4", 11211));
4668 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 3000);
4669 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4670 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4671 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4672 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4673 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4675 memcached_return_t rc
;
4679 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4683 test_compare(MEMCACHED_TIMEOUT
, memc
);
4685 memcached_free(memc
);
4687 return TEST_SUCCESS
;
4690 test_return_t
regression_bug_581030(memcached_st
*)
4693 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4694 test_false(local_stat
);
4696 memcached_stat_free(NULL
, NULL
);
4699 return TEST_SUCCESS
;
4702 #define regression_bug_655423_COUNT 6000
4703 test_return_t
regression_bug_655423(memcached_st
*memc
)
4705 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4706 memc
= NULL
; // Just to make sure it is not used
4711 return TEST_SKIPPED
;
4714 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4715 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4716 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4717 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4719 memset(payload
, int('x'), sizeof(payload
));
4721 keys_st
keys(regression_bug_655423_COUNT
);
4723 for (size_t x
= 0; x
< keys
.size(); x
++)
4725 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4728 payload
, sizeof(payload
), 0, 0));
4731 for (size_t x
= 0; x
< keys
.size(); x
++)
4733 size_t value_length
;
4734 memcached_return_t rc
;
4735 char *value
= memcached_get(clone
,
4738 &value_length
, NULL
, &rc
);
4740 if (rc
== MEMCACHED_NOTFOUND
)
4743 test_zero(value_length
);
4747 test_compare(MEMCACHED_SUCCESS
, rc
);
4749 test_compare(100LLU, value_length
);
4753 test_compare(MEMCACHED_SUCCESS
,
4754 memcached_mget(clone
,
4755 keys
.keys_ptr(), keys
.lengths_ptr(),
4759 memcached_result_st
*result
= NULL
;
4760 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4762 test_compare(size_t(100), memcached_result_length(result
));
4766 test_true(count
> 100); // If we don't get back atleast this, something is up
4768 memcached_free(clone
);
4770 return TEST_SUCCESS
;
4774 * Test that ensures that buffered set to not trigger problems during io_flush
4776 #define regression_bug_490520_COUNT 200480
4777 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4779 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4781 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4782 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4783 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4784 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4785 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4787 /* First add all of the items.. */
4788 char blob
[3333] = {0};
4789 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4792 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4794 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4795 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4798 memcached_free(memc
);
4800 return TEST_SUCCESS
;
4803 test_return_t
regression_1009493_TEST(memcached_st
*)
4805 memcached_st
* memc
= memcached_create(NULL
);
4807 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, true));
4809 memcached_st
* clone
= memcached_clone(NULL
, memc
);
4812 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
),
4813 memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
4815 memcached_free(memc
);
4816 memcached_free(clone
);
4818 return TEST_SUCCESS
;
4821 test_return_t
regression_994772_TEST(memcached_st
* memc
)
4823 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4825 test_compare(MEMCACHED_SUCCESS
,
4827 test_literal_param(__func__
), // Key
4828 test_literal_param(__func__
), // Value
4829 time_t(0), uint32_t(0)));
4831 const char *keys
[] = { __func__
};
4832 size_t key_length
[]= { strlen(__func__
) };
4833 test_compare(MEMCACHED_SUCCESS
,
4834 memcached_mget(memc
, keys
, key_length
, 1));
4836 memcached_return_t rc
;
4837 memcached_result_st
*results
= memcached_fetch_result(memc
, NULL
, &rc
);
4839 test_compare(MEMCACHED_SUCCESS
, rc
);
4841 test_strcmp(__func__
, memcached_result_value(results
));
4842 uint64_t cas_value
= memcached_result_cas(results
);
4843 test_true(cas_value
);
4845 char* take_value
= memcached_result_take_value(results
);
4846 test_strcmp(__func__
, take_value
);
4849 memcached_result_free(results
);
4851 // Bad cas value, sanity check
4852 test_true(cas_value
!= 9999);
4853 test_compare(MEMCACHED_END
,
4855 test_literal_param(__func__
), // Key
4856 test_literal_param(__FILE__
), // Value
4857 time_t(0), uint32_t(0), 9999));
4859 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
4860 "different", strlen("different"), // Key
4861 test_literal_param(__FILE__
), // Value
4862 time_t(0), uint32_t(0)));
4864 return TEST_SUCCESS
;
4867 test_return_t
regression_bug_854604(memcached_st
*)
4871 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4873 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4875 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4876 test_compare(buffer
[0], 0);
4878 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4879 test_true(strlen(buffer
));
4881 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4882 test_true(strlen(buffer
));
4884 return TEST_SUCCESS
;
4887 static void die_message(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4889 fprintf(stderr
, "Iteration #%u: ", it
);
4891 if (error
== MEMCACHED_ERRNO
)
4893 fprintf(stderr
, "system error %d from %s: %s\n",
4894 errno
, what
, strerror(errno
));
4898 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4899 memcached_strerror(mc
, error
));
4903 #define TEST_CONSTANT_CREATION 200
4905 test_return_t
regression_bug_(memcached_st
*memc
)
4907 const char *remote_server
;
4910 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4912 return TEST_SKIPPED
;
4915 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4917 memcached_st
* mc
= memcached_create(NULL
);
4918 memcached_return rc
;
4920 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4921 if (rc
!= MEMCACHED_SUCCESS
)
4923 die_message(mc
, rc
, "memcached_behavior_set", x
);
4926 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4927 if (rc
!= MEMCACHED_SUCCESS
)
4929 die_message(mc
, rc
, "memcached_behavior_set", x
);
4932 rc
= memcached_server_add(mc
, remote_server
, 0);
4933 if (rc
!= MEMCACHED_SUCCESS
)
4935 die_message(mc
, rc
, "memcached_server_add", x
);
4938 const char *set_key
= "akey";
4939 const size_t set_key_len
= strlen(set_key
);
4940 const char *set_value
= "a value";
4941 const size_t set_value_len
= strlen(set_value
);
4943 if (rc
== MEMCACHED_SUCCESS
)
4947 size_t get_value_len
;
4949 uint32_t get_value_flags
;
4951 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
4952 &get_value_flags
, &rc
);
4953 if (rc
!= MEMCACHED_SUCCESS
)
4955 die_message(mc
, rc
, "memcached_get", x
);
4961 (get_value_len
!= set_value_len
4962 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
4964 fprintf(stderr
, "Values don't match?\n");
4965 rc
= MEMCACHED_FAILURE
;
4971 rc
= memcached_set(mc
,
4972 set_key
, set_key_len
,
4973 set_value
, set_value_len
,
4977 if (rc
!= MEMCACHED_SUCCESS
)
4979 die_message(mc
, rc
, "memcached_set", x
);
4986 if (rc
!= MEMCACHED_SUCCESS
)
4992 return TEST_SUCCESS
;
4995 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
4997 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
5000 const memcached_instance_st
* instance
= memcached_server_instance_by_position(memc
, 0);
5003 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
5004 memcached_server_port(instance
), NULL
)) > -1);
5007 test_compare(MEMCACHED_SUCCESS
,
5009 test_literal_param(__func__
), // Keys
5010 test_literal_param(__func__
), // Values
5012 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
5014 memcached_return_t ret
= memcached_set(memc
,
5015 test_literal_param(__func__
), // Keys
5016 test_literal_param(__func__
), // Values
5018 test_compare(ret
, memc
);
5019 test_compare(MEMCACHED_CONNECTION_FAILURE
, memc
);
5021 memcached_free(memc
);
5023 return TEST_SUCCESS
;