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.
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>
58 #include <semaphore.h>
62 #include <sys/types.h>
67 #include <libtest/server.h>
69 #include "clients/generator.h"
71 #define SMALL_STRING_LEN 1024
73 #include <libtest/test.hpp>
75 using namespace libtest
;
77 #include <libmemcached/util.h>
79 #include "tests/hash_results.h"
81 #include "tests/libmemcached-1.0/callback_counter.h"
82 #include "tests/libmemcached-1.0/fetch_all_results.h"
83 #include "tests/libmemcached-1.0/mem_functions.h"
84 #include "tests/libmemcached-1.0/setup_and_teardowns.h"
85 #include "tests/print.h"
86 #include "tests/debug.h"
88 #define UUID_STRING_MAXLENGTH 36
90 #include "tests/keys.hpp"
92 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
95 If no options are given, copy over at least the binary flag.
97 char options_buffer
[1024]= { 0 };
100 if (memcached_is_binary(original_memc
))
102 snprintf(options_buffer
, sizeof(options_buffer
), "--BINARY");
107 * I only want to hit _one_ server so I know the number of requests I'm
108 * sending in the pipeline.
110 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
112 char server_string
[1024];
113 int server_string_length
;
114 if (instance
->type
== MEMCACHED_CONNECTION_UNIX_SOCKET
)
118 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\" %s",
119 memcached_server_name(instance
), options
);
123 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\"",
124 memcached_server_name(instance
));
131 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
132 memcached_server_name(instance
), int(memcached_server_port(instance
)),
137 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
138 memcached_server_name(instance
), int(memcached_server_port(instance
)));
142 if (server_string_length
<= 0)
147 char errror_buffer
[1024];
148 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, errror_buffer
, sizeof(errror_buffer
))))
150 Error
<< "Failed to parse (" << server_string
<< ") " << errror_buffer
;
154 return memcached(server_string
, server_string_length
);
158 test_return_t
init_test(memcached_st
*not_used
)
163 (void)memcached_create(&memc
);
164 memcached_free(&memc
);
169 #define TEST_PORT_COUNT 7
170 in_port_t test_ports
[TEST_PORT_COUNT
];
172 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
173 const memcached_server_st
*server
,
177 size_t bigger
= *((size_t *)(context
));
179 fatal_assert(bigger
<= memcached_server_port(server
));
180 *((size_t *)(context
))= memcached_server_port(server
);
182 return MEMCACHED_SUCCESS
;
185 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
186 const memcached_server_st
*instance
,
190 FILE *stream
= (FILE *)context
;
193 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
194 memcached_server_name(instance
),
195 memcached_server_port(instance
),
196 instance
->major_version
,
197 instance
->minor_version
,
198 instance
->micro_version
);
200 return MEMCACHED_SUCCESS
;
203 test_return_t
server_sort_test(memcached_st
*ptr
)
205 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
207 memcached_return_t rc
;
208 memcached_server_fn callbacks
[1];
209 memcached_st
*local_memc
;
212 local_memc
= memcached_create(NULL
);
213 test_true(local_memc
);
214 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
216 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
218 test_ports
[x
]= (in_port_t
)random() % 64000;
219 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
220 test_compare(memcached_server_count(local_memc
), x
+1);
222 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
224 test_compare(MEMCACHED_SUCCESS
, rc
);
227 callbacks
[0]= server_display_function
;
228 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
231 memcached_free(local_memc
);
236 test_return_t
server_sort2_test(memcached_st
*ptr
)
238 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
239 memcached_server_fn callbacks
[1];
240 memcached_st
*local_memc
;
241 memcached_server_instance_st instance
;
244 local_memc
= memcached_create(NULL
);
245 test_true(local_memc
);
246 test_compare(MEMCACHED_SUCCESS
,
247 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
249 test_compare(MEMCACHED_SUCCESS
,
250 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
251 instance
= memcached_server_instance_by_position(local_memc
, 0);
252 test_compare(in_port_t(43043), memcached_server_port(instance
));
254 test_compare(MEMCACHED_SUCCESS
,
255 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
257 instance
= memcached_server_instance_by_position(local_memc
, 0);
258 test_compare(in_port_t(43042), memcached_server_port(instance
));
260 instance
= memcached_server_instance_by_position(local_memc
, 1);
261 test_compare(in_port_t(43043), memcached_server_port(instance
));
263 callbacks
[0]= server_display_function
;
264 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
267 memcached_free(local_memc
);
272 test_return_t
memcached_server_remove_test(memcached_st
*)
274 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";
277 test_compare(MEMCACHED_SUCCESS
,
278 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
279 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
282 memcached_server_fn callbacks
[1];
283 callbacks
[0]= server_print_callback
;
284 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
286 memcached_free(memc
);
291 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
292 const memcached_server_st
*server
,
296 uint32_t x
= *((uint32_t *)(context
));
298 if (! (test_ports
[x
] == server
->port
))
300 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
301 return MEMCACHED_FAILURE
;
304 *((uint32_t *)(context
))= ++x
;
306 return MEMCACHED_SUCCESS
;
309 test_return_t
server_unsort_test(memcached_st
*ptr
)
311 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
312 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
313 memcached_server_fn callbacks
[1];
314 memcached_st
*local_memc
;
317 local_memc
= memcached_create(NULL
);
318 test_true(local_memc
);
320 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
322 test_ports
[x
]= (in_port_t
)(random() % 64000);
323 test_compare(MEMCACHED_SUCCESS
,
324 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
325 test_compare(memcached_server_count(local_memc
), x
+1);
327 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
331 callbacks
[0]= server_display_unsort_function
;
332 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
334 /* Now we sort old data! */
335 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
336 callbacks
[0]= server_display_function
;
337 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
340 memcached_free(local_memc
);
345 test_return_t
allocation_test(memcached_st
*not_used
)
349 memc
= memcached_create(NULL
);
351 memcached_free(memc
);
356 test_return_t
clone_test(memcached_st
*memc
)
360 memcached_st
*memc_clone
;
361 memc_clone
= memcached_clone(NULL
, NULL
);
362 test_true(memc_clone
);
363 memcached_free(memc_clone
);
366 /* Can we init from null? */
368 memcached_st
*memc_clone
;
369 memc_clone
= memcached_clone(NULL
, memc
);
370 test_true(memc_clone
);
373 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
374 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
375 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
376 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
379 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
380 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
381 test_true(memc_clone
->distribution
== memc
->distribution
);
382 { // Test all of the flags
383 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
384 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
385 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
386 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
387 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
388 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
389 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
390 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
391 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
392 test_true(memc_clone
->flags
.reply
== memc
->flags
.reply
);
393 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
394 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
395 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
397 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
398 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
399 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
400 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
401 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
402 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
403 test_true(memc_clone
->on_clone
== memc
->on_clone
);
404 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
405 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
406 test_true(memc_clone
->recv_size
== memc
->recv_size
);
407 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
408 test_true(memc_clone
->send_size
== memc
->send_size
);
409 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
410 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
411 test_true(memc_clone
->user_data
== memc
->user_data
);
413 memcached_free(memc_clone
);
416 /* Can we init from struct? */
418 memcached_st declared_clone
;
419 memcached_st
*memc_clone
;
420 memset(&declared_clone
, 0 , sizeof(memcached_st
));
421 memc_clone
= memcached_clone(&declared_clone
, NULL
);
422 test_true(memc_clone
);
423 memcached_free(memc_clone
);
426 /* Can we init from struct? */
428 memcached_st declared_clone
;
429 memcached_st
*memc_clone
;
430 memset(&declared_clone
, 0 , sizeof(memcached_st
));
431 memc_clone
= memcached_clone(&declared_clone
, memc
);
432 test_true(memc_clone
);
433 memcached_free(memc_clone
);
439 test_return_t
userdata_test(memcached_st
*memc
)
442 test_false(memcached_set_user_data(memc
, foo
));
443 test_true(memcached_get_user_data(memc
) == foo
);
444 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
449 test_return_t
connection_test(memcached_st
*memc
)
451 test_compare(MEMCACHED_SUCCESS
,
452 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
457 test_return_t
libmemcached_string_behavior_test(memcached_st
*)
459 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
461 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
463 test_compare(37, int(MEMCACHED_BEHAVIOR_MAX
));
468 test_return_t
libmemcached_string_distribution_test(memcached_st
*)
470 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
472 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
474 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
479 test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
481 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
482 982370485U, 1263635348U, 4242906218U, 3829656100U,
483 1891735253U, 334139633U, 2257084983U, 3351789013U,
484 13199785U, 2542027183U, 1097051614U, 199566778U,
485 2748246961U, 2465192557U, 1664094137U, 2405439045U,
486 1842224848U, 692413798U, 3479807801U, 919913813U,
487 4269430871U, 610793021U, 527273862U, 1437122909U,
488 2300930706U, 2943759320U, 674306647U, 2400528935U,
489 54481931U, 4186304426U, 1741088401U, 2979625118U,
490 4159057246U, 3425930182U, 2593724503U, 1868899624U,
491 1769812374U, 2302537950U, 1110330676U, 3365377466U,
492 1336171666U, 3021258493U, 2334992265U, 3861994737U,
493 3582734124U, 3365377466U };
495 // You have updated the memcache_error messages but not updated docs/tests.
496 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
499 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
500 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
501 MEMCACHED_HASH_JENKINS
);
502 if (values
[rc
] != hash_val
)
504 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
505 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
507 test_compare(values
[rc
], hash_val
);
509 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
514 test_return_t
set_test(memcached_st
*memc
)
516 memcached_return_t rc
= memcached_set(memc
,
517 test_literal_param("foo"),
518 test_literal_param("when we sanitize"),
519 time_t(0), (uint32_t)0);
520 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
525 test_return_t
append_test(memcached_st
*memc
)
527 memcached_return_t rc
;
528 const char *in_value
= "we";
532 test_compare(MEMCACHED_SUCCESS
,
533 memcached_flush(memc
, 0));
535 test_compare(MEMCACHED_SUCCESS
,
537 test_literal_param(__func__
),
538 in_value
, strlen(in_value
),
539 time_t(0), uint32_t(0)));
541 test_compare(MEMCACHED_SUCCESS
,
542 memcached_append(memc
,
543 test_literal_param(__func__
),
544 " the", strlen(" the"),
545 time_t(0), uint32_t(0)));
547 test_compare(MEMCACHED_SUCCESS
,
548 memcached_append(memc
,
549 test_literal_param(__func__
),
550 " people", strlen(" people"),
551 time_t(0), uint32_t(0)));
553 char *out_value
= memcached_get(memc
,
554 test_literal_param(__func__
),
555 &value_length
, &flags
, &rc
);
556 test_memcmp(out_value
, "we the people", strlen("we the people"));
557 test_compare(strlen("we the people"), value_length
);
558 test_compare(MEMCACHED_SUCCESS
, rc
);
564 test_return_t
append_binary_test(memcached_st
*memc
)
566 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
568 test_compare(MEMCACHED_SUCCESS
,
569 memcached_flush(memc
, 0));
571 test_compare(MEMCACHED_SUCCESS
,
573 test_literal_param(__func__
),
575 time_t(0), uint32_t(0)));
578 for (uint32_t x
= 0; store_list
[x
] ; x
++)
580 test_compare(MEMCACHED_SUCCESS
,
581 memcached_append(memc
,
582 test_literal_param(__func__
),
583 (char *)&store_list
[x
], sizeof(uint32_t),
584 time_t(0), uint32_t(0)));
590 memcached_return_t rc
;
591 uint32_t *value
= (uint32_t *)memcached_get(memc
,
592 test_literal_param(__func__
),
593 &value_length
, &flags
, &rc
);
594 test_compare(value_length
, sizeof(uint32_t) * count
);
595 test_compare(MEMCACHED_SUCCESS
, rc
);
597 for (uint32_t counter
= count
, *ptr
= value
; counter
; counter
--)
599 test_compare(*ptr
, store_list
[count
- counter
]);
607 test_return_t
memcached_mget_mixed_memcached_get_TEST(memcached_st
*memc
)
611 for (libtest::vchar_ptr_t::iterator iter
= keys
.begin();
615 test_compare_hint(MEMCACHED_SUCCESS
,
619 time_t(0), uint32_t(0)),
620 memcached_last_error_message(memc
));
623 for (ptrdiff_t loop
= 0; loop
< 20; loop
++)
627 test_compare(MEMCACHED_SUCCESS
,
628 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
630 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
633 size_t result_count
= 0;
634 memcached_return_t rc
;
635 while (memcached_fetch_result(memc
, results
, &rc
))
639 test_true(keys
.size() >= result_count
);
643 int which_key
= random() %keys
.size();
646 memcached_return_t rc
;
647 char *out_value
= memcached_get(memc
, keys
.key_at(which_key
), keys
.length_at(which_key
),
648 &value_length
, &flags
, &rc
);
649 test_compare(MEMCACHED_SUCCESS
, rc
);
650 test_null(out_value
);
651 test_zero(value_length
);
659 test_return_t
cas2_test(memcached_st
*memc
)
661 const char *keys
[]= {"fudge", "son", "food"};
662 size_t key_length
[]= {5, 3, 4};
663 const char *value
= "we the people";
664 size_t value_length
= strlen("we the people");
666 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
668 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
670 for (uint32_t x
= 0; x
< 3; x
++)
672 test_compare(MEMCACHED_SUCCESS
,
673 memcached_set(memc
, keys
[x
], key_length
[x
],
674 keys
[x
], key_length
[x
],
675 time_t(50), uint32_t(9)));
678 test_compare(MEMCACHED_SUCCESS
,
679 memcached_mget(memc
, keys
, key_length
, 3));
681 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
684 memcached_return_t rc
;
685 results
= memcached_fetch_result(memc
, results
, &rc
);
687 test_true(results
->item_cas
);
688 test_compare(MEMCACHED_SUCCESS
, rc
);
689 test_true(memcached_result_cas(results
));
691 test_memcmp(value
, "we the people", strlen("we the people"));
692 test_compare(strlen("we the people"), value_length
);
693 test_compare(MEMCACHED_SUCCESS
, rc
);
695 memcached_result_free(results
);
700 test_return_t
cas_test(memcached_st
*memc
)
702 const char* keys
[2] = { __func__
, NULL
};
703 size_t keylengths
[2] = { strlen(__func__
), 0 };
705 memcached_result_st results_obj
;
707 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
709 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
711 test_compare(MEMCACHED_SUCCESS
,
713 test_literal_param(__func__
),
714 test_literal_param("we the people"),
715 (time_t)0, (uint32_t)0));
717 test_compare(MEMCACHED_SUCCESS
,
718 memcached_mget(memc
, keys
, keylengths
, 1));
720 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
723 memcached_return_t rc
;
724 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
726 test_compare(MEMCACHED_SUCCESS
, rc
);
727 test_true(memcached_result_cas(results
));
728 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
729 test_compare(test_literal_param_size("we the people"),
730 strlen(memcached_result_value(results
)));
732 uint64_t cas
= memcached_result_cas(results
);
735 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
736 test_true(rc
== MEMCACHED_END
);
737 test_true(results
== NULL
);
740 test_compare(MEMCACHED_SUCCESS
,
742 test_literal_param(__func__
),
743 test_literal_param("change the value"),
747 * The item will have a new cas value, so try to set it again with the old
748 * value. This should fail!
750 test_compare(MEMCACHED_DATA_EXISTS
,
752 test_literal_param(__func__
),
753 test_literal_param("change the value"),
756 memcached_result_free(&results_obj
);
762 test_return_t
prepend_test(memcached_st
*memc
)
764 const char *key
= "fig";
765 const char *value
= "people";
767 test_compare(MEMCACHED_SUCCESS
,
768 memcached_flush(memc
, 0));
770 test_compare(MEMCACHED_SUCCESS
,
771 memcached_set(memc
, key
, strlen(key
),
772 value
, strlen(value
),
773 time_t(0), uint32_t(0)));
775 test_compare(MEMCACHED_SUCCESS
,
776 memcached_prepend(memc
, key
, strlen(key
),
777 "the ", strlen("the "),
778 time_t(0), uint32_t(0)));
780 test_compare(MEMCACHED_SUCCESS
,
781 memcached_prepend(memc
, key
, strlen(key
),
782 "we ", strlen("we "),
783 time_t(0), uint32_t(0)));
787 memcached_return_t rc
;
788 char *out_value
= memcached_get(memc
, key
, strlen(key
),
789 &value_length
, &flags
, &rc
);
790 test_memcmp(out_value
, "we the people", strlen("we the people"));
791 test_compare(strlen("we the people"), value_length
);
792 test_compare(MEMCACHED_SUCCESS
, rc
);
799 Set the value, then quit to make sure it is flushed.
800 Come back in and test that add fails.
802 test_return_t
add_test(memcached_st
*memc
)
804 test_compare_hint(return_value_based_on_buffering(memc
),
806 test_literal_param(__func__
),
807 test_literal_param("when we sanitize"),
808 time_t(0), uint32_t(0)),
809 memcached_last_error_message(memc
));
811 memcached_quit(memc
);
813 test_compare_hint(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
815 test_literal_param(__func__
),
816 test_literal_param("try something else"),
817 time_t(0), uint32_t(0)),
818 memcached_last_error_message(memc
));
824 ** There was a problem of leaking filedescriptors in the initial release
825 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
826 ** systems it seems that the kernel is slow on reclaiming the resources
827 ** because the connects starts to time out (the test doesn't do much
828 ** anyway, so just loop 10 iterations)
830 test_return_t
add_wrapper(memcached_st
*memc
)
832 unsigned int max
= 10000;
840 for (uint32_t x
= 0; x
< max
; x
++)
846 test_return_t
replace_test(memcached_st
*memc
)
848 test_compare_hint(return_value_based_on_buffering(memc
),
850 test_literal_param(__func__
),
851 test_literal_param("when we sanitize"),
852 time_t(0), uint32_t(0)),
853 memcached_last_error_message(memc
));
855 test_compare_hint(MEMCACHED_SUCCESS
,
856 memcached_replace(memc
,
857 test_literal_param(__func__
),
858 test_literal_param("first we insert some data"),
859 time_t(0), uint32_t(0)),
860 memcached_last_error_message(memc
));
865 test_return_t
delete_test(memcached_st
*memc
)
867 test_compare_hint(return_value_based_on_buffering(memc
),
869 test_literal_param(__func__
),
870 test_literal_param("when we sanitize"),
871 time_t(0), uint32_t(0)),
872 memcached_last_error_message(memc
));
874 test_compare_hint(return_value_based_on_buffering(memc
),
875 memcached_delete(memc
,
876 test_literal_param(__func__
),
878 memcached_last_error_message(memc
));
883 test_return_t
flush_test(memcached_st
*memc
)
885 uint64_t query_id
= memcached_query_id(memc
);
886 test_compare(MEMCACHED_SUCCESS
,
887 memcached_flush(memc
, 0));
888 test_compare(query_id
+1, memcached_query_id(memc
));
893 static memcached_return_t
server_function(const memcached_st
*,
894 const memcached_server_st
*,
898 return MEMCACHED_SUCCESS
;
901 test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
904 strncpy(context
, "foo bad", sizeof(context
));
905 memcached_server_fn callbacks
[1];
907 callbacks
[0]= server_function
;
908 memcached_server_cursor(memc
, callbacks
, context
, 1);
912 test_return_t
bad_key_test(memcached_st
*memc
)
914 memcached_return_t rc
;
915 const char *key
= "foo bad";
918 uint64_t query_id
= memcached_query_id(memc
);
920 // Just skip if we are in binary mode.
921 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
923 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
925 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
926 test_true(memc_clone
);
928 query_id
= memcached_query_id(memc_clone
);
929 test_compare(MEMCACHED_SUCCESS
,
930 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
931 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
933 /* All keys are valid in the binary protocol (except for length) */
934 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == false)
936 uint64_t before_query_id
= memcached_query_id(memc_clone
);
938 size_t string_length
;
939 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
940 &string_length
, &flags
, &rc
);
941 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
942 test_zero(string_length
);
945 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
947 query_id
= memcached_query_id(memc_clone
);
948 test_compare(MEMCACHED_SUCCESS
,
949 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
950 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
952 size_t string_length
;
953 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
954 &string_length
, &flags
, &rc
);
955 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
956 test_zero(string_length
);
960 /* Test multi key for bad keys */
961 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
962 size_t key_lengths
[] = { 7, 7, 7 };
963 query_id
= memcached_query_id(memc_clone
);
964 test_compare(MEMCACHED_SUCCESS
,
965 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
966 test_compare(query_id
, memcached_query_id(memc_clone
));
968 query_id
= memcached_query_id(memc_clone
);
969 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
970 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
971 test_compare(query_id
+1, memcached_query_id(memc_clone
));
973 query_id
= memcached_query_id(memc_clone
);
974 // Grouping keys are not required to follow normal key behaviors
975 test_compare(MEMCACHED_SUCCESS
,
976 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
977 test_compare(query_id
+1, memcached_query_id(memc_clone
));
979 /* The following test should be moved to the end of this function when the
980 memcached server is updated to allow max size length of the keys in the
983 test_compare(MEMCACHED_SUCCESS
,
984 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
986 libtest::vchar_t longkey
;
988 libtest::vchar_t::iterator it
= longkey
.begin();
989 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
992 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
994 size_t string_length
;
996 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
997 test_compare(MEMCACHED_NOTFOUND
, rc
);
998 test_zero(string_length
);
1000 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
1001 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1002 test_zero(string_length
);
1006 /* Make sure zero length keys are marked as bad */
1008 test_compare(MEMCACHED_SUCCESS
,
1009 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1010 size_t string_length
;
1011 char *string
= memcached_get(memc_clone
, key
, 0,
1012 &string_length
, &flags
, &rc
);
1013 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1014 test_zero(string_length
);
1018 memcached_free(memc_clone
);
1020 return TEST_SUCCESS
;
1023 #define READ_THROUGH_VALUE "set for me"
1024 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
1027 memcached_result_st
*result
)
1029 (void)memc
;(void)key
;(void)key_length
;
1030 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
1033 #ifndef __INTEL_COMPILER
1034 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1037 test_return_t
read_through(memcached_st
*memc
)
1039 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1041 size_t string_length
;
1043 memcached_return_t rc
;
1044 char *string
= memcached_get(memc
,
1045 test_literal_param(__func__
),
1046 &string_length
, &flags
, &rc
);
1048 test_compare(MEMCACHED_NOTFOUND
, rc
);
1049 test_false(string_length
);
1052 test_compare(MEMCACHED_SUCCESS
,
1053 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1055 string
= memcached_get(memc
,
1056 test_literal_param(__func__
),
1057 &string_length
, &flags
, &rc
);
1059 test_compare(MEMCACHED_SUCCESS
, rc
);
1060 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1061 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1062 test_strcmp(READ_THROUGH_VALUE
, string
);
1065 string
= memcached_get(memc
,
1066 test_literal_param(__func__
),
1067 &string_length
, &flags
, &rc
);
1069 test_compare(MEMCACHED_SUCCESS
, rc
);
1071 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1072 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1073 test_strcmp(READ_THROUGH_VALUE
, string
);
1076 return TEST_SUCCESS
;
1079 test_return_t
set_test2(memcached_st
*memc
)
1081 for (uint32_t x
= 0; x
< 10; x
++)
1083 test_compare_hint(return_value_based_on_buffering(memc
),
1085 test_literal_param("foo"),
1086 test_literal_param("train in the brain"),
1087 time_t(0), uint32_t(0)),
1088 memcached_last_error_message(memc
));
1091 return TEST_SUCCESS
;
1094 test_return_t
set_test3(memcached_st
*memc
)
1096 size_t value_length
= 8191;
1098 libtest::vchar_t value
;
1099 value
.reserve(value_length
);
1100 for (uint32_t x
= 0; x
< value_length
; x
++)
1102 value
.push_back(char(x
% 127));
1105 /* The dump test relies on there being at least 32 items in memcached */
1106 for (uint32_t x
= 0; x
< 32; x
++)
1110 snprintf(key
, sizeof(key
), "foo%u", x
);
1112 uint64_t query_id
= memcached_query_id(memc
);
1113 test_compare_hint(return_value_based_on_buffering(memc
),
1114 memcached_set(memc
, key
, strlen(key
),
1115 &value
[0], value
.size(),
1116 time_t(0), uint32_t(0)),
1117 memcached_last_error_message(memc
));
1118 test_compare(query_id
+1, memcached_query_id(memc
));
1121 return TEST_SUCCESS
;
1124 test_return_t
mget_end(memcached_st
*memc
)
1126 const char *keys
[]= { "foo", "foo2" };
1127 size_t lengths
[]= { 3, 4 };
1128 const char *values
[]= { "fjord", "41" };
1131 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1133 test_compare(MEMCACHED_SUCCESS
,
1135 keys
[x
], lengths
[x
],
1136 values
[x
], strlen(values
[x
]),
1137 time_t(0), uint32_t(0)));
1141 size_t string_length
;
1144 // retrieve both via mget
1145 test_compare(MEMCACHED_SUCCESS
,
1146 memcached_mget(memc
,
1148 test_array_length(keys
)));
1150 char key
[MEMCACHED_MAX_KEY
];
1152 memcached_return_t rc
;
1154 // this should get both
1155 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1157 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1159 test_compare(MEMCACHED_SUCCESS
, rc
);
1161 if (key_length
== 4)
1166 test_compare(string_length
, strlen(values
[val
]));
1167 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1171 // this should indicate end
1172 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1173 test_compare(MEMCACHED_END
, rc
);
1177 test_compare(MEMCACHED_SUCCESS
,
1178 memcached_mget(memc
, keys
, lengths
, 1));
1180 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1181 test_compare(key_length
, lengths
[0]);
1182 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1183 test_compare(string_length
, strlen(values
[0]));
1184 test_true(strncmp(values
[0], string
, string_length
) == 0);
1185 test_compare(MEMCACHED_SUCCESS
, rc
);
1188 // this should indicate end
1189 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1190 test_compare(MEMCACHED_END
, rc
);
1193 return TEST_SUCCESS
;
1196 /* Do not copy the style of this code, I just access hosts to testthis function */
1197 test_return_t
stats_servername_test(memcached_st
*memc
)
1199 memcached_stat_st memc_stat
;
1200 memcached_server_instance_st instance
=
1201 memcached_server_instance_by_position(memc
, 0);
1203 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1205 return TEST_SKIPPED
;
1208 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1209 memcached_server_name(instance
),
1210 memcached_server_port(instance
)));
1212 return TEST_SUCCESS
;
1215 test_return_t
increment_test(memcached_st
*memc
)
1217 uint64_t new_number
;
1219 test_compare(MEMCACHED_SUCCESS
,
1221 test_literal_param("number"),
1222 test_literal_param("0"),
1223 (time_t)0, (uint32_t)0));
1225 test_compare(MEMCACHED_SUCCESS
,
1226 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1227 test_compare(uint64_t(1), new_number
);
1229 test_compare(MEMCACHED_SUCCESS
,
1230 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1231 test_compare(uint64_t(2), new_number
);
1233 return TEST_SUCCESS
;
1236 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1238 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1240 uint64_t new_number
;
1241 uint64_t initial
= 0;
1243 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1245 test_compare(MEMCACHED_SUCCESS
,
1246 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1247 test_compare(new_number
, initial
);
1249 test_compare(MEMCACHED_SUCCESS
,
1250 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1251 test_compare(new_number
, (initial
+1));
1253 return TEST_SUCCESS
;
1256 test_return_t
decrement_test(memcached_st
*memc
)
1258 test_compare(return_value_based_on_buffering(memc
),
1260 test_literal_param(__func__
),
1261 test_literal_param("3"),
1262 time_t(0), uint32_t(0)));
1263 // Make sure we flush the value we just set
1264 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1266 uint64_t new_number
;
1267 test_compare(MEMCACHED_SUCCESS
,
1268 memcached_decrement(memc
,
1269 test_literal_param(__func__
),
1271 test_compare(uint64_t(2), new_number
);
1273 test_compare(MEMCACHED_SUCCESS
,
1274 memcached_decrement(memc
,
1275 test_literal_param(__func__
),
1277 test_compare(uint64_t(1), new_number
);
1279 return TEST_SUCCESS
;
1282 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1284 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1286 uint64_t initial
= 3;
1288 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1290 uint64_t new_number
;
1291 test_compare(MEMCACHED_SUCCESS
,
1292 memcached_decrement_with_initial(memc
,
1293 test_literal_param(__func__
),
1296 test_compare(new_number
, initial
);
1298 test_compare(MEMCACHED_SUCCESS
,
1299 memcached_decrement_with_initial(memc
,
1300 test_literal_param(__func__
),
1303 test_compare(new_number
, (initial
- 1));
1305 return TEST_SUCCESS
;
1308 test_return_t
increment_by_key_test(memcached_st
*memc
)
1310 const char *master_key
= "foo";
1311 const char *key
= "number";
1312 const char *value
= "0";
1314 test_compare(return_value_based_on_buffering(memc
),
1315 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1317 value
, strlen(value
),
1318 time_t(0), uint32_t(0)));
1320 // Make sure we flush the value we just set
1321 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1323 uint64_t new_number
;
1324 test_compare(MEMCACHED_SUCCESS
,
1325 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1326 key
, strlen(key
), 1, &new_number
));
1327 test_compare(uint64_t(1), new_number
);
1329 test_compare(MEMCACHED_SUCCESS
,
1330 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1331 key
, strlen(key
), 1, &new_number
));
1332 test_compare(uint64_t(2), new_number
);
1334 return TEST_SUCCESS
;
1337 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1339 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1341 uint64_t new_number
;
1342 const char *master_key
= "foo";
1343 const char *key
= "number";
1344 uint64_t initial
= 0;
1346 test_compare(MEMCACHED_SUCCESS
,
1347 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1349 1, initial
, 0, &new_number
));
1350 test_compare(new_number
, initial
);
1352 test_compare(MEMCACHED_SUCCESS
,
1353 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1355 1, initial
, 0, &new_number
));
1356 test_compare(new_number
, (initial
+1));
1358 return TEST_SUCCESS
;
1361 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1363 uint64_t new_number
;
1364 const char *value
= "3";
1366 test_compare(return_value_based_on_buffering(memc
),
1367 memcached_set_by_key(memc
,
1368 test_literal_param("foo"),
1369 test_literal_param("number"),
1370 value
, strlen(value
),
1371 (time_t)0, (uint32_t)0));
1373 test_compare(MEMCACHED_SUCCESS
,
1374 memcached_decrement_by_key(memc
,
1375 test_literal_param("foo"),
1376 test_literal_param("number"),
1378 test_compare(uint64_t(2), new_number
);
1380 test_compare(MEMCACHED_SUCCESS
,
1381 memcached_decrement_by_key(memc
,
1382 test_literal_param("foo"),
1383 test_literal_param("number"),
1385 test_compare(uint64_t(1), new_number
);
1387 return TEST_SUCCESS
;
1390 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1392 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1394 uint64_t new_number
;
1395 uint64_t initial
= 3;
1397 test_compare(MEMCACHED_SUCCESS
,
1398 memcached_decrement_with_initial_by_key(memc
,
1399 test_literal_param("foo"),
1400 test_literal_param("number"),
1401 1, initial
, 0, &new_number
));
1402 test_compare(new_number
, initial
);
1404 test_compare(MEMCACHED_SUCCESS
,
1405 memcached_decrement_with_initial_by_key(memc
,
1406 test_literal_param("foo"),
1407 test_literal_param("number"),
1408 1, initial
, 0, &new_number
));
1409 test_compare(new_number
, (initial
- 1));
1411 return TEST_SUCCESS
;
1413 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1415 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1417 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1419 test_compare(return_value_based_on_buffering(memc
),
1421 test_literal_param("number"),
1422 test_literal_param("0"),
1423 (time_t)0, (uint32_t)0));
1425 uint64_t new_number
;
1426 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1427 test_literal_param("number"),
1429 test_compare(uint64_t(1), new_number
);
1431 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1432 test_literal_param("number"),
1434 test_compare(uint64_t(2), new_number
);
1436 return TEST_SUCCESS
;
1439 test_return_t
quit_test(memcached_st
*memc
)
1441 const char *value
= "sanford and sun";
1443 test_compare_hint(return_value_based_on_buffering(memc
),
1445 test_literal_param(__func__
),
1446 value
, strlen(value
),
1447 (time_t)10, (uint32_t)3),
1448 memcached_last_error_message(memc
));
1449 memcached_quit(memc
);
1451 test_compare_hint(return_value_based_on_buffering(memc
),
1453 test_literal_param(__func__
),
1454 value
, strlen(value
),
1455 (time_t)50, (uint32_t)9),
1456 memcached_last_error_message(memc
));
1458 return TEST_SUCCESS
;
1461 test_return_t
mget_result_test(memcached_st
*memc
)
1463 const char *keys
[]= {"fudge", "son", "food"};
1464 size_t key_length
[]= {5, 3, 4};
1466 memcached_result_st results_obj
;
1467 memcached_result_st
*results
;
1469 results
= memcached_result_create(memc
, &results_obj
);
1471 test_true(&results_obj
== results
);
1473 /* We need to empty the server before continueing test */
1474 test_compare(MEMCACHED_SUCCESS
,
1475 memcached_flush(memc
, 0));
1477 test_compare(MEMCACHED_SUCCESS
,
1478 memcached_mget(memc
, keys
, key_length
, 3));
1480 memcached_return_t rc
;
1481 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1486 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1487 test_false(results
);
1488 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1490 for (uint32_t x
= 0; x
< 3; x
++)
1492 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1493 keys
[x
], key_length
[x
],
1494 (time_t)50, (uint32_t)9);
1495 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1498 test_compare(MEMCACHED_SUCCESS
,
1499 memcached_mget(memc
, keys
, key_length
, 3));
1501 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1504 test_true(&results_obj
== results
);
1505 test_compare(MEMCACHED_SUCCESS
, rc
);
1506 test_memcmp(memcached_result_key_value(results
),
1507 memcached_result_value(results
),
1508 memcached_result_length(results
));
1509 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1512 memcached_result_free(&results_obj
);
1514 return TEST_SUCCESS
;
1517 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1519 const char *keys
[]= {"fudge", "son", "food"};
1520 size_t key_length
[]= {5, 3, 4};
1522 memcached_result_st
*results
;
1524 /* We need to empty the server before continueing test */
1525 test_compare(MEMCACHED_SUCCESS
,
1526 memcached_flush(memc
, 0));
1528 test_compare(MEMCACHED_SUCCESS
,
1529 memcached_mget(memc
, keys
, key_length
, 3));
1531 memcached_return_t rc
;
1532 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1536 test_false(results
);
1537 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1539 for (uint32_t x
= 0; x
< 3; x
++)
1541 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1542 keys
[x
], key_length
[x
],
1543 (time_t)50, (uint32_t)9);
1544 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1547 test_compare(MEMCACHED_SUCCESS
,
1548 memcached_mget(memc
, keys
, key_length
, 3));
1551 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1554 test_compare(MEMCACHED_SUCCESS
, rc
);
1555 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1556 test_memcmp(memcached_result_key_value(results
),
1557 memcached_result_value(results
),
1558 memcached_result_length(results
));
1559 memcached_result_free(results
);
1563 return TEST_SUCCESS
;
1566 test_return_t
mget_result_function(memcached_st
*memc
)
1568 const char *keys
[]= {"fudge", "son", "food"};
1569 size_t key_length
[]= {5, 3, 4};
1571 memcached_execute_fn callbacks
[1];
1573 for (uint32_t x
= 0; x
< 3; x
++)
1575 test_compare(return_value_based_on_buffering(memc
),
1576 memcached_set(memc
, keys
[x
], key_length
[x
],
1577 keys
[x
], key_length
[x
],
1578 time_t(50), uint32_t(9)));
1580 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1581 memcached_quit(memc
);
1583 test_compare(MEMCACHED_SUCCESS
,
1584 memcached_mget(memc
, keys
, key_length
, 3));
1586 callbacks
[0]= &callback_counter
;
1589 test_compare(MEMCACHED_SUCCESS
,
1590 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1592 test_compare(size_t(3), counter
);
1594 return TEST_SUCCESS
;
1597 test_return_t
mget_test(memcached_st
*memc
)
1599 const char *keys
[]= {"fudge", "son", "food"};
1600 size_t key_length
[]= {5, 3, 4};
1602 char return_key
[MEMCACHED_MAX_KEY
];
1603 size_t return_key_length
;
1605 size_t return_value_length
;
1607 test_compare(MEMCACHED_SUCCESS
,
1608 memcached_mget(memc
, keys
, key_length
, 3));
1611 memcached_return_t rc
;
1612 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1613 &return_value_length
, &flags
, &rc
)))
1615 test_true(return_value
);
1617 test_false(return_value
);
1618 test_zero(return_value_length
);
1619 test_compare(MEMCACHED_NOTFOUND
, rc
);
1621 for (uint32_t x
= 0; x
< 3; x
++)
1623 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1624 keys
[x
], key_length
[x
],
1625 (time_t)50, (uint32_t)9);
1626 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1628 test_compare(MEMCACHED_SUCCESS
,
1629 memcached_mget(memc
, keys
, key_length
, 3));
1632 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1633 &return_value_length
, &flags
, &rc
)))
1635 test_true(return_value
);
1636 test_compare(MEMCACHED_SUCCESS
, rc
);
1637 if (not memc
->_namespace
)
1639 test_compare(return_key_length
, return_value_length
);
1640 test_memcmp(return_value
, return_key
, return_value_length
);
1646 return TEST_SUCCESS
;
1649 test_return_t
mget_execute(memcached_st
*original_memc
)
1651 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1653 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1656 keys_st
keys(20480);
1658 /* First add all of the items.. */
1659 char blob
[1024] = {0};
1661 for (size_t x
= 0; x
< keys
.size(); ++x
)
1663 uint64_t query_id
= memcached_query_id(memc
);
1664 memcached_return_t rc
= memcached_add(memc
,
1665 keys
.key_at(x
), keys
.length_at(x
),
1668 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
,
1669 memcached_last_error_message(memc
));
1670 test_compare(query_id
+1, memcached_query_id(memc
));
1673 /* Try to get all of them with a large multiget */
1675 memcached_execute_fn callbacks
[]= { &callback_counter
};
1676 test_compare(MEMCACHED_SUCCESS
,
1677 memcached_mget_execute(memc
,
1678 keys
.keys_ptr(), keys
.lengths_ptr(),
1679 keys
.size(), callbacks
, &counter
, 1));
1682 uint64_t query_id
= memcached_query_id(memc
);
1683 test_compare(MEMCACHED_SUCCESS
,
1684 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1685 test_compare(query_id
, memcached_query_id(memc
));
1687 /* Verify that we got all of the items */
1688 test_compare(keys
.size(), counter
);
1691 memcached_free(memc
);
1693 return TEST_SUCCESS
;
1696 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1697 static pairs_st
*global_pairs
;
1699 test_return_t
key_setup(memcached_st
*memc
)
1701 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1703 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1705 return TEST_SUCCESS
;
1708 test_return_t
key_teardown(memcached_st
*)
1710 pairs_free(global_pairs
);
1712 return TEST_SUCCESS
;
1715 test_return_t
block_add_regression(memcached_st
*memc
)
1717 /* First add all of the items.. */
1718 for (ptrdiff_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1720 char blob
[1024] = {0};
1722 memcached_return_t rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1723 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
, memcached_strerror(NULL
, rc
));
1726 return TEST_SUCCESS
;
1729 test_return_t
binary_add_regression(memcached_st
*memc
)
1731 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1732 test_return_t rc
= block_add_regression(memc
);
1737 test_return_t
get_stats_keys(memcached_st
*memc
)
1741 memcached_stat_st memc_stat
;
1742 memcached_return_t rc
;
1744 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1745 test_compare(MEMCACHED_SUCCESS
, rc
);
1746 for (ptr
= stat_list
; *ptr
; ptr
++)
1751 return TEST_SUCCESS
;
1754 test_return_t
version_string_test(memcached_st
*)
1756 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1758 return TEST_SUCCESS
;
1761 test_return_t
get_stats(memcached_st
*memc
)
1763 memcached_return_t rc
;
1765 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1766 test_compare(MEMCACHED_SUCCESS
, rc
);
1767 test_true(memc_stat
);
1769 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1771 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1772 test_compare(MEMCACHED_SUCCESS
, rc
);
1773 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1778 memcached_stat_free(NULL
, memc_stat
);
1780 return TEST_SUCCESS
;
1783 test_return_t
add_host_test(memcached_st
*memc
)
1785 char servername
[]= "0.example.com";
1787 memcached_return_t rc
;
1788 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1789 test_compare(1U, memcached_server_list_count(servers
));
1791 for (unsigned int x
= 2; x
< 20; x
++)
1793 char buffer
[SMALL_STRING_LEN
];
1795 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1796 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1798 test_compare(MEMCACHED_SUCCESS
, rc
);
1799 test_compare(x
, memcached_server_list_count(servers
));
1802 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1803 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1805 memcached_server_list_free(servers
);
1807 return TEST_SUCCESS
;
1810 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1812 memcached_return_t rc
;
1814 const char *key
= "not_found";
1815 size_t key_length
= test_literal_param_size("not_found");
1817 test_compare(MEMCACHED_SUCCESS
,
1818 memcached_mget(memc
, &key
, &key_length
, 1));
1820 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1822 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1824 memcached_result_free(result
);
1826 return TEST_SUCCESS
;
1829 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1831 return MEMCACHED_SUCCESS
;
1834 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1836 return MEMCACHED_SUCCESS
;
1839 test_return_t
callback_test(memcached_st
*memc
)
1841 /* Test User Data */
1845 memcached_return_t rc
;
1847 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1848 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1849 test_true(*test_ptr
== x
);
1852 /* Test Clone Callback */
1854 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1855 void *clone_cb_ptr
= *(void **)&clone_cb
;
1856 void *temp_function
= NULL
;
1858 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
1859 memcached_return_t rc
;
1860 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1861 test_true(temp_function
== clone_cb_ptr
);
1862 test_compare(MEMCACHED_SUCCESS
, rc
);
1865 /* Test Cleanup Callback */
1867 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
1868 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1869 void *temp_function
= NULL
;
1870 memcached_return_t rc
;
1872 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
1873 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1874 test_true(temp_function
== cleanup_cb_ptr
);
1877 return TEST_SUCCESS
;
1880 /* We don't test the behavior itself, we test the switches */
1881 test_return_t
behavior_test(memcached_st
*memc
)
1883 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
1884 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
1886 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
1887 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
1889 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
1890 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1892 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
1893 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
1895 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
1896 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
1898 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
1899 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1901 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
1902 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1904 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
1906 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
1908 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
1909 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
1910 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
1912 return TEST_SUCCESS
;
1915 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
1917 test_compare(MEMCACHED_DEPRECATED
,
1918 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
1920 // Platform dependent
1922 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
1926 return TEST_SUCCESS
;
1930 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
1932 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
1933 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
1935 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
1937 if (memcached_success(rc
))
1946 return TEST_SUCCESS
;
1950 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
1952 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
1953 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
1955 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
1957 if (memcached_success(rc
))
1966 return TEST_SUCCESS
;
1969 /* Make sure we behave properly if server list has no values */
1970 test_return_t
user_supplied_bug4(memcached_st
*memc
)
1972 const char *keys
[]= {"fudge", "son", "food"};
1973 size_t key_length
[]= {5, 3, 4};
1975 /* Here we free everything before running a bunch of mget tests */
1976 memcached_servers_reset(memc
);
1979 /* We need to empty the server before continueing test */
1980 test_compare(MEMCACHED_NO_SERVERS
,
1981 memcached_flush(memc
, 0));
1983 test_compare(MEMCACHED_NO_SERVERS
,
1984 memcached_mget(memc
, keys
, key_length
, 3));
1987 unsigned int keys_returned
;
1988 memcached_return_t rc
;
1989 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
1990 test_compare(MEMCACHED_NOTFOUND
, rc
);
1991 test_zero(keys_returned
);
1994 for (uint32_t x
= 0; x
< 3; x
++)
1996 test_compare(MEMCACHED_NO_SERVERS
,
1997 memcached_set(memc
, keys
[x
], key_length
[x
],
1998 keys
[x
], key_length
[x
],
1999 (time_t)50, (uint32_t)9));
2002 test_compare(MEMCACHED_NO_SERVERS
,
2003 memcached_mget(memc
, keys
, key_length
, 3));
2007 char return_key
[MEMCACHED_MAX_KEY
];
2008 memcached_return_t rc
;
2009 size_t return_key_length
;
2010 size_t return_value_length
;
2013 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2014 &return_value_length
, &flags
, &rc
)))
2016 test_true(return_value
);
2017 test_compare(MEMCACHED_SUCCESS
, rc
);
2018 test_true(return_key_length
== return_value_length
);
2019 test_memcmp(return_value
, return_key
, return_value_length
);
2025 return TEST_SUCCESS
;
2028 #define VALUE_SIZE_BUG5 1048064
2029 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2031 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2032 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2034 size_t value_length
;
2036 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2038 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2040 insert_data
[x
]= (signed char)rand();
2043 test_compare(MEMCACHED_SUCCESS
,
2044 memcached_flush(memc
, 0));
2046 memcached_return_t rc
;
2047 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2048 test_compare(MEMCACHED_SUCCESS
,
2049 memcached_mget(memc
, keys
, key_length
, 4));
2052 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2053 test_compare(MEMCACHED_NOTFOUND
, rc
);
2056 for (uint32_t x
= 0; x
< 4; x
++)
2058 test_compare(MEMCACHED_SUCCESS
,
2059 memcached_set(memc
, keys
[x
], key_length
[x
],
2060 insert_data
, VALUE_SIZE_BUG5
,
2061 (time_t)0, (uint32_t)0));
2064 for (uint32_t x
= 0; x
< 10; x
++)
2066 value
= memcached_get(memc
, keys
[0], key_length
[0],
2067 &value_length
, &flags
, &rc
);
2068 test_compare(rc
, MEMCACHED_SUCCESS
);
2072 test_compare(MEMCACHED_SUCCESS
,
2073 memcached_mget(memc
, keys
, key_length
, 4));
2075 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2076 test_compare(4U, count
);
2078 delete [] insert_data
;
2080 return TEST_SUCCESS
;
2083 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2085 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2086 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2087 char return_key
[MEMCACHED_MAX_KEY
];
2088 size_t return_key_length
;
2090 size_t value_length
;
2092 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2094 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2096 insert_data
[x
]= (signed char)rand();
2099 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2101 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2103 // We will now confirm that memcached_mget() returns success, but we will
2104 // then check to make sure that no actual keys are returned.
2105 test_compare(MEMCACHED_SUCCESS
,
2106 memcached_mget(memc
, keys
, key_length
, 4));
2108 memcached_return_t rc
;
2110 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2111 &value_length
, &flags
, &rc
)))
2116 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2118 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2120 test_compare(MEMCACHED_SUCCESS
,
2121 memcached_set(memc
, keys
[x
], key_length
[x
],
2122 insert_data
, VALUE_SIZE_BUG5
,
2123 (time_t)0, (uint32_t)0));
2125 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2127 for (uint32_t x
= 0; x
< 2; x
++)
2129 value
= memcached_get(memc
, keys
[0], key_length
[0],
2130 &value_length
, &flags
, &rc
);
2134 test_compare(MEMCACHED_SUCCESS
,
2135 memcached_mget(memc
, keys
, key_length
, 4));
2136 /* We test for purge of partial complete fetches */
2137 for (count
= 3; count
; count
--)
2139 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2140 &value_length
, &flags
, &rc
);
2141 test_compare(MEMCACHED_SUCCESS
, rc
);
2142 test_memcmp(value
, insert_data
, value_length
);
2143 test_true(value_length
);
2147 delete [] insert_data
;
2149 return TEST_SUCCESS
;
2152 test_return_t
user_supplied_bug8(memcached_st
*)
2154 memcached_return_t rc
;
2156 memcached_st
*memc_clone
;
2158 memcached_server_st
*servers
;
2159 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";
2161 servers
= memcached_servers_parse(server_list
);
2164 mine
= memcached_create(NULL
);
2165 rc
= memcached_server_push(mine
, servers
);
2166 test_compare(MEMCACHED_SUCCESS
, rc
);
2167 memcached_server_list_free(servers
);
2170 memc_clone
= memcached_clone(NULL
, mine
);
2172 memcached_quit(mine
);
2173 memcached_quit(memc_clone
);
2176 memcached_free(mine
);
2177 memcached_free(memc_clone
);
2179 return TEST_SUCCESS
;
2182 /* Test flag store/retrieve */
2183 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2185 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2186 test_true(insert_data
);
2188 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2190 insert_data
[x
]= (signed char)rand();
2193 memcached_flush(memc
, 0);
2195 const char *keys
= "036790384900";
2196 size_t key_length
= strlen(keys
);
2197 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2198 insert_data
, VALUE_SIZE_BUG5
,
2200 memcached_last_error_message(memc
));
2202 memcached_return_t rc
;
2203 size_t value_length
;
2205 char *value
= memcached_get(memc
, keys
, key_length
,
2206 &value_length
, &flags
, &rc
);
2207 test_compare(245U, flags
);
2211 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2213 char return_key
[MEMCACHED_MAX_KEY
];
2214 size_t return_key_length
;
2216 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2217 &value_length
, &flags
, &rc
);
2218 test_compare(uint32_t(245), flags
);
2221 delete [] insert_data
;
2224 return TEST_SUCCESS
;
2227 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2229 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2230 size_t key_length
[3];
2234 char return_key
[MEMCACHED_MAX_KEY
];
2235 size_t return_key_length
;
2237 size_t return_value_length
;
2240 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2241 key_length
[1]= strlen("fudge&*@#");
2242 key_length
[2]= strlen("for^#@&$not");
2245 for (unsigned int x
= 0; x
< 3; x
++)
2247 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2248 keys
[x
], key_length
[x
],
2249 (time_t)50, (uint32_t)9);
2250 test_compare(MEMCACHED_SUCCESS
, rc
);
2253 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2254 test_compare(MEMCACHED_SUCCESS
, rc
);
2256 /* We need to empty the server before continueing test */
2257 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2258 &return_value_length
, &flags
, &rc
)) != NULL
)
2260 test_true(return_value
);
2264 test_compare(3U, count
);
2266 return TEST_SUCCESS
;
2269 /* We are testing with aggressive timeout to get failures */
2270 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2272 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
2274 size_t value_length
= 512;
2275 unsigned int set
= 1;
2276 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2278 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2279 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2280 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2282 libtest::vchar_t value
;
2283 value
.reserve(value_length
);
2284 for (uint32_t x
= 0; x
< value_length
; x
++)
2286 value
.push_back(char(x
% 127));
2289 for (unsigned int x
= 1; x
<= 100000; ++x
)
2291 memcached_return_t rc
= memcached_set(mclone
,
2292 test_literal_param("foo"),
2293 &value
[0], value
.size(),
2296 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2297 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2298 memcached_strerror(NULL
, rc
));
2300 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2306 memcached_free(mclone
);
2308 return TEST_SUCCESS
;
2312 We are looking failures in the async protocol
2314 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2316 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2318 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2319 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2320 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2322 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2325 libtest::vchar_t value
;
2327 for (unsigned int x
= 0; x
< 512; x
++)
2329 value
.push_back(char(x
% 127));
2332 for (unsigned int x
= 1; x
<= 100000; ++x
)
2334 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2338 memcached_free(mclone
);
2340 return TEST_SUCCESS
;
2344 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2346 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2348 memcached_return_t rc
;
2350 size_t value_length
;
2352 uint64_t number_value
;
2354 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2355 &value_length
, &flags
, &rc
);
2357 test_compare(MEMCACHED_NOTFOUND
, rc
);
2359 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2362 /* The binary protocol will set the key if it doesn't exist */
2363 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2365 test_compare(MEMCACHED_SUCCESS
, rc
);
2369 test_compare(MEMCACHED_NOTFOUND
, rc
);
2372 test_compare(MEMCACHED_SUCCESS
,
2373 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2375 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2379 test_compare(MEMCACHED_SUCCESS
,
2380 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2381 test_compare(2UL, number_value
);
2383 return TEST_SUCCESS
;
2387 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2388 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2390 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2392 char key
[] = "key34567890";
2394 char commandFirst
[]= "set key34567890 0 0 ";
2395 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2396 size_t commandLength
;
2398 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2400 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2402 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2404 char *overflow
= new (std::nothrow
) char[testSize
];
2405 test_true(overflow
);
2407 memset(overflow
, 'x', testSize
);
2408 test_compare(MEMCACHED_SUCCESS
,
2409 memcached_set(memc
, key
, strlen(key
),
2410 overflow
, testSize
, 0, 0));
2414 return TEST_SUCCESS
;
2419 Test values of many different sizes
2420 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2421 set key34567890 0 0 8169 \r\n
2422 is sent followed by buffer of size 8169, followed by 8169
2424 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2426 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2428 libtest::vchar_t value
;
2429 value
.reserve(18000);
2430 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2432 value
.push_back((char) (x
% 127));
2435 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2437 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2438 &value
[0], current_length
,
2439 (time_t)0, (uint32_t)0);
2440 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2442 size_t string_length
;
2444 char *string
= memcached_get(memc
, test_literal_param("foo"),
2445 &string_length
, &flags
, &rc
);
2447 test_compare(MEMCACHED_SUCCESS
, rc
);
2448 test_compare(string_length
, current_length
);
2450 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2451 test_memcmp_hint(string
, &value
[0], string_length
, buffer
);
2456 return TEST_SUCCESS
;
2460 Look for zero length value problems
2462 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2464 for (uint32_t x
= 0; x
< 2; x
++)
2466 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2468 (time_t)0, (uint32_t)0);
2470 test_compare(MEMCACHED_SUCCESS
, rc
);
2474 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2475 &length
, &flags
, &rc
);
2477 test_compare(MEMCACHED_SUCCESS
, rc
);
2482 value
= memcached_get(memc
, test_literal_param("mykey"),
2483 &length
, &flags
, &rc
);
2485 test_compare(MEMCACHED_SUCCESS
, rc
);
2491 return TEST_SUCCESS
;
2494 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2495 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2497 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2499 (time_t)0, UINT32_MAX
),
2500 memcached_last_error_message(memc
));
2505 memcached_return_t rc
;
2506 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2507 &length
, &flags
, &rc
);
2509 test_compare(MEMCACHED_SUCCESS
, rc
);
2512 test_compare(flags
, UINT32_MAX
);
2514 return TEST_SUCCESS
;
2517 #if !defined(__sun) && !defined(__OpenBSD__)
2518 /* Check the validity of chinese key*/
2519 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2521 const char *key
= "豆瓣";
2522 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2523 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2524 value
, strlen(value
),
2527 test_compare(MEMCACHED_SUCCESS
, rc
);
2531 char *value2
= memcached_get(memc
, key
, strlen(key
),
2532 &length
, &flags
, &rc
);
2534 test_true(length
==strlen(value
));
2535 test_compare(MEMCACHED_SUCCESS
, rc
);
2536 test_memcmp(value
, value2
, length
);
2539 return TEST_SUCCESS
;
2547 test_return_t
user_supplied_bug19(memcached_st
*)
2549 memcached_return_t res
;
2551 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2553 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2556 memcached_free(memc
);
2558 return TEST_SUCCESS
;
2561 /* CAS test from Andei */
2562 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2564 const char *key
= "abc";
2565 size_t key_len
= strlen("abc");
2567 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2569 test_compare(MEMCACHED_SUCCESS
,
2571 test_literal_param("abc"),
2572 test_literal_param("foobar"),
2573 (time_t)0, (uint32_t)0));
2575 test_compare(MEMCACHED_SUCCESS
,
2576 memcached_mget(memc
, &key
, &key_len
, 1));
2578 memcached_result_st result_obj
;
2579 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2582 memcached_result_create(memc
, &result_obj
);
2583 memcached_return_t status
;
2584 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2587 test_compare(MEMCACHED_SUCCESS
, status
);
2589 memcached_result_free(result
);
2591 return TEST_SUCCESS
;
2594 /* Large mget() of missing keys with binary proto
2596 * If many binary quiet commands (such as getq's in an mget) fill the output
2597 * buffer and the server chooses not to respond, memcached_flush hangs. See
2598 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2601 /* sighandler_t function that always asserts false */
2602 static void fail(int)
2608 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2613 return TEST_SKIPPED
;
2615 void (*oldalarm
)(int);
2617 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2618 test_true(memc_clone
);
2620 /* only binproto uses getq for mget */
2621 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2623 /* empty the cache to ensure misses (hence non-responses) */
2624 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2626 keys_st
keys(key_count
);
2628 oldalarm
= signal(SIGALRM
, fail
);
2631 test_compare_got(MEMCACHED_SUCCESS
,
2632 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2633 memcached_last_error_message(memc_clone
));
2636 signal(SIGALRM
, oldalarm
);
2638 memcached_return_t rc
;
2640 char return_key
[MEMCACHED_MAX_KEY
];
2641 size_t return_key_length
;
2643 size_t return_value_length
;
2644 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2645 &return_value_length
, &flags
, &rc
)))
2647 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2649 test_compare(MEMCACHED_NOTFOUND
, rc
);
2650 test_zero(return_value_length
);
2651 test_zero(return_key_length
);
2652 test_false(return_key
[0]);
2653 test_false(return_value
);
2655 memcached_free(memc_clone
);
2657 return TEST_SUCCESS
;
2661 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2663 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2665 /* should work as of r580 */
2666 test_compare(TEST_SUCCESS
,
2667 _user_supplied_bug21(memc
, 10));
2669 /* should fail as of r580 */
2670 test_compare(TEST_SUCCESS
,
2671 _user_supplied_bug21(memc
, 1000));
2673 return TEST_SUCCESS
;
2676 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2678 memcached_st
*memc
= memcached_create(NULL
);
2682 test_compare(MEMCACHED_SUCCESS
,
2683 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2685 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2686 test_compare(value
, uint64_t(1));
2688 test_compare(MEMCACHED_SUCCESS
,
2689 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2691 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2692 test_true(value
== MEMCACHED_HASH_MD5
);
2695 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2697 memcached_server_st
*server_pool
;
2698 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");
2699 memcached_server_push(memc
, server_pool
);
2701 // @todo this needs to be refactored to actually test something.
2704 if ((fp
= fopen("ketama_keys.txt", "w")))
2708 printf("cannot write to file ketama_keys.txt");
2709 return TEST_FAILURE
;
2712 for (int x
= 0; x
< 10000; x
++)
2715 snprintf(key
, sizeof(key
), "%d", x
);
2717 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2718 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2719 in_port_t port
= memc
->hosts
[server_idx
].port
;
2720 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2721 memcached_server_instance_st instance
=
2722 memcached_server_instance_by_position(memc
, host_index
);
2726 memcached_server_list_free(server_pool
);
2727 memcached_free(memc
);
2729 return TEST_SUCCESS
;
2733 test_return_t
result_static(memcached_st
*memc
)
2735 memcached_result_st result
;
2736 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
2737 test_false(result
.options
.is_allocated
);
2738 test_true(memcached_is_initialized(&result
));
2739 test_true(result_ptr
);
2740 test_true(result_ptr
== &result
);
2742 memcached_result_free(&result
);
2744 test_false(result
.options
.is_allocated
);
2745 test_false(memcached_is_initialized(&result
));
2747 return TEST_SUCCESS
;
2750 test_return_t
result_alloc(memcached_st
*memc
)
2752 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
2753 test_true(result_ptr
);
2754 test_true(result_ptr
->options
.is_allocated
);
2755 test_true(memcached_is_initialized(result_ptr
));
2756 memcached_result_free(result_ptr
);
2758 return TEST_SUCCESS
;
2762 test_return_t
add_host_test1(memcached_st
*memc
)
2764 memcached_return_t rc
;
2765 char servername
[]= "0.example.com";
2767 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2769 test_compare(1U, memcached_server_list_count(servers
));
2771 for (uint32_t x
= 2; x
< 20; x
++)
2773 char buffer
[SMALL_STRING_LEN
];
2775 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
2776 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2778 test_compare(MEMCACHED_SUCCESS
, rc
);
2779 test_compare(x
, memcached_server_list_count(servers
));
2782 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2783 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2785 memcached_server_list_free(servers
);
2787 return TEST_SUCCESS
;
2791 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
2795 #ifdef HARD_MALLOC_TESTS
2796 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
2804 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
2808 #ifdef HARD_MALLOC_TESTS
2809 void *ret
= malloc(size
+ 8);
2812 ret
= (void*)((caddr_t
)ret
+ 8);
2815 void *ret
= malloc(size
);
2820 memset(ret
, 0xff, size
);
2827 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
2829 #ifdef HARD_MALLOC_TESTS
2830 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
2831 void *nmem
= realloc(real_ptr
, size
+ 8);
2836 ret
= (void*)((caddr_t
)nmem
+ 8);
2842 return realloc(mem
, size
);
2847 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
2849 #ifdef HARD_MALLOC_TESTS
2850 void *mem
= my_malloc(ptr
, nelem
* size
);
2853 memset(mem
, 0, nelem
* size
);
2859 return calloc(nelem
, size
);
2863 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
2865 memcached_return_t rc
;
2866 const char *key
= "mine";
2869 /* Make sure be default none exists */
2870 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2872 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2874 /* Test a clean set */
2875 test_compare(MEMCACHED_SUCCESS
,
2876 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2878 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2880 test_memcmp(value
, key
, 4);
2881 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2883 /* Test that we can turn it off */
2884 test_compare(MEMCACHED_SUCCESS
,
2885 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
2887 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2889 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2891 /* Now setup for main test */
2892 test_compare(MEMCACHED_SUCCESS
,
2893 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2895 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2897 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2898 test_memcmp(value
, key
, 4);
2900 /* Set to Zero, and then Set to something too large */
2903 memset(long_key
, 0, 255);
2905 test_compare(MEMCACHED_SUCCESS
,
2906 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
2908 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2910 test_compare(MEMCACHED_SUCCESS
, rc
);
2912 /* Test a long key for failure */
2913 /* TODO, extend test to determine based on setting, what result should be */
2914 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
2915 test_compare(MEMCACHED_SUCCESS
,
2916 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
2918 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
2919 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
2920 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
2921 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
2923 /* Test for a bad prefix, but with a short key */
2924 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
2925 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
2927 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
2928 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
2931 return TEST_SUCCESS
;
2934 test_return_t
set_namespace(memcached_st
*memc
)
2936 memcached_return_t rc
;
2937 const char *key
= "mine";
2940 // Make sure we default to a null namespace
2941 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2943 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2945 /* Test a clean set */
2946 test_compare(MEMCACHED_SUCCESS
,
2947 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2949 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2951 test_memcmp(value
, key
, 4);
2952 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2954 return TEST_SUCCESS
;
2957 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
2959 test_return_if(pre_binary(memc
));
2960 test_return_if(set_namespace(memc
));
2962 return TEST_SUCCESS
;
2965 #ifdef MEMCACHED_ENABLE_DEPRECATED
2966 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
2968 void *test_ptr
= NULL
;
2971 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
2972 cb_ptr
= *(void **)&malloc_cb
;
2973 memcached_return_t rc
;
2975 test_compare(MEMCACHED_SUCCESS
,
2976 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
2977 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
2978 test_compare(MEMCACHED_SUCCESS
, rc
);
2979 test_true(test_ptr
== cb_ptr
);
2983 memcached_realloc_fn realloc_cb
=
2984 (memcached_realloc_fn
)my_realloc
;
2985 cb_ptr
= *(void **)&realloc_cb
;
2986 memcached_return_t rc
;
2988 test_compare(MEMCACHED_SUCCESS
,
2989 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
2990 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
2991 test_compare(MEMCACHED_SUCCESS
, rc
);
2992 test_true(test_ptr
== cb_ptr
);
2996 memcached_free_fn free_cb
=
2997 (memcached_free_fn
)my_free
;
2998 cb_ptr
= *(void **)&free_cb
;
2999 memcached_return_t rc
;
3001 test_compare(MEMCACHED_SUCCESS
,
3002 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3003 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3004 test_compare(MEMCACHED_SUCCESS
, rc
);
3005 test_true(test_ptr
== cb_ptr
);
3008 return TEST_SUCCESS
;
3013 test_return_t
set_memory_alloc(memcached_st
*memc
)
3015 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3016 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3017 my_realloc
, my_calloc
, NULL
));
3019 test_compare(MEMCACHED_SUCCESS
,
3020 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3021 my_realloc
, my_calloc
, NULL
));
3023 memcached_malloc_fn mem_malloc
;
3024 memcached_free_fn mem_free
;
3025 memcached_realloc_fn mem_realloc
;
3026 memcached_calloc_fn mem_calloc
;
3027 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3028 &mem_realloc
, &mem_calloc
);
3030 test_true(mem_malloc
== my_malloc
);
3031 test_true(mem_realloc
== my_realloc
);
3032 test_true(mem_calloc
== my_calloc
);
3033 test_true(mem_free
== my_free
);
3035 return TEST_SUCCESS
;
3038 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3041 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3042 memcached_hash_t hash
;
3043 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3044 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3047 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3048 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3050 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3052 if (hash
!= MEMCACHED_HASH_CRC
)
3053 return TEST_SKIPPED
;
3055 return TEST_SUCCESS
;
3058 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3061 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3062 memcached_hash_t hash
;
3063 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3064 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3069 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3070 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3072 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3074 if (hash
!= MEMCACHED_HASH_HSIEH
)
3075 return TEST_SKIPPED
;
3078 return TEST_SUCCESS
;
3081 test_return_t
enable_cas(memcached_st
*memc
)
3083 unsigned int set
= 1;
3085 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3087 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3089 return TEST_SUCCESS
;
3092 return TEST_SKIPPED
;
3095 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3097 memcached_version(memc
);
3099 memcached_server_instance_st instance
=
3100 memcached_server_instance_by_position(memc
, 0);
3102 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3103 or instance
->minor_version
> 2)
3105 return TEST_SUCCESS
;
3108 return TEST_SKIPPED
;
3111 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3113 const uint64_t timeout
= 100; // Not using, just checking that it sets
3115 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3117 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3119 return TEST_SUCCESS
;
3122 test_return_t
noreply_test(memcached_st
*memc
)
3124 test_compare(MEMCACHED_SUCCESS
,
3125 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3126 test_compare(MEMCACHED_SUCCESS
,
3127 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3128 test_compare(MEMCACHED_SUCCESS
,
3129 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3130 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3131 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3132 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3134 memcached_return_t ret
;
3135 for (int count
= 0; count
< 5; ++count
)
3137 for (size_t x
= 0; x
< 100; ++x
)
3139 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3140 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3141 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3143 size_t len
= (size_t)check_length
;
3148 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3151 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3154 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3157 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3160 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3166 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3167 memcached_strerror(NULL
, ret
));
3171 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3172 ** API and is _ONLY_ done this way to verify that the library works the
3173 ** way it is supposed to do!!!!
3177 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3179 memcached_server_instance_st instance
=
3180 memcached_server_instance_by_position(memc
, x
);
3181 no_msg
+=(int)(instance
->cursor_active
);
3184 test_true(no_msg
== 0);
3186 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3189 ** Now validate that all items was set properly!
3191 for (size_t x
= 0; x
< 100; ++x
)
3195 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3197 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3199 size_t len
= (size_t)check_length
;
3202 char* value
=memcached_get(memc
, key
, strlen(key
),
3203 &length
, &flags
, &ret
);
3204 // For the moment we will just go to the next key
3205 if (MEMCACHED_TIMEOUT
== ret
)
3209 test_true_hint(ret
== MEMCACHED_SUCCESS
and value
!= NULL
, memcached_last_error_message(memc
));
3212 case 0: /* FALLTHROUGH */
3213 case 1: /* FALLTHROUGH */
3215 test_true(strncmp(value
, key
, len
) == 0);
3216 test_true(len
== length
);
3219 test_true(length
== len
* 2);
3222 test_true(length
== len
* 3);
3232 /* Try setting an illegal cas value (should not return an error to
3233 * the caller (because we don't expect a return message from the server)
3235 const char* keys
[]= {"0"};
3236 size_t lengths
[]= {1};
3239 memcached_result_st results_obj
;
3240 memcached_result_st
*results
;
3241 test_compare(MEMCACHED_SUCCESS
,
3242 memcached_mget(memc
, keys
, lengths
, 1));
3244 results
= memcached_result_create(memc
, &results_obj
);
3246 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3248 test_compare(MEMCACHED_SUCCESS
, ret
);
3249 uint64_t cas
= memcached_result_cas(results
);
3250 memcached_result_free(&results_obj
);
3252 test_compare(MEMCACHED_SUCCESS
,
3253 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3256 * The item will have a new cas value, so try to set it again with the old
3257 * value. This should fail!
3259 test_compare(MEMCACHED_SUCCESS
,
3260 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3261 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3262 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3263 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3266 return TEST_SUCCESS
;
3269 test_return_t
analyzer_test(memcached_st
*memc
)
3271 memcached_analysis_st
*report
;
3272 memcached_return_t rc
;
3274 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3275 test_compare(MEMCACHED_SUCCESS
, rc
);
3276 test_true(memc_stat
);
3278 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3279 test_compare(MEMCACHED_SUCCESS
, rc
);
3283 memcached_stat_free(NULL
, memc_stat
);
3285 return TEST_SUCCESS
;
3288 test_return_t
util_version_test(memcached_st
*memc
)
3290 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
3291 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3293 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3295 // We expect failure
3298 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3299 fprintf(stderr
, "\nDumping Server Information\n\n");
3300 memcached_server_fn callbacks
[1];
3302 callbacks
[0]= dump_server_information
;
3303 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3304 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3306 test_true(if_successful
== false);
3308 memcached_server_instance_st instance
=
3309 memcached_server_instance_by_position(memc
, 0);
3311 memcached_version(memc
);
3313 // We only use one binary when we test, so this should be just fine.
3314 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3315 test_true(if_successful
== true);
3317 if (instance
->micro_version
> 0)
3319 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3321 else if (instance
->minor_version
> 0)
3323 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3325 else if (instance
->major_version
> 0)
3327 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3330 test_true(if_successful
== true);
3332 if (instance
->micro_version
> 0)
3334 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3336 else if (instance
->minor_version
> 0)
3338 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3340 else if (instance
->major_version
> 0)
3342 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3345 test_true(if_successful
== false);
3347 return TEST_SUCCESS
;
3350 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3352 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3353 memcached_return_t rc
;
3354 memcached_server_instance_st instance
=
3355 memcached_server_instance_by_position(memc
, 0);
3357 // Test both the version that returns a code, and the one that does not.
3358 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3359 memcached_server_port(instance
) -1, NULL
) == -1);
3361 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3362 memcached_server_port(instance
) -1, &rc
) == -1);
3363 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3365 return TEST_SUCCESS
;
3369 test_return_t
getpid_test(memcached_st
*memc
)
3371 memcached_return_t rc
;
3372 memcached_server_instance_st instance
=
3373 memcached_server_instance_by_position(memc
, 0);
3375 // Test both the version that returns a code, and the one that does not.
3376 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3377 memcached_server_port(instance
), NULL
) > -1);
3379 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3380 memcached_server_port(instance
), &rc
) > -1);
3381 test_compare(MEMCACHED_SUCCESS
, rc
);
3383 return TEST_SUCCESS
;
3386 test_return_t
ping_test(memcached_st
*memc
)
3388 memcached_return_t rc
;
3389 memcached_server_instance_st instance
=
3390 memcached_server_instance_by_position(memc
, 0);
3392 // Test both the version that returns a code, and the one that does not.
3393 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3394 memcached_server_port(instance
), NULL
));
3396 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3397 memcached_server_port(instance
), &rc
));
3399 test_compare(MEMCACHED_SUCCESS
, rc
);
3401 return TEST_SUCCESS
;
3406 test_return_t
hash_sanity_test (memcached_st
*memc
)
3410 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3411 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3412 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3413 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3414 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3415 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3416 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3417 #ifdef HAVE_HSIEH_HASH
3418 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3420 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3421 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3422 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3424 return TEST_SUCCESS
;
3428 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3430 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3432 test_compare(MEMCACHED_SUCCESS
,
3433 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3434 (uint64_t)MEMCACHED_HASH_HSIEH
));
3436 return TEST_SUCCESS
;
3439 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3441 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3443 test_compare(MEMCACHED_SUCCESS
,
3444 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3446 return TEST_SUCCESS
;
3449 test_return_t
one_at_a_time_run (memcached_st
*)
3454 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3456 test_compare(one_at_a_time_values
[x
],
3457 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3460 return TEST_SUCCESS
;
3463 test_return_t
md5_run (memcached_st
*)
3468 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3470 test_compare(md5_values
[x
],
3471 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3474 return TEST_SUCCESS
;
3477 test_return_t
crc_run (memcached_st
*)
3482 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3484 test_compare(crc_values
[x
],
3485 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3488 return TEST_SUCCESS
;
3491 test_return_t
fnv1_64_run (memcached_st
*)
3493 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3498 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3500 test_compare(fnv1_64_values
[x
],
3501 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3504 return TEST_SUCCESS
;
3507 test_return_t
fnv1a_64_run (memcached_st
*)
3509 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3514 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3516 test_compare(fnv1a_64_values
[x
],
3517 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3520 return TEST_SUCCESS
;
3523 test_return_t
fnv1_32_run (memcached_st
*)
3528 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3530 test_compare(fnv1_32_values
[x
],
3531 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3534 return TEST_SUCCESS
;
3537 test_return_t
fnv1a_32_run (memcached_st
*)
3542 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3544 test_compare(fnv1a_32_values
[x
],
3545 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3548 return TEST_SUCCESS
;
3551 test_return_t
hsieh_run (memcached_st
*)
3553 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3558 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3560 test_compare(hsieh_values
[x
],
3561 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3564 return TEST_SUCCESS
;
3567 test_return_t
murmur_run (memcached_st
*)
3569 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3571 #ifdef WORDS_BIGENDIAN
3572 (void)murmur_values
;
3573 return TEST_SKIPPED
;
3578 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3580 test_compare(murmur_values
[x
],
3581 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3584 return TEST_SUCCESS
;
3588 test_return_t
jenkins_run (memcached_st
*)
3593 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3595 test_compare(jenkins_values
[x
],
3596 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3599 return TEST_SUCCESS
;
3602 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3604 return libhashkit_md5(string
, string_length
);
3607 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3609 return libhashkit_crc32(string
, string_length
);
3612 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3618 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3620 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};
3621 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};
3623 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3625 hashkit_clone(&new_kit
, kit
);
3626 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3628 memcached_set_hashkit(memc
, &new_kit
);
3631 Verify Setting the hash.
3633 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3637 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3638 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3643 Now check memcached_st.
3645 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3649 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3650 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3653 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3655 memcached_set_hashkit(memc
, &new_kit
);
3658 Verify Setting the hash.
3660 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3664 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3665 test_true(crc_values
[x
] == hash_val
);
3668 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3672 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3673 test_compare(crc_hosts
[x
], hash_val
);
3676 memcached_free(memc
);
3678 return TEST_SUCCESS
;
3682 Test case adapted from John Gorman <johngorman2@gmail.com>
3684 We are testing the error condition when we connect to a server via memcached_get()
3685 but find that the server is not available.
3687 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3691 memcached_return rc
;
3694 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3696 // See if memcached is reachable.
3697 char *value
= memcached_get(tl_memc_h
,
3698 test_literal_param(__func__
),
3703 test_true(memcached_failed(rc
));
3705 memcached_free(tl_memc_h
);
3707 return TEST_SUCCESS
;
3711 We connect to a server which exists, but search for a key that does not exist.
3713 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3717 memcached_return rc
;
3719 // See if memcached is reachable.
3720 char *value
= memcached_get(memc
,
3721 test_literal_param(__func__
),
3726 test_compare(MEMCACHED_NOTFOUND
, rc
);
3728 return TEST_SUCCESS
;
3732 Test case adapted from John Gorman <johngorman2@gmail.com>
3734 We are testing the error condition when we connect to a server via memcached_get_by_key()
3735 but find that the server is not available.
3737 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
3741 memcached_return rc
;
3744 memcached_st
*tl_memc_h
= memcached_create(NULL
);
3745 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
3746 memcached_server_push(tl_memc_h
, servers
);
3747 memcached_server_list_free(servers
);
3749 // See if memcached is reachable.
3750 char *value
= memcached_get_by_key(tl_memc_h
,
3751 test_literal_param(__func__
), // Key
3752 test_literal_param(__func__
), // Value
3757 test_true(memcached_failed(rc
));
3759 memcached_free(tl_memc_h
);
3761 return TEST_SUCCESS
;
3765 We connect to a server which exists, but search for a key that does not exist.
3767 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3771 memcached_return rc
;
3773 // See if memcached is reachable.
3774 char *value
= memcached_get_by_key(memc
,
3775 test_literal_param(__func__
), // Key
3776 test_literal_param(__func__
), // Value
3781 test_compare(MEMCACHED_NOTFOUND
, rc
);
3783 return TEST_SUCCESS
;
3786 test_return_t
regression_bug_434484(memcached_st
*memc
)
3788 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3790 test_compare(MEMCACHED_NOTSTORED
,
3791 memcached_append(memc
,
3792 test_literal_param(__func__
), // Key
3793 test_literal_param(__func__
), // Value
3796 libtest::vchar_t data
;
3797 data
.resize(2048 * 1024);
3798 test_compare(MEMCACHED_E2BIG
,
3800 test_literal_param(__func__
), // Key
3801 &data
[0], data
.size(), 0, 0));
3803 return TEST_SUCCESS
;
3806 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
3808 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
3810 memcached_return_t rc
;
3812 memcached_execute_fn callbacks
[]= { &callback_counter
};
3815 * I only want to hit only _one_ server so I know the number of requests I'm
3816 * sending in the pipleine to the server. Let's try to do a multiget of
3817 * 1024 (that should satisfy most users don't you think?). Future versions
3818 * will include a mget_execute function call if you need a higher number.
3820 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
3825 * Run two times.. the first time we should have 100% cache miss,
3826 * and the second time we should have 100% cache hits
3828 for (ptrdiff_t y
= 0; y
< 2; y
++)
3830 test_compare(MEMCACHED_SUCCESS
,
3831 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
3833 // One the first run we should get a NOT_FOUND, but on the second some data
3834 // should be returned.
3835 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
3836 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3840 /* The first iteration should give me a 100% cache miss. verify that*/
3841 char blob
[1024]= { 0 };
3843 test_false(counter
);
3845 for (size_t x
= 0; x
< keys
.size(); ++x
)
3847 rc
= memcached_add(memc
,
3848 keys
.key_at(x
), keys
.length_at(x
),
3849 blob
, sizeof(blob
), 0, 0);
3850 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3855 /* Verify that we received all of the key/value pairs */
3856 test_compare(counter
, keys
.size());
3860 memcached_free(memc
);
3862 return TEST_SUCCESS
;
3865 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
3867 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3869 return regression_bug_434843(memc
);
3872 test_return_t
regression_bug_421108(memcached_st
*memc
)
3874 memcached_return_t rc
;
3875 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3876 test_compare(MEMCACHED_SUCCESS
, rc
);
3878 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
3879 test_compare(MEMCACHED_SUCCESS
, rc
);
3880 test_true(bytes_str
);
3881 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
3883 test_compare(MEMCACHED_SUCCESS
, rc
);
3884 test_true(bytes_read_str
);
3886 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
3887 "bytes_written", &rc
);
3888 test_compare(MEMCACHED_SUCCESS
, rc
);
3889 test_true(bytes_written_str
);
3891 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
3892 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
3893 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
3895 test_true(bytes
!= bytes_read
);
3896 test_true(bytes
!= bytes_written
);
3898 /* Release allocated resources */
3900 free(bytes_read_str
);
3901 free(bytes_written_str
);
3902 memcached_stat_free(NULL
, memc_stat
);
3904 return TEST_SUCCESS
;
3908 * The test case isn't obvious so I should probably document why
3909 * it works the way it does. Bug 442914 was caused by a bug
3910 * in the logic in memcached_purge (it did not handle the case
3911 * where the number of bytes sent was equal to the watermark).
3912 * In this test case, create messages so that we hit that case
3913 * and then disable noreply mode and issue a new command to
3914 * verify that it isn't stuck. If we change the format for the
3915 * delete command or the watermarks, we need to update this
3918 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
3920 test_skip(original_memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3922 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
3924 for (uint32_t x
= 0; x
< 250; ++x
)
3927 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
3928 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
3929 char error_buffer
[2048]= { 0 };
3930 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
3931 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
3934 // Delete, and then delete again to look for not found
3937 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
3938 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
3939 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
3941 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
3942 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
3945 memcached_free(memc
);
3947 return TEST_SUCCESS
;
3950 test_return_t
regression_bug_447342(memcached_st
*memc
)
3952 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
3954 return TEST_SKIPPED
;
3957 test_compare(MEMCACHED_SUCCESS
,
3958 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
3962 for (size_t x
= 0; x
< keys
.size(); ++x
)
3964 test_compare(MEMCACHED_SUCCESS
,
3966 keys
.key_at(x
), keys
.length_at(x
), // Keys
3967 keys
.key_at(x
), keys
.length_at(x
), // Values
3972 ** We are using the quiet commands to store the replicas, so we need
3973 ** to ensure that all of them are processed before we can continue.
3974 ** In the test we go directly from storing the object to trying to
3975 ** receive the object from all of the different servers, so we
3976 ** could end up in a race condition (the memcached server hasn't yet
3977 ** processed the quiet command from the replication set when it process
3978 ** the request from the other client (created by the clone)). As a
3979 ** workaround for that we call memcached_quit to send the quit command
3980 ** to the server and wait for the response ;-) If you use the test code
3981 ** as an example for your own code, please note that you shouldn't need
3984 memcached_quit(memc
);
3986 /* Verify that all messages are stored, and we didn't stuff too much
3989 test_compare(MEMCACHED_SUCCESS
,
3990 memcached_mget(memc
,
3991 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
3993 unsigned int counter
= 0;
3994 memcached_execute_fn callbacks
[]= { &callback_counter
};
3995 test_compare(MEMCACHED_SUCCESS
,
3996 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3998 /* Verify that we received all of the key/value pairs */
3999 test_compare(counter
, keys
.size());
4001 memcached_quit(memc
);
4003 * Don't do the following in your code. I am abusing the internal details
4004 * within the library, and this is not a supported interface.
4005 * This is to verify correct behavior in the library. Fake that two servers
4008 memcached_server_instance_st instance_one
= memcached_server_instance_by_position(memc
, 0);
4009 memcached_server_instance_st instance_two
= memcached_server_instance_by_position(memc
, 2);
4010 in_port_t port0
= instance_one
->port
;
4011 in_port_t port2
= instance_two
->port
;
4013 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4014 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4016 test_compare(MEMCACHED_SUCCESS
,
4017 memcached_mget(memc
,
4018 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4021 test_compare(MEMCACHED_SUCCESS
,
4022 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4023 test_compare(counter
, keys
.size());
4025 /* restore the memc handle */
4026 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4027 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4029 memcached_quit(memc
);
4031 /* Remove half of the objects */
4032 for (size_t x
= 0; x
< keys
.size(); ++x
)
4036 test_compare(MEMCACHED_SUCCESS
,
4037 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4041 memcached_quit(memc
);
4042 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4043 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4045 /* now retry the command, this time we should have cache misses */
4046 test_compare(MEMCACHED_SUCCESS
,
4047 memcached_mget(memc
,
4048 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4051 test_compare(MEMCACHED_SUCCESS
,
4052 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4053 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4055 /* restore the memc handle */
4056 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4057 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4059 return TEST_SUCCESS
;
4062 test_return_t
regression_bug_463297(memcached_st
*memc
)
4064 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4066 // Since we blocked timed delete, this test is no longer valid.
4068 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4069 test_true(memc_clone
);
4070 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4072 memcached_server_instance_st instance
=
4073 memcached_server_instance_by_position(memc_clone
, 0);
4075 if (instance
->major_version
> 1 ||
4076 (instance
->major_version
== 1 &&
4077 instance
->minor_version
> 2))
4079 /* Binary protocol doesn't support deferred delete */
4080 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4081 test_true(bin_clone
);
4082 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4083 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4084 memcached_free(bin_clone
);
4086 memcached_quit(memc_clone
);
4088 /* If we know the server version, deferred delete should fail
4089 * with invalid arguments */
4090 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4092 /* If we don't know the server version, we should get a protocol error */
4093 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4095 /* but there is a bug in some of the memcached servers (1.4) that treats
4096 * the counter as noreply so it doesn't send the proper error message
4098 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4100 /* And buffered mode should be disabled and we should get protocol error */
4101 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4102 rc
= memcached_delete(memc
, "foo", 3, 1);
4103 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4105 /* Same goes for noreply... */
4106 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4107 rc
= memcached_delete(memc
, "foo", 3, 1);
4108 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4110 /* but a normal request should go through (and be buffered) */
4111 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4112 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4114 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4115 /* unbuffered noreply should be success */
4116 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4117 /* unbuffered with reply should be not found... */
4118 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4119 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4122 memcached_free(memc_clone
);
4125 return TEST_SUCCESS
;
4129 /* Test memcached_server_get_last_disconnect
4130 * For a working server set, shall be NULL
4131 * For a set of non existing server, shall not be NULL
4133 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4135 memcached_return_t rc
;
4136 memcached_server_instance_st disconnected_server
;
4138 /* With the working set of server */
4139 const char *key
= "marmotte";
4140 const char *value
= "milka";
4142 memcached_reset_last_disconnected_server(memc
);
4143 test_false(memc
->last_disconnected_server
);
4144 rc
= memcached_set(memc
, key
, strlen(key
),
4145 value
, strlen(value
),
4146 (time_t)0, (uint32_t)0);
4147 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4149 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4150 test_false(disconnected_server
);
4152 /* With a non existing server */
4154 memcached_server_st
*servers
;
4156 const char *server_list
= "localhost:9";
4158 servers
= memcached_servers_parse(server_list
);
4160 mine
= memcached_create(NULL
);
4161 rc
= memcached_server_push(mine
, servers
);
4162 test_compare(MEMCACHED_SUCCESS
, rc
);
4163 memcached_server_list_free(servers
);
4166 rc
= memcached_set(mine
, key
, strlen(key
),
4167 value
, strlen(value
),
4168 (time_t)0, (uint32_t)0);
4169 test_true(memcached_failed(rc
));
4171 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4172 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4173 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4174 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4176 memcached_quit(mine
);
4177 memcached_free(mine
);
4179 return TEST_SUCCESS
;
4182 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4184 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4185 char buffer
[BUFSIZ
];
4187 test_compare(MEMCACHED_SUCCESS
,
4188 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4190 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4193 // We will just use the error strings as our keys
4194 uint32_t counter
= 100;
4197 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4199 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4200 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4201 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4203 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
4204 test_true(disconnected_server
);
4205 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4206 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4210 memcached_reset_last_disconnected_server(memc
);
4215 memcached_free(memc
);
4217 return TEST_SUCCESS
;
4220 test_return_t
test_verbosity(memcached_st
*memc
)
4222 memcached_verbosity(memc
, 3);
4224 return TEST_SUCCESS
;
4228 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
4229 const char *key
, size_t key_length
,
4230 const char *value
, size_t value_length
,
4240 return MEMCACHED_SUCCESS
;
4243 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4245 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4246 test_compare(MEMCACHED_SUCCESS
, rc
);
4248 test_compare(MEMCACHED_SUCCESS
,
4249 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4251 test_compare(MEMCACHED_SUCCESS
,
4252 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4254 test_compare(MEMCACHED_SUCCESS
,
4255 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4257 return TEST_SUCCESS
;
4261 * This test ensures that the failure counter isn't incremented during
4262 * normal termination of the memcached instance.
4264 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4266 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4268 /* Ensure that we are connected to the server by setting a value */
4269 memcached_return_t rc
= memcached_set(memc
,
4270 test_literal_param(__func__
), // Key
4271 test_literal_param(__func__
), // Value
4272 time_t(0), uint32_t(0));
4273 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4276 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4278 /* The test is to see that the memcached_quit doesn't increase the
4279 * the server failure conter, so let's ensure that it is zero
4280 * before sending quit
4282 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4284 memcached_quit(memc
);
4286 /* Verify that it memcached_quit didn't increment the failure counter
4287 * Please note that this isn't bullet proof, because an error could
4290 test_zero(instance
->server_failure_counter
);
4292 memcached_free(memc
);
4294 return TEST_SUCCESS
;
4298 * This tests ensures expected disconnections (for some behavior changes
4299 * for instance) do not wrongly increase failure counter
4301 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4303 /* Set value to force connection to the server */
4304 const char *key
= "marmotte";
4305 const char *value
= "milka";
4307 test_compare_hint(MEMCACHED_SUCCESS
,
4308 memcached_set(memc
, key
, strlen(key
),
4309 value
, strlen(value
),
4310 (time_t)0, (uint32_t)0),
4311 memcached_last_error_message(memc
));
4314 /* put failure limit to 1 */
4315 test_compare(MEMCACHED_SUCCESS
,
4316 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4318 /* Put a retry timeout to effectively activate failure_limit effect */
4319 test_compare(MEMCACHED_SUCCESS
,
4320 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4322 /* change behavior that triggers memcached_quit()*/
4323 test_compare(MEMCACHED_SUCCESS
,
4324 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4327 /* Check if we still are connected */
4329 size_t string_length
;
4330 memcached_return rc
;
4331 char *string
= memcached_get(memc
, key
, strlen(key
),
4332 &string_length
, &flags
, &rc
);
4334 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4338 return TEST_SUCCESS
;
4343 * Test that ensures mget_execute does not end into recursive calls that finally fails
4345 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4349 return TEST_SKIPPED
; // My MAC can't handle this test
4352 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4355 * I only want to hit _one_ server so I know the number of requests I'm
4356 * sending in the pipeline.
4358 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4361 keys_st
keys(20480);
4363 /* First add all of the items.. */
4364 char blob
[1024]= { 0 };
4365 for (size_t x
= 0; x
< keys
.size(); ++x
)
4367 memcached_return rc
= memcached_set(memc
,
4368 keys
.key_at(x
), keys
.length_at(x
),
4369 blob
, sizeof(blob
), 0, 0);
4370 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4375 /* Try to get all of them with a large multiget */
4377 memcached_execute_function callbacks
[]= { &callback_counter
};
4378 memcached_return_t rc
= memcached_mget_execute(memc
,
4379 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4380 callbacks
, &counter
, 1);
4381 test_compare(MEMCACHED_SUCCESS
, rc
);
4383 char* the_value
= NULL
;
4384 char the_key
[MEMCACHED_MAX_KEY
];
4385 size_t the_key_length
;
4386 size_t the_value_length
;
4390 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4392 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4398 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4401 test_compare(MEMCACHED_END
, rc
);
4403 /* Verify that we got all of the items */
4404 test_compare(counter
, keys
.size());
4407 memcached_free(memc
);
4409 return TEST_SUCCESS
;
4412 test_return_t
regression_bug_583031(memcached_st
*)
4414 memcached_st
*memc
= memcached_create(NULL
);
4416 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
4418 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
4419 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4420 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4421 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4422 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4423 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4425 memcached_return_t rc
;
4429 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4433 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
4435 memcached_free(memc
);
4437 return TEST_SUCCESS
;
4440 test_return_t
regression_bug_581030(memcached_st
*)
4443 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4444 test_false(local_stat
);
4446 memcached_stat_free(NULL
, NULL
);
4449 return TEST_SUCCESS
;
4452 #define regression_bug_655423_COUNT 6000
4453 test_return_t
regression_bug_655423(memcached_st
*memc
)
4455 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4456 memc
= NULL
; // Just to make sure it is not used
4461 return TEST_SKIPPED
;
4464 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4465 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4466 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4467 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4469 memset(payload
, int('x'), sizeof(payload
));
4471 keys_st
keys(regression_bug_655423_COUNT
);
4473 for (size_t x
= 0; x
< keys
.size(); x
++)
4475 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4478 payload
, sizeof(payload
), 0, 0));
4481 for (size_t x
= 0; x
< keys
.size(); x
++)
4483 size_t value_length
;
4484 memcached_return_t rc
;
4485 char *value
= memcached_get(clone
,
4488 &value_length
, NULL
, &rc
);
4490 if (rc
== MEMCACHED_NOTFOUND
)
4493 test_zero(value_length
);
4497 test_compare(MEMCACHED_SUCCESS
, rc
);
4499 test_compare(100LLU, value_length
);
4503 test_compare(MEMCACHED_SUCCESS
,
4504 memcached_mget(clone
,
4505 keys
.keys_ptr(), keys
.lengths_ptr(),
4509 memcached_result_st
*result
= NULL
;
4510 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4512 test_compare(size_t(100), memcached_result_length(result
));
4516 test_true(count
> 100); // If we don't get back atleast this, something is up
4518 memcached_free(clone
);
4520 return TEST_SUCCESS
;
4524 * Test that ensures that buffered set to not trigger problems during io_flush
4526 #define regression_bug_490520_COUNT 200480
4527 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4529 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4531 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4532 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4533 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4534 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4535 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4537 /* First add all of the items.. */
4538 char blob
[3333] = {0};
4539 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4542 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4544 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4545 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4548 memcached_free(memc
);
4550 return TEST_SUCCESS
;
4554 test_return_t
regression_bug_854604(memcached_st
*)
4558 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4560 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4562 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4563 test_compare(buffer
[0], 0);
4565 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4566 test_true(strlen(buffer
));
4568 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4569 test_true(strlen(buffer
));
4571 return TEST_SUCCESS
;
4574 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4576 fprintf(stderr
, "Iteration #%u: ", it
);
4578 if (error
== MEMCACHED_ERRNO
)
4580 fprintf(stderr
, "system error %d from %s: %s\n",
4581 errno
, what
, strerror(errno
));
4585 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4586 memcached_strerror(mc
, error
));
4590 #define TEST_CONSTANT_CREATION 200
4592 test_return_t
regression_bug_(memcached_st
*memc
)
4594 const char *remote_server
;
4597 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4599 return TEST_SKIPPED
;
4602 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4604 memcached_st
* mc
= memcached_create(NULL
);
4605 memcached_return rc
;
4607 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4608 if (rc
!= MEMCACHED_SUCCESS
)
4610 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
4613 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4614 if (rc
!= MEMCACHED_SUCCESS
)
4616 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
4619 rc
= memcached_server_add(mc
, remote_server
, 0);
4620 if (rc
!= MEMCACHED_SUCCESS
)
4622 memcached_die(mc
, rc
, "memcached_server_add", x
);
4625 const char *set_key
= "akey";
4626 const size_t set_key_len
= strlen(set_key
);
4627 const char *set_value
= "a value";
4628 const size_t set_value_len
= strlen(set_value
);
4630 if (rc
== MEMCACHED_SUCCESS
)
4634 size_t get_value_len
;
4636 uint32_t get_value_flags
;
4638 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
4639 &get_value_flags
, &rc
);
4640 if (rc
!= MEMCACHED_SUCCESS
)
4642 memcached_die(mc
, rc
, "memcached_get", x
);
4648 (get_value_len
!= set_value_len
4649 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
4651 fprintf(stderr
, "Values don't match?\n");
4652 rc
= MEMCACHED_FAILURE
;
4658 rc
= memcached_set(mc
,
4659 set_key
, set_key_len
,
4660 set_value
, set_value_len
,
4664 if (rc
!= MEMCACHED_SUCCESS
)
4666 memcached_die(mc
, rc
, "memcached_set", x
);
4673 if (rc
!= MEMCACHED_SUCCESS
)
4679 return TEST_SUCCESS
;
4682 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
4684 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
4687 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4690 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
4691 memcached_server_port(instance
), NULL
)) > -1);
4694 test_compare(MEMCACHED_SUCCESS
,
4696 test_literal_param(__func__
), // Keys
4697 test_literal_param(__func__
), // Values
4699 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
4701 test_compare(MEMCACHED_CONNECTION_FAILURE
,
4703 test_literal_param(__func__
), // Keys
4704 test_literal_param(__func__
), // Values
4707 memcached_free(memc
);
4709 return TEST_SUCCESS
;