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
->server_timeout_limit
== memc
->server_timeout_limit
);
416 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
417 test_true(memc_clone
->user_data
== memc
->user_data
);
419 memcached_free(memc_clone
);
422 /* Can we init from struct? */
424 memcached_st declared_clone
;
425 memcached_st
*memc_clone
;
426 memset(&declared_clone
, 0 , sizeof(memcached_st
));
427 memc_clone
= memcached_clone(&declared_clone
, NULL
);
428 test_true(memc_clone
);
429 memcached_free(memc_clone
);
432 /* Can we init from struct? */
434 memcached_st declared_clone
;
435 memcached_st
*memc_clone
;
436 memset(&declared_clone
, 0 , sizeof(memcached_st
));
437 memc_clone
= memcached_clone(&declared_clone
, memc
);
438 test_true(memc_clone
);
439 memcached_free(memc_clone
);
445 test_return_t
userdata_test(memcached_st
*memc
)
448 test_false(memcached_set_user_data(memc
, foo
));
449 test_true(memcached_get_user_data(memc
) == foo
);
450 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
455 test_return_t
connection_test(memcached_st
*memc
)
457 test_compare(MEMCACHED_SUCCESS
,
458 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
463 test_return_t
libmemcached_string_behavior_test(memcached_st
*)
465 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
467 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
469 test_compare(38, int(MEMCACHED_BEHAVIOR_MAX
));
474 test_return_t
libmemcached_string_distribution_test(memcached_st
*)
476 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
478 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
480 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
485 test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
487 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
488 982370485U, 1263635348U, 4242906218U, 3829656100U,
489 1891735253U, 334139633U, 2257084983U, 3351789013U,
490 13199785U, 2542027183U, 1097051614U, 199566778U,
491 2748246961U, 2465192557U, 1664094137U, 2405439045U,
492 1842224848U, 692413798U, 3479807801U, 919913813U,
493 4269430871U, 610793021U, 527273862U, 1437122909U,
494 2300930706U, 2943759320U, 674306647U, 2400528935U,
495 54481931U, 4186304426U, 1741088401U, 2979625118U,
496 4159057246U, 3425930182U, 2593724503U, 1868899624U,
497 1769812374U, 2302537950U, 1110330676U, 3365377466U,
498 1336171666U, 3021258493U, 2334992265U, 3861994737U,
499 3582734124U, 3889811103, 3365377466U };
501 // You have updated the memcache_error messages but not updated docs/tests.
502 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
505 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
506 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
507 MEMCACHED_HASH_JENKINS
);
508 if (values
[rc
] != hash_val
)
510 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
511 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
513 test_compare(values
[rc
], hash_val
);
515 test_compare(50, int(MEMCACHED_MAXIMUM_RETURN
));
520 test_return_t
set_test(memcached_st
*memc
)
522 memcached_return_t rc
= memcached_set(memc
,
523 test_literal_param("foo"),
524 test_literal_param("when we sanitize"),
525 time_t(0), (uint32_t)0);
526 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
531 test_return_t
append_test(memcached_st
*memc
)
533 memcached_return_t rc
;
534 const char *in_value
= "we";
538 test_compare(MEMCACHED_SUCCESS
,
539 memcached_flush(memc
, 0));
541 test_compare(MEMCACHED_SUCCESS
,
543 test_literal_param(__func__
),
544 in_value
, strlen(in_value
),
545 time_t(0), uint32_t(0)));
547 test_compare(MEMCACHED_SUCCESS
,
548 memcached_append(memc
,
549 test_literal_param(__func__
),
550 " the", strlen(" the"),
551 time_t(0), uint32_t(0)));
553 test_compare(MEMCACHED_SUCCESS
,
554 memcached_append(memc
,
555 test_literal_param(__func__
),
556 " people", strlen(" people"),
557 time_t(0), uint32_t(0)));
559 char *out_value
= memcached_get(memc
,
560 test_literal_param(__func__
),
561 &value_length
, &flags
, &rc
);
562 test_memcmp(out_value
, "we the people", strlen("we the people"));
563 test_compare(strlen("we the people"), value_length
);
564 test_compare(MEMCACHED_SUCCESS
, rc
);
570 test_return_t
append_binary_test(memcached_st
*memc
)
572 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
574 test_compare(MEMCACHED_SUCCESS
,
575 memcached_flush(memc
, 0));
577 test_compare(MEMCACHED_SUCCESS
,
579 test_literal_param(__func__
),
581 time_t(0), uint32_t(0)));
584 for (uint32_t x
= 0; store_list
[x
] ; x
++)
586 test_compare(MEMCACHED_SUCCESS
,
587 memcached_append(memc
,
588 test_literal_param(__func__
),
589 (char *)&store_list
[x
], sizeof(uint32_t),
590 time_t(0), uint32_t(0)));
596 memcached_return_t rc
;
597 uint32_t *value
= (uint32_t *)memcached_get(memc
,
598 test_literal_param(__func__
),
599 &value_length
, &flags
, &rc
);
600 test_compare(value_length
, sizeof(uint32_t) * count
);
601 test_compare(MEMCACHED_SUCCESS
, rc
);
603 for (uint32_t counter
= uint32_t(count
), *ptr
= value
; counter
; counter
--)
605 test_compare(*ptr
, store_list
[count
- counter
]);
613 test_return_t
memcached_mget_mixed_memcached_get_TEST(memcached_st
*memc
)
617 for (libtest::vchar_ptr_t::iterator iter
= keys
.begin();
621 test_compare_hint(MEMCACHED_SUCCESS
,
625 time_t(0), uint32_t(0)),
626 memcached_last_error_message(memc
));
629 for (ptrdiff_t loop
= 0; loop
< 20; loop
++)
633 test_compare(MEMCACHED_SUCCESS
,
634 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
636 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
639 size_t result_count
= 0;
640 memcached_return_t rc
;
641 while (memcached_fetch_result(memc
, results
, &rc
))
645 test_true(keys
.size() >= result_count
);
649 int which_key
= random() % int(keys
.size());
652 memcached_return_t rc
;
653 char *out_value
= memcached_get(memc
, keys
.key_at(which_key
), keys
.length_at(which_key
),
654 &value_length
, &flags
, &rc
);
655 if (rc
== MEMCACHED_NOTFOUND
)
656 { } // It is possible that the value has been purged.
659 test_compare(MEMCACHED_SUCCESS
, rc
);
661 test_null(out_value
);
662 test_zero(value_length
);
670 test_return_t
cas2_test(memcached_st
*memc
)
672 const char *keys
[]= {"fudge", "son", "food"};
673 size_t key_length
[]= {5, 3, 4};
674 const char *value
= "we the people";
675 size_t value_length
= strlen("we the people");
677 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
679 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
681 for (uint32_t x
= 0; x
< 3; x
++)
683 test_compare(MEMCACHED_SUCCESS
,
684 memcached_set(memc
, keys
[x
], key_length
[x
],
685 keys
[x
], key_length
[x
],
686 time_t(50), uint32_t(9)));
689 test_compare(MEMCACHED_SUCCESS
,
690 memcached_mget(memc
, keys
, key_length
, 3));
692 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
695 memcached_return_t rc
;
696 results
= memcached_fetch_result(memc
, results
, &rc
);
698 test_true(results
->item_cas
);
699 test_compare(MEMCACHED_SUCCESS
, rc
);
700 test_true(memcached_result_cas(results
));
702 test_memcmp(value
, "we the people", strlen("we the people"));
703 test_compare(strlen("we the people"), value_length
);
704 test_compare(MEMCACHED_SUCCESS
, rc
);
706 memcached_result_free(results
);
711 test_return_t
cas_test(memcached_st
*memc
)
713 const char* keys
[2] = { __func__
, NULL
};
714 size_t keylengths
[2] = { strlen(__func__
), 0 };
716 memcached_result_st results_obj
;
718 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
720 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
722 test_compare(MEMCACHED_SUCCESS
,
724 test_literal_param(__func__
),
725 test_literal_param("we the people"),
726 (time_t)0, (uint32_t)0));
728 test_compare(MEMCACHED_SUCCESS
,
729 memcached_mget(memc
, keys
, keylengths
, 1));
731 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
734 memcached_return_t rc
;
735 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
737 test_compare(MEMCACHED_SUCCESS
, rc
);
738 test_true(memcached_result_cas(results
));
739 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
740 test_compare(test_literal_param_size("we the people"),
741 strlen(memcached_result_value(results
)));
743 uint64_t cas
= memcached_result_cas(results
);
746 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
747 test_true(rc
== MEMCACHED_END
);
748 test_true(results
== NULL
);
751 test_compare(MEMCACHED_SUCCESS
,
753 test_literal_param(__func__
),
754 test_literal_param("change the value"),
758 * The item will have a new cas value, so try to set it again with the old
759 * value. This should fail!
761 test_compare(MEMCACHED_DATA_EXISTS
,
763 test_literal_param(__func__
),
764 test_literal_param("change the value"),
767 memcached_result_free(&results_obj
);
773 test_return_t
prepend_test(memcached_st
*memc
)
775 const char *key
= "fig";
776 const char *value
= "people";
778 test_compare(MEMCACHED_SUCCESS
,
779 memcached_flush(memc
, 0));
781 test_compare(MEMCACHED_SUCCESS
,
782 memcached_set(memc
, key
, strlen(key
),
783 value
, strlen(value
),
784 time_t(0), uint32_t(0)));
786 test_compare(MEMCACHED_SUCCESS
,
787 memcached_prepend(memc
, key
, strlen(key
),
788 "the ", strlen("the "),
789 time_t(0), uint32_t(0)));
791 test_compare(MEMCACHED_SUCCESS
,
792 memcached_prepend(memc
, key
, strlen(key
),
793 "we ", strlen("we "),
794 time_t(0), uint32_t(0)));
798 memcached_return_t rc
;
799 char *out_value
= memcached_get(memc
, key
, strlen(key
),
800 &value_length
, &flags
, &rc
);
801 test_memcmp(out_value
, "we the people", strlen("we the people"));
802 test_compare(strlen("we the people"), value_length
);
803 test_compare(MEMCACHED_SUCCESS
, rc
);
810 Set the value, then quit to make sure it is flushed.
811 Come back in and test that add fails.
813 test_return_t
memcached_add_SUCCESS_TEST(memcached_st
*memc
)
815 memcached_return_t rc
;
816 test_null(memcached_get(memc
, test_literal_param(__func__
), NULL
, NULL
, &rc
));
817 test_compare(MEMCACHED_NOTFOUND
, rc
);
819 test_compare(MEMCACHED_SUCCESS
,
821 test_literal_param(__func__
),
822 test_literal_param("try something else"),
823 time_t(0), uint32_t(0)));
828 test_return_t
regression_1067242_TEST(memcached_st
*memc
)
830 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
831 test_literal_param(__func__
),
832 test_literal_param("-2"),
835 memcached_return_t rc
;
837 test_true((value
= memcached_get(memc
, test_literal_param(__func__
), NULL
, NULL
, &rc
)));
838 test_compare(MEMCACHED_SUCCESS
, rc
);
841 for (size_t x
= 0; x
< 10; x
++)
844 test_compare(MEMCACHED_CLIENT_ERROR
,
845 memcached_increment(memc
,
846 test_literal_param(__func__
), 1, &new_number
));
847 test_compare(MEMCACHED_CLIENT_ERROR
, memcached_last_error(memc
));
848 test_true((value
= memcached_get(memc
, test_literal_param(__func__
), NULL
, NULL
, &rc
)));
849 test_compare(MEMCACHED_SUCCESS
, rc
);
857 Set the value, then quit to make sure it is flushed.
858 Come back in and test that add fails.
860 test_return_t
add_test(memcached_st
*memc
)
862 test_compare(return_value_based_on_buffering(memc
),
864 test_literal_param(__func__
),
865 test_literal_param("when we sanitize"),
866 time_t(0), uint32_t(0)));
868 memcached_quit(memc
);
872 memcached_return_t rc
;
873 char *check_value
= memcached_get(memc
,
874 test_literal_param(__func__
),
875 &value_length
, &flags
, &rc
);
876 test_memcmp(check_value
, "when we sanitize", strlen("when we sanitize"));
877 test_compare(test_literal_param_size("when we sanitize"), value_length
);
878 test_compare(MEMCACHED_SUCCESS
, rc
);
881 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
883 test_literal_param(__func__
),
884 test_literal_param("try something else"),
885 time_t(0), uint32_t(0)));
891 ** There was a problem of leaking filedescriptors in the initial release
892 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
893 ** systems it seems that the kernel is slow on reclaiming the resources
894 ** because the connects starts to time out (the test doesn't do much
895 ** anyway, so just loop 10 iterations)
897 test_return_t
add_wrapper(memcached_st
*memc
)
899 unsigned int max
= 10000;
907 for (uint32_t x
= 0; x
< max
; x
++)
915 test_return_t
replace_test(memcached_st
*memc
)
917 test_compare(return_value_based_on_buffering(memc
),
919 test_literal_param(__func__
),
920 test_literal_param("when we sanitize"),
921 time_t(0), uint32_t(0)));
923 test_compare(MEMCACHED_SUCCESS
,
924 memcached_replace(memc
,
925 test_literal_param(__func__
),
926 test_literal_param("first we insert some data"),
927 time_t(0), uint32_t(0)));
932 test_return_t
delete_test(memcached_st
*memc
)
934 test_compare(return_value_based_on_buffering(memc
),
936 test_literal_param(__func__
),
937 test_literal_param("when we sanitize"),
938 time_t(0), uint32_t(0)));
940 test_compare(return_value_based_on_buffering(memc
),
941 memcached_delete(memc
,
942 test_literal_param(__func__
),
948 test_return_t
flush_test(memcached_st
*memc
)
950 uint64_t query_id
= memcached_query_id(memc
);
951 test_compare(MEMCACHED_SUCCESS
,
952 memcached_flush(memc
, 0));
953 test_compare(query_id
+1, memcached_query_id(memc
));
958 static memcached_return_t
server_function(const memcached_st
*,
959 const memcached_instance_st
*,
963 return MEMCACHED_SUCCESS
;
966 test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
969 strncpy(context
, "foo bad", sizeof(context
));
970 memcached_server_fn callbacks
[1];
972 callbacks
[0]= server_function
;
973 memcached_server_cursor(memc
, callbacks
, context
, 1);
977 test_return_t
bad_key_test(memcached_st
*memc
)
979 memcached_return_t rc
;
980 const char *key
= "foo bad";
983 uint64_t query_id
= memcached_query_id(memc
);
985 // Just skip if we are in binary mode.
986 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
988 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
990 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
991 test_true(memc_clone
);
993 query_id
= memcached_query_id(memc_clone
);
994 test_compare(MEMCACHED_SUCCESS
,
995 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
996 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
997 ASSERT_TRUE(memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
));
999 /* All keys are valid in the binary protocol (except for length) */
1000 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == false)
1002 uint64_t before_query_id
= memcached_query_id(memc_clone
);
1004 size_t string_length
;
1005 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1006 &string_length
, &flags
, &rc
);
1007 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1008 test_zero(string_length
);
1011 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
1013 query_id
= memcached_query_id(memc_clone
);
1014 test_compare(MEMCACHED_SUCCESS
,
1015 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
1016 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
1018 size_t string_length
;
1019 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1020 &string_length
, &flags
, &rc
);
1021 test_compare(MEMCACHED_NOTFOUND
, rc
);
1022 test_zero(string_length
);
1026 /* Test multi key for bad keys */
1027 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
1028 size_t key_lengths
[] = { 7, 7, 7 };
1029 query_id
= memcached_query_id(memc_clone
);
1030 test_compare(MEMCACHED_SUCCESS
,
1031 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1032 test_compare(query_id
, memcached_query_id(memc_clone
));
1034 query_id
= memcached_query_id(memc_clone
);
1035 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
1036 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
1037 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1039 query_id
= memcached_query_id(memc_clone
);
1040 // Grouping keys are not required to follow normal key behaviors
1041 test_compare(MEMCACHED_SUCCESS
,
1042 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
1043 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1045 /* The following test should be moved to the end of this function when the
1046 memcached server is updated to allow max size length of the keys in the
1049 test_compare(MEMCACHED_SUCCESS
,
1050 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
1052 libtest::vchar_t longkey
;
1054 libtest::vchar_t::iterator it
= longkey
.begin();
1055 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
1058 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
1060 size_t string_length
;
1062 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
1063 test_compare(MEMCACHED_NOTFOUND
, rc
);
1064 test_zero(string_length
);
1066 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
1067 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1068 test_zero(string_length
);
1072 /* Make sure zero length keys are marked as bad */
1074 test_compare(MEMCACHED_SUCCESS
,
1075 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1076 size_t string_length
;
1077 char *string
= memcached_get(memc_clone
, key
, 0,
1078 &string_length
, &flags
, &rc
);
1079 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1080 test_zero(string_length
);
1084 memcached_free(memc_clone
);
1086 return TEST_SUCCESS
;
1089 #define READ_THROUGH_VALUE "set for me"
1090 static memcached_return_t
read_through_trigger(memcached_st
*, // memc
1092 size_t, // key_length,
1093 memcached_result_st
*result
)
1095 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
1098 #ifndef __INTEL_COMPILER
1099 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1102 test_return_t
read_through(memcached_st
*memc
)
1104 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1106 size_t string_length
;
1108 memcached_return_t rc
;
1109 char *string
= memcached_get(memc
,
1110 test_literal_param(__func__
),
1111 &string_length
, &flags
, &rc
);
1113 test_compare(MEMCACHED_NOTFOUND
, rc
);
1114 test_false(string_length
);
1117 test_compare(MEMCACHED_SUCCESS
,
1118 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1120 string
= memcached_get(memc
,
1121 test_literal_param(__func__
),
1122 &string_length
, &flags
, &rc
);
1124 test_compare(MEMCACHED_SUCCESS
, rc
);
1125 test_compare(sizeof(READ_THROUGH_VALUE
) -1, string_length
);
1126 test_compare(0, string
[sizeof(READ_THROUGH_VALUE
) -1]);
1127 test_strcmp(READ_THROUGH_VALUE
, string
);
1130 string
= memcached_get(memc
,
1131 test_literal_param(__func__
),
1132 &string_length
, &flags
, &rc
);
1134 test_compare(MEMCACHED_SUCCESS
, rc
);
1136 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1137 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1138 test_strcmp(READ_THROUGH_VALUE
, string
);
1141 return TEST_SUCCESS
;
1144 test_return_t
set_test2(memcached_st
*memc
)
1146 for (uint32_t x
= 0; x
< 10; x
++)
1148 test_compare(return_value_based_on_buffering(memc
),
1150 test_literal_param("foo"),
1151 test_literal_param("train in the brain"),
1152 time_t(0), uint32_t(0)));
1155 return TEST_SUCCESS
;
1158 test_return_t
set_test3(memcached_st
*memc
)
1160 size_t value_length
= 8191;
1162 libtest::vchar_t value
;
1163 value
.reserve(value_length
);
1164 for (uint32_t x
= 0; x
< value_length
; x
++)
1166 value
.push_back(char(x
% 127));
1169 /* The dump test relies on there being at least 32 items in memcached */
1170 for (uint32_t x
= 0; x
< 32; x
++)
1174 snprintf(key
, sizeof(key
), "foo%u", x
);
1176 uint64_t query_id
= memcached_query_id(memc
);
1177 test_compare(return_value_based_on_buffering(memc
),
1178 memcached_set(memc
, key
, strlen(key
),
1179 &value
[0], value
.size(),
1180 time_t(0), uint32_t(0)));
1181 test_compare(query_id
+1, memcached_query_id(memc
));
1184 return TEST_SUCCESS
;
1187 test_return_t
mget_end(memcached_st
*memc
)
1189 const char *keys
[]= { "foo", "foo2" };
1190 size_t lengths
[]= { 3, 4 };
1191 const char *values
[]= { "fjord", "41" };
1194 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1196 test_compare(MEMCACHED_SUCCESS
,
1198 keys
[x
], lengths
[x
],
1199 values
[x
], strlen(values
[x
]),
1200 time_t(0), uint32_t(0)));
1204 size_t string_length
;
1207 // retrieve both via mget
1208 test_compare(MEMCACHED_SUCCESS
,
1209 memcached_mget(memc
,
1211 test_array_length(keys
)));
1213 char key
[MEMCACHED_MAX_KEY
];
1215 memcached_return_t rc
;
1217 // this should get both
1218 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1220 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1222 test_compare(MEMCACHED_SUCCESS
, rc
);
1224 if (key_length
== 4)
1229 test_compare(string_length
, strlen(values
[val
]));
1230 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1234 // this should indicate end
1235 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1236 test_compare(MEMCACHED_END
, rc
);
1240 test_compare(MEMCACHED_SUCCESS
,
1241 memcached_mget(memc
, keys
, lengths
, 1));
1243 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1244 test_compare(key_length
, lengths
[0]);
1245 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1246 test_compare(string_length
, strlen(values
[0]));
1247 test_true(strncmp(values
[0], string
, string_length
) == 0);
1248 test_compare(MEMCACHED_SUCCESS
, rc
);
1251 // this should indicate end
1252 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1253 test_compare(MEMCACHED_END
, rc
);
1256 return TEST_SUCCESS
;
1259 /* Do not copy the style of this code, I just access hosts to testthis function */
1260 test_return_t
stats_servername_test(memcached_st
*memc
)
1262 memcached_stat_st memc_stat
;
1263 const memcached_instance_st
* instance
=
1264 memcached_server_instance_by_position(memc
, 0);
1266 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1268 return TEST_SKIPPED
;
1271 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1272 memcached_server_name(instance
),
1273 memcached_server_port(instance
)));
1275 return TEST_SUCCESS
;
1278 test_return_t
increment_test(memcached_st
*memc
)
1280 uint64_t new_number
;
1282 test_compare(MEMCACHED_SUCCESS
,
1284 test_literal_param("number"),
1285 test_literal_param("0"),
1286 (time_t)0, (uint32_t)0));
1288 test_compare(MEMCACHED_SUCCESS
,
1289 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1290 test_compare(uint64_t(1), new_number
);
1292 test_compare(MEMCACHED_SUCCESS
,
1293 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1294 test_compare(uint64_t(2), new_number
);
1296 return TEST_SUCCESS
;
1299 static test_return_t
__increment_with_initial_test(memcached_st
*memc
, uint64_t initial
)
1301 uint64_t new_number
;
1303 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1305 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
1307 test_compare(MEMCACHED_SUCCESS
,
1308 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1309 test_compare(new_number
, initial
);
1311 test_compare(MEMCACHED_SUCCESS
,
1312 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1313 test_compare(new_number
, (initial
+1));
1317 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
1318 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1321 return TEST_SUCCESS
;
1324 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1326 return __increment_with_initial_test(memc
, 0);
1329 test_return_t
increment_with_initial_999_test(memcached_st
*memc
)
1331 return __increment_with_initial_test(memc
, 999);
1334 test_return_t
decrement_test(memcached_st
*memc
)
1336 test_compare(return_value_based_on_buffering(memc
),
1338 test_literal_param(__func__
),
1339 test_literal_param("3"),
1340 time_t(0), uint32_t(0)));
1342 // Make sure we flush the value we just set
1343 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1345 uint64_t new_number
;
1346 test_compare(MEMCACHED_SUCCESS
,
1347 memcached_decrement(memc
,
1348 test_literal_param(__func__
),
1350 test_compare(uint64_t(2), new_number
);
1352 test_compare(MEMCACHED_SUCCESS
,
1353 memcached_decrement(memc
,
1354 test_literal_param(__func__
),
1356 test_compare(uint64_t(1), new_number
);
1358 return TEST_SUCCESS
;
1361 static test_return_t
__decrement_with_initial_test(memcached_st
*memc
, uint64_t initial
)
1363 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1365 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1367 uint64_t new_number
;
1368 test_compare(MEMCACHED_SUCCESS
,
1369 memcached_decrement_with_initial(memc
,
1370 test_literal_param(__func__
),
1373 test_compare(new_number
, initial
);
1375 test_compare(MEMCACHED_SUCCESS
,
1376 memcached_decrement_with_initial(memc
,
1377 test_literal_param(__func__
),
1380 test_compare(new_number
, (initial
- 1));
1382 return TEST_SUCCESS
;
1385 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1387 return __decrement_with_initial_test(memc
, 3);
1390 test_return_t
decrement_with_initial_999_test(memcached_st
*memc
)
1392 return __decrement_with_initial_test(memc
, 999);
1395 test_return_t
increment_by_key_test(memcached_st
*memc
)
1397 const char *master_key
= "foo";
1398 const char *key
= "number";
1399 const char *value
= "0";
1401 test_compare(return_value_based_on_buffering(memc
),
1402 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1404 value
, strlen(value
),
1405 time_t(0), uint32_t(0)));
1407 // Make sure we flush the value we just set
1408 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1410 uint64_t new_number
;
1411 test_compare(MEMCACHED_SUCCESS
,
1412 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1413 key
, strlen(key
), 1, &new_number
));
1414 test_compare(uint64_t(1), new_number
);
1416 test_compare(MEMCACHED_SUCCESS
,
1417 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1418 key
, strlen(key
), 1, &new_number
));
1419 test_compare(uint64_t(2), new_number
);
1421 return TEST_SUCCESS
;
1424 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1426 uint64_t new_number
;
1427 const char *master_key
= "foo";
1428 const char *key
= "number";
1429 uint64_t initial
= 0;
1431 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
1433 test_compare(MEMCACHED_SUCCESS
,
1434 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1436 1, initial
, 0, &new_number
));
1437 test_compare(new_number
, initial
);
1439 test_compare(MEMCACHED_SUCCESS
,
1440 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1442 1, initial
, 0, &new_number
));
1443 test_compare(new_number
, (initial
+1));
1447 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
1448 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1450 1, initial
, 0, &new_number
));
1453 return TEST_SUCCESS
;
1456 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1458 uint64_t new_number
;
1459 const char *value
= "3";
1461 test_compare(return_value_based_on_buffering(memc
),
1462 memcached_set_by_key(memc
,
1463 test_literal_param("foo"),
1464 test_literal_param("number"),
1465 value
, strlen(value
),
1466 (time_t)0, (uint32_t)0));
1468 test_compare(MEMCACHED_SUCCESS
,
1469 memcached_decrement_by_key(memc
,
1470 test_literal_param("foo"),
1471 test_literal_param("number"),
1473 test_compare(uint64_t(2), new_number
);
1475 test_compare(MEMCACHED_SUCCESS
,
1476 memcached_decrement_by_key(memc
,
1477 test_literal_param("foo"),
1478 test_literal_param("number"),
1480 test_compare(uint64_t(1), new_number
);
1482 return TEST_SUCCESS
;
1485 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1487 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1489 uint64_t new_number
;
1490 uint64_t initial
= 3;
1492 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
1494 test_compare(MEMCACHED_SUCCESS
,
1495 memcached_decrement_with_initial_by_key(memc
,
1496 test_literal_param("foo"),
1497 test_literal_param("number"),
1498 1, initial
, 0, &new_number
));
1499 test_compare(new_number
, initial
);
1501 test_compare(MEMCACHED_SUCCESS
,
1502 memcached_decrement_with_initial_by_key(memc
,
1503 test_literal_param("foo"),
1504 test_literal_param("number"),
1505 1, initial
, 0, &new_number
));
1506 test_compare(new_number
, (initial
- 1));
1510 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
1511 memcached_decrement_with_initial_by_key(memc
,
1512 test_literal_param("foo"),
1513 test_literal_param("number"),
1514 1, initial
, 0, &new_number
));
1517 return TEST_SUCCESS
;
1519 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1521 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1523 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1525 test_compare(return_value_based_on_buffering(memc
),
1527 test_literal_param("number"),
1528 test_literal_param("0"),
1529 (time_t)0, (uint32_t)0));
1531 uint64_t new_number
;
1532 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1533 test_literal_param("number"),
1535 test_compare(uint64_t(1), new_number
);
1537 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1538 test_literal_param("number"),
1540 test_compare(uint64_t(2), new_number
);
1542 return TEST_SUCCESS
;
1545 test_return_t
quit_test(memcached_st
*memc
)
1547 const char *value
= "sanford and sun";
1549 test_compare(return_value_based_on_buffering(memc
),
1551 test_literal_param(__func__
),
1552 value
, strlen(value
),
1553 time_t(10), uint32_t(3)));
1554 memcached_quit(memc
);
1556 test_compare(return_value_based_on_buffering(memc
),
1558 test_literal_param(__func__
),
1559 value
, strlen(value
),
1560 time_t(50), uint32_t(9)));
1562 return TEST_SUCCESS
;
1565 test_return_t
mget_result_test(memcached_st
*memc
)
1567 const char *keys
[]= {"fudge", "son", "food"};
1568 size_t key_length
[]= {5, 3, 4};
1570 memcached_result_st results_obj
;
1571 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1573 test_true(&results_obj
== results
);
1575 /* We need to empty the server before continueing test */
1576 test_compare(MEMCACHED_SUCCESS
,
1577 memcached_flush(memc
, 0));
1579 test_compare(MEMCACHED_SUCCESS
,
1580 memcached_mget(memc
, keys
, key_length
, 3));
1582 memcached_return_t rc
;
1583 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1588 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1589 test_false(results
);
1590 test_compare(MEMCACHED_NOTFOUND
, rc
);
1592 for (uint32_t x
= 0; x
< 3; x
++)
1594 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1595 keys
[x
], key_length
[x
],
1596 (time_t)50, (uint32_t)9);
1597 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1600 test_compare(MEMCACHED_SUCCESS
,
1601 memcached_mget(memc
, keys
, key_length
, 3));
1603 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1606 test_true(&results_obj
== results
);
1607 test_compare(MEMCACHED_SUCCESS
, rc
);
1608 test_memcmp(memcached_result_key_value(results
),
1609 memcached_result_value(results
),
1610 memcached_result_length(results
));
1611 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1614 memcached_result_free(&results_obj
);
1616 return TEST_SUCCESS
;
1619 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1621 const char *keys
[]= {"fudge", "son", "food"};
1622 size_t key_length
[]= {5, 3, 4};
1624 memcached_result_st
*results
;
1626 /* We need to empty the server before continueing test */
1627 test_compare(MEMCACHED_SUCCESS
,
1628 memcached_flush(memc
, 0));
1630 test_compare(MEMCACHED_SUCCESS
,
1631 memcached_mget(memc
, keys
, key_length
, 3));
1633 memcached_return_t rc
;
1634 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1638 test_false(results
);
1639 test_compare(MEMCACHED_NOTFOUND
, rc
);
1641 for (uint32_t x
= 0; x
< 3; x
++)
1643 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1644 keys
[x
], key_length
[x
],
1645 (time_t)50, (uint32_t)9);
1646 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1649 test_compare(MEMCACHED_SUCCESS
,
1650 memcached_mget(memc
, keys
, key_length
, 3));
1653 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1656 test_compare(MEMCACHED_SUCCESS
, rc
);
1657 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1658 test_memcmp(memcached_result_key_value(results
),
1659 memcached_result_value(results
),
1660 memcached_result_length(results
));
1661 memcached_result_free(results
);
1665 return TEST_SUCCESS
;
1668 test_return_t
mget_result_function(memcached_st
*memc
)
1670 const char *keys
[]= {"fudge", "son", "food"};
1671 size_t key_length
[]= {5, 3, 4};
1673 memcached_execute_fn callbacks
[1];
1675 for (uint32_t x
= 0; x
< 3; x
++)
1677 test_compare(return_value_based_on_buffering(memc
),
1678 memcached_set(memc
, keys
[x
], key_length
[x
],
1679 keys
[x
], key_length
[x
],
1680 time_t(50), uint32_t(9)));
1682 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1683 memcached_quit(memc
);
1685 test_compare(MEMCACHED_SUCCESS
,
1686 memcached_mget(memc
, keys
, key_length
, 3));
1688 callbacks
[0]= &callback_counter
;
1691 test_compare(MEMCACHED_SUCCESS
,
1692 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1694 test_compare(size_t(3), counter
);
1696 return TEST_SUCCESS
;
1699 test_return_t
mget_test(memcached_st
*memc
)
1701 const char *keys
[]= {"fudge", "son", "food"};
1702 size_t key_length
[]= {5, 3, 4};
1704 char return_key
[MEMCACHED_MAX_KEY
];
1705 size_t return_key_length
;
1707 size_t return_value_length
;
1709 test_compare(MEMCACHED_SUCCESS
,
1710 memcached_mget(memc
, keys
, key_length
, 3));
1713 memcached_return_t rc
;
1714 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1715 &return_value_length
, &flags
, &rc
)))
1717 test_true(return_value
);
1719 test_false(return_value
);
1720 test_zero(return_value_length
);
1721 test_compare(MEMCACHED_NOTFOUND
, rc
);
1723 for (uint32_t x
= 0; x
< 3; x
++)
1725 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1726 keys
[x
], key_length
[x
],
1727 (time_t)50, (uint32_t)9);
1728 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1730 test_compare(MEMCACHED_SUCCESS
,
1731 memcached_mget(memc
, keys
, key_length
, 3));
1734 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1735 &return_value_length
, &flags
, &rc
)))
1737 test_true(return_value
);
1738 test_compare(MEMCACHED_SUCCESS
, rc
);
1739 if (not memc
->_namespace
)
1741 test_compare(return_key_length
, return_value_length
);
1742 test_memcmp(return_value
, return_key
, return_value_length
);
1748 return TEST_SUCCESS
;
1751 test_return_t
mget_execute(memcached_st
*original_memc
)
1753 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1755 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1758 keys_st
keys(20480);
1760 /* First add all of the items.. */
1761 char blob
[1024] = {0};
1763 for (size_t x
= 0; x
< keys
.size(); ++x
)
1765 uint64_t query_id
= memcached_query_id(memc
);
1766 memcached_return_t rc
= memcached_add(memc
,
1767 keys
.key_at(x
), keys
.length_at(x
),
1770 ASSERT_TRUE_(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, "Returned %s", memcached_strerror(NULL
, rc
));
1771 test_compare(query_id
+1, memcached_query_id(memc
));
1774 /* Try to get all of them with a large multiget */
1776 memcached_execute_fn callbacks
[]= { &callback_counter
};
1777 test_compare(MEMCACHED_SUCCESS
,
1778 memcached_mget_execute(memc
,
1779 keys
.keys_ptr(), keys
.lengths_ptr(),
1780 keys
.size(), callbacks
, &counter
, 1));
1783 uint64_t query_id
= memcached_query_id(memc
);
1784 test_compare(MEMCACHED_SUCCESS
,
1785 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1786 test_compare(query_id
, memcached_query_id(memc
));
1788 /* Verify that we got all of the items */
1789 test_compare(keys
.size(), counter
);
1792 memcached_free(memc
);
1794 return TEST_SUCCESS
;
1797 test_return_t
MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST(memcached_st
*original_memc
)
1799 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1801 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1804 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 8));
1806 keys_st
keys(20480);
1808 /* First add all of the items.. */
1809 char blob
[1024] = {0};
1811 for (size_t x
= 0; x
< keys
.size(); ++x
)
1813 uint64_t query_id
= memcached_query_id(memc
);
1814 memcached_return_t rc
= memcached_add(memc
,
1815 keys
.key_at(x
), keys
.length_at(x
),
1818 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1819 test_compare(query_id
+1, memcached_query_id(memc
));
1822 /* Try to get all of them with a large multiget */
1824 memcached_execute_fn callbacks
[]= { &callback_counter
};
1825 test_compare(MEMCACHED_SUCCESS
,
1826 memcached_mget_execute(memc
,
1827 keys
.keys_ptr(), keys
.lengths_ptr(),
1828 keys
.size(), callbacks
, &counter
, 1));
1831 uint64_t query_id
= memcached_query_id(memc
);
1832 test_compare(MEMCACHED_SUCCESS
,
1833 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1834 test_compare(query_id
, memcached_query_id(memc
));
1836 /* Verify that we got all of the items */
1837 test_compare(keys
.size(), counter
);
1840 memcached_free(memc
);
1842 return TEST_SUCCESS
;
1845 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1846 static pairs_st
*global_pairs
= NULL
;
1848 test_return_t
key_setup(memcached_st
*memc
)
1850 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1852 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1854 return TEST_SUCCESS
;
1857 test_return_t
key_teardown(memcached_st
*)
1859 pairs_free(global_pairs
);
1862 return TEST_SUCCESS
;
1865 test_return_t
block_add_regression(memcached_st
*memc
)
1867 /* First add all of the items.. */
1868 for (ptrdiff_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1870 libtest::vchar_t blob
;
1871 libtest::vchar::make(blob
, 1024);
1873 memcached_return_t rc
= memcached_add_by_key(memc
,
1874 test_literal_param("bob"),
1875 global_pairs
[x
].key
, global_pairs
[x
].key_length
,
1876 &blob
[0], blob
.size(),
1877 time_t(0), uint32_t(0));
1878 if (rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
)
1880 Error
<< memcached_last_error_message(memc
);
1881 return TEST_SKIPPED
;
1883 test_compare(*memc
, MEMCACHED_SUCCESS
);
1884 test_compare(rc
, MEMCACHED_SUCCESS
);
1887 return TEST_SUCCESS
;
1890 test_return_t
binary_add_regression(memcached_st
*memc
)
1892 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1893 return block_add_regression(memc
);
1896 test_return_t
get_stats_keys(memcached_st
*memc
)
1900 memcached_stat_st memc_stat
;
1901 memcached_return_t rc
;
1903 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1904 test_compare(MEMCACHED_SUCCESS
, rc
);
1905 for (ptr
= stat_list
; *ptr
; ptr
++)
1910 return TEST_SUCCESS
;
1913 test_return_t
version_string_test(memcached_st
*)
1915 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1917 return TEST_SUCCESS
;
1920 test_return_t
get_stats(memcached_st
*memc
)
1922 memcached_return_t rc
;
1924 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1925 test_compare(MEMCACHED_SUCCESS
, rc
);
1926 test_true(memc_stat
);
1928 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1930 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1931 test_compare(MEMCACHED_SUCCESS
, rc
);
1932 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1937 memcached_stat_free(NULL
, memc_stat
);
1939 return TEST_SUCCESS
;
1942 test_return_t
add_host_test(memcached_st
*memc
)
1944 char servername
[]= "0.example.com";
1946 memcached_return_t rc
;
1947 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1948 test_compare(1U, memcached_server_list_count(servers
));
1950 for (unsigned int x
= 2; x
< 20; x
++)
1952 char buffer
[SMALL_STRING_LEN
];
1954 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1955 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1957 test_compare(MEMCACHED_SUCCESS
, rc
);
1958 test_compare(x
, memcached_server_list_count(servers
));
1961 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1962 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1964 memcached_server_list_free(servers
);
1966 return TEST_SUCCESS
;
1969 test_return_t
regression_1048945_TEST(memcached_st
*)
1971 memcached_return status
;
1973 memcached_server_st
* list
= memcached_server_list_append_with_weight(NULL
, "a", 11211, 0, &status
);
1974 test_compare(status
, MEMCACHED_SUCCESS
);
1976 list
= memcached_server_list_append_with_weight(list
, "b", 11211, 0, &status
);
1977 test_compare(status
, MEMCACHED_SUCCESS
);
1979 list
= memcached_server_list_append_with_weight(list
, "c", 11211, 0, &status
);
1980 test_compare(status
, MEMCACHED_SUCCESS
);
1982 memcached_st
* memc
= memcached_create(NULL
);
1984 status
= memcached_server_push(memc
, list
);
1985 memcached_server_list_free(list
);
1986 test_compare(status
, MEMCACHED_SUCCESS
);
1988 const memcached_instance_st
* server
= memcached_server_by_key(memc
, test_literal_param(__func__
), &status
);
1990 test_compare(status
, MEMCACHED_SUCCESS
);
1992 memcached_free(memc
);
1994 return TEST_SUCCESS
;
1997 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1999 memcached_return_t rc
;
2001 const char *key
= "not_found";
2002 size_t key_length
= test_literal_param_size("not_found");
2004 test_compare(MEMCACHED_SUCCESS
,
2005 memcached_mget(memc
, &key
, &key_length
, 1));
2007 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
2009 test_compare(MEMCACHED_NOTFOUND
, rc
);
2011 memcached_result_free(result
);
2013 return TEST_SUCCESS
;
2016 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
2018 return MEMCACHED_SUCCESS
;
2021 static memcached_return_t
cleanup_test_callback(memcached_st
*)
2023 return MEMCACHED_SUCCESS
;
2026 test_return_t
callback_test(memcached_st
*memc
)
2028 /* Test User Data */
2032 memcached_return_t rc
;
2034 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
2035 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
2036 test_true(*test_ptr
== x
);
2039 /* Test Clone Callback */
2041 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2042 void *clone_cb_ptr
= *(void **)&clone_cb
;
2043 void *temp_function
= NULL
;
2045 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
2046 memcached_return_t rc
;
2047 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2048 test_true(temp_function
== clone_cb_ptr
);
2049 test_compare(MEMCACHED_SUCCESS
, rc
);
2052 /* Test Cleanup Callback */
2054 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2055 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2056 void *temp_function
= NULL
;
2057 memcached_return_t rc
;
2059 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2060 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2061 test_true(temp_function
== cleanup_cb_ptr
);
2064 return TEST_SUCCESS
;
2067 /* We don't test the behavior itself, we test the switches */
2068 test_return_t
behavior_test(memcached_st
*memc
)
2070 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2071 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2073 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2074 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2076 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2077 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2079 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2080 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2082 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2083 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2085 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2086 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2088 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2089 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2091 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2093 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2095 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2096 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2097 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2099 return TEST_SUCCESS
;
2102 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2104 test_compare(MEMCACHED_DEPRECATED
,
2105 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2107 // Platform dependent
2109 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2113 return TEST_SUCCESS
;
2117 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2119 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2120 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2122 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2124 if (memcached_success(rc
))
2133 return TEST_SUCCESS
;
2137 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2139 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2140 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2142 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2144 if (memcached_success(rc
))
2153 return TEST_SUCCESS
;
2156 /* Make sure we behave properly if server list has no values */
2157 test_return_t
user_supplied_bug4(memcached_st
*memc
)
2159 const char *keys
[]= {"fudge", "son", "food"};
2160 size_t key_length
[]= {5, 3, 4};
2162 /* Here we free everything before running a bunch of mget tests */
2163 memcached_servers_reset(memc
);
2166 /* We need to empty the server before continueing test */
2167 test_compare(MEMCACHED_NO_SERVERS
,
2168 memcached_flush(memc
, 0));
2170 test_compare(MEMCACHED_NO_SERVERS
,
2171 memcached_mget(memc
, keys
, key_length
, 3));
2174 unsigned int keys_returned
;
2175 memcached_return_t rc
;
2176 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2177 test_compare(MEMCACHED_NOTFOUND
, rc
);
2178 test_zero(keys_returned
);
2181 for (uint32_t x
= 0; x
< 3; x
++)
2183 test_compare(MEMCACHED_NO_SERVERS
,
2184 memcached_set(memc
, keys
[x
], key_length
[x
],
2185 keys
[x
], key_length
[x
],
2186 (time_t)50, (uint32_t)9));
2189 test_compare(MEMCACHED_NO_SERVERS
,
2190 memcached_mget(memc
, keys
, key_length
, 3));
2194 char return_key
[MEMCACHED_MAX_KEY
];
2195 memcached_return_t rc
;
2196 size_t return_key_length
;
2197 size_t return_value_length
;
2200 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2201 &return_value_length
, &flags
, &rc
)))
2203 test_true(return_value
);
2204 test_compare(MEMCACHED_SUCCESS
, rc
);
2205 test_true(return_key_length
== return_value_length
);
2206 test_memcmp(return_value
, return_key
, return_value_length
);
2212 return TEST_SUCCESS
;
2215 #define VALUE_SIZE_BUG5 1048064
2216 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2218 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2219 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2221 size_t value_length
;
2223 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2225 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2227 insert_data
[x
]= (signed char)rand();
2230 test_compare(MEMCACHED_SUCCESS
,
2231 memcached_flush(memc
, 0));
2233 memcached_return_t rc
;
2234 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2235 test_compare(MEMCACHED_SUCCESS
,
2236 memcached_mget(memc
, keys
, key_length
, 4));
2239 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2240 test_compare(MEMCACHED_NOTFOUND
, rc
);
2243 for (uint32_t x
= 0; x
< 4; x
++)
2245 test_compare(MEMCACHED_SUCCESS
,
2246 memcached_set(memc
, keys
[x
], key_length
[x
],
2247 insert_data
, VALUE_SIZE_BUG5
,
2248 (time_t)0, (uint32_t)0));
2251 for (uint32_t x
= 0; x
< 10; x
++)
2253 value
= memcached_get(memc
, keys
[0], key_length
[0],
2254 &value_length
, &flags
, &rc
);
2255 test_compare(rc
, MEMCACHED_SUCCESS
);
2259 test_compare(MEMCACHED_SUCCESS
,
2260 memcached_mget(memc
, keys
, key_length
, 4));
2262 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2263 test_compare(4U, count
);
2265 delete [] insert_data
;
2267 return TEST_SUCCESS
;
2270 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2272 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2273 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2274 char return_key
[MEMCACHED_MAX_KEY
];
2275 size_t return_key_length
;
2277 size_t value_length
;
2279 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2281 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2283 insert_data
[x
]= (signed char)rand();
2286 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2288 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2290 // We will now confirm that memcached_mget() returns success, but we will
2291 // then check to make sure that no actual keys are returned.
2292 test_compare(MEMCACHED_SUCCESS
,
2293 memcached_mget(memc
, keys
, key_length
, 4));
2295 memcached_return_t rc
;
2297 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2298 &value_length
, &flags
, &rc
)))
2303 test_compare(MEMCACHED_NOTFOUND
, rc
);
2305 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2307 test_compare(MEMCACHED_SUCCESS
,
2308 memcached_set(memc
, keys
[x
], key_length
[x
],
2309 insert_data
, VALUE_SIZE_BUG5
,
2310 (time_t)0, (uint32_t)0));
2312 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2314 for (uint32_t x
= 0; x
< 2; x
++)
2316 value
= memcached_get(memc
, keys
[0], key_length
[0],
2317 &value_length
, &flags
, &rc
);
2321 test_compare(MEMCACHED_SUCCESS
,
2322 memcached_mget(memc
, keys
, key_length
, 4));
2323 /* We test for purge of partial complete fetches */
2324 for (count
= 3; count
; count
--)
2326 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2327 &value_length
, &flags
, &rc
);
2328 test_compare(MEMCACHED_SUCCESS
, rc
);
2329 test_memcmp(value
, insert_data
, value_length
);
2330 test_true(value_length
);
2334 delete [] insert_data
;
2336 return TEST_SUCCESS
;
2339 test_return_t
user_supplied_bug8(memcached_st
*)
2341 memcached_return_t rc
;
2343 memcached_st
*memc_clone
;
2345 memcached_server_st
*servers
;
2346 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";
2348 servers
= memcached_servers_parse(server_list
);
2351 mine
= memcached_create(NULL
);
2352 rc
= memcached_server_push(mine
, servers
);
2353 test_compare(MEMCACHED_SUCCESS
, rc
);
2354 memcached_server_list_free(servers
);
2357 memc_clone
= memcached_clone(NULL
, mine
);
2359 memcached_quit(mine
);
2360 memcached_quit(memc_clone
);
2363 memcached_free(mine
);
2364 memcached_free(memc_clone
);
2366 return TEST_SUCCESS
;
2369 /* Test flag store/retrieve */
2370 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2372 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2373 test_true(insert_data
);
2375 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2377 insert_data
[x
]= (signed char)rand();
2380 memcached_flush(memc
, 0);
2382 const char *keys
= "036790384900";
2383 size_t key_length
= strlen(keys
);
2384 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2385 insert_data
, VALUE_SIZE_BUG5
,
2388 memcached_return_t rc
;
2389 size_t value_length
;
2391 char *value
= memcached_get(memc
, keys
, key_length
,
2392 &value_length
, &flags
, &rc
);
2393 test_compare(245U, flags
);
2397 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2399 char return_key
[MEMCACHED_MAX_KEY
];
2400 size_t return_key_length
;
2402 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2403 &value_length
, &flags
, &rc
);
2404 test_compare(uint32_t(245), flags
);
2407 delete [] insert_data
;
2410 return TEST_SUCCESS
;
2413 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2415 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2416 size_t key_length
[3];
2420 char return_key
[MEMCACHED_MAX_KEY
];
2421 size_t return_key_length
;
2423 size_t return_value_length
;
2426 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2427 key_length
[1]= strlen("fudge&*@#");
2428 key_length
[2]= strlen("for^#@&$not");
2431 for (unsigned int x
= 0; x
< 3; x
++)
2433 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2434 keys
[x
], key_length
[x
],
2435 (time_t)50, (uint32_t)9);
2436 test_compare(MEMCACHED_SUCCESS
, rc
);
2439 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2440 test_compare(MEMCACHED_SUCCESS
, rc
);
2442 /* We need to empty the server before continueing test */
2443 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2444 &return_value_length
, &flags
, &rc
)) != NULL
)
2446 test_true(return_value
);
2450 test_compare(3U, count
);
2452 return TEST_SUCCESS
;
2455 /* We are testing with aggressive timeout to get failures */
2456 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2458 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
2460 size_t value_length
= 512;
2461 unsigned int set
= 1;
2462 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2464 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2465 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2466 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2468 libtest::vchar_t value
;
2469 value
.reserve(value_length
);
2470 for (uint32_t x
= 0; x
< value_length
; x
++)
2472 value
.push_back(char(x
% 127));
2475 for (unsigned int x
= 1; x
<= 100000; ++x
)
2477 memcached_return_t rc
= memcached_set(mclone
,
2478 test_literal_param("foo"),
2479 &value
[0], value
.size(),
2482 test_true((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2483 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
));
2485 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2491 memcached_free(mclone
);
2493 return TEST_SUCCESS
;
2497 We are looking failures in the async protocol
2499 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2503 test::Memc
mclone(memc
);
2505 memcached_behavior_set(&mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2506 memcached_behavior_set(&mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2507 memcached_behavior_set(&mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2509 test_compare(-1, int32_t(memcached_behavior_get(&mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2511 libtest::vchar_t value
;
2513 for (unsigned int x
= 0; x
< 512; x
++)
2515 value
.push_back(char(x
% 127));
2518 for (unsigned int x
= 1; x
<= 100000; ++x
)
2520 memcached_return_t rc
= memcached_set(&mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2526 return TEST_SUCCESS
;
2530 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2532 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2534 memcached_return_t rc
;
2536 size_t value_length
;
2538 uint64_t number_value
;
2540 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2541 &value_length
, &flags
, &rc
);
2543 test_compare(MEMCACHED_NOTFOUND
, rc
);
2545 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2548 /* The binary protocol will set the key if it doesn't exist */
2549 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2551 test_compare(MEMCACHED_SUCCESS
, rc
);
2555 test_compare(MEMCACHED_NOTFOUND
, rc
);
2558 test_compare(MEMCACHED_SUCCESS
,
2559 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2561 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2565 test_compare(MEMCACHED_SUCCESS
,
2566 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2567 test_compare(2UL, number_value
);
2569 return TEST_SUCCESS
;
2573 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2574 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2576 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2578 char key
[] = "key34567890";
2580 char commandFirst
[]= "set key34567890 0 0 ";
2581 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2582 size_t commandLength
;
2584 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2586 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2588 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2590 char *overflow
= new (std::nothrow
) char[testSize
];
2591 test_true(overflow
);
2593 memset(overflow
, 'x', testSize
);
2594 test_compare(MEMCACHED_SUCCESS
,
2595 memcached_set(memc
, key
, strlen(key
),
2596 overflow
, testSize
, 0, 0));
2600 return TEST_SUCCESS
;
2605 Test values of many different sizes
2606 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2607 set key34567890 0 0 8169 \r\n
2608 is sent followed by buffer of size 8169, followed by 8169
2610 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2612 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2614 libtest::vchar_t value
;
2615 value
.reserve(18000);
2616 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2618 value
.push_back((char) (x
% 127));
2621 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2623 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2624 &value
[0], current_length
,
2625 (time_t)0, (uint32_t)0);
2626 ASSERT_TRUE_(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, "Instead got %s", memcached_strerror(NULL
, rc
));
2628 size_t string_length
;
2630 char *string
= memcached_get(memc
, test_literal_param("foo"),
2631 &string_length
, &flags
, &rc
);
2633 test_compare(MEMCACHED_SUCCESS
, rc
);
2634 test_compare(string_length
, current_length
);
2636 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2637 test_memcmp(string
, &value
[0], string_length
);
2642 return TEST_SUCCESS
;
2646 Look for zero length value problems
2648 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2650 for (uint32_t x
= 0; x
< 2; x
++)
2652 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2654 (time_t)0, (uint32_t)0);
2656 test_compare(MEMCACHED_SUCCESS
, rc
);
2660 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2661 &length
, &flags
, &rc
);
2663 test_compare(MEMCACHED_SUCCESS
, rc
);
2668 value
= memcached_get(memc
, test_literal_param("mykey"),
2669 &length
, &flags
, &rc
);
2671 test_compare(MEMCACHED_SUCCESS
, rc
);
2677 return TEST_SUCCESS
;
2680 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2681 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2683 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2685 (time_t)0, UINT32_MAX
));
2690 memcached_return_t rc
;
2691 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2692 &length
, &flags
, &rc
);
2694 test_compare(MEMCACHED_SUCCESS
, rc
);
2697 test_compare(flags
, UINT32_MAX
);
2699 return TEST_SUCCESS
;
2702 #if !defined(__sun) && !defined(__OpenBSD__)
2703 /* Check the validity of chinese key*/
2704 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2706 const char *key
= "豆瓣";
2707 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2708 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2709 value
, strlen(value
),
2712 test_compare(MEMCACHED_SUCCESS
, rc
);
2716 char *value2
= memcached_get(memc
, key
, strlen(key
),
2717 &length
, &flags
, &rc
);
2719 test_compare(length
, strlen(value
));
2720 test_compare(MEMCACHED_SUCCESS
, rc
);
2721 test_memcmp(value
, value2
, length
);
2724 return TEST_SUCCESS
;
2732 test_return_t
user_supplied_bug19(memcached_st
*)
2734 memcached_return_t res
;
2736 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2738 const memcached_instance_st
* server
= memcached_server_by_key(memc
, "a", 1, &res
);
2741 memcached_free(memc
);
2743 return TEST_SUCCESS
;
2746 /* CAS test from Andei */
2747 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2749 const char *key
= "abc";
2750 size_t key_len
= strlen("abc");
2752 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2754 test_compare(MEMCACHED_SUCCESS
,
2756 test_literal_param("abc"),
2757 test_literal_param("foobar"),
2758 (time_t)0, (uint32_t)0));
2760 test_compare(MEMCACHED_SUCCESS
,
2761 memcached_mget(memc
, &key
, &key_len
, 1));
2763 memcached_result_st result_obj
;
2764 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2767 memcached_result_create(memc
, &result_obj
);
2768 memcached_return_t status
;
2769 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2772 test_compare(MEMCACHED_SUCCESS
, status
);
2774 memcached_result_free(result
);
2776 return TEST_SUCCESS
;
2779 /* Large mget() of missing keys with binary proto
2781 * If many binary quiet commands (such as getq's in an mget) fill the output
2782 * buffer and the server chooses not to respond, memcached_flush hangs. See
2783 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2786 /* sighandler_t function that always asserts false */
2787 static __attribute__((noreturn
)) void fail(int)
2793 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2798 return TEST_SKIPPED
;
2800 void (*oldalarm
)(int);
2802 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2803 test_true(memc_clone
);
2805 /* only binproto uses getq for mget */
2806 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2808 /* empty the cache to ensure misses (hence non-responses) */
2809 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2811 keys_st
keys(key_count
);
2813 oldalarm
= signal(SIGALRM
, fail
);
2816 test_compare_got(MEMCACHED_SUCCESS
,
2817 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2818 memcached_last_error_message(memc_clone
));
2821 signal(SIGALRM
, oldalarm
);
2823 memcached_return_t rc
;
2825 char return_key
[MEMCACHED_MAX_KEY
];
2826 size_t return_key_length
;
2828 size_t return_value_length
;
2829 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2830 &return_value_length
, &flags
, &rc
)))
2832 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2834 test_compare(MEMCACHED_NOTFOUND
, rc
);
2835 test_zero(return_value_length
);
2836 test_zero(return_key_length
);
2837 test_false(return_key
[0]);
2838 test_false(return_value
);
2840 memcached_free(memc_clone
);
2842 return TEST_SUCCESS
;
2846 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2848 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2850 /* should work as of r580 */
2851 test_compare(TEST_SUCCESS
,
2852 _user_supplied_bug21(memc
, 10));
2854 /* should fail as of r580 */
2855 test_compare(TEST_SUCCESS
,
2856 _user_supplied_bug21(memc
, 1000));
2858 return TEST_SUCCESS
;
2861 test_return_t
comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st
*)
2865 memcached_st
*memc
= &memc_
;
2867 ASSERT_EQ(memc
, MEMCACHED_SUCCESS
);
2868 test_compare(memc
, MEMCACHED_SUCCESS
);
2870 ASSERT_NEQ(memc
, MEMCACHED_FAILURE
);
2872 return TEST_SUCCESS
;
2875 test_return_t
ketama_TEST(memcached_st
*)
2877 test::Memc
memc("--server=10.0.1.1:11211 --server=10.0.1.2:11211");
2879 test_compare(MEMCACHED_SUCCESS
,
2880 memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2882 test_compare(memcached_behavior_get(&memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
), uint64_t(1));
2884 test_compare(memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
), MEMCACHED_SUCCESS
);
2886 test_compare(memcached_hash_t(memcached_behavior_get(&memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
)), MEMCACHED_HASH_MD5
);
2888 test_compare(memcached_behavior_set_distribution(&memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
), MEMCACHED_SUCCESS
);
2891 return TEST_SUCCESS
;
2894 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2896 memcached_st
*memc
= memcached_create(NULL
);
2900 test_compare(MEMCACHED_SUCCESS
,
2901 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2903 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2904 test_compare(value
, uint64_t(1));
2906 test_compare(MEMCACHED_SUCCESS
,
2907 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2909 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2910 test_true(value
== MEMCACHED_HASH_MD5
);
2913 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2915 memcached_server_st
*server_pool
;
2916 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");
2917 memcached_server_push(memc
, server_pool
);
2919 // @todo this needs to be refactored to actually test something.
2922 if ((fp
= fopen("ketama_keys.txt", "w")))
2926 printf("cannot write to file ketama_keys.txt");
2927 return TEST_FAILURE
;
2930 for (int x
= 0; x
< 10000; x
++)
2933 snprintf(key
, sizeof(key
), "%d", x
);
2935 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2936 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2937 in_port_t port
= memc
->hosts
[server_idx
].port
;
2938 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2939 const memcached_instance_st
* instance
=
2940 memcached_server_instance_by_position(memc
, host_index
);
2944 memcached_server_list_free(server_pool
);
2945 memcached_free(memc
);
2947 return TEST_SUCCESS
;
2951 test_return_t
result_static(memcached_st
*memc
)
2953 memcached_result_st result
;
2954 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
2955 test_false(result
.options
.is_allocated
);
2956 test_true(memcached_is_initialized(&result
));
2957 test_true(result_ptr
);
2958 test_true(result_ptr
== &result
);
2960 memcached_result_free(&result
);
2962 test_false(result
.options
.is_allocated
);
2963 test_false(memcached_is_initialized(&result
));
2965 return TEST_SUCCESS
;
2968 test_return_t
result_alloc(memcached_st
*memc
)
2970 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
2971 test_true(result_ptr
);
2972 test_true(result_ptr
->options
.is_allocated
);
2973 test_true(memcached_is_initialized(result_ptr
));
2974 memcached_result_free(result_ptr
);
2976 return TEST_SUCCESS
;
2980 test_return_t
add_host_test1(memcached_st
*memc
)
2982 memcached_return_t rc
;
2983 char servername
[]= "0.example.com";
2985 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2987 test_compare(1U, memcached_server_list_count(servers
));
2989 for (uint32_t x
= 2; x
< 20; x
++)
2991 char buffer
[SMALL_STRING_LEN
];
2993 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
2994 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2996 test_compare(MEMCACHED_SUCCESS
, rc
);
2997 test_compare(x
, memcached_server_list_count(servers
));
3000 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3001 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3003 memcached_server_list_free(servers
);
3005 return TEST_SUCCESS
;
3009 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3013 #ifdef HARD_MALLOC_TESTS
3014 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3022 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3026 #ifdef HARD_MALLOC_TESTS
3027 void *ret
= malloc(size
+ 8);
3030 ret
= (void*)((caddr_t
)ret
+ 8);
3033 void *ret
= malloc(size
);
3038 memset(ret
, 0xff, size
);
3045 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3047 #ifdef HARD_MALLOC_TESTS
3048 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3049 void *nmem
= realloc(real_ptr
, size
+ 8);
3054 ret
= (void*)((caddr_t
)nmem
+ 8);
3060 return realloc(mem
, size
);
3065 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3067 #ifdef HARD_MALLOC_TESTS
3068 void *mem
= my_malloc(ptr
, nelem
* size
);
3071 memset(mem
, 0, nelem
* size
);
3077 return calloc(nelem
, size
);
3081 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3083 memcached_return_t rc
;
3084 const char *key
= "mine";
3087 /* Make sure by default none exists */
3088 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3090 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3092 /* Test a clean set */
3093 test_compare(MEMCACHED_SUCCESS
,
3094 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3096 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3098 test_memcmp(value
, key
, strlen(key
));
3099 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3101 /* Test that we can turn it off */
3102 test_compare(MEMCACHED_SUCCESS
,
3103 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3105 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3107 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3109 /* Now setup for main test */
3110 test_compare(MEMCACHED_SUCCESS
,
3111 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3113 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3115 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3116 test_memcmp(value
, key
, strlen(key
));
3118 /* Set to Zero, and then Set to something too large */
3121 memset(long_key
, 0, 255);
3123 test_compare(MEMCACHED_SUCCESS
,
3124 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3126 ASSERT_NULL_(memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
), "Setting namespace to NULL did not work");
3128 /* Test a long key for failure */
3129 /* TODO, extend test to determine based on setting, what result should be */
3130 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3131 test_compare(MEMCACHED_SUCCESS
,
3132 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3134 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3135 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3136 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3137 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3139 /* Test for a bad prefix, but with a short key */
3140 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3141 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3143 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3144 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3147 return TEST_SUCCESS
;
3150 test_return_t
set_namespace(memcached_st
*memc
)
3152 memcached_return_t rc
;
3153 const char *key
= "mine";
3155 // Make sure we default to a null namespace
3156 char* value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3157 ASSERT_NULL_(value
, "memc had a value for namespace when none should exist");
3158 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3160 /* Test a clean set */
3161 test_compare(MEMCACHED_SUCCESS
,
3162 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3164 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3166 test_memcmp(value
, key
, strlen(key
));
3167 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3169 return TEST_SUCCESS
;
3172 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3174 test_return_if(pre_binary(memc
));
3175 test_return_if(set_namespace(memc
));
3177 return TEST_SUCCESS
;
3180 #ifdef MEMCACHED_ENABLE_DEPRECATED
3181 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3183 void *test_ptr
= NULL
;
3186 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
3187 cb_ptr
= *(void **)&malloc_cb
;
3188 memcached_return_t rc
;
3190 test_compare(MEMCACHED_SUCCESS
,
3191 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3192 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3193 test_compare(MEMCACHED_SUCCESS
, rc
);
3194 test_true(test_ptr
== cb_ptr
);
3198 memcached_realloc_fn realloc_cb
=
3199 (memcached_realloc_fn
)my_realloc
;
3200 cb_ptr
= *(void **)&realloc_cb
;
3201 memcached_return_t rc
;
3203 test_compare(MEMCACHED_SUCCESS
,
3204 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3205 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3206 test_compare(MEMCACHED_SUCCESS
, rc
);
3207 test_true(test_ptr
== cb_ptr
);
3211 memcached_free_fn free_cb
=
3212 (memcached_free_fn
)my_free
;
3213 cb_ptr
= *(void **)&free_cb
;
3214 memcached_return_t rc
;
3216 test_compare(MEMCACHED_SUCCESS
,
3217 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3218 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3219 test_compare(MEMCACHED_SUCCESS
, rc
);
3220 test_true(test_ptr
== cb_ptr
);
3223 return TEST_SUCCESS
;
3228 test_return_t
set_memory_alloc(memcached_st
*memc
)
3230 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3231 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3232 my_realloc
, my_calloc
, NULL
));
3234 test_compare(MEMCACHED_SUCCESS
,
3235 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3236 my_realloc
, my_calloc
, NULL
));
3238 memcached_malloc_fn mem_malloc
;
3239 memcached_free_fn mem_free
;
3240 memcached_realloc_fn mem_realloc
;
3241 memcached_calloc_fn mem_calloc
;
3242 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3243 &mem_realloc
, &mem_calloc
);
3245 test_true(mem_malloc
== my_malloc
);
3246 test_true(mem_realloc
== my_realloc
);
3247 test_true(mem_calloc
== my_calloc
);
3248 test_true(mem_free
== my_free
);
3250 return TEST_SUCCESS
;
3253 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3255 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
));
3256 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3259 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3264 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3266 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_CRC
)
3268 return TEST_SKIPPED
;
3271 return TEST_SUCCESS
;
3274 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3277 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
);
3278 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3283 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3285 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_HSIEH
)
3287 return TEST_SKIPPED
;
3290 return TEST_SUCCESS
;
3293 test_return_t
enable_cas(memcached_st
*memc
)
3295 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3297 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true);
3299 return TEST_SUCCESS
;
3302 return TEST_SKIPPED
;
3305 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3307 memcached_version(memc
);
3309 const memcached_instance_st
* instance
=
3310 memcached_server_instance_by_position(memc
, 0);
3312 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3313 or instance
->minor_version
> 2)
3315 return TEST_SUCCESS
;
3318 return TEST_SKIPPED
;
3321 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3323 const uint64_t timeout
= 100; // Not using, just checking that it sets
3325 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3327 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3329 return TEST_SUCCESS
;
3332 test_return_t
noreply_test(memcached_st
*memc
)
3334 test_compare(MEMCACHED_SUCCESS
,
3335 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3336 test_compare(MEMCACHED_SUCCESS
,
3337 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3338 test_compare(MEMCACHED_SUCCESS
,
3339 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3340 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3341 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3342 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3344 memcached_return_t ret
;
3345 for (int count
= 0; count
< 5; ++count
)
3347 for (size_t x
= 0; x
< 100; ++x
)
3349 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3350 int check_length
= snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3351 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3353 size_t len
= (size_t)check_length
;
3358 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3361 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3364 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3367 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3370 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3376 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3377 memcached_strerror(NULL
, ret
));
3381 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3382 ** API and is _ONLY_ done this way to verify that the library works the
3383 ** way it is supposed to do!!!!
3387 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3389 const memcached_instance_st
* instance
=
3390 memcached_server_instance_by_position(memc
, x
);
3391 no_msg
+=(int)(instance
->cursor_active
);
3394 test_true(no_msg
== 0);
3396 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3399 ** Now validate that all items was set properly!
3401 for (size_t x
= 0; x
< 100; ++x
)
3405 int check_length
= snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3407 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3409 size_t len
= (size_t)check_length
;
3412 char* value
=memcached_get(memc
, key
, strlen(key
),
3413 &length
, &flags
, &ret
);
3414 // For the moment we will just go to the next key
3415 if (MEMCACHED_TIMEOUT
== ret
)
3419 test_true(ret
== MEMCACHED_SUCCESS
and value
!= NULL
);
3422 case 0: /* FALLTHROUGH */
3423 case 1: /* FALLTHROUGH */
3425 test_true(strncmp(value
, key
, len
) == 0);
3426 test_true(len
== length
);
3429 test_true(length
== len
* 2);
3432 test_true(length
== len
* 3);
3442 /* Try setting an illegal cas value (should not return an error to
3443 * the caller (because we don't expect a return message from the server)
3445 const char* keys
[]= {"0"};
3446 size_t lengths
[]= {1};
3449 memcached_result_st results_obj
;
3450 memcached_result_st
*results
;
3451 test_compare(MEMCACHED_SUCCESS
,
3452 memcached_mget(memc
, keys
, lengths
, 1));
3454 results
= memcached_result_create(memc
, &results_obj
);
3456 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3458 test_compare(MEMCACHED_SUCCESS
, ret
);
3459 uint64_t cas
= memcached_result_cas(results
);
3460 memcached_result_free(&results_obj
);
3462 test_compare(MEMCACHED_SUCCESS
,
3463 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3466 * The item will have a new cas value, so try to set it again with the old
3467 * value. This should fail!
3469 test_compare(MEMCACHED_SUCCESS
,
3470 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3471 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3472 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3473 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3476 return TEST_SUCCESS
;
3479 test_return_t
analyzer_test(memcached_st
*memc
)
3481 memcached_analysis_st
*report
;
3482 memcached_return_t rc
;
3484 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3485 test_compare(MEMCACHED_SUCCESS
, rc
);
3486 test_true(memc_stat
);
3488 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3489 test_compare(MEMCACHED_SUCCESS
, rc
);
3493 memcached_stat_free(NULL
, memc_stat
);
3495 return TEST_SUCCESS
;
3498 test_return_t
util_version_test(memcached_st
*memc
)
3500 test_compare(memcached_version(memc
), MEMCACHED_SUCCESS
);
3501 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3503 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3505 // We expect failure
3508 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3509 fprintf(stderr
, "\nDumping Server Information\n\n");
3510 memcached_server_fn callbacks
[1];
3512 callbacks
[0]= dump_server_information
;
3513 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3514 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3516 test_true(if_successful
== false);
3518 const memcached_instance_st
* instance
=
3519 memcached_server_instance_by_position(memc
, 0);
3521 memcached_version(memc
);
3523 // We only use one binary when we test, so this should be just fine.
3524 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3525 test_true(if_successful
== true);
3527 if (instance
->micro_version
> 0)
3529 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3531 else if (instance
->minor_version
> 0)
3533 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3535 else if (instance
->major_version
> 0)
3537 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3540 test_true(if_successful
== true);
3542 if (instance
->micro_version
> 0)
3544 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3546 else if (instance
->minor_version
> 0)
3548 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3550 else if (instance
->major_version
> 0)
3552 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3555 test_true(if_successful
== false);
3557 return TEST_SUCCESS
;
3560 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3562 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3563 memcached_return_t rc
;
3564 const memcached_instance_st
* instance
=
3565 memcached_server_instance_by_position(memc
, 0);
3567 // Test both the version that returns a code, and the one that does not.
3568 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3569 memcached_server_port(instance
) -1, NULL
) == -1);
3571 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3572 memcached_server_port(instance
) -1, &rc
) == -1);
3573 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3575 return TEST_SUCCESS
;
3579 test_return_t
getpid_test(memcached_st
*memc
)
3581 memcached_return_t rc
;
3582 const memcached_instance_st
* instance
=
3583 memcached_server_instance_by_position(memc
, 0);
3585 // Test both the version that returns a code, and the one that does not.
3586 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3587 memcached_server_port(instance
), NULL
) > -1);
3589 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3590 memcached_server_port(instance
), &rc
) > -1);
3591 test_compare(MEMCACHED_SUCCESS
, rc
);
3593 return TEST_SUCCESS
;
3596 static memcached_return_t
ping_each_server(const memcached_st
*,
3597 const memcached_instance_st
* instance
,
3600 // Test both the version that returns a code, and the one that does not.
3601 memcached_return_t rc
;
3602 if (libmemcached_util_ping(memcached_server_name(instance
),
3603 memcached_server_port(instance
), &rc
) == false)
3605 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d %s", memcached_server_name(instance
),
3606 memcached_server_port(instance
), memcached_strerror(NULL
, rc
));
3609 if (libmemcached_util_ping(memcached_server_name(instance
),
3610 memcached_server_port(instance
), NULL
) == false)
3612 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d", memcached_server_name(instance
), memcached_server_port(instance
));
3615 return MEMCACHED_SUCCESS
;
3618 test_return_t
libmemcached_util_ping_TEST(memcached_st
*memc
)
3620 memcached_server_fn callbacks
[1]= { ping_each_server
};
3621 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
3623 return TEST_SUCCESS
;
3628 test_return_t
hash_sanity_test (memcached_st
*memc
)
3632 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3633 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3634 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3635 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3636 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3637 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3638 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3639 #ifdef HAVE_HSIEH_HASH
3640 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3642 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3643 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3644 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3646 return TEST_SUCCESS
;
3650 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3652 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3654 test_compare(MEMCACHED_SUCCESS
,
3655 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3656 (uint64_t)MEMCACHED_HASH_HSIEH
));
3658 return TEST_SUCCESS
;
3661 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3663 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3665 test_compare(MEMCACHED_SUCCESS
,
3666 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3668 return TEST_SUCCESS
;
3671 test_return_t
one_at_a_time_run (memcached_st
*)
3676 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3678 test_compare(one_at_a_time_values
[x
],
3679 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3682 return TEST_SUCCESS
;
3685 test_return_t
md5_run (memcached_st
*)
3690 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3692 test_compare(md5_values
[x
],
3693 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3696 return TEST_SUCCESS
;
3699 test_return_t
crc_run (memcached_st
*)
3704 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3706 test_compare(crc_values
[x
],
3707 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3710 return TEST_SUCCESS
;
3713 test_return_t
fnv1_64_run (memcached_st
*)
3715 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3720 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3722 test_compare(fnv1_64_values
[x
],
3723 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3726 return TEST_SUCCESS
;
3729 test_return_t
fnv1a_64_run (memcached_st
*)
3731 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3736 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3738 test_compare(fnv1a_64_values
[x
],
3739 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3742 return TEST_SUCCESS
;
3745 test_return_t
fnv1_32_run (memcached_st
*)
3750 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3752 test_compare(fnv1_32_values
[x
],
3753 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3756 return TEST_SUCCESS
;
3759 test_return_t
fnv1a_32_run (memcached_st
*)
3764 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3766 test_compare(fnv1a_32_values
[x
],
3767 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3770 return TEST_SUCCESS
;
3773 test_return_t
hsieh_run (memcached_st
*)
3775 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3780 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3782 test_compare(hsieh_values
[x
],
3783 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3786 return TEST_SUCCESS
;
3789 test_return_t
murmur_run (memcached_st
*)
3791 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3793 #ifdef WORDS_BIGENDIAN
3794 (void)murmur_values
;
3795 return TEST_SKIPPED
;
3800 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3802 test_compare(murmur_values
[x
],
3803 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3806 return TEST_SUCCESS
;
3810 test_return_t
murmur3_TEST(hashkit_st
*)
3812 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR3
));
3814 #ifdef WORDS_BIGENDIAN
3815 (void)murmur3_values
;
3816 return TEST_SKIPPED
;
3821 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3823 test_compare(murmur3_values
[x
],
3824 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR3
));
3827 return TEST_SUCCESS
;
3831 test_return_t
jenkins_run (memcached_st
*)
3836 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3838 test_compare(jenkins_values
[x
],
3839 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3842 return TEST_SUCCESS
;
3845 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3847 return libhashkit_md5(string
, string_length
);
3850 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3852 return libhashkit_crc32(string
, string_length
);
3855 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3861 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3863 uint32_t md5_hosts
[]= {4U, 1U, 0U, 1U, 4U, 2U, 0U, 3U, 0U, 0U, 3U, 1U, 0U, 0U, 1U, 3U, 0U, 0U, 0U, 3U, 1U, 0U, 4U, 4U, 3U};
3864 uint32_t crc_hosts
[]= {2U, 4U, 1U, 0U, 2U, 4U, 4U, 4U, 1U, 2U, 3U, 4U, 3U, 4U, 1U, 3U, 3U, 2U, 0U, 0U, 0U, 1U, 2U, 4U, 0U};
3866 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3868 hashkit_clone(&new_kit
, kit
);
3869 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3871 memcached_set_hashkit(memc
, &new_kit
);
3874 Verify Setting the hash.
3876 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3880 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3881 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3886 Now check memcached_st.
3888 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3892 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3893 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3896 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3898 memcached_set_hashkit(memc
, &new_kit
);
3901 Verify Setting the hash.
3903 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3907 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3908 test_true(crc_values
[x
] == hash_val
);
3911 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3915 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3916 test_compare(crc_hosts
[x
], hash_val
);
3919 memcached_free(memc
);
3921 return TEST_SUCCESS
;
3925 Test case adapted from John Gorman <johngorman2@gmail.com>
3927 We are testing the error condition when we connect to a server via memcached_get()
3928 but find that the server is not available.
3930 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3934 memcached_return rc
;
3937 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3939 // See if memcached is reachable.
3940 char *value
= memcached_get(tl_memc_h
,
3941 test_literal_param(__func__
),
3946 test_true(memcached_failed(rc
));
3948 memcached_free(tl_memc_h
);
3950 return TEST_SUCCESS
;
3954 We connect to a server which exists, but search for a key that does not exist.
3956 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3960 memcached_return rc
;
3962 // See if memcached is reachable.
3963 char *value
= memcached_get(memc
,
3964 test_literal_param(__func__
),
3969 test_compare(MEMCACHED_NOTFOUND
, rc
);
3971 return TEST_SUCCESS
;
3975 Test case adapted from John Gorman <johngorman2@gmail.com>
3977 We are testing the error condition when we connect to a server via memcached_get_by_key()
3978 but find that the server is not available.
3980 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
3984 memcached_return rc
;
3987 memcached_st
*tl_memc_h
= memcached_create(NULL
);
3988 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
3989 memcached_server_push(tl_memc_h
, servers
);
3990 memcached_server_list_free(servers
);
3992 // See if memcached is reachable.
3993 char *value
= memcached_get_by_key(tl_memc_h
,
3994 test_literal_param(__func__
), // Key
3995 test_literal_param(__func__
), // Value
4000 test_true(memcached_failed(rc
));
4002 memcached_free(tl_memc_h
);
4004 return TEST_SUCCESS
;
4008 We connect to a server which exists, but search for a key that does not exist.
4010 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4014 memcached_return rc
;
4016 // See if memcached is reachable.
4017 char *value
= memcached_get_by_key(memc
,
4018 test_literal_param(__func__
), // Key
4019 test_literal_param(__func__
), // Value
4024 test_compare(MEMCACHED_NOTFOUND
, rc
);
4026 return TEST_SUCCESS
;
4029 test_return_t
regression_bug_434484(memcached_st
*memc
)
4031 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4033 test_compare(MEMCACHED_NOTSTORED
,
4034 memcached_append(memc
,
4035 test_literal_param(__func__
), // Key
4036 test_literal_param(__func__
), // Value
4039 libtest::vchar_t data
;
4040 data
.resize(2048 * 1024);
4041 test_compare(MEMCACHED_E2BIG
,
4043 test_literal_param(__func__
), // Key
4044 &data
[0], data
.size(), 0, 0));
4046 return TEST_SUCCESS
;
4049 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4051 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4053 memcached_return_t rc
;
4055 memcached_execute_fn callbacks
[]= { &callback_counter
};
4058 * I only want to hit only _one_ server so I know the number of requests I'm
4059 * sending in the pipleine to the server. Let's try to do a multiget of
4060 * 1024 (that should satisfy most users don't you think?). Future versions
4061 * will include a mget_execute function call if you need a higher number.
4063 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4068 * Run two times.. the first time we should have 100% cache miss,
4069 * and the second time we should have 100% cache hits
4071 for (ptrdiff_t y
= 0; y
< 2; y
++)
4073 test_compare(MEMCACHED_SUCCESS
,
4074 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4076 // One the first run we should get a NOT_FOUND, but on the second some data
4077 // should be returned.
4078 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4079 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4083 /* The first iteration should give me a 100% cache miss. verify that*/
4084 char blob
[1024]= { 0 };
4086 test_false(counter
);
4088 for (size_t x
= 0; x
< keys
.size(); ++x
)
4090 rc
= memcached_add(memc
,
4091 keys
.key_at(x
), keys
.length_at(x
),
4092 blob
, sizeof(blob
), 0, 0);
4093 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4098 /* Verify that we received all of the key/value pairs */
4099 test_compare(counter
, keys
.size());
4103 memcached_free(memc
);
4105 return TEST_SUCCESS
;
4108 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4110 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
4112 return regression_bug_434843(memc
);
4115 test_return_t
regression_bug_421108(memcached_st
*memc
)
4117 memcached_return_t rc
;
4118 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4119 test_compare(MEMCACHED_SUCCESS
, rc
);
4121 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4122 test_compare(MEMCACHED_SUCCESS
, rc
);
4123 test_true(bytes_str
);
4124 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4126 test_compare(MEMCACHED_SUCCESS
, rc
);
4127 test_true(bytes_read_str
);
4129 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4130 "bytes_written", &rc
);
4131 test_compare(MEMCACHED_SUCCESS
, rc
);
4132 test_true(bytes_written_str
);
4134 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4135 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4136 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4138 test_true(bytes
!= bytes_read
);
4139 test_true(bytes
!= bytes_written
);
4141 /* Release allocated resources */
4143 free(bytes_read_str
);
4144 free(bytes_written_str
);
4145 memcached_stat_free(NULL
, memc_stat
);
4147 return TEST_SUCCESS
;
4151 * The test case isn't obvious so I should probably document why
4152 * it works the way it does. Bug 442914 was caused by a bug
4153 * in the logic in memcached_purge (it did not handle the case
4154 * where the number of bytes sent was equal to the watermark).
4155 * In this test case, create messages so that we hit that case
4156 * and then disable noreply mode and issue a new command to
4157 * verify that it isn't stuck. If we change the format for the
4158 * delete command or the watermarks, we need to update this
4161 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
4163 test_skip(original_memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
4165 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
4167 for (uint32_t x
= 0; x
< 250; ++x
)
4170 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
4171 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4172 char error_buffer
[2048]= { 0 };
4173 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
4174 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
4177 // Delete, and then delete again to look for not found
4180 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
4181 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4182 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4184 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
4185 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
4188 memcached_free(memc
);
4190 return TEST_SUCCESS
;
4193 test_return_t
regression_bug_447342(memcached_st
*memc
)
4195 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4197 return TEST_SKIPPED
;
4200 test_compare(MEMCACHED_SUCCESS
,
4201 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4205 for (size_t x
= 0; x
< keys
.size(); ++x
)
4207 test_compare(MEMCACHED_SUCCESS
,
4209 keys
.key_at(x
), keys
.length_at(x
), // Keys
4210 keys
.key_at(x
), keys
.length_at(x
), // Values
4215 ** We are using the quiet commands to store the replicas, so we need
4216 ** to ensure that all of them are processed before we can continue.
4217 ** In the test we go directly from storing the object to trying to
4218 ** receive the object from all of the different servers, so we
4219 ** could end up in a race condition (the memcached server hasn't yet
4220 ** processed the quiet command from the replication set when it process
4221 ** the request from the other client (created by the clone)). As a
4222 ** workaround for that we call memcached_quit to send the quit command
4223 ** to the server and wait for the response ;-) If you use the test code
4224 ** as an example for your own code, please note that you shouldn't need
4227 memcached_quit(memc
);
4229 /* Verify that all messages are stored, and we didn't stuff too much
4232 test_compare(MEMCACHED_SUCCESS
,
4233 memcached_mget(memc
,
4234 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4236 unsigned int counter
= 0;
4237 memcached_execute_fn callbacks
[]= { &callback_counter
};
4238 test_compare(MEMCACHED_SUCCESS
,
4239 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4241 /* Verify that we received all of the key/value pairs */
4242 test_compare(counter
, keys
.size());
4244 memcached_quit(memc
);
4246 * Don't do the following in your code. I am abusing the internal details
4247 * within the library, and this is not a supported interface.
4248 * This is to verify correct behavior in the library. Fake that two servers
4251 const memcached_instance_st
* instance_one
= memcached_server_instance_by_position(memc
, 0);
4252 const memcached_instance_st
* instance_two
= memcached_server_instance_by_position(memc
, 2);
4253 in_port_t port0
= instance_one
->port();
4254 in_port_t port2
= instance_two
->port();
4256 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4257 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4259 test_compare(MEMCACHED_SUCCESS
,
4260 memcached_mget(memc
,
4261 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4264 test_compare(MEMCACHED_SUCCESS
,
4265 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4266 test_compare(counter
, keys
.size());
4268 /* restore the memc handle */
4269 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4270 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4272 memcached_quit(memc
);
4274 /* Remove half of the objects */
4275 for (size_t x
= 0; x
< keys
.size(); ++x
)
4279 test_compare(MEMCACHED_SUCCESS
,
4280 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4284 memcached_quit(memc
);
4285 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4286 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4288 /* now retry the command, this time we should have cache misses */
4289 test_compare(MEMCACHED_SUCCESS
,
4290 memcached_mget(memc
,
4291 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4294 test_compare(MEMCACHED_SUCCESS
,
4295 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4296 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4298 /* restore the memc handle */
4299 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4300 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4302 return TEST_SUCCESS
;
4305 test_return_t
regression_bug_463297(memcached_st
*memc
)
4307 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4309 // Since we blocked timed delete, this test is no longer valid.
4311 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4312 test_true(memc_clone
);
4313 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4315 const memcached_instance_st
* instance
=
4316 memcached_server_instance_by_position(memc_clone
, 0);
4318 if (instance
->major_version
> 1 ||
4319 (instance
->major_version
== 1 &&
4320 instance
->minor_version
> 2))
4322 /* Binary protocol doesn't support deferred delete */
4323 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4324 test_true(bin_clone
);
4325 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4326 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4327 memcached_free(bin_clone
);
4329 memcached_quit(memc_clone
);
4331 /* If we know the server version, deferred delete should fail
4332 * with invalid arguments */
4333 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4335 /* If we don't know the server version, we should get a protocol error */
4336 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4338 /* but there is a bug in some of the memcached servers (1.4) that treats
4339 * the counter as noreply so it doesn't send the proper error message
4341 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4343 /* And buffered mode should be disabled and we should get protocol error */
4344 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4345 rc
= memcached_delete(memc
, "foo", 3, 1);
4346 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4348 /* Same goes for noreply... */
4349 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4350 rc
= memcached_delete(memc
, "foo", 3, 1);
4351 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4353 /* but a normal request should go through (and be buffered) */
4354 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4355 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4357 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4358 /* unbuffered noreply should be success */
4359 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4360 /* unbuffered with reply should be not found... */
4361 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4362 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4365 memcached_free(memc_clone
);
4368 return TEST_SUCCESS
;
4372 /* Test memcached_server_get_last_disconnect
4373 * For a working server set, shall be NULL
4374 * For a set of non existing server, shall not be NULL
4376 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4378 memcached_return_t rc
;
4379 const memcached_instance_st
* disconnected_server
;
4381 /* With the working set of server */
4382 const char *key
= "marmotte";
4383 const char *value
= "milka";
4385 memcached_reset_last_disconnected_server(memc
);
4386 test_false(memc
->last_disconnected_server
);
4387 rc
= memcached_set(memc
, key
, strlen(key
),
4388 value
, strlen(value
),
4389 (time_t)0, (uint32_t)0);
4390 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4392 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4393 test_false(disconnected_server
);
4395 /* With a non existing server */
4397 memcached_server_st
*servers
;
4399 const char *server_list
= "localhost:9";
4401 servers
= memcached_servers_parse(server_list
);
4403 mine
= memcached_create(NULL
);
4404 rc
= memcached_server_push(mine
, servers
);
4405 test_compare(MEMCACHED_SUCCESS
, rc
);
4406 memcached_server_list_free(servers
);
4409 rc
= memcached_set(mine
, key
, strlen(key
),
4410 value
, strlen(value
),
4411 (time_t)0, (uint32_t)0);
4412 test_true(memcached_failed(rc
));
4414 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4415 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4416 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4417 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4419 memcached_quit(mine
);
4420 memcached_free(mine
);
4422 return TEST_SUCCESS
;
4425 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4427 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4428 char buffer
[BUFSIZ
];
4430 test_compare(MEMCACHED_SUCCESS
,
4431 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4433 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4436 // We will just use the error strings as our keys
4437 uint32_t counter
= 100;
4440 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4442 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4443 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4444 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4446 const memcached_instance_st
* disconnected_server
= memcached_server_get_last_disconnect(memc
);
4447 test_true(disconnected_server
);
4448 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4449 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4453 memcached_reset_last_disconnected_server(memc
);
4458 memcached_free(memc
);
4460 return TEST_SUCCESS
;
4463 test_return_t
test_verbosity(memcached_st
*memc
)
4465 memcached_verbosity(memc
, 3);
4467 return TEST_SUCCESS
;
4471 static memcached_return_t
stat_printer(const memcached_instance_st
* server
,
4472 const char *key
, size_t key_length
,
4473 const char *value
, size_t value_length
,
4483 return MEMCACHED_SUCCESS
;
4486 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4488 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4489 test_compare(MEMCACHED_SUCCESS
, rc
);
4491 test_compare(MEMCACHED_SUCCESS
,
4492 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4494 test_compare(MEMCACHED_SUCCESS
,
4495 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4497 test_compare(MEMCACHED_SUCCESS
,
4498 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4500 return TEST_SUCCESS
;
4504 * This test ensures that the failure counter isn't incremented during
4505 * normal termination of the memcached instance.
4507 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4509 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4511 /* Ensure that we are connected to the server by setting a value */
4512 memcached_return_t rc
= memcached_set(memc
,
4513 test_literal_param(__func__
), // Key
4514 test_literal_param(__func__
), // Value
4515 time_t(0), uint32_t(0));
4516 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4519 const memcached_instance_st
* instance
= memcached_server_instance_by_position(memc
, 0);
4521 /* The test is to see that the memcached_quit doesn't increase the
4522 * the server failure conter, so let's ensure that it is zero
4523 * before sending quit
4525 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4527 memcached_quit(memc
);
4529 /* Verify that it memcached_quit didn't increment the failure counter
4530 * Please note that this isn't bullet proof, because an error could
4533 test_zero(instance
->server_failure_counter
);
4535 memcached_free(memc
);
4537 return TEST_SUCCESS
;
4541 * This tests ensures expected disconnections (for some behavior changes
4542 * for instance) do not wrongly increase failure counter
4544 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4546 /* Set value to force connection to the server */
4547 const char *key
= "marmotte";
4548 const char *value
= "milka";
4550 test_compare_hint(MEMCACHED_SUCCESS
,
4551 memcached_set(memc
, key
, strlen(key
),
4552 value
, strlen(value
),
4553 (time_t)0, (uint32_t)0),
4554 memcached_last_error_message(memc
));
4557 /* put failure limit to 1 */
4558 test_compare(MEMCACHED_SUCCESS
,
4559 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4561 /* Put a retry timeout to effectively activate failure_limit effect */
4562 test_compare(MEMCACHED_SUCCESS
,
4563 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
4565 /* change behavior that triggers memcached_quit()*/
4566 test_compare(MEMCACHED_SUCCESS
,
4567 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4570 /* Check if we still are connected */
4572 size_t string_length
;
4573 memcached_return rc
;
4574 char *string
= memcached_get(memc
, key
, strlen(key
),
4575 &string_length
, &flags
, &rc
);
4577 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4581 return TEST_SUCCESS
;
4584 test_return_t
regression_996813_TEST(memcached_st
*)
4586 memcached_st
* memc
= memcached_create(NULL
);
4588 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
4589 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
4590 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4591 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4592 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1));
4593 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 300));
4594 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 30));
4596 // We will never connect to these servers
4597 in_port_t base_port
= 11211;
4598 for (size_t x
= 0; x
< 17; x
++)
4600 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", base_port
+x
));
4602 test_compare(6U, memcached_generate_hash(memc
, test_literal_param("SZ6hu0SHweFmpwpc0w2R")));
4603 test_compare(1U, memcached_generate_hash(memc
, test_literal_param("SQCK9eiCf53YxHWnYA.o")));
4604 test_compare(9U, memcached_generate_hash(memc
, test_literal_param("SUSDkGXuuZC9t9VhMwa.")));
4605 test_compare(0U, memcached_generate_hash(memc
, test_literal_param("SnnqnJARfaCNT679iAF_")));
4607 memcached_free(memc
);
4609 return TEST_SUCCESS
;
4614 * Test that ensures mget_execute does not end into recursive calls that finally fails
4616 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4620 return TEST_SKIPPED
; // My MAC can't handle this test
4623 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4626 * I only want to hit _one_ server so I know the number of requests I'm
4627 * sending in the pipeline.
4629 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4632 keys_st
keys(20480);
4634 /* First add all of the items.. */
4635 char blob
[1024]= { 0 };
4636 for (size_t x
= 0; x
< keys
.size(); ++x
)
4638 memcached_return rc
= memcached_set(memc
,
4639 keys
.key_at(x
), keys
.length_at(x
),
4640 blob
, sizeof(blob
), 0, 0);
4641 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4646 /* Try to get all of them with a large multiget */
4648 memcached_execute_function callbacks
[]= { &callback_counter
};
4649 memcached_return_t rc
= memcached_mget_execute(memc
,
4650 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4651 callbacks
, &counter
, 1);
4652 test_compare(MEMCACHED_SUCCESS
, rc
);
4654 char* the_value
= NULL
;
4655 char the_key
[MEMCACHED_MAX_KEY
];
4656 size_t the_key_length
;
4657 size_t the_value_length
;
4661 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4663 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4669 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4672 test_compare(MEMCACHED_END
, rc
);
4674 /* Verify that we got all of the items */
4675 test_compare(counter
, keys
.size());
4678 memcached_free(memc
);
4680 return TEST_SUCCESS
;
4683 test_return_t
regression_1021819_TEST(memcached_st
*original
)
4685 memcached_st
*memc
= memcached_clone(NULL
, original
);
4688 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 2000000), MEMCACHED_SUCCESS
);
4689 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 3000000), MEMCACHED_SUCCESS
);
4691 memcached_return_t rc
;
4694 test_literal_param(__func__
),
4697 test_compare(rc
, MEMCACHED_NOTFOUND
);
4699 memcached_free(memc
);
4701 return TEST_SUCCESS
;
4704 test_return_t
regression_bug_583031(memcached_st
*)
4706 memcached_st
*memc
= memcached_create(NULL
);
4708 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.251.4", 11211));
4710 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 3000);
4711 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4712 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4713 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4714 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4715 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4717 memcached_return_t rc
;
4721 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4725 test_compare(MEMCACHED_TIMEOUT
, memc
);
4727 memcached_free(memc
);
4729 return TEST_SUCCESS
;
4732 test_return_t
regression_bug_581030(memcached_st
*)
4735 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4736 test_false(local_stat
);
4738 memcached_stat_free(NULL
, NULL
);
4741 return TEST_SUCCESS
;
4744 #define regression_bug_655423_COUNT 6000
4745 test_return_t
regression_bug_655423(memcached_st
*memc
)
4747 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4748 memc
= NULL
; // Just to make sure it is not used
4753 return TEST_SKIPPED
;
4756 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4757 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4758 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4759 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4761 memset(payload
, int('x'), sizeof(payload
));
4763 keys_st
keys(regression_bug_655423_COUNT
);
4765 for (size_t x
= 0; x
< keys
.size(); x
++)
4767 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4770 payload
, sizeof(payload
), 0, 0));
4773 for (size_t x
= 0; x
< keys
.size(); x
++)
4775 size_t value_length
;
4776 memcached_return_t rc
;
4777 char *value
= memcached_get(clone
,
4780 &value_length
, NULL
, &rc
);
4782 if (rc
== MEMCACHED_NOTFOUND
)
4785 test_zero(value_length
);
4789 test_compare(MEMCACHED_SUCCESS
, rc
);
4791 test_compare(100LLU, value_length
);
4795 test_compare(MEMCACHED_SUCCESS
,
4796 memcached_mget(clone
,
4797 keys
.keys_ptr(), keys
.lengths_ptr(),
4801 memcached_result_st
*result
= NULL
;
4802 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4804 test_compare(size_t(100), memcached_result_length(result
));
4808 test_true(count
> 100); // If we don't get back atleast this, something is up
4810 memcached_free(clone
);
4812 return TEST_SUCCESS
;
4816 * Test that ensures that buffered set to not trigger problems during io_flush
4818 #define regression_bug_490520_COUNT 200480
4819 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4821 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4823 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4824 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4825 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4826 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4827 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4829 /* First add all of the items.. */
4830 char blob
[3333] = {0};
4831 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4834 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4836 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4837 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4840 memcached_free(memc
);
4842 return TEST_SUCCESS
;
4845 test_return_t
regression_bug_1251482(memcached_st
*)
4847 test::Memc
memc("--server=localhost:5");
4849 memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 0);
4851 for (size_t x
= 0; x
< 5; ++x
)
4853 size_t value_length
;
4854 memcached_return_t rc
;
4855 char *value
= memcached_get(&memc
,
4856 test_literal_param(__func__
),
4857 &value_length
, NULL
, &rc
);
4860 test_compare(0LLU, value_length
);
4862 test_ne_compare(MEMCACHED_SUCCESS
, rc
);
4864 test_compare(MEMCACHED_CONNECTION_FAILURE
, rc
);
4868 return TEST_SUCCESS
;
4871 test_return_t
regression_1009493_TEST(memcached_st
*)
4873 memcached_st
* memc
= memcached_create(NULL
);
4875 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, true));
4877 memcached_st
* clone
= memcached_clone(NULL
, memc
);
4880 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
),
4881 memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
4883 memcached_free(memc
);
4884 memcached_free(clone
);
4886 return TEST_SUCCESS
;
4889 test_return_t
regression_994772_TEST(memcached_st
* memc
)
4891 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4893 test_compare(MEMCACHED_SUCCESS
,
4895 test_literal_param(__func__
), // Key
4896 test_literal_param(__func__
), // Value
4897 time_t(0), uint32_t(0)));
4899 const char *keys
[] = { __func__
};
4900 size_t key_length
[]= { strlen(__func__
) };
4901 test_compare(MEMCACHED_SUCCESS
,
4902 memcached_mget(memc
, keys
, key_length
, 1));
4904 memcached_return_t rc
;
4905 memcached_result_st
*results
= memcached_fetch_result(memc
, NULL
, &rc
);
4907 test_compare(MEMCACHED_SUCCESS
, rc
);
4909 test_strcmp(__func__
, memcached_result_value(results
));
4910 uint64_t cas_value
= memcached_result_cas(results
);
4911 test_true(cas_value
);
4913 char* take_value
= memcached_result_take_value(results
);
4914 test_strcmp(__func__
, take_value
);
4917 memcached_result_free(results
);
4919 // Bad cas value, sanity check
4920 test_true(cas_value
!= 9999);
4921 test_compare(MEMCACHED_END
,
4923 test_literal_param(__func__
), // Key
4924 test_literal_param(__FILE__
), // Value
4925 time_t(0), uint32_t(0), 9999));
4927 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
4928 "different", strlen("different"), // Key
4929 test_literal_param(__FILE__
), // Value
4930 time_t(0), uint32_t(0)));
4932 return TEST_SUCCESS
;
4935 test_return_t
regression_bug_854604(memcached_st
*)
4939 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4941 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4943 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4944 test_compare(buffer
[0], 0);
4946 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4947 test_true(strlen(buffer
));
4949 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4950 test_true(strlen(buffer
));
4952 return TEST_SUCCESS
;
4955 static void die_message(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4957 fprintf(stderr
, "Iteration #%u: ", it
);
4959 if (error
== MEMCACHED_ERRNO
)
4961 fprintf(stderr
, "system error %d from %s: %s\n",
4962 errno
, what
, strerror(errno
));
4966 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4967 memcached_strerror(mc
, error
));
4971 #define TEST_CONSTANT_CREATION 200
4973 test_return_t
regression_bug_(memcached_st
*memc
)
4975 const char *remote_server
;
4978 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4980 return TEST_SKIPPED
;
4983 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4985 memcached_st
* mc
= memcached_create(NULL
);
4986 memcached_return rc
;
4988 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4989 if (rc
!= MEMCACHED_SUCCESS
)
4991 die_message(mc
, rc
, "memcached_behavior_set", x
);
4994 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4995 if (rc
!= MEMCACHED_SUCCESS
)
4997 die_message(mc
, rc
, "memcached_behavior_set", x
);
5000 rc
= memcached_server_add(mc
, remote_server
, 0);
5001 if (rc
!= MEMCACHED_SUCCESS
)
5003 die_message(mc
, rc
, "memcached_server_add", x
);
5006 const char *set_key
= "akey";
5007 const size_t set_key_len
= strlen(set_key
);
5008 const char *set_value
= "a value";
5009 const size_t set_value_len
= strlen(set_value
);
5011 if (rc
== MEMCACHED_SUCCESS
)
5015 size_t get_value_len
;
5017 uint32_t get_value_flags
;
5019 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5020 &get_value_flags
, &rc
);
5021 if (rc
!= MEMCACHED_SUCCESS
)
5023 die_message(mc
, rc
, "memcached_get", x
);
5029 (get_value_len
!= set_value_len
5030 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5032 fprintf(stderr
, "Values don't match?\n");
5033 rc
= MEMCACHED_FAILURE
;
5039 rc
= memcached_set(mc
,
5040 set_key
, set_key_len
,
5041 set_value
, set_value_len
,
5045 if (rc
!= MEMCACHED_SUCCESS
)
5047 die_message(mc
, rc
, "memcached_set", x
);
5054 if (rc
!= MEMCACHED_SUCCESS
)
5060 return TEST_SUCCESS
;
5063 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
5065 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
5068 const memcached_instance_st
* instance
= memcached_server_instance_by_position(memc
, 0);
5071 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
5072 memcached_server_port(instance
), NULL
)) > -1);
5075 test_compare(MEMCACHED_SUCCESS
,
5077 test_literal_param(__func__
), // Keys
5078 test_literal_param(__func__
), // Values
5080 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
5082 memcached_return_t ret
= memcached_set(memc
,
5083 test_literal_param(__func__
), // Keys
5084 test_literal_param(__func__
), // Values
5086 test_compare(MEMCACHED_CONNECTION_FAILURE
, ret
);
5088 memcached_free(memc
);
5090 return TEST_SUCCESS
;