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 if (rc
== MEMCACHED_NOTFOUND
)
650 { } // It is possible that the value has been purged.
653 test_compare_hint(MEMCACHED_SUCCESS
, rc
, memcached_last_error_message(memc
));
655 test_null(out_value
);
656 test_zero(value_length
);
664 test_return_t
cas2_test(memcached_st
*memc
)
666 const char *keys
[]= {"fudge", "son", "food"};
667 size_t key_length
[]= {5, 3, 4};
668 const char *value
= "we the people";
669 size_t value_length
= strlen("we the people");
671 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
673 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
675 for (uint32_t x
= 0; x
< 3; x
++)
677 test_compare(MEMCACHED_SUCCESS
,
678 memcached_set(memc
, keys
[x
], key_length
[x
],
679 keys
[x
], key_length
[x
],
680 time_t(50), uint32_t(9)));
683 test_compare(MEMCACHED_SUCCESS
,
684 memcached_mget(memc
, keys
, key_length
, 3));
686 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
689 memcached_return_t rc
;
690 results
= memcached_fetch_result(memc
, results
, &rc
);
692 test_true(results
->item_cas
);
693 test_compare(MEMCACHED_SUCCESS
, rc
);
694 test_true(memcached_result_cas(results
));
696 test_memcmp(value
, "we the people", strlen("we the people"));
697 test_compare(strlen("we the people"), value_length
);
698 test_compare(MEMCACHED_SUCCESS
, rc
);
700 memcached_result_free(results
);
705 test_return_t
cas_test(memcached_st
*memc
)
707 const char* keys
[2] = { __func__
, NULL
};
708 size_t keylengths
[2] = { strlen(__func__
), 0 };
710 memcached_result_st results_obj
;
712 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
714 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
716 test_compare(MEMCACHED_SUCCESS
,
718 test_literal_param(__func__
),
719 test_literal_param("we the people"),
720 (time_t)0, (uint32_t)0));
722 test_compare(MEMCACHED_SUCCESS
,
723 memcached_mget(memc
, keys
, keylengths
, 1));
725 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
728 memcached_return_t rc
;
729 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
731 test_compare(MEMCACHED_SUCCESS
, rc
);
732 test_true(memcached_result_cas(results
));
733 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
734 test_compare(test_literal_param_size("we the people"),
735 strlen(memcached_result_value(results
)));
737 uint64_t cas
= memcached_result_cas(results
);
740 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
741 test_true(rc
== MEMCACHED_END
);
742 test_true(results
== NULL
);
745 test_compare(MEMCACHED_SUCCESS
,
747 test_literal_param(__func__
),
748 test_literal_param("change the value"),
752 * The item will have a new cas value, so try to set it again with the old
753 * value. This should fail!
755 test_compare(MEMCACHED_DATA_EXISTS
,
757 test_literal_param(__func__
),
758 test_literal_param("change the value"),
761 memcached_result_free(&results_obj
);
767 test_return_t
prepend_test(memcached_st
*memc
)
769 const char *key
= "fig";
770 const char *value
= "people";
772 test_compare(MEMCACHED_SUCCESS
,
773 memcached_flush(memc
, 0));
775 test_compare(MEMCACHED_SUCCESS
,
776 memcached_set(memc
, key
, strlen(key
),
777 value
, strlen(value
),
778 time_t(0), uint32_t(0)));
780 test_compare(MEMCACHED_SUCCESS
,
781 memcached_prepend(memc
, key
, strlen(key
),
782 "the ", strlen("the "),
783 time_t(0), uint32_t(0)));
785 test_compare(MEMCACHED_SUCCESS
,
786 memcached_prepend(memc
, key
, strlen(key
),
787 "we ", strlen("we "),
788 time_t(0), uint32_t(0)));
792 memcached_return_t rc
;
793 char *out_value
= memcached_get(memc
, key
, strlen(key
),
794 &value_length
, &flags
, &rc
);
795 test_memcmp(out_value
, "we the people", strlen("we the people"));
796 test_compare(strlen("we the people"), value_length
);
797 test_compare(MEMCACHED_SUCCESS
, rc
);
804 Set the value, then quit to make sure it is flushed.
805 Come back in and test that add fails.
807 test_return_t
add_test(memcached_st
*memc
)
809 test_compare_hint(return_value_based_on_buffering(memc
),
811 test_literal_param(__func__
),
812 test_literal_param("when we sanitize"),
813 time_t(0), uint32_t(0)),
814 memcached_last_error_message(memc
));
816 memcached_quit(memc
);
818 test_compare_hint(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
820 test_literal_param(__func__
),
821 test_literal_param("try something else"),
822 time_t(0), uint32_t(0)),
823 memcached_last_error_message(memc
));
829 ** There was a problem of leaking filedescriptors in the initial release
830 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
831 ** systems it seems that the kernel is slow on reclaiming the resources
832 ** because the connects starts to time out (the test doesn't do much
833 ** anyway, so just loop 10 iterations)
835 test_return_t
add_wrapper(memcached_st
*memc
)
837 unsigned int max
= 10000;
845 for (uint32_t x
= 0; x
< max
; x
++)
851 test_return_t
replace_test(memcached_st
*memc
)
853 test_compare_hint(return_value_based_on_buffering(memc
),
855 test_literal_param(__func__
),
856 test_literal_param("when we sanitize"),
857 time_t(0), uint32_t(0)),
858 memcached_last_error_message(memc
));
860 test_compare_hint(MEMCACHED_SUCCESS
,
861 memcached_replace(memc
,
862 test_literal_param(__func__
),
863 test_literal_param("first we insert some data"),
864 time_t(0), uint32_t(0)),
865 memcached_last_error_message(memc
));
870 test_return_t
delete_test(memcached_st
*memc
)
872 test_compare_hint(return_value_based_on_buffering(memc
),
874 test_literal_param(__func__
),
875 test_literal_param("when we sanitize"),
876 time_t(0), uint32_t(0)),
877 memcached_last_error_message(memc
));
879 test_compare_hint(return_value_based_on_buffering(memc
),
880 memcached_delete(memc
,
881 test_literal_param(__func__
),
883 memcached_last_error_message(memc
));
888 test_return_t
flush_test(memcached_st
*memc
)
890 uint64_t query_id
= memcached_query_id(memc
);
891 test_compare(MEMCACHED_SUCCESS
,
892 memcached_flush(memc
, 0));
893 test_compare(query_id
+1, memcached_query_id(memc
));
898 static memcached_return_t
server_function(const memcached_st
*,
899 const memcached_server_st
*,
903 return MEMCACHED_SUCCESS
;
906 test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
909 strncpy(context
, "foo bad", sizeof(context
));
910 memcached_server_fn callbacks
[1];
912 callbacks
[0]= server_function
;
913 memcached_server_cursor(memc
, callbacks
, context
, 1);
917 test_return_t
bad_key_test(memcached_st
*memc
)
919 memcached_return_t rc
;
920 const char *key
= "foo bad";
923 uint64_t query_id
= memcached_query_id(memc
);
925 // Just skip if we are in binary mode.
926 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
928 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
930 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
931 test_true(memc_clone
);
933 query_id
= memcached_query_id(memc_clone
);
934 test_compare(MEMCACHED_SUCCESS
,
935 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
936 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
938 /* All keys are valid in the binary protocol (except for length) */
939 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == false)
941 uint64_t before_query_id
= memcached_query_id(memc_clone
);
943 size_t string_length
;
944 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
945 &string_length
, &flags
, &rc
);
946 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
947 test_zero(string_length
);
950 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
952 query_id
= memcached_query_id(memc_clone
);
953 test_compare(MEMCACHED_SUCCESS
,
954 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
955 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
957 size_t string_length
;
958 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
959 &string_length
, &flags
, &rc
);
960 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
961 test_zero(string_length
);
965 /* Test multi key for bad keys */
966 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
967 size_t key_lengths
[] = { 7, 7, 7 };
968 query_id
= memcached_query_id(memc_clone
);
969 test_compare(MEMCACHED_SUCCESS
,
970 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
971 test_compare(query_id
, memcached_query_id(memc_clone
));
973 query_id
= memcached_query_id(memc_clone
);
974 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
975 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
976 test_compare(query_id
+1, memcached_query_id(memc_clone
));
978 query_id
= memcached_query_id(memc_clone
);
979 // Grouping keys are not required to follow normal key behaviors
980 test_compare(MEMCACHED_SUCCESS
,
981 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
982 test_compare(query_id
+1, memcached_query_id(memc_clone
));
984 /* The following test should be moved to the end of this function when the
985 memcached server is updated to allow max size length of the keys in the
988 test_compare(MEMCACHED_SUCCESS
,
989 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
991 libtest::vchar_t longkey
;
993 libtest::vchar_t::iterator it
= longkey
.begin();
994 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
997 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
999 size_t string_length
;
1001 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
1002 test_compare(MEMCACHED_NOTFOUND
, rc
);
1003 test_zero(string_length
);
1005 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
1006 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1007 test_zero(string_length
);
1011 /* Make sure zero length keys are marked as bad */
1013 test_compare(MEMCACHED_SUCCESS
,
1014 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1015 size_t string_length
;
1016 char *string
= memcached_get(memc_clone
, key
, 0,
1017 &string_length
, &flags
, &rc
);
1018 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1019 test_zero(string_length
);
1023 memcached_free(memc_clone
);
1025 return TEST_SUCCESS
;
1028 #define READ_THROUGH_VALUE "set for me"
1029 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
1032 memcached_result_st
*result
)
1034 (void)memc
;(void)key
;(void)key_length
;
1035 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
1038 #ifndef __INTEL_COMPILER
1039 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1042 test_return_t
read_through(memcached_st
*memc
)
1044 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1046 size_t string_length
;
1048 memcached_return_t rc
;
1049 char *string
= memcached_get(memc
,
1050 test_literal_param(__func__
),
1051 &string_length
, &flags
, &rc
);
1053 test_compare(MEMCACHED_NOTFOUND
, rc
);
1054 test_false(string_length
);
1057 test_compare(MEMCACHED_SUCCESS
,
1058 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1060 string
= memcached_get(memc
,
1061 test_literal_param(__func__
),
1062 &string_length
, &flags
, &rc
);
1064 test_compare(MEMCACHED_SUCCESS
, rc
);
1065 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1066 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1067 test_strcmp(READ_THROUGH_VALUE
, string
);
1070 string
= memcached_get(memc
,
1071 test_literal_param(__func__
),
1072 &string_length
, &flags
, &rc
);
1074 test_compare(MEMCACHED_SUCCESS
, rc
);
1076 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1077 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1078 test_strcmp(READ_THROUGH_VALUE
, string
);
1081 return TEST_SUCCESS
;
1084 test_return_t
set_test2(memcached_st
*memc
)
1086 for (uint32_t x
= 0; x
< 10; x
++)
1088 test_compare_hint(return_value_based_on_buffering(memc
),
1090 test_literal_param("foo"),
1091 test_literal_param("train in the brain"),
1092 time_t(0), uint32_t(0)),
1093 memcached_last_error_message(memc
));
1096 return TEST_SUCCESS
;
1099 test_return_t
set_test3(memcached_st
*memc
)
1101 size_t value_length
= 8191;
1103 libtest::vchar_t value
;
1104 value
.reserve(value_length
);
1105 for (uint32_t x
= 0; x
< value_length
; x
++)
1107 value
.push_back(char(x
% 127));
1110 /* The dump test relies on there being at least 32 items in memcached */
1111 for (uint32_t x
= 0; x
< 32; x
++)
1115 snprintf(key
, sizeof(key
), "foo%u", x
);
1117 uint64_t query_id
= memcached_query_id(memc
);
1118 test_compare_hint(return_value_based_on_buffering(memc
),
1119 memcached_set(memc
, key
, strlen(key
),
1120 &value
[0], value
.size(),
1121 time_t(0), uint32_t(0)),
1122 memcached_last_error_message(memc
));
1123 test_compare(query_id
+1, memcached_query_id(memc
));
1126 return TEST_SUCCESS
;
1129 test_return_t
mget_end(memcached_st
*memc
)
1131 const char *keys
[]= { "foo", "foo2" };
1132 size_t lengths
[]= { 3, 4 };
1133 const char *values
[]= { "fjord", "41" };
1136 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1138 test_compare(MEMCACHED_SUCCESS
,
1140 keys
[x
], lengths
[x
],
1141 values
[x
], strlen(values
[x
]),
1142 time_t(0), uint32_t(0)));
1146 size_t string_length
;
1149 // retrieve both via mget
1150 test_compare(MEMCACHED_SUCCESS
,
1151 memcached_mget(memc
,
1153 test_array_length(keys
)));
1155 char key
[MEMCACHED_MAX_KEY
];
1157 memcached_return_t rc
;
1159 // this should get both
1160 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1162 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1164 test_compare(MEMCACHED_SUCCESS
, rc
);
1166 if (key_length
== 4)
1171 test_compare(string_length
, strlen(values
[val
]));
1172 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1176 // this should indicate end
1177 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1178 test_compare(MEMCACHED_END
, rc
);
1182 test_compare(MEMCACHED_SUCCESS
,
1183 memcached_mget(memc
, keys
, lengths
, 1));
1185 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1186 test_compare(key_length
, lengths
[0]);
1187 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1188 test_compare(string_length
, strlen(values
[0]));
1189 test_true(strncmp(values
[0], string
, string_length
) == 0);
1190 test_compare(MEMCACHED_SUCCESS
, rc
);
1193 // this should indicate end
1194 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1195 test_compare(MEMCACHED_END
, rc
);
1198 return TEST_SUCCESS
;
1201 /* Do not copy the style of this code, I just access hosts to testthis function */
1202 test_return_t
stats_servername_test(memcached_st
*memc
)
1204 memcached_stat_st memc_stat
;
1205 memcached_server_instance_st instance
=
1206 memcached_server_instance_by_position(memc
, 0);
1208 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1210 return TEST_SKIPPED
;
1213 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1214 memcached_server_name(instance
),
1215 memcached_server_port(instance
)));
1217 return TEST_SUCCESS
;
1220 test_return_t
increment_test(memcached_st
*memc
)
1222 uint64_t new_number
;
1224 test_compare(MEMCACHED_SUCCESS
,
1226 test_literal_param("number"),
1227 test_literal_param("0"),
1228 (time_t)0, (uint32_t)0));
1230 test_compare(MEMCACHED_SUCCESS
,
1231 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1232 test_compare(uint64_t(1), new_number
);
1234 test_compare(MEMCACHED_SUCCESS
,
1235 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1236 test_compare(uint64_t(2), new_number
);
1238 return TEST_SUCCESS
;
1241 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1243 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1245 uint64_t new_number
;
1246 uint64_t initial
= 0;
1248 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1250 test_compare(MEMCACHED_SUCCESS
,
1251 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1252 test_compare(new_number
, initial
);
1254 test_compare(MEMCACHED_SUCCESS
,
1255 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1256 test_compare(new_number
, (initial
+1));
1258 return TEST_SUCCESS
;
1261 test_return_t
decrement_test(memcached_st
*memc
)
1263 test_compare(return_value_based_on_buffering(memc
),
1265 test_literal_param(__func__
),
1266 test_literal_param("3"),
1267 time_t(0), uint32_t(0)));
1268 // Make sure we flush the value we just set
1269 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1271 uint64_t new_number
;
1272 test_compare(MEMCACHED_SUCCESS
,
1273 memcached_decrement(memc
,
1274 test_literal_param(__func__
),
1276 test_compare(uint64_t(2), new_number
);
1278 test_compare(MEMCACHED_SUCCESS
,
1279 memcached_decrement(memc
,
1280 test_literal_param(__func__
),
1282 test_compare(uint64_t(1), new_number
);
1284 return TEST_SUCCESS
;
1287 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1289 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1291 uint64_t initial
= 3;
1293 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1295 uint64_t new_number
;
1296 test_compare(MEMCACHED_SUCCESS
,
1297 memcached_decrement_with_initial(memc
,
1298 test_literal_param(__func__
),
1301 test_compare(new_number
, initial
);
1303 test_compare(MEMCACHED_SUCCESS
,
1304 memcached_decrement_with_initial(memc
,
1305 test_literal_param(__func__
),
1308 test_compare(new_number
, (initial
- 1));
1310 return TEST_SUCCESS
;
1313 test_return_t
increment_by_key_test(memcached_st
*memc
)
1315 const char *master_key
= "foo";
1316 const char *key
= "number";
1317 const char *value
= "0";
1319 test_compare(return_value_based_on_buffering(memc
),
1320 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1322 value
, strlen(value
),
1323 time_t(0), uint32_t(0)));
1325 // Make sure we flush the value we just set
1326 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1328 uint64_t new_number
;
1329 test_compare(MEMCACHED_SUCCESS
,
1330 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1331 key
, strlen(key
), 1, &new_number
));
1332 test_compare(uint64_t(1), new_number
);
1334 test_compare(MEMCACHED_SUCCESS
,
1335 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1336 key
, strlen(key
), 1, &new_number
));
1337 test_compare(uint64_t(2), new_number
);
1339 return TEST_SUCCESS
;
1342 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1344 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1346 uint64_t new_number
;
1347 const char *master_key
= "foo";
1348 const char *key
= "number";
1349 uint64_t initial
= 0;
1351 test_compare(MEMCACHED_SUCCESS
,
1352 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1354 1, initial
, 0, &new_number
));
1355 test_compare(new_number
, initial
);
1357 test_compare(MEMCACHED_SUCCESS
,
1358 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1360 1, initial
, 0, &new_number
));
1361 test_compare(new_number
, (initial
+1));
1363 return TEST_SUCCESS
;
1366 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1368 uint64_t new_number
;
1369 const char *value
= "3";
1371 test_compare(return_value_based_on_buffering(memc
),
1372 memcached_set_by_key(memc
,
1373 test_literal_param("foo"),
1374 test_literal_param("number"),
1375 value
, strlen(value
),
1376 (time_t)0, (uint32_t)0));
1378 test_compare(MEMCACHED_SUCCESS
,
1379 memcached_decrement_by_key(memc
,
1380 test_literal_param("foo"),
1381 test_literal_param("number"),
1383 test_compare(uint64_t(2), new_number
);
1385 test_compare(MEMCACHED_SUCCESS
,
1386 memcached_decrement_by_key(memc
,
1387 test_literal_param("foo"),
1388 test_literal_param("number"),
1390 test_compare(uint64_t(1), new_number
);
1392 return TEST_SUCCESS
;
1395 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1397 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1399 uint64_t new_number
;
1400 uint64_t initial
= 3;
1402 test_compare(MEMCACHED_SUCCESS
,
1403 memcached_decrement_with_initial_by_key(memc
,
1404 test_literal_param("foo"),
1405 test_literal_param("number"),
1406 1, initial
, 0, &new_number
));
1407 test_compare(new_number
, initial
);
1409 test_compare(MEMCACHED_SUCCESS
,
1410 memcached_decrement_with_initial_by_key(memc
,
1411 test_literal_param("foo"),
1412 test_literal_param("number"),
1413 1, initial
, 0, &new_number
));
1414 test_compare(new_number
, (initial
- 1));
1416 return TEST_SUCCESS
;
1418 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1420 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1422 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1424 test_compare(return_value_based_on_buffering(memc
),
1426 test_literal_param("number"),
1427 test_literal_param("0"),
1428 (time_t)0, (uint32_t)0));
1430 uint64_t new_number
;
1431 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1432 test_literal_param("number"),
1434 test_compare(uint64_t(1), new_number
);
1436 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1437 test_literal_param("number"),
1439 test_compare(uint64_t(2), new_number
);
1441 return TEST_SUCCESS
;
1444 test_return_t
quit_test(memcached_st
*memc
)
1446 const char *value
= "sanford and sun";
1448 test_compare_hint(return_value_based_on_buffering(memc
),
1450 test_literal_param(__func__
),
1451 value
, strlen(value
),
1452 (time_t)10, (uint32_t)3),
1453 memcached_last_error_message(memc
));
1454 memcached_quit(memc
);
1456 test_compare_hint(return_value_based_on_buffering(memc
),
1458 test_literal_param(__func__
),
1459 value
, strlen(value
),
1460 (time_t)50, (uint32_t)9),
1461 memcached_last_error_message(memc
));
1463 return TEST_SUCCESS
;
1466 test_return_t
mget_result_test(memcached_st
*memc
)
1468 const char *keys
[]= {"fudge", "son", "food"};
1469 size_t key_length
[]= {5, 3, 4};
1471 memcached_result_st results_obj
;
1472 memcached_result_st
*results
;
1474 results
= memcached_result_create(memc
, &results_obj
);
1476 test_true(&results_obj
== results
);
1478 /* We need to empty the server before continueing test */
1479 test_compare(MEMCACHED_SUCCESS
,
1480 memcached_flush(memc
, 0));
1482 test_compare(MEMCACHED_SUCCESS
,
1483 memcached_mget(memc
, keys
, key_length
, 3));
1485 memcached_return_t rc
;
1486 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1491 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1492 test_false(results
);
1493 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1495 for (uint32_t x
= 0; x
< 3; x
++)
1497 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1498 keys
[x
], key_length
[x
],
1499 (time_t)50, (uint32_t)9);
1500 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1503 test_compare(MEMCACHED_SUCCESS
,
1504 memcached_mget(memc
, keys
, key_length
, 3));
1506 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1509 test_true(&results_obj
== results
);
1510 test_compare(MEMCACHED_SUCCESS
, rc
);
1511 test_memcmp(memcached_result_key_value(results
),
1512 memcached_result_value(results
),
1513 memcached_result_length(results
));
1514 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1517 memcached_result_free(&results_obj
);
1519 return TEST_SUCCESS
;
1522 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1524 const char *keys
[]= {"fudge", "son", "food"};
1525 size_t key_length
[]= {5, 3, 4};
1527 memcached_result_st
*results
;
1529 /* We need to empty the server before continueing test */
1530 test_compare(MEMCACHED_SUCCESS
,
1531 memcached_flush(memc
, 0));
1533 test_compare(MEMCACHED_SUCCESS
,
1534 memcached_mget(memc
, keys
, key_length
, 3));
1536 memcached_return_t rc
;
1537 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1541 test_false(results
);
1542 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1544 for (uint32_t x
= 0; x
< 3; x
++)
1546 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1547 keys
[x
], key_length
[x
],
1548 (time_t)50, (uint32_t)9);
1549 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1552 test_compare(MEMCACHED_SUCCESS
,
1553 memcached_mget(memc
, keys
, key_length
, 3));
1556 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1559 test_compare(MEMCACHED_SUCCESS
, rc
);
1560 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1561 test_memcmp(memcached_result_key_value(results
),
1562 memcached_result_value(results
),
1563 memcached_result_length(results
));
1564 memcached_result_free(results
);
1568 return TEST_SUCCESS
;
1571 test_return_t
mget_result_function(memcached_st
*memc
)
1573 const char *keys
[]= {"fudge", "son", "food"};
1574 size_t key_length
[]= {5, 3, 4};
1576 memcached_execute_fn callbacks
[1];
1578 for (uint32_t x
= 0; x
< 3; x
++)
1580 test_compare(return_value_based_on_buffering(memc
),
1581 memcached_set(memc
, keys
[x
], key_length
[x
],
1582 keys
[x
], key_length
[x
],
1583 time_t(50), uint32_t(9)));
1585 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1586 memcached_quit(memc
);
1588 test_compare(MEMCACHED_SUCCESS
,
1589 memcached_mget(memc
, keys
, key_length
, 3));
1591 callbacks
[0]= &callback_counter
;
1594 test_compare(MEMCACHED_SUCCESS
,
1595 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1597 test_compare(size_t(3), counter
);
1599 return TEST_SUCCESS
;
1602 test_return_t
mget_test(memcached_st
*memc
)
1604 const char *keys
[]= {"fudge", "son", "food"};
1605 size_t key_length
[]= {5, 3, 4};
1607 char return_key
[MEMCACHED_MAX_KEY
];
1608 size_t return_key_length
;
1610 size_t return_value_length
;
1612 test_compare(MEMCACHED_SUCCESS
,
1613 memcached_mget(memc
, keys
, key_length
, 3));
1616 memcached_return_t rc
;
1617 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1618 &return_value_length
, &flags
, &rc
)))
1620 test_true(return_value
);
1622 test_false(return_value
);
1623 test_zero(return_value_length
);
1624 test_compare(MEMCACHED_NOTFOUND
, rc
);
1626 for (uint32_t x
= 0; x
< 3; x
++)
1628 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1629 keys
[x
], key_length
[x
],
1630 (time_t)50, (uint32_t)9);
1631 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1633 test_compare(MEMCACHED_SUCCESS
,
1634 memcached_mget(memc
, keys
, key_length
, 3));
1637 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1638 &return_value_length
, &flags
, &rc
)))
1640 test_true(return_value
);
1641 test_compare(MEMCACHED_SUCCESS
, rc
);
1642 if (not memc
->_namespace
)
1644 test_compare(return_key_length
, return_value_length
);
1645 test_memcmp(return_value
, return_key
, return_value_length
);
1651 return TEST_SUCCESS
;
1654 test_return_t
mget_execute(memcached_st
*original_memc
)
1656 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1658 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1661 keys_st
keys(20480);
1663 /* First add all of the items.. */
1664 char blob
[1024] = {0};
1666 for (size_t x
= 0; x
< keys
.size(); ++x
)
1668 uint64_t query_id
= memcached_query_id(memc
);
1669 memcached_return_t rc
= memcached_add(memc
,
1670 keys
.key_at(x
), keys
.length_at(x
),
1673 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
,
1674 memcached_last_error_message(memc
));
1675 test_compare(query_id
+1, memcached_query_id(memc
));
1678 /* Try to get all of them with a large multiget */
1680 memcached_execute_fn callbacks
[]= { &callback_counter
};
1681 test_compare(MEMCACHED_SUCCESS
,
1682 memcached_mget_execute(memc
,
1683 keys
.keys_ptr(), keys
.lengths_ptr(),
1684 keys
.size(), callbacks
, &counter
, 1));
1687 uint64_t query_id
= memcached_query_id(memc
);
1688 test_compare(MEMCACHED_SUCCESS
,
1689 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1690 test_compare(query_id
, memcached_query_id(memc
));
1692 /* Verify that we got all of the items */
1693 test_compare(keys
.size(), counter
);
1696 memcached_free(memc
);
1698 return TEST_SUCCESS
;
1701 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1702 static pairs_st
*global_pairs
;
1704 test_return_t
key_setup(memcached_st
*memc
)
1706 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1708 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1710 return TEST_SUCCESS
;
1713 test_return_t
key_teardown(memcached_st
*)
1715 pairs_free(global_pairs
);
1717 return TEST_SUCCESS
;
1720 test_return_t
block_add_regression(memcached_st
*memc
)
1722 /* First add all of the items.. */
1723 for (ptrdiff_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1725 char blob
[1024] = {0};
1727 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);
1728 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
, memcached_strerror(NULL
, rc
));
1731 return TEST_SUCCESS
;
1734 test_return_t
binary_add_regression(memcached_st
*memc
)
1736 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1737 test_return_t rc
= block_add_regression(memc
);
1742 test_return_t
get_stats_keys(memcached_st
*memc
)
1746 memcached_stat_st memc_stat
;
1747 memcached_return_t rc
;
1749 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1750 test_compare(MEMCACHED_SUCCESS
, rc
);
1751 for (ptr
= stat_list
; *ptr
; ptr
++)
1756 return TEST_SUCCESS
;
1759 test_return_t
version_string_test(memcached_st
*)
1761 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1763 return TEST_SUCCESS
;
1766 test_return_t
get_stats(memcached_st
*memc
)
1768 memcached_return_t rc
;
1770 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1771 test_compare(MEMCACHED_SUCCESS
, rc
);
1772 test_true(memc_stat
);
1774 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1776 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1777 test_compare(MEMCACHED_SUCCESS
, rc
);
1778 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1783 memcached_stat_free(NULL
, memc_stat
);
1785 return TEST_SUCCESS
;
1788 test_return_t
add_host_test(memcached_st
*memc
)
1790 char servername
[]= "0.example.com";
1792 memcached_return_t rc
;
1793 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1794 test_compare(1U, memcached_server_list_count(servers
));
1796 for (unsigned int x
= 2; x
< 20; x
++)
1798 char buffer
[SMALL_STRING_LEN
];
1800 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1801 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1803 test_compare(MEMCACHED_SUCCESS
, rc
);
1804 test_compare(x
, memcached_server_list_count(servers
));
1807 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1808 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1810 memcached_server_list_free(servers
);
1812 return TEST_SUCCESS
;
1815 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1817 memcached_return_t rc
;
1819 const char *key
= "not_found";
1820 size_t key_length
= test_literal_param_size("not_found");
1822 test_compare(MEMCACHED_SUCCESS
,
1823 memcached_mget(memc
, &key
, &key_length
, 1));
1825 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1827 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1829 memcached_result_free(result
);
1831 return TEST_SUCCESS
;
1834 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1836 return MEMCACHED_SUCCESS
;
1839 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1841 return MEMCACHED_SUCCESS
;
1844 test_return_t
callback_test(memcached_st
*memc
)
1846 /* Test User Data */
1850 memcached_return_t rc
;
1852 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1853 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1854 test_true(*test_ptr
== x
);
1857 /* Test Clone Callback */
1859 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1860 void *clone_cb_ptr
= *(void **)&clone_cb
;
1861 void *temp_function
= NULL
;
1863 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
1864 memcached_return_t rc
;
1865 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1866 test_true(temp_function
== clone_cb_ptr
);
1867 test_compare(MEMCACHED_SUCCESS
, rc
);
1870 /* Test Cleanup Callback */
1872 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
1873 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1874 void *temp_function
= NULL
;
1875 memcached_return_t rc
;
1877 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
1878 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1879 test_true(temp_function
== cleanup_cb_ptr
);
1882 return TEST_SUCCESS
;
1885 /* We don't test the behavior itself, we test the switches */
1886 test_return_t
behavior_test(memcached_st
*memc
)
1888 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
1889 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
1891 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
1892 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
1894 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
1895 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1897 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
1898 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
1900 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
1901 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
1903 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
1904 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1906 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
1907 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1909 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
1911 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
1913 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
1914 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
1915 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
1917 return TEST_SUCCESS
;
1920 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
1922 test_compare(MEMCACHED_DEPRECATED
,
1923 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
1925 // Platform dependent
1927 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
1931 return TEST_SUCCESS
;
1935 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
1937 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
1938 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
1940 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
1942 if (memcached_success(rc
))
1951 return TEST_SUCCESS
;
1955 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
1957 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
1958 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
1960 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
1962 if (memcached_success(rc
))
1971 return TEST_SUCCESS
;
1974 /* Make sure we behave properly if server list has no values */
1975 test_return_t
user_supplied_bug4(memcached_st
*memc
)
1977 const char *keys
[]= {"fudge", "son", "food"};
1978 size_t key_length
[]= {5, 3, 4};
1980 /* Here we free everything before running a bunch of mget tests */
1981 memcached_servers_reset(memc
);
1984 /* We need to empty the server before continueing test */
1985 test_compare(MEMCACHED_NO_SERVERS
,
1986 memcached_flush(memc
, 0));
1988 test_compare(MEMCACHED_NO_SERVERS
,
1989 memcached_mget(memc
, keys
, key_length
, 3));
1992 unsigned int keys_returned
;
1993 memcached_return_t rc
;
1994 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
1995 test_compare(MEMCACHED_NOTFOUND
, rc
);
1996 test_zero(keys_returned
);
1999 for (uint32_t x
= 0; x
< 3; x
++)
2001 test_compare(MEMCACHED_NO_SERVERS
,
2002 memcached_set(memc
, keys
[x
], key_length
[x
],
2003 keys
[x
], key_length
[x
],
2004 (time_t)50, (uint32_t)9));
2007 test_compare(MEMCACHED_NO_SERVERS
,
2008 memcached_mget(memc
, keys
, key_length
, 3));
2012 char return_key
[MEMCACHED_MAX_KEY
];
2013 memcached_return_t rc
;
2014 size_t return_key_length
;
2015 size_t return_value_length
;
2018 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2019 &return_value_length
, &flags
, &rc
)))
2021 test_true(return_value
);
2022 test_compare(MEMCACHED_SUCCESS
, rc
);
2023 test_true(return_key_length
== return_value_length
);
2024 test_memcmp(return_value
, return_key
, return_value_length
);
2030 return TEST_SUCCESS
;
2033 #define VALUE_SIZE_BUG5 1048064
2034 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2036 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2037 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2039 size_t value_length
;
2041 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2043 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2045 insert_data
[x
]= (signed char)rand();
2048 test_compare(MEMCACHED_SUCCESS
,
2049 memcached_flush(memc
, 0));
2051 memcached_return_t rc
;
2052 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2053 test_compare(MEMCACHED_SUCCESS
,
2054 memcached_mget(memc
, keys
, key_length
, 4));
2057 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2058 test_compare(MEMCACHED_NOTFOUND
, rc
);
2061 for (uint32_t x
= 0; x
< 4; x
++)
2063 test_compare(MEMCACHED_SUCCESS
,
2064 memcached_set(memc
, keys
[x
], key_length
[x
],
2065 insert_data
, VALUE_SIZE_BUG5
,
2066 (time_t)0, (uint32_t)0));
2069 for (uint32_t x
= 0; x
< 10; x
++)
2071 value
= memcached_get(memc
, keys
[0], key_length
[0],
2072 &value_length
, &flags
, &rc
);
2073 test_compare(rc
, MEMCACHED_SUCCESS
);
2077 test_compare(MEMCACHED_SUCCESS
,
2078 memcached_mget(memc
, keys
, key_length
, 4));
2080 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2081 test_compare(4U, count
);
2083 delete [] insert_data
;
2085 return TEST_SUCCESS
;
2088 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2090 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2091 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2092 char return_key
[MEMCACHED_MAX_KEY
];
2093 size_t return_key_length
;
2095 size_t value_length
;
2097 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2099 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2101 insert_data
[x
]= (signed char)rand();
2104 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2106 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2108 // We will now confirm that memcached_mget() returns success, but we will
2109 // then check to make sure that no actual keys are returned.
2110 test_compare(MEMCACHED_SUCCESS
,
2111 memcached_mget(memc
, keys
, key_length
, 4));
2113 memcached_return_t rc
;
2115 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2116 &value_length
, &flags
, &rc
)))
2121 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2123 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2125 test_compare(MEMCACHED_SUCCESS
,
2126 memcached_set(memc
, keys
[x
], key_length
[x
],
2127 insert_data
, VALUE_SIZE_BUG5
,
2128 (time_t)0, (uint32_t)0));
2130 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2132 for (uint32_t x
= 0; x
< 2; x
++)
2134 value
= memcached_get(memc
, keys
[0], key_length
[0],
2135 &value_length
, &flags
, &rc
);
2139 test_compare(MEMCACHED_SUCCESS
,
2140 memcached_mget(memc
, keys
, key_length
, 4));
2141 /* We test for purge of partial complete fetches */
2142 for (count
= 3; count
; count
--)
2144 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2145 &value_length
, &flags
, &rc
);
2146 test_compare(MEMCACHED_SUCCESS
, rc
);
2147 test_memcmp(value
, insert_data
, value_length
);
2148 test_true(value_length
);
2152 delete [] insert_data
;
2154 return TEST_SUCCESS
;
2157 test_return_t
user_supplied_bug8(memcached_st
*)
2159 memcached_return_t rc
;
2161 memcached_st
*memc_clone
;
2163 memcached_server_st
*servers
;
2164 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";
2166 servers
= memcached_servers_parse(server_list
);
2169 mine
= memcached_create(NULL
);
2170 rc
= memcached_server_push(mine
, servers
);
2171 test_compare(MEMCACHED_SUCCESS
, rc
);
2172 memcached_server_list_free(servers
);
2175 memc_clone
= memcached_clone(NULL
, mine
);
2177 memcached_quit(mine
);
2178 memcached_quit(memc_clone
);
2181 memcached_free(mine
);
2182 memcached_free(memc_clone
);
2184 return TEST_SUCCESS
;
2187 /* Test flag store/retrieve */
2188 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2190 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2191 test_true(insert_data
);
2193 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2195 insert_data
[x
]= (signed char)rand();
2198 memcached_flush(memc
, 0);
2200 const char *keys
= "036790384900";
2201 size_t key_length
= strlen(keys
);
2202 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2203 insert_data
, VALUE_SIZE_BUG5
,
2205 memcached_last_error_message(memc
));
2207 memcached_return_t rc
;
2208 size_t value_length
;
2210 char *value
= memcached_get(memc
, keys
, key_length
,
2211 &value_length
, &flags
, &rc
);
2212 test_compare(245U, flags
);
2216 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2218 char return_key
[MEMCACHED_MAX_KEY
];
2219 size_t return_key_length
;
2221 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2222 &value_length
, &flags
, &rc
);
2223 test_compare(uint32_t(245), flags
);
2226 delete [] insert_data
;
2229 return TEST_SUCCESS
;
2232 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2234 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2235 size_t key_length
[3];
2239 char return_key
[MEMCACHED_MAX_KEY
];
2240 size_t return_key_length
;
2242 size_t return_value_length
;
2245 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2246 key_length
[1]= strlen("fudge&*@#");
2247 key_length
[2]= strlen("for^#@&$not");
2250 for (unsigned int x
= 0; x
< 3; x
++)
2252 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2253 keys
[x
], key_length
[x
],
2254 (time_t)50, (uint32_t)9);
2255 test_compare(MEMCACHED_SUCCESS
, rc
);
2258 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2259 test_compare(MEMCACHED_SUCCESS
, rc
);
2261 /* We need to empty the server before continueing test */
2262 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2263 &return_value_length
, &flags
, &rc
)) != NULL
)
2265 test_true(return_value
);
2269 test_compare(3U, count
);
2271 return TEST_SUCCESS
;
2274 /* We are testing with aggressive timeout to get failures */
2275 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2277 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
2279 size_t value_length
= 512;
2280 unsigned int set
= 1;
2281 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2283 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2284 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2285 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2287 libtest::vchar_t value
;
2288 value
.reserve(value_length
);
2289 for (uint32_t x
= 0; x
< value_length
; x
++)
2291 value
.push_back(char(x
% 127));
2294 for (unsigned int x
= 1; x
<= 100000; ++x
)
2296 memcached_return_t rc
= memcached_set(mclone
,
2297 test_literal_param("foo"),
2298 &value
[0], value
.size(),
2301 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2302 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2303 memcached_strerror(NULL
, rc
));
2305 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2311 memcached_free(mclone
);
2313 return TEST_SUCCESS
;
2317 We are looking failures in the async protocol
2319 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2321 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2323 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2324 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2325 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2327 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2330 libtest::vchar_t value
;
2332 for (unsigned int x
= 0; x
< 512; x
++)
2334 value
.push_back(char(x
% 127));
2337 for (unsigned int x
= 1; x
<= 100000; ++x
)
2339 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2343 memcached_free(mclone
);
2345 return TEST_SUCCESS
;
2349 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2351 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2353 memcached_return_t rc
;
2355 size_t value_length
;
2357 uint64_t number_value
;
2359 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2360 &value_length
, &flags
, &rc
);
2362 test_compare(MEMCACHED_NOTFOUND
, rc
);
2364 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2367 /* The binary protocol will set the key if it doesn't exist */
2368 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2370 test_compare(MEMCACHED_SUCCESS
, rc
);
2374 test_compare(MEMCACHED_NOTFOUND
, rc
);
2377 test_compare(MEMCACHED_SUCCESS
,
2378 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2380 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2384 test_compare(MEMCACHED_SUCCESS
,
2385 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2386 test_compare(2UL, number_value
);
2388 return TEST_SUCCESS
;
2392 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2393 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2395 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2397 char key
[] = "key34567890";
2399 char commandFirst
[]= "set key34567890 0 0 ";
2400 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2401 size_t commandLength
;
2403 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2405 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2407 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2409 char *overflow
= new (std::nothrow
) char[testSize
];
2410 test_true(overflow
);
2412 memset(overflow
, 'x', testSize
);
2413 test_compare(MEMCACHED_SUCCESS
,
2414 memcached_set(memc
, key
, strlen(key
),
2415 overflow
, testSize
, 0, 0));
2419 return TEST_SUCCESS
;
2424 Test values of many different sizes
2425 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2426 set key34567890 0 0 8169 \r\n
2427 is sent followed by buffer of size 8169, followed by 8169
2429 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2431 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2433 libtest::vchar_t value
;
2434 value
.reserve(18000);
2435 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2437 value
.push_back((char) (x
% 127));
2440 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2442 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2443 &value
[0], current_length
,
2444 (time_t)0, (uint32_t)0);
2445 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2447 size_t string_length
;
2449 char *string
= memcached_get(memc
, test_literal_param("foo"),
2450 &string_length
, &flags
, &rc
);
2452 test_compare(MEMCACHED_SUCCESS
, rc
);
2453 test_compare(string_length
, current_length
);
2455 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2456 test_memcmp_hint(string
, &value
[0], string_length
, buffer
);
2461 return TEST_SUCCESS
;
2465 Look for zero length value problems
2467 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2469 for (uint32_t x
= 0; x
< 2; x
++)
2471 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2473 (time_t)0, (uint32_t)0);
2475 test_compare(MEMCACHED_SUCCESS
, rc
);
2479 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2480 &length
, &flags
, &rc
);
2482 test_compare(MEMCACHED_SUCCESS
, rc
);
2487 value
= memcached_get(memc
, test_literal_param("mykey"),
2488 &length
, &flags
, &rc
);
2490 test_compare(MEMCACHED_SUCCESS
, rc
);
2496 return TEST_SUCCESS
;
2499 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2500 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2502 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2504 (time_t)0, UINT32_MAX
),
2505 memcached_last_error_message(memc
));
2510 memcached_return_t rc
;
2511 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2512 &length
, &flags
, &rc
);
2514 test_compare(MEMCACHED_SUCCESS
, rc
);
2517 test_compare(flags
, UINT32_MAX
);
2519 return TEST_SUCCESS
;
2522 #if !defined(__sun) && !defined(__OpenBSD__)
2523 /* Check the validity of chinese key*/
2524 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2526 const char *key
= "豆瓣";
2527 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2528 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2529 value
, strlen(value
),
2532 test_compare(MEMCACHED_SUCCESS
, rc
);
2536 char *value2
= memcached_get(memc
, key
, strlen(key
),
2537 &length
, &flags
, &rc
);
2539 test_true(length
==strlen(value
));
2540 test_compare(MEMCACHED_SUCCESS
, rc
);
2541 test_memcmp(value
, value2
, length
);
2544 return TEST_SUCCESS
;
2552 test_return_t
user_supplied_bug19(memcached_st
*)
2554 memcached_return_t res
;
2556 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2558 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2561 memcached_free(memc
);
2563 return TEST_SUCCESS
;
2566 /* CAS test from Andei */
2567 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2569 const char *key
= "abc";
2570 size_t key_len
= strlen("abc");
2572 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2574 test_compare(MEMCACHED_SUCCESS
,
2576 test_literal_param("abc"),
2577 test_literal_param("foobar"),
2578 (time_t)0, (uint32_t)0));
2580 test_compare(MEMCACHED_SUCCESS
,
2581 memcached_mget(memc
, &key
, &key_len
, 1));
2583 memcached_result_st result_obj
;
2584 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2587 memcached_result_create(memc
, &result_obj
);
2588 memcached_return_t status
;
2589 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2592 test_compare(MEMCACHED_SUCCESS
, status
);
2594 memcached_result_free(result
);
2596 return TEST_SUCCESS
;
2599 /* Large mget() of missing keys with binary proto
2601 * If many binary quiet commands (such as getq's in an mget) fill the output
2602 * buffer and the server chooses not to respond, memcached_flush hangs. See
2603 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2606 /* sighandler_t function that always asserts false */
2607 static void fail(int)
2613 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2618 return TEST_SKIPPED
;
2620 void (*oldalarm
)(int);
2622 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2623 test_true(memc_clone
);
2625 /* only binproto uses getq for mget */
2626 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2628 /* empty the cache to ensure misses (hence non-responses) */
2629 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2631 keys_st
keys(key_count
);
2633 oldalarm
= signal(SIGALRM
, fail
);
2636 test_compare_got(MEMCACHED_SUCCESS
,
2637 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2638 memcached_last_error_message(memc_clone
));
2641 signal(SIGALRM
, oldalarm
);
2643 memcached_return_t rc
;
2645 char return_key
[MEMCACHED_MAX_KEY
];
2646 size_t return_key_length
;
2648 size_t return_value_length
;
2649 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2650 &return_value_length
, &flags
, &rc
)))
2652 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2654 test_compare(MEMCACHED_NOTFOUND
, rc
);
2655 test_zero(return_value_length
);
2656 test_zero(return_key_length
);
2657 test_false(return_key
[0]);
2658 test_false(return_value
);
2660 memcached_free(memc_clone
);
2662 return TEST_SUCCESS
;
2666 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2668 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2670 /* should work as of r580 */
2671 test_compare(TEST_SUCCESS
,
2672 _user_supplied_bug21(memc
, 10));
2674 /* should fail as of r580 */
2675 test_compare(TEST_SUCCESS
,
2676 _user_supplied_bug21(memc
, 1000));
2678 return TEST_SUCCESS
;
2681 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2683 memcached_st
*memc
= memcached_create(NULL
);
2687 test_compare(MEMCACHED_SUCCESS
,
2688 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2690 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2691 test_compare(value
, uint64_t(1));
2693 test_compare(MEMCACHED_SUCCESS
,
2694 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2696 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2697 test_true(value
== MEMCACHED_HASH_MD5
);
2700 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2702 memcached_server_st
*server_pool
;
2703 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");
2704 memcached_server_push(memc
, server_pool
);
2706 // @todo this needs to be refactored to actually test something.
2709 if ((fp
= fopen("ketama_keys.txt", "w")))
2713 printf("cannot write to file ketama_keys.txt");
2714 return TEST_FAILURE
;
2717 for (int x
= 0; x
< 10000; x
++)
2720 snprintf(key
, sizeof(key
), "%d", x
);
2722 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2723 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2724 in_port_t port
= memc
->hosts
[server_idx
].port
;
2725 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2726 memcached_server_instance_st instance
=
2727 memcached_server_instance_by_position(memc
, host_index
);
2731 memcached_server_list_free(server_pool
);
2732 memcached_free(memc
);
2734 return TEST_SUCCESS
;
2738 test_return_t
result_static(memcached_st
*memc
)
2740 memcached_result_st result
;
2741 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
2742 test_false(result
.options
.is_allocated
);
2743 test_true(memcached_is_initialized(&result
));
2744 test_true(result_ptr
);
2745 test_true(result_ptr
== &result
);
2747 memcached_result_free(&result
);
2749 test_false(result
.options
.is_allocated
);
2750 test_false(memcached_is_initialized(&result
));
2752 return TEST_SUCCESS
;
2755 test_return_t
result_alloc(memcached_st
*memc
)
2757 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
2758 test_true(result_ptr
);
2759 test_true(result_ptr
->options
.is_allocated
);
2760 test_true(memcached_is_initialized(result_ptr
));
2761 memcached_result_free(result_ptr
);
2763 return TEST_SUCCESS
;
2767 test_return_t
add_host_test1(memcached_st
*memc
)
2769 memcached_return_t rc
;
2770 char servername
[]= "0.example.com";
2772 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2774 test_compare(1U, memcached_server_list_count(servers
));
2776 for (uint32_t x
= 2; x
< 20; x
++)
2778 char buffer
[SMALL_STRING_LEN
];
2780 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
2781 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2783 test_compare(MEMCACHED_SUCCESS
, rc
);
2784 test_compare(x
, memcached_server_list_count(servers
));
2787 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2788 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2790 memcached_server_list_free(servers
);
2792 return TEST_SUCCESS
;
2796 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
2800 #ifdef HARD_MALLOC_TESTS
2801 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
2809 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
2813 #ifdef HARD_MALLOC_TESTS
2814 void *ret
= malloc(size
+ 8);
2817 ret
= (void*)((caddr_t
)ret
+ 8);
2820 void *ret
= malloc(size
);
2825 memset(ret
, 0xff, size
);
2832 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
2834 #ifdef HARD_MALLOC_TESTS
2835 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
2836 void *nmem
= realloc(real_ptr
, size
+ 8);
2841 ret
= (void*)((caddr_t
)nmem
+ 8);
2847 return realloc(mem
, size
);
2852 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
2854 #ifdef HARD_MALLOC_TESTS
2855 void *mem
= my_malloc(ptr
, nelem
* size
);
2858 memset(mem
, 0, nelem
* size
);
2864 return calloc(nelem
, size
);
2868 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
2870 memcached_return_t rc
;
2871 const char *key
= "mine";
2874 /* Make sure be default none exists */
2875 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2877 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2879 /* Test a clean set */
2880 test_compare(MEMCACHED_SUCCESS
,
2881 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2883 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2885 test_memcmp(value
, key
, 4);
2886 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2888 /* Test that we can turn it off */
2889 test_compare(MEMCACHED_SUCCESS
,
2890 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
2892 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2894 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2896 /* Now setup for main test */
2897 test_compare(MEMCACHED_SUCCESS
,
2898 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2900 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2902 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2903 test_memcmp(value
, key
, 4);
2905 /* Set to Zero, and then Set to something too large */
2908 memset(long_key
, 0, 255);
2910 test_compare(MEMCACHED_SUCCESS
,
2911 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
2913 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2915 test_compare(MEMCACHED_SUCCESS
, rc
);
2917 /* Test a long key for failure */
2918 /* TODO, extend test to determine based on setting, what result should be */
2919 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
2920 test_compare(MEMCACHED_SUCCESS
,
2921 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
2923 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
2924 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
2925 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
2926 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
2928 /* Test for a bad prefix, but with a short key */
2929 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
2930 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
2932 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
2933 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
2936 return TEST_SUCCESS
;
2939 test_return_t
set_namespace(memcached_st
*memc
)
2941 memcached_return_t rc
;
2942 const char *key
= "mine";
2945 // Make sure we default to a null namespace
2946 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2948 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2950 /* Test a clean set */
2951 test_compare(MEMCACHED_SUCCESS
,
2952 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2954 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2956 test_memcmp(value
, key
, 4);
2957 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2959 return TEST_SUCCESS
;
2962 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
2964 test_return_if(pre_binary(memc
));
2965 test_return_if(set_namespace(memc
));
2967 return TEST_SUCCESS
;
2970 #ifdef MEMCACHED_ENABLE_DEPRECATED
2971 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
2973 void *test_ptr
= NULL
;
2976 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
2977 cb_ptr
= *(void **)&malloc_cb
;
2978 memcached_return_t rc
;
2980 test_compare(MEMCACHED_SUCCESS
,
2981 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
2982 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
2983 test_compare(MEMCACHED_SUCCESS
, rc
);
2984 test_true(test_ptr
== cb_ptr
);
2988 memcached_realloc_fn realloc_cb
=
2989 (memcached_realloc_fn
)my_realloc
;
2990 cb_ptr
= *(void **)&realloc_cb
;
2991 memcached_return_t rc
;
2993 test_compare(MEMCACHED_SUCCESS
,
2994 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
2995 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
2996 test_compare(MEMCACHED_SUCCESS
, rc
);
2997 test_true(test_ptr
== cb_ptr
);
3001 memcached_free_fn free_cb
=
3002 (memcached_free_fn
)my_free
;
3003 cb_ptr
= *(void **)&free_cb
;
3004 memcached_return_t rc
;
3006 test_compare(MEMCACHED_SUCCESS
,
3007 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3008 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3009 test_compare(MEMCACHED_SUCCESS
, rc
);
3010 test_true(test_ptr
== cb_ptr
);
3013 return TEST_SUCCESS
;
3018 test_return_t
set_memory_alloc(memcached_st
*memc
)
3020 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3021 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3022 my_realloc
, my_calloc
, NULL
));
3024 test_compare(MEMCACHED_SUCCESS
,
3025 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3026 my_realloc
, my_calloc
, NULL
));
3028 memcached_malloc_fn mem_malloc
;
3029 memcached_free_fn mem_free
;
3030 memcached_realloc_fn mem_realloc
;
3031 memcached_calloc_fn mem_calloc
;
3032 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3033 &mem_realloc
, &mem_calloc
);
3035 test_true(mem_malloc
== my_malloc
);
3036 test_true(mem_realloc
== my_realloc
);
3037 test_true(mem_calloc
== my_calloc
);
3038 test_true(mem_free
== my_free
);
3040 return TEST_SUCCESS
;
3043 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3046 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3047 memcached_hash_t hash
;
3048 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3049 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3052 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3053 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3055 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3057 if (hash
!= MEMCACHED_HASH_CRC
)
3058 return TEST_SKIPPED
;
3060 return TEST_SUCCESS
;
3063 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3066 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3067 memcached_hash_t hash
;
3068 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3069 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3074 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3075 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3077 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3079 if (hash
!= MEMCACHED_HASH_HSIEH
)
3080 return TEST_SKIPPED
;
3083 return TEST_SUCCESS
;
3086 test_return_t
enable_cas(memcached_st
*memc
)
3088 unsigned int set
= 1;
3090 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3092 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3094 return TEST_SUCCESS
;
3097 return TEST_SKIPPED
;
3100 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3102 memcached_version(memc
);
3104 memcached_server_instance_st instance
=
3105 memcached_server_instance_by_position(memc
, 0);
3107 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3108 or instance
->minor_version
> 2)
3110 return TEST_SUCCESS
;
3113 return TEST_SKIPPED
;
3116 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3118 const uint64_t timeout
= 100; // Not using, just checking that it sets
3120 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3122 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3124 return TEST_SUCCESS
;
3127 test_return_t
noreply_test(memcached_st
*memc
)
3129 test_compare(MEMCACHED_SUCCESS
,
3130 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3131 test_compare(MEMCACHED_SUCCESS
,
3132 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3133 test_compare(MEMCACHED_SUCCESS
,
3134 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3135 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3136 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3137 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3139 memcached_return_t ret
;
3140 for (int count
= 0; count
< 5; ++count
)
3142 for (size_t x
= 0; x
< 100; ++x
)
3144 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3145 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3146 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3148 size_t len
= (size_t)check_length
;
3153 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3156 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3159 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3162 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3165 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3171 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3172 memcached_strerror(NULL
, ret
));
3176 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3177 ** API and is _ONLY_ done this way to verify that the library works the
3178 ** way it is supposed to do!!!!
3182 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3184 memcached_server_instance_st instance
=
3185 memcached_server_instance_by_position(memc
, x
);
3186 no_msg
+=(int)(instance
->cursor_active
);
3189 test_true(no_msg
== 0);
3191 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3194 ** Now validate that all items was set properly!
3196 for (size_t x
= 0; x
< 100; ++x
)
3200 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3202 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3204 size_t len
= (size_t)check_length
;
3207 char* value
=memcached_get(memc
, key
, strlen(key
),
3208 &length
, &flags
, &ret
);
3209 // For the moment we will just go to the next key
3210 if (MEMCACHED_TIMEOUT
== ret
)
3214 test_true_hint(ret
== MEMCACHED_SUCCESS
and value
!= NULL
, memcached_last_error_message(memc
));
3217 case 0: /* FALLTHROUGH */
3218 case 1: /* FALLTHROUGH */
3220 test_true(strncmp(value
, key
, len
) == 0);
3221 test_true(len
== length
);
3224 test_true(length
== len
* 2);
3227 test_true(length
== len
* 3);
3237 /* Try setting an illegal cas value (should not return an error to
3238 * the caller (because we don't expect a return message from the server)
3240 const char* keys
[]= {"0"};
3241 size_t lengths
[]= {1};
3244 memcached_result_st results_obj
;
3245 memcached_result_st
*results
;
3246 test_compare(MEMCACHED_SUCCESS
,
3247 memcached_mget(memc
, keys
, lengths
, 1));
3249 results
= memcached_result_create(memc
, &results_obj
);
3251 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3253 test_compare(MEMCACHED_SUCCESS
, ret
);
3254 uint64_t cas
= memcached_result_cas(results
);
3255 memcached_result_free(&results_obj
);
3257 test_compare(MEMCACHED_SUCCESS
,
3258 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3261 * The item will have a new cas value, so try to set it again with the old
3262 * value. This should fail!
3264 test_compare(MEMCACHED_SUCCESS
,
3265 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3266 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3267 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3268 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3271 return TEST_SUCCESS
;
3274 test_return_t
analyzer_test(memcached_st
*memc
)
3276 memcached_analysis_st
*report
;
3277 memcached_return_t rc
;
3279 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3280 test_compare(MEMCACHED_SUCCESS
, rc
);
3281 test_true(memc_stat
);
3283 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3284 test_compare(MEMCACHED_SUCCESS
, rc
);
3288 memcached_stat_free(NULL
, memc_stat
);
3290 return TEST_SUCCESS
;
3293 test_return_t
util_version_test(memcached_st
*memc
)
3295 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
3296 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3298 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3300 // We expect failure
3303 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3304 fprintf(stderr
, "\nDumping Server Information\n\n");
3305 memcached_server_fn callbacks
[1];
3307 callbacks
[0]= dump_server_information
;
3308 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3309 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3311 test_true(if_successful
== false);
3313 memcached_server_instance_st instance
=
3314 memcached_server_instance_by_position(memc
, 0);
3316 memcached_version(memc
);
3318 // We only use one binary when we test, so this should be just fine.
3319 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3320 test_true(if_successful
== true);
3322 if (instance
->micro_version
> 0)
3324 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3326 else if (instance
->minor_version
> 0)
3328 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3330 else if (instance
->major_version
> 0)
3332 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3335 test_true(if_successful
== true);
3337 if (instance
->micro_version
> 0)
3339 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3341 else if (instance
->minor_version
> 0)
3343 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3345 else if (instance
->major_version
> 0)
3347 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3350 test_true(if_successful
== false);
3352 return TEST_SUCCESS
;
3355 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3357 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3358 memcached_return_t rc
;
3359 memcached_server_instance_st instance
=
3360 memcached_server_instance_by_position(memc
, 0);
3362 // Test both the version that returns a code, and the one that does not.
3363 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3364 memcached_server_port(instance
) -1, NULL
) == -1);
3366 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3367 memcached_server_port(instance
) -1, &rc
) == -1);
3368 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3370 return TEST_SUCCESS
;
3374 test_return_t
getpid_test(memcached_st
*memc
)
3376 memcached_return_t rc
;
3377 memcached_server_instance_st instance
=
3378 memcached_server_instance_by_position(memc
, 0);
3380 // Test both the version that returns a code, and the one that does not.
3381 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3382 memcached_server_port(instance
), NULL
) > -1);
3384 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3385 memcached_server_port(instance
), &rc
) > -1);
3386 test_compare(MEMCACHED_SUCCESS
, rc
);
3388 return TEST_SUCCESS
;
3391 test_return_t
ping_test(memcached_st
*memc
)
3393 memcached_return_t rc
;
3394 memcached_server_instance_st instance
=
3395 memcached_server_instance_by_position(memc
, 0);
3397 // Test both the version that returns a code, and the one that does not.
3398 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3399 memcached_server_port(instance
), NULL
));
3401 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3402 memcached_server_port(instance
), &rc
));
3404 test_compare(MEMCACHED_SUCCESS
, rc
);
3406 return TEST_SUCCESS
;
3411 test_return_t
hash_sanity_test (memcached_st
*memc
)
3415 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3416 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3417 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3418 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3419 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3420 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3421 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3422 #ifdef HAVE_HSIEH_HASH
3423 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3425 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3426 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3427 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3429 return TEST_SUCCESS
;
3433 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3435 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3437 test_compare(MEMCACHED_SUCCESS
,
3438 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3439 (uint64_t)MEMCACHED_HASH_HSIEH
));
3441 return TEST_SUCCESS
;
3444 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3446 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3448 test_compare(MEMCACHED_SUCCESS
,
3449 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3451 return TEST_SUCCESS
;
3454 test_return_t
one_at_a_time_run (memcached_st
*)
3459 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3461 test_compare(one_at_a_time_values
[x
],
3462 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3465 return TEST_SUCCESS
;
3468 test_return_t
md5_run (memcached_st
*)
3473 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3475 test_compare(md5_values
[x
],
3476 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3479 return TEST_SUCCESS
;
3482 test_return_t
crc_run (memcached_st
*)
3487 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3489 test_compare(crc_values
[x
],
3490 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3493 return TEST_SUCCESS
;
3496 test_return_t
fnv1_64_run (memcached_st
*)
3498 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3503 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3505 test_compare(fnv1_64_values
[x
],
3506 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3509 return TEST_SUCCESS
;
3512 test_return_t
fnv1a_64_run (memcached_st
*)
3514 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3519 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3521 test_compare(fnv1a_64_values
[x
],
3522 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3525 return TEST_SUCCESS
;
3528 test_return_t
fnv1_32_run (memcached_st
*)
3533 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3535 test_compare(fnv1_32_values
[x
],
3536 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3539 return TEST_SUCCESS
;
3542 test_return_t
fnv1a_32_run (memcached_st
*)
3547 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3549 test_compare(fnv1a_32_values
[x
],
3550 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3553 return TEST_SUCCESS
;
3556 test_return_t
hsieh_run (memcached_st
*)
3558 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3563 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3565 test_compare(hsieh_values
[x
],
3566 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3569 return TEST_SUCCESS
;
3572 test_return_t
murmur_run (memcached_st
*)
3574 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3576 #ifdef WORDS_BIGENDIAN
3577 (void)murmur_values
;
3578 return TEST_SKIPPED
;
3583 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3585 test_compare(murmur_values
[x
],
3586 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3589 return TEST_SUCCESS
;
3593 test_return_t
jenkins_run (memcached_st
*)
3598 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3600 test_compare(jenkins_values
[x
],
3601 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3604 return TEST_SUCCESS
;
3607 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3609 return libhashkit_md5(string
, string_length
);
3612 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3614 return libhashkit_crc32(string
, string_length
);
3617 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3623 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3625 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};
3626 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};
3628 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3630 hashkit_clone(&new_kit
, kit
);
3631 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3633 memcached_set_hashkit(memc
, &new_kit
);
3636 Verify Setting the hash.
3638 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3642 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3643 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3648 Now check memcached_st.
3650 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3654 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3655 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3658 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3660 memcached_set_hashkit(memc
, &new_kit
);
3663 Verify Setting the hash.
3665 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3669 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3670 test_true(crc_values
[x
] == hash_val
);
3673 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3677 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3678 test_compare(crc_hosts
[x
], hash_val
);
3681 memcached_free(memc
);
3683 return TEST_SUCCESS
;
3687 Test case adapted from John Gorman <johngorman2@gmail.com>
3689 We are testing the error condition when we connect to a server via memcached_get()
3690 but find that the server is not available.
3692 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3696 memcached_return rc
;
3699 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3701 // See if memcached is reachable.
3702 char *value
= memcached_get(tl_memc_h
,
3703 test_literal_param(__func__
),
3708 test_true(memcached_failed(rc
));
3710 memcached_free(tl_memc_h
);
3712 return TEST_SUCCESS
;
3716 We connect to a server which exists, but search for a key that does not exist.
3718 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3722 memcached_return rc
;
3724 // See if memcached is reachable.
3725 char *value
= memcached_get(memc
,
3726 test_literal_param(__func__
),
3731 test_compare(MEMCACHED_NOTFOUND
, rc
);
3733 return TEST_SUCCESS
;
3737 Test case adapted from John Gorman <johngorman2@gmail.com>
3739 We are testing the error condition when we connect to a server via memcached_get_by_key()
3740 but find that the server is not available.
3742 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
3746 memcached_return rc
;
3749 memcached_st
*tl_memc_h
= memcached_create(NULL
);
3750 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
3751 memcached_server_push(tl_memc_h
, servers
);
3752 memcached_server_list_free(servers
);
3754 // See if memcached is reachable.
3755 char *value
= memcached_get_by_key(tl_memc_h
,
3756 test_literal_param(__func__
), // Key
3757 test_literal_param(__func__
), // Value
3762 test_true(memcached_failed(rc
));
3764 memcached_free(tl_memc_h
);
3766 return TEST_SUCCESS
;
3770 We connect to a server which exists, but search for a key that does not exist.
3772 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3776 memcached_return rc
;
3778 // See if memcached is reachable.
3779 char *value
= memcached_get_by_key(memc
,
3780 test_literal_param(__func__
), // Key
3781 test_literal_param(__func__
), // Value
3786 test_compare(MEMCACHED_NOTFOUND
, rc
);
3788 return TEST_SUCCESS
;
3791 test_return_t
regression_bug_434484(memcached_st
*memc
)
3793 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3795 test_compare(MEMCACHED_NOTSTORED
,
3796 memcached_append(memc
,
3797 test_literal_param(__func__
), // Key
3798 test_literal_param(__func__
), // Value
3801 libtest::vchar_t data
;
3802 data
.resize(2048 * 1024);
3803 test_compare(MEMCACHED_E2BIG
,
3805 test_literal_param(__func__
), // Key
3806 &data
[0], data
.size(), 0, 0));
3808 return TEST_SUCCESS
;
3811 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
3813 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
3815 memcached_return_t rc
;
3817 memcached_execute_fn callbacks
[]= { &callback_counter
};
3820 * I only want to hit only _one_ server so I know the number of requests I'm
3821 * sending in the pipleine to the server. Let's try to do a multiget of
3822 * 1024 (that should satisfy most users don't you think?). Future versions
3823 * will include a mget_execute function call if you need a higher number.
3825 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
3830 * Run two times.. the first time we should have 100% cache miss,
3831 * and the second time we should have 100% cache hits
3833 for (ptrdiff_t y
= 0; y
< 2; y
++)
3835 test_compare(MEMCACHED_SUCCESS
,
3836 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
3838 // One the first run we should get a NOT_FOUND, but on the second some data
3839 // should be returned.
3840 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
3841 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3845 /* The first iteration should give me a 100% cache miss. verify that*/
3846 char blob
[1024]= { 0 };
3848 test_false(counter
);
3850 for (size_t x
= 0; x
< keys
.size(); ++x
)
3852 rc
= memcached_add(memc
,
3853 keys
.key_at(x
), keys
.length_at(x
),
3854 blob
, sizeof(blob
), 0, 0);
3855 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3860 /* Verify that we received all of the key/value pairs */
3861 test_compare(counter
, keys
.size());
3865 memcached_free(memc
);
3867 return TEST_SUCCESS
;
3870 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
3872 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3874 return regression_bug_434843(memc
);
3877 test_return_t
regression_bug_421108(memcached_st
*memc
)
3879 memcached_return_t rc
;
3880 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3881 test_compare(MEMCACHED_SUCCESS
, rc
);
3883 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
3884 test_compare(MEMCACHED_SUCCESS
, rc
);
3885 test_true(bytes_str
);
3886 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
3888 test_compare(MEMCACHED_SUCCESS
, rc
);
3889 test_true(bytes_read_str
);
3891 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
3892 "bytes_written", &rc
);
3893 test_compare(MEMCACHED_SUCCESS
, rc
);
3894 test_true(bytes_written_str
);
3896 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
3897 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
3898 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
3900 test_true(bytes
!= bytes_read
);
3901 test_true(bytes
!= bytes_written
);
3903 /* Release allocated resources */
3905 free(bytes_read_str
);
3906 free(bytes_written_str
);
3907 memcached_stat_free(NULL
, memc_stat
);
3909 return TEST_SUCCESS
;
3913 * The test case isn't obvious so I should probably document why
3914 * it works the way it does. Bug 442914 was caused by a bug
3915 * in the logic in memcached_purge (it did not handle the case
3916 * where the number of bytes sent was equal to the watermark).
3917 * In this test case, create messages so that we hit that case
3918 * and then disable noreply mode and issue a new command to
3919 * verify that it isn't stuck. If we change the format for the
3920 * delete command or the watermarks, we need to update this
3923 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
3925 test_skip(original_memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3927 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
3929 for (uint32_t x
= 0; x
< 250; ++x
)
3932 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
3933 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
3934 char error_buffer
[2048]= { 0 };
3935 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
3936 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
3939 // Delete, and then delete again to look for not found
3942 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
3943 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
3944 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
3946 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
3947 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
3950 memcached_free(memc
);
3952 return TEST_SUCCESS
;
3955 test_return_t
regression_bug_447342(memcached_st
*memc
)
3957 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
3959 return TEST_SKIPPED
;
3962 test_compare(MEMCACHED_SUCCESS
,
3963 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
3967 for (size_t x
= 0; x
< keys
.size(); ++x
)
3969 test_compare(MEMCACHED_SUCCESS
,
3971 keys
.key_at(x
), keys
.length_at(x
), // Keys
3972 keys
.key_at(x
), keys
.length_at(x
), // Values
3977 ** We are using the quiet commands to store the replicas, so we need
3978 ** to ensure that all of them are processed before we can continue.
3979 ** In the test we go directly from storing the object to trying to
3980 ** receive the object from all of the different servers, so we
3981 ** could end up in a race condition (the memcached server hasn't yet
3982 ** processed the quiet command from the replication set when it process
3983 ** the request from the other client (created by the clone)). As a
3984 ** workaround for that we call memcached_quit to send the quit command
3985 ** to the server and wait for the response ;-) If you use the test code
3986 ** as an example for your own code, please note that you shouldn't need
3989 memcached_quit(memc
);
3991 /* Verify that all messages are stored, and we didn't stuff too much
3994 test_compare(MEMCACHED_SUCCESS
,
3995 memcached_mget(memc
,
3996 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
3998 unsigned int counter
= 0;
3999 memcached_execute_fn callbacks
[]= { &callback_counter
};
4000 test_compare(MEMCACHED_SUCCESS
,
4001 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4003 /* Verify that we received all of the key/value pairs */
4004 test_compare(counter
, keys
.size());
4006 memcached_quit(memc
);
4008 * Don't do the following in your code. I am abusing the internal details
4009 * within the library, and this is not a supported interface.
4010 * This is to verify correct behavior in the library. Fake that two servers
4013 memcached_server_instance_st instance_one
= memcached_server_instance_by_position(memc
, 0);
4014 memcached_server_instance_st instance_two
= memcached_server_instance_by_position(memc
, 2);
4015 in_port_t port0
= instance_one
->port
;
4016 in_port_t port2
= instance_two
->port
;
4018 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4019 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4021 test_compare(MEMCACHED_SUCCESS
,
4022 memcached_mget(memc
,
4023 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4026 test_compare(MEMCACHED_SUCCESS
,
4027 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4028 test_compare(counter
, keys
.size());
4030 /* restore the memc handle */
4031 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4032 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4034 memcached_quit(memc
);
4036 /* Remove half of the objects */
4037 for (size_t x
= 0; x
< keys
.size(); ++x
)
4041 test_compare(MEMCACHED_SUCCESS
,
4042 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4046 memcached_quit(memc
);
4047 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4048 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4050 /* now retry the command, this time we should have cache misses */
4051 test_compare(MEMCACHED_SUCCESS
,
4052 memcached_mget(memc
,
4053 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4056 test_compare(MEMCACHED_SUCCESS
,
4057 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4058 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4060 /* restore the memc handle */
4061 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4062 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4064 return TEST_SUCCESS
;
4067 test_return_t
regression_bug_463297(memcached_st
*memc
)
4069 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4071 // Since we blocked timed delete, this test is no longer valid.
4073 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4074 test_true(memc_clone
);
4075 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4077 memcached_server_instance_st instance
=
4078 memcached_server_instance_by_position(memc_clone
, 0);
4080 if (instance
->major_version
> 1 ||
4081 (instance
->major_version
== 1 &&
4082 instance
->minor_version
> 2))
4084 /* Binary protocol doesn't support deferred delete */
4085 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4086 test_true(bin_clone
);
4087 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4088 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4089 memcached_free(bin_clone
);
4091 memcached_quit(memc_clone
);
4093 /* If we know the server version, deferred delete should fail
4094 * with invalid arguments */
4095 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4097 /* If we don't know the server version, we should get a protocol error */
4098 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4100 /* but there is a bug in some of the memcached servers (1.4) that treats
4101 * the counter as noreply so it doesn't send the proper error message
4103 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4105 /* And buffered mode should be disabled and we should get protocol error */
4106 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
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 /* Same goes for noreply... */
4111 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4112 rc
= memcached_delete(memc
, "foo", 3, 1);
4113 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4115 /* but a normal request should go through (and be buffered) */
4116 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4117 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4119 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4120 /* unbuffered noreply should be success */
4121 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4122 /* unbuffered with reply should be not found... */
4123 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4124 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4127 memcached_free(memc_clone
);
4130 return TEST_SUCCESS
;
4134 /* Test memcached_server_get_last_disconnect
4135 * For a working server set, shall be NULL
4136 * For a set of non existing server, shall not be NULL
4138 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4140 memcached_return_t rc
;
4141 memcached_server_instance_st disconnected_server
;
4143 /* With the working set of server */
4144 const char *key
= "marmotte";
4145 const char *value
= "milka";
4147 memcached_reset_last_disconnected_server(memc
);
4148 test_false(memc
->last_disconnected_server
);
4149 rc
= memcached_set(memc
, key
, strlen(key
),
4150 value
, strlen(value
),
4151 (time_t)0, (uint32_t)0);
4152 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4154 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4155 test_false(disconnected_server
);
4157 /* With a non existing server */
4159 memcached_server_st
*servers
;
4161 const char *server_list
= "localhost:9";
4163 servers
= memcached_servers_parse(server_list
);
4165 mine
= memcached_create(NULL
);
4166 rc
= memcached_server_push(mine
, servers
);
4167 test_compare(MEMCACHED_SUCCESS
, rc
);
4168 memcached_server_list_free(servers
);
4171 rc
= memcached_set(mine
, key
, strlen(key
),
4172 value
, strlen(value
),
4173 (time_t)0, (uint32_t)0);
4174 test_true(memcached_failed(rc
));
4176 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4177 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4178 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4179 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4181 memcached_quit(mine
);
4182 memcached_free(mine
);
4184 return TEST_SUCCESS
;
4187 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4189 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4190 char buffer
[BUFSIZ
];
4192 test_compare(MEMCACHED_SUCCESS
,
4193 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4195 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4198 // We will just use the error strings as our keys
4199 uint32_t counter
= 100;
4202 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4204 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4205 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4206 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4208 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
4209 test_true(disconnected_server
);
4210 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4211 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4215 memcached_reset_last_disconnected_server(memc
);
4220 memcached_free(memc
);
4222 return TEST_SUCCESS
;
4225 test_return_t
test_verbosity(memcached_st
*memc
)
4227 memcached_verbosity(memc
, 3);
4229 return TEST_SUCCESS
;
4233 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
4234 const char *key
, size_t key_length
,
4235 const char *value
, size_t value_length
,
4245 return MEMCACHED_SUCCESS
;
4248 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4250 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4251 test_compare(MEMCACHED_SUCCESS
, rc
);
4253 test_compare(MEMCACHED_SUCCESS
,
4254 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4256 test_compare(MEMCACHED_SUCCESS
,
4257 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4259 test_compare(MEMCACHED_SUCCESS
,
4260 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4262 return TEST_SUCCESS
;
4266 * This test ensures that the failure counter isn't incremented during
4267 * normal termination of the memcached instance.
4269 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4271 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4273 /* Ensure that we are connected to the server by setting a value */
4274 memcached_return_t rc
= memcached_set(memc
,
4275 test_literal_param(__func__
), // Key
4276 test_literal_param(__func__
), // Value
4277 time_t(0), uint32_t(0));
4278 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4281 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4283 /* The test is to see that the memcached_quit doesn't increase the
4284 * the server failure conter, so let's ensure that it is zero
4285 * before sending quit
4287 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4289 memcached_quit(memc
);
4291 /* Verify that it memcached_quit didn't increment the failure counter
4292 * Please note that this isn't bullet proof, because an error could
4295 test_zero(instance
->server_failure_counter
);
4297 memcached_free(memc
);
4299 return TEST_SUCCESS
;
4303 * This tests ensures expected disconnections (for some behavior changes
4304 * for instance) do not wrongly increase failure counter
4306 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4308 /* Set value to force connection to the server */
4309 const char *key
= "marmotte";
4310 const char *value
= "milka";
4312 test_compare_hint(MEMCACHED_SUCCESS
,
4313 memcached_set(memc
, key
, strlen(key
),
4314 value
, strlen(value
),
4315 (time_t)0, (uint32_t)0),
4316 memcached_last_error_message(memc
));
4319 /* put failure limit to 1 */
4320 test_compare(MEMCACHED_SUCCESS
,
4321 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4323 /* Put a retry timeout to effectively activate failure_limit effect */
4324 test_compare(MEMCACHED_SUCCESS
,
4325 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4327 /* change behavior that triggers memcached_quit()*/
4328 test_compare(MEMCACHED_SUCCESS
,
4329 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4332 /* Check if we still are connected */
4334 size_t string_length
;
4335 memcached_return rc
;
4336 char *string
= memcached_get(memc
, key
, strlen(key
),
4337 &string_length
, &flags
, &rc
);
4339 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4343 return TEST_SUCCESS
;
4348 * Test that ensures mget_execute does not end into recursive calls that finally fails
4350 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4354 return TEST_SKIPPED
; // My MAC can't handle this test
4357 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4360 * I only want to hit _one_ server so I know the number of requests I'm
4361 * sending in the pipeline.
4363 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4366 keys_st
keys(20480);
4368 /* First add all of the items.. */
4369 char blob
[1024]= { 0 };
4370 for (size_t x
= 0; x
< keys
.size(); ++x
)
4372 memcached_return rc
= memcached_set(memc
,
4373 keys
.key_at(x
), keys
.length_at(x
),
4374 blob
, sizeof(blob
), 0, 0);
4375 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4380 /* Try to get all of them with a large multiget */
4382 memcached_execute_function callbacks
[]= { &callback_counter
};
4383 memcached_return_t rc
= memcached_mget_execute(memc
,
4384 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4385 callbacks
, &counter
, 1);
4386 test_compare(MEMCACHED_SUCCESS
, rc
);
4388 char* the_value
= NULL
;
4389 char the_key
[MEMCACHED_MAX_KEY
];
4390 size_t the_key_length
;
4391 size_t the_value_length
;
4395 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4397 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4403 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4406 test_compare(MEMCACHED_END
, rc
);
4408 /* Verify that we got all of the items */
4409 test_compare(counter
, keys
.size());
4412 memcached_free(memc
);
4414 return TEST_SUCCESS
;
4417 test_return_t
regression_bug_583031(memcached_st
*)
4419 memcached_st
*memc
= memcached_create(NULL
);
4421 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
4423 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
4424 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4425 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4426 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4427 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4428 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4430 memcached_return_t rc
;
4434 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4438 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
4440 memcached_free(memc
);
4442 return TEST_SUCCESS
;
4445 test_return_t
regression_bug_581030(memcached_st
*)
4448 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4449 test_false(local_stat
);
4451 memcached_stat_free(NULL
, NULL
);
4454 return TEST_SUCCESS
;
4457 #define regression_bug_655423_COUNT 6000
4458 test_return_t
regression_bug_655423(memcached_st
*memc
)
4460 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4461 memc
= NULL
; // Just to make sure it is not used
4466 return TEST_SKIPPED
;
4469 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4470 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4471 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4472 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4474 memset(payload
, int('x'), sizeof(payload
));
4476 keys_st
keys(regression_bug_655423_COUNT
);
4478 for (size_t x
= 0; x
< keys
.size(); x
++)
4480 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4483 payload
, sizeof(payload
), 0, 0));
4486 for (size_t x
= 0; x
< keys
.size(); x
++)
4488 size_t value_length
;
4489 memcached_return_t rc
;
4490 char *value
= memcached_get(clone
,
4493 &value_length
, NULL
, &rc
);
4495 if (rc
== MEMCACHED_NOTFOUND
)
4498 test_zero(value_length
);
4502 test_compare(MEMCACHED_SUCCESS
, rc
);
4504 test_compare(100LLU, value_length
);
4508 test_compare(MEMCACHED_SUCCESS
,
4509 memcached_mget(clone
,
4510 keys
.keys_ptr(), keys
.lengths_ptr(),
4514 memcached_result_st
*result
= NULL
;
4515 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4517 test_compare(size_t(100), memcached_result_length(result
));
4521 test_true(count
> 100); // If we don't get back atleast this, something is up
4523 memcached_free(clone
);
4525 return TEST_SUCCESS
;
4529 * Test that ensures that buffered set to not trigger problems during io_flush
4531 #define regression_bug_490520_COUNT 200480
4532 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4534 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4536 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4537 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4538 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4539 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4540 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4542 /* First add all of the items.. */
4543 char blob
[3333] = {0};
4544 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4547 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4549 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4550 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4553 memcached_free(memc
);
4555 return TEST_SUCCESS
;
4559 test_return_t
regression_bug_854604(memcached_st
*)
4563 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4565 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4567 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4568 test_compare(buffer
[0], 0);
4570 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4571 test_true(strlen(buffer
));
4573 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4574 test_true(strlen(buffer
));
4576 return TEST_SUCCESS
;
4579 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4581 fprintf(stderr
, "Iteration #%u: ", it
);
4583 if (error
== MEMCACHED_ERRNO
)
4585 fprintf(stderr
, "system error %d from %s: %s\n",
4586 errno
, what
, strerror(errno
));
4590 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4591 memcached_strerror(mc
, error
));
4595 #define TEST_CONSTANT_CREATION 200
4597 test_return_t
regression_bug_(memcached_st
*memc
)
4599 const char *remote_server
;
4602 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4604 return TEST_SKIPPED
;
4607 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4609 memcached_st
* mc
= memcached_create(NULL
);
4610 memcached_return rc
;
4612 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4613 if (rc
!= MEMCACHED_SUCCESS
)
4615 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
4618 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4619 if (rc
!= MEMCACHED_SUCCESS
)
4621 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
4624 rc
= memcached_server_add(mc
, remote_server
, 0);
4625 if (rc
!= MEMCACHED_SUCCESS
)
4627 memcached_die(mc
, rc
, "memcached_server_add", x
);
4630 const char *set_key
= "akey";
4631 const size_t set_key_len
= strlen(set_key
);
4632 const char *set_value
= "a value";
4633 const size_t set_value_len
= strlen(set_value
);
4635 if (rc
== MEMCACHED_SUCCESS
)
4639 size_t get_value_len
;
4641 uint32_t get_value_flags
;
4643 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
4644 &get_value_flags
, &rc
);
4645 if (rc
!= MEMCACHED_SUCCESS
)
4647 memcached_die(mc
, rc
, "memcached_get", x
);
4653 (get_value_len
!= set_value_len
4654 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
4656 fprintf(stderr
, "Values don't match?\n");
4657 rc
= MEMCACHED_FAILURE
;
4663 rc
= memcached_set(mc
,
4664 set_key
, set_key_len
,
4665 set_value
, set_value_len
,
4669 if (rc
!= MEMCACHED_SUCCESS
)
4671 memcached_die(mc
, rc
, "memcached_set", x
);
4678 if (rc
!= MEMCACHED_SUCCESS
)
4684 return TEST_SUCCESS
;
4687 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
4689 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
4692 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4695 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
4696 memcached_server_port(instance
), NULL
)) > -1);
4699 test_compare(MEMCACHED_SUCCESS
,
4701 test_literal_param(__func__
), // Keys
4702 test_literal_param(__func__
), // Values
4704 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
4706 test_compare(MEMCACHED_CONNECTION_FAILURE
,
4708 test_literal_param(__func__
), // Keys
4709 test_literal_param(__func__
), // Values
4712 memcached_free(memc
);
4714 return TEST_SUCCESS
;