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>
55 #include <libtest/memcached.hpp>
60 #include <semaphore.h>
64 #include <sys/types.h>
69 #include <libtest/server.h>
71 #include "clients/generator.h"
73 #define SMALL_STRING_LEN 1024
75 #include <libtest/test.hpp>
77 using namespace libtest
;
79 #include <libmemcached/util.h>
81 #include "tests/hash_results.h"
83 #include "tests/libmemcached-1.0/callback_counter.h"
84 #include "tests/libmemcached-1.0/fetch_all_results.h"
85 #include "tests/libmemcached-1.0/mem_functions.h"
86 #include "tests/libmemcached-1.0/setup_and_teardowns.h"
87 #include "tests/print.h"
88 #include "tests/debug.h"
90 #define UUID_STRING_MAXLENGTH 36
92 #include "tests/keys.hpp"
94 #include "libmemcached/instance.h"
96 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
99 If no options are given, copy over at least the binary flag.
101 char options_buffer
[1024]= { 0 };
104 if (memcached_is_binary(original_memc
))
106 snprintf(options_buffer
, sizeof(options_buffer
), "--BINARY");
111 * I only want to hit _one_ server so I know the number of requests I'm
112 * sending in the pipeline.
114 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
116 char server_string
[1024];
117 int server_string_length
;
118 if (instance
->type
== MEMCACHED_CONNECTION_UNIX_SOCKET
)
122 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\" %s",
123 memcached_server_name(instance
), options
);
127 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\"",
128 memcached_server_name(instance
));
135 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
136 memcached_server_name(instance
), int(memcached_server_port(instance
)),
141 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
142 memcached_server_name(instance
), int(memcached_server_port(instance
)));
146 if (server_string_length
<= 0)
151 char errror_buffer
[1024];
152 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, errror_buffer
, sizeof(errror_buffer
))))
154 Error
<< "Failed to parse (" << server_string
<< ") " << errror_buffer
;
158 return memcached(server_string
, server_string_length
);
162 test_return_t
init_test(memcached_st
*not_used
)
167 (void)memcached_create(&memc
);
168 memcached_free(&memc
);
173 #define TEST_PORT_COUNT 7
174 in_port_t test_ports
[TEST_PORT_COUNT
];
176 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
177 memcached_server_instance_st server
,
181 size_t bigger
= *((size_t *)(context
));
183 fatal_assert(bigger
<= memcached_server_port(server
));
184 *((size_t *)(context
))= memcached_server_port(server
);
186 return MEMCACHED_SUCCESS
;
189 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
190 memcached_server_instance_st instance
,
194 FILE *stream
= (FILE *)context
;
197 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
198 memcached_server_name(instance
),
199 memcached_server_port(instance
),
200 instance
->major_version
,
201 instance
->minor_version
,
202 instance
->micro_version
);
204 return MEMCACHED_SUCCESS
;
207 test_return_t
server_sort_test(memcached_st
*ptr
)
209 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
211 memcached_return_t rc
;
212 memcached_server_fn callbacks
[1];
213 memcached_st
*local_memc
;
216 local_memc
= memcached_create(NULL
);
217 test_true(local_memc
);
218 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
220 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
222 test_ports
[x
]= (in_port_t
)random() % 64000;
223 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
224 test_compare(memcached_server_count(local_memc
), x
+1);
226 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
228 test_compare(MEMCACHED_SUCCESS
, rc
);
231 callbacks
[0]= server_display_function
;
232 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
235 memcached_free(local_memc
);
240 test_return_t
server_sort2_test(memcached_st
*ptr
)
242 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
243 memcached_server_fn callbacks
[1];
244 memcached_st
*local_memc
;
245 memcached_server_instance_st instance
;
248 local_memc
= memcached_create(NULL
);
249 test_true(local_memc
);
250 test_compare(MEMCACHED_SUCCESS
,
251 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
253 test_compare(MEMCACHED_SUCCESS
,
254 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
255 instance
= memcached_server_instance_by_position(local_memc
, 0);
256 test_compare(in_port_t(43043), memcached_server_port(instance
));
258 test_compare(MEMCACHED_SUCCESS
,
259 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
261 instance
= memcached_server_instance_by_position(local_memc
, 0);
262 test_compare(in_port_t(43042), memcached_server_port(instance
));
264 instance
= memcached_server_instance_by_position(local_memc
, 1);
265 test_compare(in_port_t(43043), memcached_server_port(instance
));
267 callbacks
[0]= server_display_function
;
268 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
271 memcached_free(local_memc
);
276 test_return_t
memcached_server_remove_test(memcached_st
*)
278 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";
281 test_compare(MEMCACHED_SUCCESS
,
282 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
283 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
286 memcached_server_fn callbacks
[1];
287 callbacks
[0]= server_print_callback
;
288 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
290 memcached_free(memc
);
295 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
296 memcached_server_instance_st server
,
300 uint32_t x
= *((uint32_t *)(context
));
302 if (! (test_ports
[x
] == server
->port
))
304 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
305 return MEMCACHED_FAILURE
;
308 *((uint32_t *)(context
))= ++x
;
310 return MEMCACHED_SUCCESS
;
313 test_return_t
server_unsort_test(memcached_st
*ptr
)
315 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
316 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
317 memcached_server_fn callbacks
[1];
318 memcached_st
*local_memc
;
321 local_memc
= memcached_create(NULL
);
322 test_true(local_memc
);
324 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
326 test_ports
[x
]= (in_port_t
)(random() % 64000);
327 test_compare(MEMCACHED_SUCCESS
,
328 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
329 test_compare(memcached_server_count(local_memc
), x
+1);
331 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
335 callbacks
[0]= server_display_unsort_function
;
336 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
338 /* Now we sort old data! */
339 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
340 callbacks
[0]= server_display_function
;
341 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
344 memcached_free(local_memc
);
349 test_return_t
allocation_test(memcached_st
*not_used
)
353 memc
= memcached_create(NULL
);
355 memcached_free(memc
);
360 test_return_t
clone_test(memcached_st
*memc
)
364 memcached_st
*memc_clone
;
365 memc_clone
= memcached_clone(NULL
, NULL
);
366 test_true(memc_clone
);
367 memcached_free(memc_clone
);
370 /* Can we init from null? */
372 memcached_st
*memc_clone
;
373 memc_clone
= memcached_clone(NULL
, memc
);
374 test_true(memc_clone
);
377 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
378 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
379 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
380 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
383 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
384 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
385 test_true(memc_clone
->distribution
== memc
->distribution
);
386 { // Test all of the flags
387 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
388 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
389 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
390 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
391 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
392 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
393 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
394 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
395 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
396 test_true(memc_clone
->flags
.reply
== memc
->flags
.reply
);
397 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
398 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
399 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
401 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
402 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
403 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
404 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
405 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
406 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
407 test_true(memc_clone
->on_clone
== memc
->on_clone
);
408 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
409 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
410 test_true(memc_clone
->recv_size
== memc
->recv_size
);
411 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
412 test_true(memc_clone
->send_size
== memc
->send_size
);
413 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
414 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
415 test_true(memc_clone
->user_data
== memc
->user_data
);
417 memcached_free(memc_clone
);
420 /* Can we init from struct? */
422 memcached_st declared_clone
;
423 memcached_st
*memc_clone
;
424 memset(&declared_clone
, 0 , sizeof(memcached_st
));
425 memc_clone
= memcached_clone(&declared_clone
, NULL
);
426 test_true(memc_clone
);
427 memcached_free(memc_clone
);
430 /* Can we init from struct? */
432 memcached_st declared_clone
;
433 memcached_st
*memc_clone
;
434 memset(&declared_clone
, 0 , sizeof(memcached_st
));
435 memc_clone
= memcached_clone(&declared_clone
, memc
);
436 test_true(memc_clone
);
437 memcached_free(memc_clone
);
443 test_return_t
userdata_test(memcached_st
*memc
)
446 test_false(memcached_set_user_data(memc
, foo
));
447 test_true(memcached_get_user_data(memc
) == foo
);
448 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
453 test_return_t
connection_test(memcached_st
*memc
)
455 test_compare(MEMCACHED_SUCCESS
,
456 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
461 test_return_t
libmemcached_string_behavior_test(memcached_st
*)
463 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
465 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
467 test_compare(37, int(MEMCACHED_BEHAVIOR_MAX
));
472 test_return_t
libmemcached_string_distribution_test(memcached_st
*)
474 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
476 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
478 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
483 test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
485 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
486 982370485U, 1263635348U, 4242906218U, 3829656100U,
487 1891735253U, 334139633U, 2257084983U, 3351789013U,
488 13199785U, 2542027183U, 1097051614U, 199566778U,
489 2748246961U, 2465192557U, 1664094137U, 2405439045U,
490 1842224848U, 692413798U, 3479807801U, 919913813U,
491 4269430871U, 610793021U, 527273862U, 1437122909U,
492 2300930706U, 2943759320U, 674306647U, 2400528935U,
493 54481931U, 4186304426U, 1741088401U, 2979625118U,
494 4159057246U, 3425930182U, 2593724503U, 1868899624U,
495 1769812374U, 2302537950U, 1110330676U, 3365377466U,
496 1336171666U, 3021258493U, 2334992265U, 3861994737U,
497 3582734124U, 3365377466U };
499 // You have updated the memcache_error messages but not updated docs/tests.
500 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
503 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
504 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
505 MEMCACHED_HASH_JENKINS
);
506 if (values
[rc
] != hash_val
)
508 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
509 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
511 test_compare(values
[rc
], hash_val
);
513 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
518 test_return_t
set_test(memcached_st
*memc
)
520 memcached_return_t rc
= memcached_set(memc
,
521 test_literal_param("foo"),
522 test_literal_param("when we sanitize"),
523 time_t(0), (uint32_t)0);
524 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
529 test_return_t
append_test(memcached_st
*memc
)
531 memcached_return_t rc
;
532 const char *in_value
= "we";
536 test_compare(MEMCACHED_SUCCESS
,
537 memcached_flush(memc
, 0));
539 test_compare(MEMCACHED_SUCCESS
,
541 test_literal_param(__func__
),
542 in_value
, strlen(in_value
),
543 time_t(0), uint32_t(0)));
545 test_compare(MEMCACHED_SUCCESS
,
546 memcached_append(memc
,
547 test_literal_param(__func__
),
548 " the", strlen(" the"),
549 time_t(0), uint32_t(0)));
551 test_compare(MEMCACHED_SUCCESS
,
552 memcached_append(memc
,
553 test_literal_param(__func__
),
554 " people", strlen(" people"),
555 time_t(0), uint32_t(0)));
557 char *out_value
= memcached_get(memc
,
558 test_literal_param(__func__
),
559 &value_length
, &flags
, &rc
);
560 test_memcmp(out_value
, "we the people", strlen("we the people"));
561 test_compare(strlen("we the people"), value_length
);
562 test_compare(MEMCACHED_SUCCESS
, rc
);
568 test_return_t
append_binary_test(memcached_st
*memc
)
570 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
572 test_compare(MEMCACHED_SUCCESS
,
573 memcached_flush(memc
, 0));
575 test_compare(MEMCACHED_SUCCESS
,
577 test_literal_param(__func__
),
579 time_t(0), uint32_t(0)));
582 for (uint32_t x
= 0; store_list
[x
] ; x
++)
584 test_compare(MEMCACHED_SUCCESS
,
585 memcached_append(memc
,
586 test_literal_param(__func__
),
587 (char *)&store_list
[x
], sizeof(uint32_t),
588 time_t(0), uint32_t(0)));
594 memcached_return_t rc
;
595 uint32_t *value
= (uint32_t *)memcached_get(memc
,
596 test_literal_param(__func__
),
597 &value_length
, &flags
, &rc
);
598 test_compare(value_length
, sizeof(uint32_t) * count
);
599 test_compare(MEMCACHED_SUCCESS
, rc
);
601 for (uint32_t counter
= count
, *ptr
= value
; counter
; counter
--)
603 test_compare(*ptr
, store_list
[count
- counter
]);
611 test_return_t
memcached_mget_mixed_memcached_get_TEST(memcached_st
*memc
)
615 for (libtest::vchar_ptr_t::iterator iter
= keys
.begin();
619 test_compare_hint(MEMCACHED_SUCCESS
,
623 time_t(0), uint32_t(0)),
624 memcached_last_error_message(memc
));
627 for (ptrdiff_t loop
= 0; loop
< 20; loop
++)
631 test_compare(MEMCACHED_SUCCESS
,
632 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
634 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
637 size_t result_count
= 0;
638 memcached_return_t rc
;
639 while (memcached_fetch_result(memc
, results
, &rc
))
643 test_true(keys
.size() >= result_count
);
647 int which_key
= random() %keys
.size();
650 memcached_return_t rc
;
651 char *out_value
= memcached_get(memc
, keys
.key_at(which_key
), keys
.length_at(which_key
),
652 &value_length
, &flags
, &rc
);
653 if (rc
== MEMCACHED_NOTFOUND
)
654 { } // It is possible that the value has been purged.
657 test_compare(MEMCACHED_SUCCESS
, rc
);
659 test_null(out_value
);
660 test_zero(value_length
);
668 test_return_t
cas2_test(memcached_st
*memc
)
670 const char *keys
[]= {"fudge", "son", "food"};
671 size_t key_length
[]= {5, 3, 4};
672 const char *value
= "we the people";
673 size_t value_length
= strlen("we the people");
675 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
677 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
679 for (uint32_t x
= 0; x
< 3; x
++)
681 test_compare(MEMCACHED_SUCCESS
,
682 memcached_set(memc
, keys
[x
], key_length
[x
],
683 keys
[x
], key_length
[x
],
684 time_t(50), uint32_t(9)));
687 test_compare(MEMCACHED_SUCCESS
,
688 memcached_mget(memc
, keys
, key_length
, 3));
690 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
693 memcached_return_t rc
;
694 results
= memcached_fetch_result(memc
, results
, &rc
);
696 test_true(results
->item_cas
);
697 test_compare(MEMCACHED_SUCCESS
, rc
);
698 test_true(memcached_result_cas(results
));
700 test_memcmp(value
, "we the people", strlen("we the people"));
701 test_compare(strlen("we the people"), value_length
);
702 test_compare(MEMCACHED_SUCCESS
, rc
);
704 memcached_result_free(results
);
709 test_return_t
cas_test(memcached_st
*memc
)
711 const char* keys
[2] = { __func__
, NULL
};
712 size_t keylengths
[2] = { strlen(__func__
), 0 };
714 memcached_result_st results_obj
;
716 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
718 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
720 test_compare(MEMCACHED_SUCCESS
,
722 test_literal_param(__func__
),
723 test_literal_param("we the people"),
724 (time_t)0, (uint32_t)0));
726 test_compare(MEMCACHED_SUCCESS
,
727 memcached_mget(memc
, keys
, keylengths
, 1));
729 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
732 memcached_return_t rc
;
733 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
735 test_compare(MEMCACHED_SUCCESS
, rc
);
736 test_true(memcached_result_cas(results
));
737 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
738 test_compare(test_literal_param_size("we the people"),
739 strlen(memcached_result_value(results
)));
741 uint64_t cas
= memcached_result_cas(results
);
744 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
745 test_true(rc
== MEMCACHED_END
);
746 test_true(results
== NULL
);
749 test_compare(MEMCACHED_SUCCESS
,
751 test_literal_param(__func__
),
752 test_literal_param("change the value"),
756 * The item will have a new cas value, so try to set it again with the old
757 * value. This should fail!
759 test_compare(MEMCACHED_DATA_EXISTS
,
761 test_literal_param(__func__
),
762 test_literal_param("change the value"),
765 memcached_result_free(&results_obj
);
771 test_return_t
prepend_test(memcached_st
*memc
)
773 const char *key
= "fig";
774 const char *value
= "people";
776 test_compare(MEMCACHED_SUCCESS
,
777 memcached_flush(memc
, 0));
779 test_compare(MEMCACHED_SUCCESS
,
780 memcached_set(memc
, key
, strlen(key
),
781 value
, strlen(value
),
782 time_t(0), uint32_t(0)));
784 test_compare(MEMCACHED_SUCCESS
,
785 memcached_prepend(memc
, key
, strlen(key
),
786 "the ", strlen("the "),
787 time_t(0), uint32_t(0)));
789 test_compare(MEMCACHED_SUCCESS
,
790 memcached_prepend(memc
, key
, strlen(key
),
791 "we ", strlen("we "),
792 time_t(0), uint32_t(0)));
796 memcached_return_t rc
;
797 char *out_value
= memcached_get(memc
, key
, strlen(key
),
798 &value_length
, &flags
, &rc
);
799 test_memcmp(out_value
, "we the people", strlen("we the people"));
800 test_compare(strlen("we the people"), value_length
);
801 test_compare(MEMCACHED_SUCCESS
, rc
);
808 Set the value, then quit to make sure it is flushed.
809 Come back in and test that add fails.
811 test_return_t
memcached_add_SUCCESS_TEST(memcached_st
*memc
)
813 memcached_return_t rc
;
814 test_null(memcached_get(memc
, test_literal_param(__func__
), NULL
, NULL
, &rc
));
815 test_compare(MEMCACHED_NOTFOUND
, rc
);
817 test_compare(MEMCACHED_SUCCESS
,
819 test_literal_param(__func__
),
820 test_literal_param("try something else"),
821 time_t(0), uint32_t(0)));
827 Set the value, then quit to make sure it is flushed.
828 Come back in and test that add fails.
830 test_return_t
add_test(memcached_st
*memc
)
832 test_compare(return_value_based_on_buffering(memc
),
834 test_literal_param(__func__
),
835 test_literal_param("when we sanitize"),
836 time_t(0), uint32_t(0)));
838 memcached_quit(memc
);
842 memcached_return_t rc
;
843 char *check_value
= memcached_get(memc
,
844 test_literal_param(__func__
),
845 &value_length
, &flags
, &rc
);
846 test_memcmp(check_value
, "when we sanitize", strlen("when we sanitize"));
847 test_compare(test_literal_param_size("when we sanitize"), value_length
);
848 test_compare(MEMCACHED_SUCCESS
, rc
);
851 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
853 test_literal_param(__func__
),
854 test_literal_param("try something else"),
855 time_t(0), uint32_t(0)));
861 ** There was a problem of leaking filedescriptors in the initial release
862 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
863 ** systems it seems that the kernel is slow on reclaiming the resources
864 ** because the connects starts to time out (the test doesn't do much
865 ** anyway, so just loop 10 iterations)
867 test_return_t
add_wrapper(memcached_st
*memc
)
869 unsigned int max
= 10000;
877 for (uint32_t x
= 0; x
< max
; x
++)
885 test_return_t
replace_test(memcached_st
*memc
)
887 test_compare(return_value_based_on_buffering(memc
),
889 test_literal_param(__func__
),
890 test_literal_param("when we sanitize"),
891 time_t(0), uint32_t(0)));
893 test_compare(MEMCACHED_SUCCESS
,
894 memcached_replace(memc
,
895 test_literal_param(__func__
),
896 test_literal_param("first we insert some data"),
897 time_t(0), uint32_t(0)));
902 test_return_t
delete_test(memcached_st
*memc
)
904 test_compare(return_value_based_on_buffering(memc
),
906 test_literal_param(__func__
),
907 test_literal_param("when we sanitize"),
908 time_t(0), uint32_t(0)));
910 test_compare(return_value_based_on_buffering(memc
),
911 memcached_delete(memc
,
912 test_literal_param(__func__
),
918 test_return_t
flush_test(memcached_st
*memc
)
920 uint64_t query_id
= memcached_query_id(memc
);
921 test_compare(MEMCACHED_SUCCESS
,
922 memcached_flush(memc
, 0));
923 test_compare(query_id
+1, memcached_query_id(memc
));
928 static memcached_return_t
server_function(const memcached_st
*,
929 memcached_server_instance_st
,
933 return MEMCACHED_SUCCESS
;
936 test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
939 strncpy(context
, "foo bad", sizeof(context
));
940 memcached_server_fn callbacks
[1];
942 callbacks
[0]= server_function
;
943 memcached_server_cursor(memc
, callbacks
, context
, 1);
947 test_return_t
bad_key_test(memcached_st
*memc
)
949 memcached_return_t rc
;
950 const char *key
= "foo bad";
953 uint64_t query_id
= memcached_query_id(memc
);
955 // Just skip if we are in binary mode.
956 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
958 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
960 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
961 test_true(memc_clone
);
963 query_id
= memcached_query_id(memc_clone
);
964 test_compare(MEMCACHED_SUCCESS
,
965 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
966 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
968 /* All keys are valid in the binary protocol (except for length) */
969 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == false)
971 uint64_t before_query_id
= memcached_query_id(memc_clone
);
973 size_t string_length
;
974 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
975 &string_length
, &flags
, &rc
);
976 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
977 test_zero(string_length
);
980 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
982 query_id
= memcached_query_id(memc_clone
);
983 test_compare(MEMCACHED_SUCCESS
,
984 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
985 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
987 size_t string_length
;
988 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
989 &string_length
, &flags
, &rc
);
990 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
991 test_zero(string_length
);
995 /* Test multi key for bad keys */
996 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
997 size_t key_lengths
[] = { 7, 7, 7 };
998 query_id
= memcached_query_id(memc_clone
);
999 test_compare(MEMCACHED_SUCCESS
,
1000 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1001 test_compare(query_id
, memcached_query_id(memc_clone
));
1003 query_id
= memcached_query_id(memc_clone
);
1004 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
1005 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
1006 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1008 query_id
= memcached_query_id(memc_clone
);
1009 // Grouping keys are not required to follow normal key behaviors
1010 test_compare(MEMCACHED_SUCCESS
,
1011 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
1012 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1014 /* The following test should be moved to the end of this function when the
1015 memcached server is updated to allow max size length of the keys in the
1018 test_compare(MEMCACHED_SUCCESS
,
1019 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
1021 libtest::vchar_t longkey
;
1023 libtest::vchar_t::iterator it
= longkey
.begin();
1024 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
1027 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
1029 size_t string_length
;
1031 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
1032 test_compare(MEMCACHED_NOTFOUND
, rc
);
1033 test_zero(string_length
);
1035 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
1036 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1037 test_zero(string_length
);
1041 /* Make sure zero length keys are marked as bad */
1043 test_compare(MEMCACHED_SUCCESS
,
1044 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1045 size_t string_length
;
1046 char *string
= memcached_get(memc_clone
, key
, 0,
1047 &string_length
, &flags
, &rc
);
1048 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1049 test_zero(string_length
);
1053 memcached_free(memc_clone
);
1055 return TEST_SUCCESS
;
1058 #define READ_THROUGH_VALUE "set for me"
1059 static memcached_return_t
read_through_trigger(memcached_st
*, // memc
1061 size_t, // key_length,
1062 memcached_result_st
*result
)
1064 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
1067 #ifndef __INTEL_COMPILER
1068 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1071 test_return_t
read_through(memcached_st
*memc
)
1073 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1075 size_t string_length
;
1077 memcached_return_t rc
;
1078 char *string
= memcached_get(memc
,
1079 test_literal_param(__func__
),
1080 &string_length
, &flags
, &rc
);
1082 test_compare(MEMCACHED_NOTFOUND
, rc
);
1083 test_false(string_length
);
1086 test_compare(MEMCACHED_SUCCESS
,
1087 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1089 string
= memcached_get(memc
,
1090 test_literal_param(__func__
),
1091 &string_length
, &flags
, &rc
);
1093 test_compare(MEMCACHED_SUCCESS
, rc
);
1094 test_compare(sizeof(READ_THROUGH_VALUE
) -1, string_length
);
1095 test_compare(0, string
[sizeof(READ_THROUGH_VALUE
) -1]);
1096 test_strcmp(READ_THROUGH_VALUE
, string
);
1099 string
= memcached_get(memc
,
1100 test_literal_param(__func__
),
1101 &string_length
, &flags
, &rc
);
1103 test_compare(MEMCACHED_SUCCESS
, rc
);
1105 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1106 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1107 test_strcmp(READ_THROUGH_VALUE
, string
);
1110 return TEST_SUCCESS
;
1113 test_return_t
set_test2(memcached_st
*memc
)
1115 for (uint32_t x
= 0; x
< 10; x
++)
1117 test_compare(return_value_based_on_buffering(memc
),
1119 test_literal_param("foo"),
1120 test_literal_param("train in the brain"),
1121 time_t(0), uint32_t(0)));
1124 return TEST_SUCCESS
;
1127 test_return_t
set_test3(memcached_st
*memc
)
1129 size_t value_length
= 8191;
1131 libtest::vchar_t value
;
1132 value
.reserve(value_length
);
1133 for (uint32_t x
= 0; x
< value_length
; x
++)
1135 value
.push_back(char(x
% 127));
1138 /* The dump test relies on there being at least 32 items in memcached */
1139 for (uint32_t x
= 0; x
< 32; x
++)
1143 snprintf(key
, sizeof(key
), "foo%u", x
);
1145 uint64_t query_id
= memcached_query_id(memc
);
1146 test_compare(return_value_based_on_buffering(memc
),
1147 memcached_set(memc
, key
, strlen(key
),
1148 &value
[0], value
.size(),
1149 time_t(0), uint32_t(0)));
1150 test_compare(query_id
+1, memcached_query_id(memc
));
1153 return TEST_SUCCESS
;
1156 test_return_t
mget_end(memcached_st
*memc
)
1158 const char *keys
[]= { "foo", "foo2" };
1159 size_t lengths
[]= { 3, 4 };
1160 const char *values
[]= { "fjord", "41" };
1163 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1165 test_compare(MEMCACHED_SUCCESS
,
1167 keys
[x
], lengths
[x
],
1168 values
[x
], strlen(values
[x
]),
1169 time_t(0), uint32_t(0)));
1173 size_t string_length
;
1176 // retrieve both via mget
1177 test_compare(MEMCACHED_SUCCESS
,
1178 memcached_mget(memc
,
1180 test_array_length(keys
)));
1182 char key
[MEMCACHED_MAX_KEY
];
1184 memcached_return_t rc
;
1186 // this should get both
1187 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1189 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1191 test_compare(MEMCACHED_SUCCESS
, rc
);
1193 if (key_length
== 4)
1198 test_compare(string_length
, strlen(values
[val
]));
1199 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1203 // this should indicate end
1204 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1205 test_compare(MEMCACHED_END
, rc
);
1209 test_compare(MEMCACHED_SUCCESS
,
1210 memcached_mget(memc
, keys
, lengths
, 1));
1212 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1213 test_compare(key_length
, lengths
[0]);
1214 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1215 test_compare(string_length
, strlen(values
[0]));
1216 test_true(strncmp(values
[0], string
, string_length
) == 0);
1217 test_compare(MEMCACHED_SUCCESS
, rc
);
1220 // this should indicate end
1221 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1222 test_compare(MEMCACHED_END
, rc
);
1225 return TEST_SUCCESS
;
1228 /* Do not copy the style of this code, I just access hosts to testthis function */
1229 test_return_t
stats_servername_test(memcached_st
*memc
)
1231 memcached_stat_st memc_stat
;
1232 memcached_server_instance_st instance
=
1233 memcached_server_instance_by_position(memc
, 0);
1235 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1237 return TEST_SKIPPED
;
1240 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1241 memcached_server_name(instance
),
1242 memcached_server_port(instance
)));
1244 return TEST_SUCCESS
;
1247 test_return_t
increment_test(memcached_st
*memc
)
1249 uint64_t new_number
;
1251 test_compare(MEMCACHED_SUCCESS
,
1253 test_literal_param("number"),
1254 test_literal_param("0"),
1255 (time_t)0, (uint32_t)0));
1257 test_compare(MEMCACHED_SUCCESS
,
1258 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1259 test_compare(uint64_t(1), new_number
);
1261 test_compare(MEMCACHED_SUCCESS
,
1262 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1263 test_compare(uint64_t(2), new_number
);
1265 return TEST_SUCCESS
;
1268 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1270 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1272 uint64_t new_number
;
1273 uint64_t initial
= 0;
1275 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1277 test_compare(MEMCACHED_SUCCESS
,
1278 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1279 test_compare(new_number
, initial
);
1281 test_compare(MEMCACHED_SUCCESS
,
1282 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1283 test_compare(new_number
, (initial
+1));
1285 return TEST_SUCCESS
;
1288 test_return_t
decrement_test(memcached_st
*memc
)
1290 test_compare(return_value_based_on_buffering(memc
),
1292 test_literal_param(__func__
),
1293 test_literal_param("3"),
1294 time_t(0), uint32_t(0)));
1296 // Make sure we flush the value we just set
1297 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1299 uint64_t new_number
;
1300 test_compare(MEMCACHED_SUCCESS
,
1301 memcached_decrement(memc
,
1302 test_literal_param(__func__
),
1304 test_compare(uint64_t(2), new_number
);
1306 test_compare(MEMCACHED_SUCCESS
,
1307 memcached_decrement(memc
,
1308 test_literal_param(__func__
),
1310 test_compare(uint64_t(1), new_number
);
1312 return TEST_SUCCESS
;
1315 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1317 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1319 uint64_t initial
= 3;
1321 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1323 uint64_t new_number
;
1324 test_compare(MEMCACHED_SUCCESS
,
1325 memcached_decrement_with_initial(memc
,
1326 test_literal_param(__func__
),
1329 test_compare(new_number
, initial
);
1331 test_compare(MEMCACHED_SUCCESS
,
1332 memcached_decrement_with_initial(memc
,
1333 test_literal_param(__func__
),
1336 test_compare(new_number
, (initial
- 1));
1338 return TEST_SUCCESS
;
1341 test_return_t
increment_by_key_test(memcached_st
*memc
)
1343 const char *master_key
= "foo";
1344 const char *key
= "number";
1345 const char *value
= "0";
1347 test_compare(return_value_based_on_buffering(memc
),
1348 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1350 value
, strlen(value
),
1351 time_t(0), uint32_t(0)));
1353 // Make sure we flush the value we just set
1354 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1356 uint64_t new_number
;
1357 test_compare(MEMCACHED_SUCCESS
,
1358 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1359 key
, strlen(key
), 1, &new_number
));
1360 test_compare(uint64_t(1), new_number
);
1362 test_compare(MEMCACHED_SUCCESS
,
1363 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1364 key
, strlen(key
), 1, &new_number
));
1365 test_compare(uint64_t(2), new_number
);
1367 return TEST_SUCCESS
;
1370 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1372 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1374 uint64_t new_number
;
1375 const char *master_key
= "foo";
1376 const char *key
= "number";
1377 uint64_t initial
= 0;
1379 test_compare(MEMCACHED_SUCCESS
,
1380 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1382 1, initial
, 0, &new_number
));
1383 test_compare(new_number
, initial
);
1385 test_compare(MEMCACHED_SUCCESS
,
1386 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1388 1, initial
, 0, &new_number
));
1389 test_compare(new_number
, (initial
+1));
1391 return TEST_SUCCESS
;
1394 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1396 uint64_t new_number
;
1397 const char *value
= "3";
1399 test_compare(return_value_based_on_buffering(memc
),
1400 memcached_set_by_key(memc
,
1401 test_literal_param("foo"),
1402 test_literal_param("number"),
1403 value
, strlen(value
),
1404 (time_t)0, (uint32_t)0));
1406 test_compare(MEMCACHED_SUCCESS
,
1407 memcached_decrement_by_key(memc
,
1408 test_literal_param("foo"),
1409 test_literal_param("number"),
1411 test_compare(uint64_t(2), new_number
);
1413 test_compare(MEMCACHED_SUCCESS
,
1414 memcached_decrement_by_key(memc
,
1415 test_literal_param("foo"),
1416 test_literal_param("number"),
1418 test_compare(uint64_t(1), new_number
);
1420 return TEST_SUCCESS
;
1423 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1425 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1427 uint64_t new_number
;
1428 uint64_t initial
= 3;
1430 test_compare(MEMCACHED_SUCCESS
,
1431 memcached_decrement_with_initial_by_key(memc
,
1432 test_literal_param("foo"),
1433 test_literal_param("number"),
1434 1, initial
, 0, &new_number
));
1435 test_compare(new_number
, initial
);
1437 test_compare(MEMCACHED_SUCCESS
,
1438 memcached_decrement_with_initial_by_key(memc
,
1439 test_literal_param("foo"),
1440 test_literal_param("number"),
1441 1, initial
, 0, &new_number
));
1442 test_compare(new_number
, (initial
- 1));
1444 return TEST_SUCCESS
;
1446 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1448 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1450 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1452 test_compare(return_value_based_on_buffering(memc
),
1454 test_literal_param("number"),
1455 test_literal_param("0"),
1456 (time_t)0, (uint32_t)0));
1458 uint64_t new_number
;
1459 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1460 test_literal_param("number"),
1462 test_compare(uint64_t(1), new_number
);
1464 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1465 test_literal_param("number"),
1467 test_compare(uint64_t(2), new_number
);
1469 return TEST_SUCCESS
;
1472 test_return_t
quit_test(memcached_st
*memc
)
1474 const char *value
= "sanford and sun";
1476 test_compare(return_value_based_on_buffering(memc
),
1478 test_literal_param(__func__
),
1479 value
, strlen(value
),
1480 time_t(10), uint32_t(3)));
1481 memcached_quit(memc
);
1483 test_compare(return_value_based_on_buffering(memc
),
1485 test_literal_param(__func__
),
1486 value
, strlen(value
),
1487 time_t(50), uint32_t(9)));
1489 return TEST_SUCCESS
;
1492 test_return_t
mget_result_test(memcached_st
*memc
)
1494 const char *keys
[]= {"fudge", "son", "food"};
1495 size_t key_length
[]= {5, 3, 4};
1497 memcached_result_st results_obj
;
1498 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1500 test_true(&results_obj
== results
);
1502 /* We need to empty the server before continueing test */
1503 test_compare(MEMCACHED_SUCCESS
,
1504 memcached_flush(memc
, 0));
1506 test_compare(MEMCACHED_SUCCESS
,
1507 memcached_mget(memc
, keys
, key_length
, 3));
1509 memcached_return_t rc
;
1510 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1515 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1516 test_false(results
);
1517 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1519 for (uint32_t x
= 0; x
< 3; x
++)
1521 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1522 keys
[x
], key_length
[x
],
1523 (time_t)50, (uint32_t)9);
1524 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1527 test_compare(MEMCACHED_SUCCESS
,
1528 memcached_mget(memc
, keys
, key_length
, 3));
1530 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1533 test_true(&results_obj
== results
);
1534 test_compare(MEMCACHED_SUCCESS
, rc
);
1535 test_memcmp(memcached_result_key_value(results
),
1536 memcached_result_value(results
),
1537 memcached_result_length(results
));
1538 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1541 memcached_result_free(&results_obj
);
1543 return TEST_SUCCESS
;
1546 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1548 const char *keys
[]= {"fudge", "son", "food"};
1549 size_t key_length
[]= {5, 3, 4};
1551 memcached_result_st
*results
;
1553 /* We need to empty the server before continueing test */
1554 test_compare(MEMCACHED_SUCCESS
,
1555 memcached_flush(memc
, 0));
1557 test_compare(MEMCACHED_SUCCESS
,
1558 memcached_mget(memc
, keys
, key_length
, 3));
1560 memcached_return_t rc
;
1561 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1565 test_false(results
);
1566 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1568 for (uint32_t x
= 0; x
< 3; x
++)
1570 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1571 keys
[x
], key_length
[x
],
1572 (time_t)50, (uint32_t)9);
1573 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1576 test_compare(MEMCACHED_SUCCESS
,
1577 memcached_mget(memc
, keys
, key_length
, 3));
1580 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1583 test_compare(MEMCACHED_SUCCESS
, rc
);
1584 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1585 test_memcmp(memcached_result_key_value(results
),
1586 memcached_result_value(results
),
1587 memcached_result_length(results
));
1588 memcached_result_free(results
);
1592 return TEST_SUCCESS
;
1595 test_return_t
mget_result_function(memcached_st
*memc
)
1597 const char *keys
[]= {"fudge", "son", "food"};
1598 size_t key_length
[]= {5, 3, 4};
1600 memcached_execute_fn callbacks
[1];
1602 for (uint32_t x
= 0; x
< 3; x
++)
1604 test_compare(return_value_based_on_buffering(memc
),
1605 memcached_set(memc
, keys
[x
], key_length
[x
],
1606 keys
[x
], key_length
[x
],
1607 time_t(50), uint32_t(9)));
1609 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1610 memcached_quit(memc
);
1612 test_compare(MEMCACHED_SUCCESS
,
1613 memcached_mget(memc
, keys
, key_length
, 3));
1615 callbacks
[0]= &callback_counter
;
1618 test_compare(MEMCACHED_SUCCESS
,
1619 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1621 test_compare(size_t(3), counter
);
1623 return TEST_SUCCESS
;
1626 test_return_t
mget_test(memcached_st
*memc
)
1628 const char *keys
[]= {"fudge", "son", "food"};
1629 size_t key_length
[]= {5, 3, 4};
1631 char return_key
[MEMCACHED_MAX_KEY
];
1632 size_t return_key_length
;
1634 size_t return_value_length
;
1636 test_compare(MEMCACHED_SUCCESS
,
1637 memcached_mget(memc
, keys
, key_length
, 3));
1640 memcached_return_t rc
;
1641 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1642 &return_value_length
, &flags
, &rc
)))
1644 test_true(return_value
);
1646 test_false(return_value
);
1647 test_zero(return_value_length
);
1648 test_compare(MEMCACHED_NOTFOUND
, rc
);
1650 for (uint32_t x
= 0; x
< 3; x
++)
1652 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1653 keys
[x
], key_length
[x
],
1654 (time_t)50, (uint32_t)9);
1655 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1657 test_compare(MEMCACHED_SUCCESS
,
1658 memcached_mget(memc
, keys
, key_length
, 3));
1661 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1662 &return_value_length
, &flags
, &rc
)))
1664 test_true(return_value
);
1665 test_compare(MEMCACHED_SUCCESS
, rc
);
1666 if (not memc
->_namespace
)
1668 test_compare(return_key_length
, return_value_length
);
1669 test_memcmp(return_value
, return_key
, return_value_length
);
1675 return TEST_SUCCESS
;
1678 test_return_t
mget_execute(memcached_st
*original_memc
)
1680 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1682 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1685 keys_st
keys(20480);
1687 /* First add all of the items.. */
1688 char blob
[1024] = {0};
1690 for (size_t x
= 0; x
< keys
.size(); ++x
)
1692 uint64_t query_id
= memcached_query_id(memc
);
1693 memcached_return_t rc
= memcached_add(memc
,
1694 keys
.key_at(x
), keys
.length_at(x
),
1697 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1698 test_compare(query_id
+1, memcached_query_id(memc
));
1701 /* Try to get all of them with a large multiget */
1703 memcached_execute_fn callbacks
[]= { &callback_counter
};
1704 test_compare(MEMCACHED_SUCCESS
,
1705 memcached_mget_execute(memc
,
1706 keys
.keys_ptr(), keys
.lengths_ptr(),
1707 keys
.size(), callbacks
, &counter
, 1));
1710 uint64_t query_id
= memcached_query_id(memc
);
1711 test_compare(MEMCACHED_SUCCESS
,
1712 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1713 test_compare(query_id
, memcached_query_id(memc
));
1715 /* Verify that we got all of the items */
1716 test_compare(keys
.size(), counter
);
1719 memcached_free(memc
);
1721 return TEST_SUCCESS
;
1724 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1725 static pairs_st
*global_pairs
= NULL
;
1727 test_return_t
key_setup(memcached_st
*memc
)
1729 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1731 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1733 return TEST_SUCCESS
;
1736 test_return_t
key_teardown(memcached_st
*)
1738 pairs_free(global_pairs
);
1741 return TEST_SUCCESS
;
1744 test_return_t
block_add_regression(memcached_st
*memc
)
1746 /* First add all of the items.. */
1747 for (ptrdiff_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1749 libtest::vchar_t blob
;
1750 libtest::vchar::make(blob
, 1024);
1752 memcached_return_t rc
= memcached_add_by_key(memc
,
1753 test_literal_param("bob"),
1754 global_pairs
[x
].key
, global_pairs
[x
].key_length
,
1755 &blob
[0], blob
.size(),
1756 time_t(0), uint32_t(0));
1757 test_compare(*memc
, MEMCACHED_SUCCESS
);
1758 test_compare(rc
, MEMCACHED_SUCCESS
);
1761 return TEST_SUCCESS
;
1764 test_return_t
binary_add_regression(memcached_st
*memc
)
1766 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1767 return block_add_regression(memc
);
1770 test_return_t
get_stats_keys(memcached_st
*memc
)
1774 memcached_stat_st memc_stat
;
1775 memcached_return_t rc
;
1777 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1778 test_compare(MEMCACHED_SUCCESS
, rc
);
1779 for (ptr
= stat_list
; *ptr
; ptr
++)
1784 return TEST_SUCCESS
;
1787 test_return_t
version_string_test(memcached_st
*)
1789 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1791 return TEST_SUCCESS
;
1794 test_return_t
get_stats(memcached_st
*memc
)
1796 memcached_return_t rc
;
1798 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1799 test_compare(MEMCACHED_SUCCESS
, rc
);
1800 test_true(memc_stat
);
1802 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1804 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1805 test_compare(MEMCACHED_SUCCESS
, rc
);
1806 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1811 memcached_stat_free(NULL
, memc_stat
);
1813 return TEST_SUCCESS
;
1816 test_return_t
add_host_test(memcached_st
*memc
)
1818 char servername
[]= "0.example.com";
1820 memcached_return_t rc
;
1821 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1822 test_compare(1U, memcached_server_list_count(servers
));
1824 for (unsigned int x
= 2; x
< 20; x
++)
1826 char buffer
[SMALL_STRING_LEN
];
1828 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1829 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1831 test_compare(MEMCACHED_SUCCESS
, rc
);
1832 test_compare(x
, memcached_server_list_count(servers
));
1835 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1836 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1838 memcached_server_list_free(servers
);
1840 return TEST_SUCCESS
;
1843 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1845 memcached_return_t rc
;
1847 const char *key
= "not_found";
1848 size_t key_length
= test_literal_param_size("not_found");
1850 test_compare(MEMCACHED_SUCCESS
,
1851 memcached_mget(memc
, &key
, &key_length
, 1));
1853 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1855 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1857 memcached_result_free(result
);
1859 return TEST_SUCCESS
;
1862 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1864 return MEMCACHED_SUCCESS
;
1867 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1869 return MEMCACHED_SUCCESS
;
1872 test_return_t
callback_test(memcached_st
*memc
)
1874 /* Test User Data */
1878 memcached_return_t rc
;
1880 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1881 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1882 test_true(*test_ptr
== x
);
1885 /* Test Clone Callback */
1887 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1888 void *clone_cb_ptr
= *(void **)&clone_cb
;
1889 void *temp_function
= NULL
;
1891 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
1892 memcached_return_t rc
;
1893 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1894 test_true(temp_function
== clone_cb_ptr
);
1895 test_compare(MEMCACHED_SUCCESS
, rc
);
1898 /* Test Cleanup Callback */
1900 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
1901 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1902 void *temp_function
= NULL
;
1903 memcached_return_t rc
;
1905 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
1906 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1907 test_true(temp_function
== cleanup_cb_ptr
);
1910 return TEST_SUCCESS
;
1913 /* We don't test the behavior itself, we test the switches */
1914 test_return_t
behavior_test(memcached_st
*memc
)
1916 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
1917 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
1919 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
1920 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
1922 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
1923 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1925 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
1926 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
1928 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
1929 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
1931 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
1932 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1934 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
1935 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1937 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
1939 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
1941 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
1942 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
1943 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
1945 return TEST_SUCCESS
;
1948 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
1950 test_compare(MEMCACHED_DEPRECATED
,
1951 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
1953 // Platform dependent
1955 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
1959 return TEST_SUCCESS
;
1963 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
1965 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
1966 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
1968 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
1970 if (memcached_success(rc
))
1979 return TEST_SUCCESS
;
1983 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
1985 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
1986 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
1988 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
1990 if (memcached_success(rc
))
1999 return TEST_SUCCESS
;
2002 /* Make sure we behave properly if server list has no values */
2003 test_return_t
user_supplied_bug4(memcached_st
*memc
)
2005 const char *keys
[]= {"fudge", "son", "food"};
2006 size_t key_length
[]= {5, 3, 4};
2008 /* Here we free everything before running a bunch of mget tests */
2009 memcached_servers_reset(memc
);
2012 /* We need to empty the server before continueing test */
2013 test_compare(MEMCACHED_NO_SERVERS
,
2014 memcached_flush(memc
, 0));
2016 test_compare(MEMCACHED_NO_SERVERS
,
2017 memcached_mget(memc
, keys
, key_length
, 3));
2020 unsigned int keys_returned
;
2021 memcached_return_t rc
;
2022 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2023 test_compare(MEMCACHED_NOTFOUND
, rc
);
2024 test_zero(keys_returned
);
2027 for (uint32_t x
= 0; x
< 3; x
++)
2029 test_compare(MEMCACHED_NO_SERVERS
,
2030 memcached_set(memc
, keys
[x
], key_length
[x
],
2031 keys
[x
], key_length
[x
],
2032 (time_t)50, (uint32_t)9));
2035 test_compare(MEMCACHED_NO_SERVERS
,
2036 memcached_mget(memc
, keys
, key_length
, 3));
2040 char return_key
[MEMCACHED_MAX_KEY
];
2041 memcached_return_t rc
;
2042 size_t return_key_length
;
2043 size_t return_value_length
;
2046 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2047 &return_value_length
, &flags
, &rc
)))
2049 test_true(return_value
);
2050 test_compare(MEMCACHED_SUCCESS
, rc
);
2051 test_true(return_key_length
== return_value_length
);
2052 test_memcmp(return_value
, return_key
, return_value_length
);
2058 return TEST_SUCCESS
;
2061 #define VALUE_SIZE_BUG5 1048064
2062 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2064 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2065 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2067 size_t value_length
;
2069 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2071 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2073 insert_data
[x
]= (signed char)rand();
2076 test_compare(MEMCACHED_SUCCESS
,
2077 memcached_flush(memc
, 0));
2079 memcached_return_t rc
;
2080 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2081 test_compare(MEMCACHED_SUCCESS
,
2082 memcached_mget(memc
, keys
, key_length
, 4));
2085 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2086 test_compare(MEMCACHED_NOTFOUND
, rc
);
2089 for (uint32_t x
= 0; x
< 4; x
++)
2091 test_compare(MEMCACHED_SUCCESS
,
2092 memcached_set(memc
, keys
[x
], key_length
[x
],
2093 insert_data
, VALUE_SIZE_BUG5
,
2094 (time_t)0, (uint32_t)0));
2097 for (uint32_t x
= 0; x
< 10; x
++)
2099 value
= memcached_get(memc
, keys
[0], key_length
[0],
2100 &value_length
, &flags
, &rc
);
2101 test_compare(rc
, MEMCACHED_SUCCESS
);
2105 test_compare(MEMCACHED_SUCCESS
,
2106 memcached_mget(memc
, keys
, key_length
, 4));
2108 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2109 test_compare(4U, count
);
2111 delete [] insert_data
;
2113 return TEST_SUCCESS
;
2116 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2118 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2119 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2120 char return_key
[MEMCACHED_MAX_KEY
];
2121 size_t return_key_length
;
2123 size_t value_length
;
2125 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2127 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2129 insert_data
[x
]= (signed char)rand();
2132 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2134 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2136 // We will now confirm that memcached_mget() returns success, but we will
2137 // then check to make sure that no actual keys are returned.
2138 test_compare(MEMCACHED_SUCCESS
,
2139 memcached_mget(memc
, keys
, key_length
, 4));
2141 memcached_return_t rc
;
2143 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2144 &value_length
, &flags
, &rc
)))
2149 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2151 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2153 test_compare(MEMCACHED_SUCCESS
,
2154 memcached_set(memc
, keys
[x
], key_length
[x
],
2155 insert_data
, VALUE_SIZE_BUG5
,
2156 (time_t)0, (uint32_t)0));
2158 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2160 for (uint32_t x
= 0; x
< 2; x
++)
2162 value
= memcached_get(memc
, keys
[0], key_length
[0],
2163 &value_length
, &flags
, &rc
);
2167 test_compare(MEMCACHED_SUCCESS
,
2168 memcached_mget(memc
, keys
, key_length
, 4));
2169 /* We test for purge of partial complete fetches */
2170 for (count
= 3; count
; count
--)
2172 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2173 &value_length
, &flags
, &rc
);
2174 test_compare(MEMCACHED_SUCCESS
, rc
);
2175 test_memcmp(value
, insert_data
, value_length
);
2176 test_true(value_length
);
2180 delete [] insert_data
;
2182 return TEST_SUCCESS
;
2185 test_return_t
user_supplied_bug8(memcached_st
*)
2187 memcached_return_t rc
;
2189 memcached_st
*memc_clone
;
2191 memcached_server_st
*servers
;
2192 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";
2194 servers
= memcached_servers_parse(server_list
);
2197 mine
= memcached_create(NULL
);
2198 rc
= memcached_server_push(mine
, servers
);
2199 test_compare(MEMCACHED_SUCCESS
, rc
);
2200 memcached_server_list_free(servers
);
2203 memc_clone
= memcached_clone(NULL
, mine
);
2205 memcached_quit(mine
);
2206 memcached_quit(memc_clone
);
2209 memcached_free(mine
);
2210 memcached_free(memc_clone
);
2212 return TEST_SUCCESS
;
2215 /* Test flag store/retrieve */
2216 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2218 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2219 test_true(insert_data
);
2221 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2223 insert_data
[x
]= (signed char)rand();
2226 memcached_flush(memc
, 0);
2228 const char *keys
= "036790384900";
2229 size_t key_length
= strlen(keys
);
2230 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2231 insert_data
, VALUE_SIZE_BUG5
,
2234 memcached_return_t rc
;
2235 size_t value_length
;
2237 char *value
= memcached_get(memc
, keys
, key_length
,
2238 &value_length
, &flags
, &rc
);
2239 test_compare(245U, flags
);
2243 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2245 char return_key
[MEMCACHED_MAX_KEY
];
2246 size_t return_key_length
;
2248 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2249 &value_length
, &flags
, &rc
);
2250 test_compare(uint32_t(245), flags
);
2253 delete [] insert_data
;
2256 return TEST_SUCCESS
;
2259 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2261 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2262 size_t key_length
[3];
2266 char return_key
[MEMCACHED_MAX_KEY
];
2267 size_t return_key_length
;
2269 size_t return_value_length
;
2272 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2273 key_length
[1]= strlen("fudge&*@#");
2274 key_length
[2]= strlen("for^#@&$not");
2277 for (unsigned int x
= 0; x
< 3; x
++)
2279 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2280 keys
[x
], key_length
[x
],
2281 (time_t)50, (uint32_t)9);
2282 test_compare(MEMCACHED_SUCCESS
, rc
);
2285 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2286 test_compare(MEMCACHED_SUCCESS
, rc
);
2288 /* We need to empty the server before continueing test */
2289 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2290 &return_value_length
, &flags
, &rc
)) != NULL
)
2292 test_true(return_value
);
2296 test_compare(3U, count
);
2298 return TEST_SUCCESS
;
2301 /* We are testing with aggressive timeout to get failures */
2302 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2304 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
2306 size_t value_length
= 512;
2307 unsigned int set
= 1;
2308 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2310 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2311 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2312 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2314 libtest::vchar_t value
;
2315 value
.reserve(value_length
);
2316 for (uint32_t x
= 0; x
< value_length
; x
++)
2318 value
.push_back(char(x
% 127));
2321 for (unsigned int x
= 1; x
<= 100000; ++x
)
2323 memcached_return_t rc
= memcached_set(mclone
,
2324 test_literal_param("foo"),
2325 &value
[0], value
.size(),
2328 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2329 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2330 memcached_strerror(NULL
, rc
));
2332 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2338 memcached_free(mclone
);
2340 return TEST_SUCCESS
;
2344 We are looking failures in the async protocol
2346 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2348 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2350 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2351 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2352 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2354 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2357 libtest::vchar_t value
;
2359 for (unsigned int x
= 0; x
< 512; x
++)
2361 value
.push_back(char(x
% 127));
2364 for (unsigned int x
= 1; x
<= 100000; ++x
)
2366 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2370 memcached_free(mclone
);
2372 return TEST_SUCCESS
;
2376 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2378 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2380 memcached_return_t rc
;
2382 size_t value_length
;
2384 uint64_t number_value
;
2386 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2387 &value_length
, &flags
, &rc
);
2389 test_compare(MEMCACHED_NOTFOUND
, rc
);
2391 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2394 /* The binary protocol will set the key if it doesn't exist */
2395 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2397 test_compare(MEMCACHED_SUCCESS
, rc
);
2401 test_compare(MEMCACHED_NOTFOUND
, rc
);
2404 test_compare(MEMCACHED_SUCCESS
,
2405 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2407 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2411 test_compare(MEMCACHED_SUCCESS
,
2412 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2413 test_compare(2UL, number_value
);
2415 return TEST_SUCCESS
;
2419 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2420 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2422 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2424 char key
[] = "key34567890";
2426 char commandFirst
[]= "set key34567890 0 0 ";
2427 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2428 size_t commandLength
;
2430 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2432 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2434 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2436 char *overflow
= new (std::nothrow
) char[testSize
];
2437 test_true(overflow
);
2439 memset(overflow
, 'x', testSize
);
2440 test_compare(MEMCACHED_SUCCESS
,
2441 memcached_set(memc
, key
, strlen(key
),
2442 overflow
, testSize
, 0, 0));
2446 return TEST_SUCCESS
;
2451 Test values of many different sizes
2452 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2453 set key34567890 0 0 8169 \r\n
2454 is sent followed by buffer of size 8169, followed by 8169
2456 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2458 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2460 libtest::vchar_t value
;
2461 value
.reserve(18000);
2462 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2464 value
.push_back((char) (x
% 127));
2467 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2469 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2470 &value
[0], current_length
,
2471 (time_t)0, (uint32_t)0);
2472 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2474 size_t string_length
;
2476 char *string
= memcached_get(memc
, test_literal_param("foo"),
2477 &string_length
, &flags
, &rc
);
2479 test_compare(MEMCACHED_SUCCESS
, rc
);
2480 test_compare(string_length
, current_length
);
2482 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2483 test_memcmp_hint(string
, &value
[0], string_length
, buffer
);
2488 return TEST_SUCCESS
;
2492 Look for zero length value problems
2494 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2496 for (uint32_t x
= 0; x
< 2; x
++)
2498 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2500 (time_t)0, (uint32_t)0);
2502 test_compare(MEMCACHED_SUCCESS
, rc
);
2506 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2507 &length
, &flags
, &rc
);
2509 test_compare(MEMCACHED_SUCCESS
, rc
);
2514 value
= memcached_get(memc
, test_literal_param("mykey"),
2515 &length
, &flags
, &rc
);
2517 test_compare(MEMCACHED_SUCCESS
, rc
);
2523 return TEST_SUCCESS
;
2526 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2527 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2529 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2531 (time_t)0, UINT32_MAX
),
2532 memcached_last_error_message(memc
));
2537 memcached_return_t rc
;
2538 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2539 &length
, &flags
, &rc
);
2541 test_compare(MEMCACHED_SUCCESS
, rc
);
2544 test_compare(flags
, UINT32_MAX
);
2546 return TEST_SUCCESS
;
2549 #if !defined(__sun) && !defined(__OpenBSD__)
2550 /* Check the validity of chinese key*/
2551 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2553 const char *key
= "豆瓣";
2554 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2555 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2556 value
, strlen(value
),
2559 test_compare(MEMCACHED_SUCCESS
, rc
);
2563 char *value2
= memcached_get(memc
, key
, strlen(key
),
2564 &length
, &flags
, &rc
);
2566 test_compare(length
, strlen(value
));
2567 test_compare(MEMCACHED_SUCCESS
, rc
);
2568 test_memcmp(value
, value2
, length
);
2571 return TEST_SUCCESS
;
2579 test_return_t
user_supplied_bug19(memcached_st
*)
2581 memcached_return_t res
;
2583 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2585 memcached_server_instance_st server
= memcached_server_by_key(memc
, "a", 1, &res
);
2588 memcached_free(memc
);
2590 return TEST_SUCCESS
;
2593 /* CAS test from Andei */
2594 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2596 const char *key
= "abc";
2597 size_t key_len
= strlen("abc");
2599 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2601 test_compare(MEMCACHED_SUCCESS
,
2603 test_literal_param("abc"),
2604 test_literal_param("foobar"),
2605 (time_t)0, (uint32_t)0));
2607 test_compare(MEMCACHED_SUCCESS
,
2608 memcached_mget(memc
, &key
, &key_len
, 1));
2610 memcached_result_st result_obj
;
2611 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2614 memcached_result_create(memc
, &result_obj
);
2615 memcached_return_t status
;
2616 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2619 test_compare(MEMCACHED_SUCCESS
, status
);
2621 memcached_result_free(result
);
2623 return TEST_SUCCESS
;
2626 /* Large mget() of missing keys with binary proto
2628 * If many binary quiet commands (such as getq's in an mget) fill the output
2629 * buffer and the server chooses not to respond, memcached_flush hangs. See
2630 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2633 /* sighandler_t function that always asserts false */
2634 static void fail(int)
2640 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2645 return TEST_SKIPPED
;
2647 void (*oldalarm
)(int);
2649 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2650 test_true(memc_clone
);
2652 /* only binproto uses getq for mget */
2653 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2655 /* empty the cache to ensure misses (hence non-responses) */
2656 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2658 keys_st
keys(key_count
);
2660 oldalarm
= signal(SIGALRM
, fail
);
2663 test_compare_got(MEMCACHED_SUCCESS
,
2664 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2665 memcached_last_error_message(memc_clone
));
2668 signal(SIGALRM
, oldalarm
);
2670 memcached_return_t rc
;
2672 char return_key
[MEMCACHED_MAX_KEY
];
2673 size_t return_key_length
;
2675 size_t return_value_length
;
2676 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2677 &return_value_length
, &flags
, &rc
)))
2679 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2681 test_compare(MEMCACHED_NOTFOUND
, rc
);
2682 test_zero(return_value_length
);
2683 test_zero(return_key_length
);
2684 test_false(return_key
[0]);
2685 test_false(return_value
);
2687 memcached_free(memc_clone
);
2689 return TEST_SUCCESS
;
2693 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2695 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2697 /* should work as of r580 */
2698 test_compare(TEST_SUCCESS
,
2699 _user_supplied_bug21(memc
, 10));
2701 /* should fail as of r580 */
2702 test_compare(TEST_SUCCESS
,
2703 _user_supplied_bug21(memc
, 1000));
2705 return TEST_SUCCESS
;
2708 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2710 memcached_st
*memc
= memcached_create(NULL
);
2714 test_compare(MEMCACHED_SUCCESS
,
2715 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2717 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2718 test_compare(value
, uint64_t(1));
2720 test_compare(MEMCACHED_SUCCESS
,
2721 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2723 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2724 test_true(value
== MEMCACHED_HASH_MD5
);
2727 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2729 memcached_server_st
*server_pool
;
2730 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");
2731 memcached_server_push(memc
, server_pool
);
2733 // @todo this needs to be refactored to actually test something.
2736 if ((fp
= fopen("ketama_keys.txt", "w")))
2740 printf("cannot write to file ketama_keys.txt");
2741 return TEST_FAILURE
;
2744 for (int x
= 0; x
< 10000; x
++)
2747 snprintf(key
, sizeof(key
), "%d", x
);
2749 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2750 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2751 in_port_t port
= memc
->hosts
[server_idx
].port
;
2752 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2753 memcached_server_instance_st instance
=
2754 memcached_server_instance_by_position(memc
, host_index
);
2758 memcached_server_list_free(server_pool
);
2759 memcached_free(memc
);
2761 return TEST_SUCCESS
;
2765 test_return_t
result_static(memcached_st
*memc
)
2767 memcached_result_st result
;
2768 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
2769 test_false(result
.options
.is_allocated
);
2770 test_true(memcached_is_initialized(&result
));
2771 test_true(result_ptr
);
2772 test_true(result_ptr
== &result
);
2774 memcached_result_free(&result
);
2776 test_false(result
.options
.is_allocated
);
2777 test_false(memcached_is_initialized(&result
));
2779 return TEST_SUCCESS
;
2782 test_return_t
result_alloc(memcached_st
*memc
)
2784 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
2785 test_true(result_ptr
);
2786 test_true(result_ptr
->options
.is_allocated
);
2787 test_true(memcached_is_initialized(result_ptr
));
2788 memcached_result_free(result_ptr
);
2790 return TEST_SUCCESS
;
2794 test_return_t
add_host_test1(memcached_st
*memc
)
2796 memcached_return_t rc
;
2797 char servername
[]= "0.example.com";
2799 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2801 test_compare(1U, memcached_server_list_count(servers
));
2803 for (uint32_t x
= 2; x
< 20; x
++)
2805 char buffer
[SMALL_STRING_LEN
];
2807 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
2808 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2810 test_compare(MEMCACHED_SUCCESS
, rc
);
2811 test_compare(x
, memcached_server_list_count(servers
));
2814 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2815 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2817 memcached_server_list_free(servers
);
2819 return TEST_SUCCESS
;
2823 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
2827 #ifdef HARD_MALLOC_TESTS
2828 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
2836 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
2840 #ifdef HARD_MALLOC_TESTS
2841 void *ret
= malloc(size
+ 8);
2844 ret
= (void*)((caddr_t
)ret
+ 8);
2847 void *ret
= malloc(size
);
2852 memset(ret
, 0xff, size
);
2859 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
2861 #ifdef HARD_MALLOC_TESTS
2862 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
2863 void *nmem
= realloc(real_ptr
, size
+ 8);
2868 ret
= (void*)((caddr_t
)nmem
+ 8);
2874 return realloc(mem
, size
);
2879 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
2881 #ifdef HARD_MALLOC_TESTS
2882 void *mem
= my_malloc(ptr
, nelem
* size
);
2885 memset(mem
, 0, nelem
* size
);
2891 return calloc(nelem
, size
);
2895 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
2897 memcached_return_t rc
;
2898 const char *key
= "mine";
2901 /* Make sure be default none exists */
2902 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2904 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2906 /* Test a clean set */
2907 test_compare(MEMCACHED_SUCCESS
,
2908 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2910 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2912 test_memcmp(value
, key
, 4);
2913 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2915 /* Test that we can turn it off */
2916 test_compare(MEMCACHED_SUCCESS
,
2917 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
2919 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2921 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2923 /* Now setup for main test */
2924 test_compare(MEMCACHED_SUCCESS
,
2925 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2927 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2929 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2930 test_memcmp(value
, key
, 4);
2932 /* Set to Zero, and then Set to something too large */
2935 memset(long_key
, 0, 255);
2937 test_compare(MEMCACHED_SUCCESS
,
2938 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
2940 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2942 test_compare(MEMCACHED_SUCCESS
, rc
);
2944 /* Test a long key for failure */
2945 /* TODO, extend test to determine based on setting, what result should be */
2946 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
2947 test_compare(MEMCACHED_SUCCESS
,
2948 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
2950 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
2951 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
2952 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
2953 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
2955 /* Test for a bad prefix, but with a short key */
2956 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
2957 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
2959 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
2960 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
2963 return TEST_SUCCESS
;
2966 test_return_t
set_namespace(memcached_st
*memc
)
2968 memcached_return_t rc
;
2969 const char *key
= "mine";
2972 // Make sure we default to a null namespace
2973 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2975 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2977 /* Test a clean set */
2978 test_compare(MEMCACHED_SUCCESS
,
2979 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2981 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2983 test_memcmp(value
, key
, 4);
2984 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2986 return TEST_SUCCESS
;
2989 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
2991 test_return_if(pre_binary(memc
));
2992 test_return_if(set_namespace(memc
));
2994 return TEST_SUCCESS
;
2997 #ifdef MEMCACHED_ENABLE_DEPRECATED
2998 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3000 void *test_ptr
= NULL
;
3003 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
3004 cb_ptr
= *(void **)&malloc_cb
;
3005 memcached_return_t rc
;
3007 test_compare(MEMCACHED_SUCCESS
,
3008 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3009 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3010 test_compare(MEMCACHED_SUCCESS
, rc
);
3011 test_true(test_ptr
== cb_ptr
);
3015 memcached_realloc_fn realloc_cb
=
3016 (memcached_realloc_fn
)my_realloc
;
3017 cb_ptr
= *(void **)&realloc_cb
;
3018 memcached_return_t rc
;
3020 test_compare(MEMCACHED_SUCCESS
,
3021 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3022 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3023 test_compare(MEMCACHED_SUCCESS
, rc
);
3024 test_true(test_ptr
== cb_ptr
);
3028 memcached_free_fn free_cb
=
3029 (memcached_free_fn
)my_free
;
3030 cb_ptr
= *(void **)&free_cb
;
3031 memcached_return_t rc
;
3033 test_compare(MEMCACHED_SUCCESS
,
3034 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3035 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3036 test_compare(MEMCACHED_SUCCESS
, rc
);
3037 test_true(test_ptr
== cb_ptr
);
3040 return TEST_SUCCESS
;
3045 test_return_t
set_memory_alloc(memcached_st
*memc
)
3047 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3048 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3049 my_realloc
, my_calloc
, NULL
));
3051 test_compare(MEMCACHED_SUCCESS
,
3052 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3053 my_realloc
, my_calloc
, NULL
));
3055 memcached_malloc_fn mem_malloc
;
3056 memcached_free_fn mem_free
;
3057 memcached_realloc_fn mem_realloc
;
3058 memcached_calloc_fn mem_calloc
;
3059 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3060 &mem_realloc
, &mem_calloc
);
3062 test_true(mem_malloc
== my_malloc
);
3063 test_true(mem_realloc
== my_realloc
);
3064 test_true(mem_calloc
== my_calloc
);
3065 test_true(mem_free
== my_free
);
3067 return TEST_SUCCESS
;
3070 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3072 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
));
3073 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3076 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3081 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3083 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_CRC
)
3085 return TEST_SKIPPED
;
3088 return TEST_SUCCESS
;
3091 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3094 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
);
3095 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3100 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3102 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_HSIEH
)
3104 return TEST_SKIPPED
;
3107 return TEST_SUCCESS
;
3110 test_return_t
enable_cas(memcached_st
*memc
)
3112 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3114 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true);
3116 return TEST_SUCCESS
;
3119 return TEST_SKIPPED
;
3122 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3124 memcached_version(memc
);
3126 memcached_server_instance_st instance
=
3127 memcached_server_instance_by_position(memc
, 0);
3129 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3130 or instance
->minor_version
> 2)
3132 return TEST_SUCCESS
;
3135 return TEST_SKIPPED
;
3138 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3140 const uint64_t timeout
= 100; // Not using, just checking that it sets
3142 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3144 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3146 return TEST_SUCCESS
;
3149 test_return_t
noreply_test(memcached_st
*memc
)
3151 test_compare(MEMCACHED_SUCCESS
,
3152 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3153 test_compare(MEMCACHED_SUCCESS
,
3154 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3155 test_compare(MEMCACHED_SUCCESS
,
3156 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3157 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3158 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3159 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3161 memcached_return_t ret
;
3162 for (int count
= 0; count
< 5; ++count
)
3164 for (size_t x
= 0; x
< 100; ++x
)
3166 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3167 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3168 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3170 size_t len
= (size_t)check_length
;
3175 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3178 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3181 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3184 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3187 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3193 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3194 memcached_strerror(NULL
, ret
));
3198 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3199 ** API and is _ONLY_ done this way to verify that the library works the
3200 ** way it is supposed to do!!!!
3204 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3206 memcached_server_instance_st instance
=
3207 memcached_server_instance_by_position(memc
, x
);
3208 no_msg
+=(int)(instance
->cursor_active
);
3211 test_true(no_msg
== 0);
3213 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3216 ** Now validate that all items was set properly!
3218 for (size_t x
= 0; x
< 100; ++x
)
3222 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3224 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3226 size_t len
= (size_t)check_length
;
3229 char* value
=memcached_get(memc
, key
, strlen(key
),
3230 &length
, &flags
, &ret
);
3231 // For the moment we will just go to the next key
3232 if (MEMCACHED_TIMEOUT
== ret
)
3236 test_true(ret
== MEMCACHED_SUCCESS
and value
!= NULL
);
3239 case 0: /* FALLTHROUGH */
3240 case 1: /* FALLTHROUGH */
3242 test_true(strncmp(value
, key
, len
) == 0);
3243 test_true(len
== length
);
3246 test_true(length
== len
* 2);
3249 test_true(length
== len
* 3);
3259 /* Try setting an illegal cas value (should not return an error to
3260 * the caller (because we don't expect a return message from the server)
3262 const char* keys
[]= {"0"};
3263 size_t lengths
[]= {1};
3266 memcached_result_st results_obj
;
3267 memcached_result_st
*results
;
3268 test_compare(MEMCACHED_SUCCESS
,
3269 memcached_mget(memc
, keys
, lengths
, 1));
3271 results
= memcached_result_create(memc
, &results_obj
);
3273 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3275 test_compare(MEMCACHED_SUCCESS
, ret
);
3276 uint64_t cas
= memcached_result_cas(results
);
3277 memcached_result_free(&results_obj
);
3279 test_compare(MEMCACHED_SUCCESS
,
3280 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3283 * The item will have a new cas value, so try to set it again with the old
3284 * value. This should fail!
3286 test_compare(MEMCACHED_SUCCESS
,
3287 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3288 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3289 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3290 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3293 return TEST_SUCCESS
;
3296 test_return_t
analyzer_test(memcached_st
*memc
)
3298 memcached_analysis_st
*report
;
3299 memcached_return_t rc
;
3301 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3302 test_compare(MEMCACHED_SUCCESS
, rc
);
3303 test_true(memc_stat
);
3305 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3306 test_compare(MEMCACHED_SUCCESS
, rc
);
3310 memcached_stat_free(NULL
, memc_stat
);
3312 return TEST_SUCCESS
;
3315 test_return_t
util_version_test(memcached_st
*memc
)
3317 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
3318 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3320 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3322 // We expect failure
3325 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3326 fprintf(stderr
, "\nDumping Server Information\n\n");
3327 memcached_server_fn callbacks
[1];
3329 callbacks
[0]= dump_server_information
;
3330 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3331 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3333 test_true(if_successful
== false);
3335 memcached_server_instance_st instance
=
3336 memcached_server_instance_by_position(memc
, 0);
3338 memcached_version(memc
);
3340 // We only use one binary when we test, so this should be just fine.
3341 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3342 test_true(if_successful
== true);
3344 if (instance
->micro_version
> 0)
3346 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3348 else if (instance
->minor_version
> 0)
3350 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3352 else if (instance
->major_version
> 0)
3354 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3357 test_true(if_successful
== true);
3359 if (instance
->micro_version
> 0)
3361 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3363 else if (instance
->minor_version
> 0)
3365 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3367 else if (instance
->major_version
> 0)
3369 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3372 test_true(if_successful
== false);
3374 return TEST_SUCCESS
;
3377 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3379 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3380 memcached_return_t rc
;
3381 memcached_server_instance_st instance
=
3382 memcached_server_instance_by_position(memc
, 0);
3384 // Test both the version that returns a code, and the one that does not.
3385 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3386 memcached_server_port(instance
) -1, NULL
) == -1);
3388 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3389 memcached_server_port(instance
) -1, &rc
) == -1);
3390 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3392 return TEST_SUCCESS
;
3396 test_return_t
getpid_test(memcached_st
*memc
)
3398 memcached_return_t rc
;
3399 memcached_server_instance_st instance
=
3400 memcached_server_instance_by_position(memc
, 0);
3402 // Test both the version that returns a code, and the one that does not.
3403 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3404 memcached_server_port(instance
), NULL
) > -1);
3406 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3407 memcached_server_port(instance
), &rc
) > -1);
3408 test_compare(MEMCACHED_SUCCESS
, rc
);
3410 return TEST_SUCCESS
;
3413 static memcached_return_t
ping_each_server(const memcached_st
*,
3414 memcached_server_instance_st instance
,
3417 // Test both the version that returns a code, and the one that does not.
3418 memcached_return_t rc
;
3419 if (libmemcached_util_ping(memcached_server_name(instance
),
3420 memcached_server_port(instance
), &rc
) == false)
3422 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d %s", memcached_server_name(instance
),
3423 memcached_server_port(instance
), memcached_strerror(NULL
, rc
));
3426 if (libmemcached_util_ping(memcached_server_name(instance
),
3427 memcached_server_port(instance
), NULL
) == false)
3429 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d", memcached_server_name(instance
), memcached_server_port(instance
));
3432 return MEMCACHED_SUCCESS
;
3435 test_return_t
libmemcached_util_ping_TEST(memcached_st
*memc
)
3437 memcached_server_fn callbacks
[1]= { ping_each_server
};
3438 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
3440 return TEST_SUCCESS
;
3445 test_return_t
hash_sanity_test (memcached_st
*memc
)
3449 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3450 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3451 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3452 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3453 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3454 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3455 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3456 #ifdef HAVE_HSIEH_HASH
3457 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3459 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3460 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3461 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3463 return TEST_SUCCESS
;
3467 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3469 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3471 test_compare(MEMCACHED_SUCCESS
,
3472 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3473 (uint64_t)MEMCACHED_HASH_HSIEH
));
3475 return TEST_SUCCESS
;
3478 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3480 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3482 test_compare(MEMCACHED_SUCCESS
,
3483 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3485 return TEST_SUCCESS
;
3488 test_return_t
one_at_a_time_run (memcached_st
*)
3493 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3495 test_compare(one_at_a_time_values
[x
],
3496 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3499 return TEST_SUCCESS
;
3502 test_return_t
md5_run (memcached_st
*)
3507 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3509 test_compare(md5_values
[x
],
3510 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3513 return TEST_SUCCESS
;
3516 test_return_t
crc_run (memcached_st
*)
3521 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3523 test_compare(crc_values
[x
],
3524 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3527 return TEST_SUCCESS
;
3530 test_return_t
fnv1_64_run (memcached_st
*)
3532 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3537 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3539 test_compare(fnv1_64_values
[x
],
3540 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3543 return TEST_SUCCESS
;
3546 test_return_t
fnv1a_64_run (memcached_st
*)
3548 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3553 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3555 test_compare(fnv1a_64_values
[x
],
3556 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3559 return TEST_SUCCESS
;
3562 test_return_t
fnv1_32_run (memcached_st
*)
3567 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3569 test_compare(fnv1_32_values
[x
],
3570 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3573 return TEST_SUCCESS
;
3576 test_return_t
fnv1a_32_run (memcached_st
*)
3581 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3583 test_compare(fnv1a_32_values
[x
],
3584 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3587 return TEST_SUCCESS
;
3590 test_return_t
hsieh_run (memcached_st
*)
3592 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3597 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3599 test_compare(hsieh_values
[x
],
3600 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3603 return TEST_SUCCESS
;
3606 test_return_t
murmur_run (memcached_st
*)
3608 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3610 #ifdef WORDS_BIGENDIAN
3611 (void)murmur_values
;
3612 return TEST_SKIPPED
;
3617 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3619 test_compare(murmur_values
[x
],
3620 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3623 return TEST_SUCCESS
;
3627 test_return_t
jenkins_run (memcached_st
*)
3632 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3634 test_compare(jenkins_values
[x
],
3635 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3638 return TEST_SUCCESS
;
3641 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3643 return libhashkit_md5(string
, string_length
);
3646 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3648 return libhashkit_crc32(string
, string_length
);
3651 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3657 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3659 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};
3660 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};
3662 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3664 hashkit_clone(&new_kit
, kit
);
3665 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3667 memcached_set_hashkit(memc
, &new_kit
);
3670 Verify Setting the hash.
3672 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3676 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3677 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3682 Now check memcached_st.
3684 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3688 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3689 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3692 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3694 memcached_set_hashkit(memc
, &new_kit
);
3697 Verify Setting the hash.
3699 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3703 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3704 test_true(crc_values
[x
] == hash_val
);
3707 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3711 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3712 test_compare(crc_hosts
[x
], hash_val
);
3715 memcached_free(memc
);
3717 return TEST_SUCCESS
;
3721 Test case adapted from John Gorman <johngorman2@gmail.com>
3723 We are testing the error condition when we connect to a server via memcached_get()
3724 but find that the server is not available.
3726 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3730 memcached_return rc
;
3733 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3735 // See if memcached is reachable.
3736 char *value
= memcached_get(tl_memc_h
,
3737 test_literal_param(__func__
),
3742 test_true(memcached_failed(rc
));
3744 memcached_free(tl_memc_h
);
3746 return TEST_SUCCESS
;
3750 We connect to a server which exists, but search for a key that does not exist.
3752 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3756 memcached_return rc
;
3758 // See if memcached is reachable.
3759 char *value
= memcached_get(memc
,
3760 test_literal_param(__func__
),
3765 test_compare(MEMCACHED_NOTFOUND
, rc
);
3767 return TEST_SUCCESS
;
3771 Test case adapted from John Gorman <johngorman2@gmail.com>
3773 We are testing the error condition when we connect to a server via memcached_get_by_key()
3774 but find that the server is not available.
3776 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
3780 memcached_return rc
;
3783 memcached_st
*tl_memc_h
= memcached_create(NULL
);
3784 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
3785 memcached_server_push(tl_memc_h
, servers
);
3786 memcached_server_list_free(servers
);
3788 // See if memcached is reachable.
3789 char *value
= memcached_get_by_key(tl_memc_h
,
3790 test_literal_param(__func__
), // Key
3791 test_literal_param(__func__
), // Value
3796 test_true(memcached_failed(rc
));
3798 memcached_free(tl_memc_h
);
3800 return TEST_SUCCESS
;
3804 We connect to a server which exists, but search for a key that does not exist.
3806 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3810 memcached_return rc
;
3812 // See if memcached is reachable.
3813 char *value
= memcached_get_by_key(memc
,
3814 test_literal_param(__func__
), // Key
3815 test_literal_param(__func__
), // Value
3820 test_compare(MEMCACHED_NOTFOUND
, rc
);
3822 return TEST_SUCCESS
;
3825 test_return_t
regression_bug_434484(memcached_st
*memc
)
3827 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3829 test_compare(MEMCACHED_NOTSTORED
,
3830 memcached_append(memc
,
3831 test_literal_param(__func__
), // Key
3832 test_literal_param(__func__
), // Value
3835 libtest::vchar_t data
;
3836 data
.resize(2048 * 1024);
3837 test_compare(MEMCACHED_E2BIG
,
3839 test_literal_param(__func__
), // Key
3840 &data
[0], data
.size(), 0, 0));
3842 return TEST_SUCCESS
;
3845 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
3847 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
3849 memcached_return_t rc
;
3851 memcached_execute_fn callbacks
[]= { &callback_counter
};
3854 * I only want to hit only _one_ server so I know the number of requests I'm
3855 * sending in the pipleine to the server. Let's try to do a multiget of
3856 * 1024 (that should satisfy most users don't you think?). Future versions
3857 * will include a mget_execute function call if you need a higher number.
3859 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
3864 * Run two times.. the first time we should have 100% cache miss,
3865 * and the second time we should have 100% cache hits
3867 for (ptrdiff_t y
= 0; y
< 2; y
++)
3869 test_compare(MEMCACHED_SUCCESS
,
3870 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
3872 // One the first run we should get a NOT_FOUND, but on the second some data
3873 // should be returned.
3874 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
3875 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3879 /* The first iteration should give me a 100% cache miss. verify that*/
3880 char blob
[1024]= { 0 };
3882 test_false(counter
);
3884 for (size_t x
= 0; x
< keys
.size(); ++x
)
3886 rc
= memcached_add(memc
,
3887 keys
.key_at(x
), keys
.length_at(x
),
3888 blob
, sizeof(blob
), 0, 0);
3889 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3894 /* Verify that we received all of the key/value pairs */
3895 test_compare(counter
, keys
.size());
3899 memcached_free(memc
);
3901 return TEST_SUCCESS
;
3904 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
3906 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3908 return regression_bug_434843(memc
);
3911 test_return_t
regression_bug_421108(memcached_st
*memc
)
3913 memcached_return_t rc
;
3914 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3915 test_compare(MEMCACHED_SUCCESS
, rc
);
3917 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
3918 test_compare(MEMCACHED_SUCCESS
, rc
);
3919 test_true(bytes_str
);
3920 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
3922 test_compare(MEMCACHED_SUCCESS
, rc
);
3923 test_true(bytes_read_str
);
3925 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
3926 "bytes_written", &rc
);
3927 test_compare(MEMCACHED_SUCCESS
, rc
);
3928 test_true(bytes_written_str
);
3930 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
3931 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
3932 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
3934 test_true(bytes
!= bytes_read
);
3935 test_true(bytes
!= bytes_written
);
3937 /* Release allocated resources */
3939 free(bytes_read_str
);
3940 free(bytes_written_str
);
3941 memcached_stat_free(NULL
, memc_stat
);
3943 return TEST_SUCCESS
;
3947 * The test case isn't obvious so I should probably document why
3948 * it works the way it does. Bug 442914 was caused by a bug
3949 * in the logic in memcached_purge (it did not handle the case
3950 * where the number of bytes sent was equal to the watermark).
3951 * In this test case, create messages so that we hit that case
3952 * and then disable noreply mode and issue a new command to
3953 * verify that it isn't stuck. If we change the format for the
3954 * delete command or the watermarks, we need to update this
3957 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
3959 test_skip(original_memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3961 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
3963 for (uint32_t x
= 0; x
< 250; ++x
)
3966 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
3967 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
3968 char error_buffer
[2048]= { 0 };
3969 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
3970 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
3973 // Delete, and then delete again to look for not found
3976 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
3977 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
3978 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
3980 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
3981 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
3984 memcached_free(memc
);
3986 return TEST_SUCCESS
;
3989 test_return_t
regression_bug_447342(memcached_st
*memc
)
3991 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
3993 return TEST_SKIPPED
;
3996 test_compare(MEMCACHED_SUCCESS
,
3997 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4001 for (size_t x
= 0; x
< keys
.size(); ++x
)
4003 test_compare(MEMCACHED_SUCCESS
,
4005 keys
.key_at(x
), keys
.length_at(x
), // Keys
4006 keys
.key_at(x
), keys
.length_at(x
), // Values
4011 ** We are using the quiet commands to store the replicas, so we need
4012 ** to ensure that all of them are processed before we can continue.
4013 ** In the test we go directly from storing the object to trying to
4014 ** receive the object from all of the different servers, so we
4015 ** could end up in a race condition (the memcached server hasn't yet
4016 ** processed the quiet command from the replication set when it process
4017 ** the request from the other client (created by the clone)). As a
4018 ** workaround for that we call memcached_quit to send the quit command
4019 ** to the server and wait for the response ;-) If you use the test code
4020 ** as an example for your own code, please note that you shouldn't need
4023 memcached_quit(memc
);
4025 /* Verify that all messages are stored, and we didn't stuff too much
4028 test_compare(MEMCACHED_SUCCESS
,
4029 memcached_mget(memc
,
4030 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4032 unsigned int counter
= 0;
4033 memcached_execute_fn callbacks
[]= { &callback_counter
};
4034 test_compare(MEMCACHED_SUCCESS
,
4035 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4037 /* Verify that we received all of the key/value pairs */
4038 test_compare(counter
, keys
.size());
4040 memcached_quit(memc
);
4042 * Don't do the following in your code. I am abusing the internal details
4043 * within the library, and this is not a supported interface.
4044 * This is to verify correct behavior in the library. Fake that two servers
4047 memcached_server_instance_st instance_one
= memcached_server_instance_by_position(memc
, 0);
4048 memcached_server_instance_st instance_two
= memcached_server_instance_by_position(memc
, 2);
4049 in_port_t port0
= instance_one
->port
;
4050 in_port_t port2
= instance_two
->port
;
4052 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4053 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4055 test_compare(MEMCACHED_SUCCESS
,
4056 memcached_mget(memc
,
4057 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4060 test_compare(MEMCACHED_SUCCESS
,
4061 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4062 test_compare(counter
, keys
.size());
4064 /* restore the memc handle */
4065 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4066 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4068 memcached_quit(memc
);
4070 /* Remove half of the objects */
4071 for (size_t x
= 0; x
< keys
.size(); ++x
)
4075 test_compare(MEMCACHED_SUCCESS
,
4076 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4080 memcached_quit(memc
);
4081 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4082 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4084 /* now retry the command, this time we should have cache misses */
4085 test_compare(MEMCACHED_SUCCESS
,
4086 memcached_mget(memc
,
4087 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4090 test_compare(MEMCACHED_SUCCESS
,
4091 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4092 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4094 /* restore the memc handle */
4095 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4096 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4098 return TEST_SUCCESS
;
4101 test_return_t
regression_bug_463297(memcached_st
*memc
)
4103 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4105 // Since we blocked timed delete, this test is no longer valid.
4107 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4108 test_true(memc_clone
);
4109 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4111 memcached_server_instance_st instance
=
4112 memcached_server_instance_by_position(memc_clone
, 0);
4114 if (instance
->major_version
> 1 ||
4115 (instance
->major_version
== 1 &&
4116 instance
->minor_version
> 2))
4118 /* Binary protocol doesn't support deferred delete */
4119 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4120 test_true(bin_clone
);
4121 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4122 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4123 memcached_free(bin_clone
);
4125 memcached_quit(memc_clone
);
4127 /* If we know the server version, deferred delete should fail
4128 * with invalid arguments */
4129 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4131 /* If we don't know the server version, we should get a protocol error */
4132 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4134 /* but there is a bug in some of the memcached servers (1.4) that treats
4135 * the counter as noreply so it doesn't send the proper error message
4137 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4139 /* And buffered mode should be disabled and we should get protocol error */
4140 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4141 rc
= memcached_delete(memc
, "foo", 3, 1);
4142 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4144 /* Same goes for noreply... */
4145 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4146 rc
= memcached_delete(memc
, "foo", 3, 1);
4147 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4149 /* but a normal request should go through (and be buffered) */
4150 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4151 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4153 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4154 /* unbuffered noreply should be success */
4155 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4156 /* unbuffered with reply should be not found... */
4157 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4158 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4161 memcached_free(memc_clone
);
4164 return TEST_SUCCESS
;
4168 /* Test memcached_server_get_last_disconnect
4169 * For a working server set, shall be NULL
4170 * For a set of non existing server, shall not be NULL
4172 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4174 memcached_return_t rc
;
4175 memcached_server_instance_st disconnected_server
;
4177 /* With the working set of server */
4178 const char *key
= "marmotte";
4179 const char *value
= "milka";
4181 memcached_reset_last_disconnected_server(memc
);
4182 test_false(memc
->last_disconnected_server
);
4183 rc
= memcached_set(memc
, key
, strlen(key
),
4184 value
, strlen(value
),
4185 (time_t)0, (uint32_t)0);
4186 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4188 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4189 test_false(disconnected_server
);
4191 /* With a non existing server */
4193 memcached_server_st
*servers
;
4195 const char *server_list
= "localhost:9";
4197 servers
= memcached_servers_parse(server_list
);
4199 mine
= memcached_create(NULL
);
4200 rc
= memcached_server_push(mine
, servers
);
4201 test_compare(MEMCACHED_SUCCESS
, rc
);
4202 memcached_server_list_free(servers
);
4205 rc
= memcached_set(mine
, key
, strlen(key
),
4206 value
, strlen(value
),
4207 (time_t)0, (uint32_t)0);
4208 test_true(memcached_failed(rc
));
4210 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4211 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4212 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4213 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4215 memcached_quit(mine
);
4216 memcached_free(mine
);
4218 return TEST_SUCCESS
;
4221 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4223 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4224 char buffer
[BUFSIZ
];
4226 test_compare(MEMCACHED_SUCCESS
,
4227 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4229 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4232 // We will just use the error strings as our keys
4233 uint32_t counter
= 100;
4236 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4238 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4239 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4240 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4242 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
4243 test_true(disconnected_server
);
4244 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4245 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4249 memcached_reset_last_disconnected_server(memc
);
4254 memcached_free(memc
);
4256 return TEST_SUCCESS
;
4259 test_return_t
test_verbosity(memcached_st
*memc
)
4261 memcached_verbosity(memc
, 3);
4263 return TEST_SUCCESS
;
4267 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
4268 const char *key
, size_t key_length
,
4269 const char *value
, size_t value_length
,
4279 return MEMCACHED_SUCCESS
;
4282 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4284 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4285 test_compare(MEMCACHED_SUCCESS
, rc
);
4287 test_compare(MEMCACHED_SUCCESS
,
4288 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4290 test_compare(MEMCACHED_SUCCESS
,
4291 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4293 test_compare(MEMCACHED_SUCCESS
,
4294 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4296 return TEST_SUCCESS
;
4300 * This test ensures that the failure counter isn't incremented during
4301 * normal termination of the memcached instance.
4303 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4305 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4307 /* Ensure that we are connected to the server by setting a value */
4308 memcached_return_t rc
= memcached_set(memc
,
4309 test_literal_param(__func__
), // Key
4310 test_literal_param(__func__
), // Value
4311 time_t(0), uint32_t(0));
4312 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4315 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4317 /* The test is to see that the memcached_quit doesn't increase the
4318 * the server failure conter, so let's ensure that it is zero
4319 * before sending quit
4321 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4323 memcached_quit(memc
);
4325 /* Verify that it memcached_quit didn't increment the failure counter
4326 * Please note that this isn't bullet proof, because an error could
4329 test_zero(instance
->server_failure_counter
);
4331 memcached_free(memc
);
4333 return TEST_SUCCESS
;
4337 * This tests ensures expected disconnections (for some behavior changes
4338 * for instance) do not wrongly increase failure counter
4340 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4342 /* Set value to force connection to the server */
4343 const char *key
= "marmotte";
4344 const char *value
= "milka";
4346 test_compare_hint(MEMCACHED_SUCCESS
,
4347 memcached_set(memc
, key
, strlen(key
),
4348 value
, strlen(value
),
4349 (time_t)0, (uint32_t)0),
4350 memcached_last_error_message(memc
));
4353 /* put failure limit to 1 */
4354 test_compare(MEMCACHED_SUCCESS
,
4355 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4357 /* Put a retry timeout to effectively activate failure_limit effect */
4358 test_compare(MEMCACHED_SUCCESS
,
4359 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4361 /* change behavior that triggers memcached_quit()*/
4362 test_compare(MEMCACHED_SUCCESS
,
4363 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4366 /* Check if we still are connected */
4368 size_t string_length
;
4369 memcached_return rc
;
4370 char *string
= memcached_get(memc
, key
, strlen(key
),
4371 &string_length
, &flags
, &rc
);
4373 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4377 return TEST_SUCCESS
;
4380 test_return_t
regression_996813_TEST(memcached_st
*)
4382 memcached_st
* memc
= memcached_create(NULL
);
4384 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
4385 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
4386 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4387 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4388 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1));
4389 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 300));
4390 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 30));
4392 // We will never connect to these servers
4393 in_port_t base_port
= 11211;
4394 for (size_t x
= 0; x
< 17; x
++)
4396 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", base_port
+x
));
4398 test_compare(6U, memcached_generate_hash(memc
, test_literal_param("SZ6hu0SHweFmpwpc0w2R")));
4399 test_compare(1U, memcached_generate_hash(memc
, test_literal_param("SQCK9eiCf53YxHWnYA.o")));
4400 test_compare(9U, memcached_generate_hash(memc
, test_literal_param("SUSDkGXuuZC9t9VhMwa.")));
4401 test_compare(0U, memcached_generate_hash(memc
, test_literal_param("SnnqnJARfaCNT679iAF_")));
4403 memcached_free(memc
);
4405 return TEST_SUCCESS
;
4410 * Test that ensures mget_execute does not end into recursive calls that finally fails
4412 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4416 return TEST_SKIPPED
; // My MAC can't handle this test
4419 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4422 * I only want to hit _one_ server so I know the number of requests I'm
4423 * sending in the pipeline.
4425 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4428 keys_st
keys(20480);
4430 /* First add all of the items.. */
4431 char blob
[1024]= { 0 };
4432 for (size_t x
= 0; x
< keys
.size(); ++x
)
4434 memcached_return rc
= memcached_set(memc
,
4435 keys
.key_at(x
), keys
.length_at(x
),
4436 blob
, sizeof(blob
), 0, 0);
4437 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4442 /* Try to get all of them with a large multiget */
4444 memcached_execute_function callbacks
[]= { &callback_counter
};
4445 memcached_return_t rc
= memcached_mget_execute(memc
,
4446 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4447 callbacks
, &counter
, 1);
4448 test_compare(MEMCACHED_SUCCESS
, rc
);
4450 char* the_value
= NULL
;
4451 char the_key
[MEMCACHED_MAX_KEY
];
4452 size_t the_key_length
;
4453 size_t the_value_length
;
4457 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4459 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4465 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4468 test_compare(MEMCACHED_END
, rc
);
4470 /* Verify that we got all of the items */
4471 test_compare(counter
, keys
.size());
4474 memcached_free(memc
);
4476 return TEST_SUCCESS
;
4479 test_return_t
regression_bug_583031(memcached_st
*)
4481 memcached_st
*memc
= memcached_create(NULL
);
4483 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
4485 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
4486 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4487 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4488 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4489 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4490 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4492 memcached_return_t rc
;
4496 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4500 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
4502 memcached_free(memc
);
4504 return TEST_SUCCESS
;
4507 test_return_t
regression_bug_581030(memcached_st
*)
4510 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4511 test_false(local_stat
);
4513 memcached_stat_free(NULL
, NULL
);
4516 return TEST_SUCCESS
;
4519 #define regression_bug_655423_COUNT 6000
4520 test_return_t
regression_bug_655423(memcached_st
*memc
)
4522 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4523 memc
= NULL
; // Just to make sure it is not used
4528 return TEST_SKIPPED
;
4531 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4532 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4533 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4534 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4536 memset(payload
, int('x'), sizeof(payload
));
4538 keys_st
keys(regression_bug_655423_COUNT
);
4540 for (size_t x
= 0; x
< keys
.size(); x
++)
4542 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4545 payload
, sizeof(payload
), 0, 0));
4548 for (size_t x
= 0; x
< keys
.size(); x
++)
4550 size_t value_length
;
4551 memcached_return_t rc
;
4552 char *value
= memcached_get(clone
,
4555 &value_length
, NULL
, &rc
);
4557 if (rc
== MEMCACHED_NOTFOUND
)
4560 test_zero(value_length
);
4564 test_compare(MEMCACHED_SUCCESS
, rc
);
4566 test_compare(100LLU, value_length
);
4570 test_compare(MEMCACHED_SUCCESS
,
4571 memcached_mget(clone
,
4572 keys
.keys_ptr(), keys
.lengths_ptr(),
4576 memcached_result_st
*result
= NULL
;
4577 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4579 test_compare(size_t(100), memcached_result_length(result
));
4583 test_true(count
> 100); // If we don't get back atleast this, something is up
4585 memcached_free(clone
);
4587 return TEST_SUCCESS
;
4591 * Test that ensures that buffered set to not trigger problems during io_flush
4593 #define regression_bug_490520_COUNT 200480
4594 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4596 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4598 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4599 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4600 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4601 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4602 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4604 /* First add all of the items.. */
4605 char blob
[3333] = {0};
4606 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4609 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4611 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4612 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4615 memcached_free(memc
);
4617 return TEST_SUCCESS
;
4620 test_return_t
regression_1009493_TEST(memcached_st
*)
4622 memcached_st
* memc
= memcached_create(NULL
);
4624 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, true));
4626 memcached_st
* clone
= memcached_clone(NULL
, memc
);
4629 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
),
4630 memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
4632 memcached_free(memc
);
4633 memcached_free(clone
);
4635 return TEST_SUCCESS
;
4638 test_return_t
regression_994772_TEST(memcached_st
* memc
)
4640 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4642 test_compare(MEMCACHED_SUCCESS
,
4644 test_literal_param(__func__
), // Key
4645 test_literal_param(__func__
), // Value
4646 time_t(0), uint32_t(0)));
4648 const char *keys
[] = { __func__
};
4649 size_t key_length
[]= { strlen(__func__
) };
4650 test_compare(MEMCACHED_SUCCESS
,
4651 memcached_mget(memc
, keys
, key_length
, 1));
4653 memcached_return_t rc
;
4654 memcached_result_st
*results
= memcached_fetch_result(memc
, NULL
, &rc
);
4656 test_compare(MEMCACHED_SUCCESS
, rc
);
4658 test_strcmp(__func__
, memcached_result_value(results
));
4659 uint64_t cas_value
= memcached_result_cas(results
);
4660 test_true(cas_value
);
4662 memcached_result_free(results
);
4664 // Bad cas value, sanity check
4665 test_true(cas_value
!= 9999);
4666 test_compare(MEMCACHED_END
,
4668 test_literal_param(__func__
), // Key
4669 test_literal_param(__FILE__
), // Value
4670 time_t(0), uint32_t(0), 9999));
4672 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
4673 "different", strlen("different"), // Key
4674 test_literal_param(__FILE__
), // Value
4675 time_t(0), uint32_t(0)));
4677 return TEST_SUCCESS
;
4680 test_return_t
regression_bug_854604(memcached_st
*)
4684 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4686 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4688 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4689 test_compare(buffer
[0], 0);
4691 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4692 test_true(strlen(buffer
));
4694 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4695 test_true(strlen(buffer
));
4697 return TEST_SUCCESS
;
4700 static void die_message(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4702 fprintf(stderr
, "Iteration #%u: ", it
);
4704 if (error
== MEMCACHED_ERRNO
)
4706 fprintf(stderr
, "system error %d from %s: %s\n",
4707 errno
, what
, strerror(errno
));
4711 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4712 memcached_strerror(mc
, error
));
4716 #define TEST_CONSTANT_CREATION 200
4718 test_return_t
regression_bug_(memcached_st
*memc
)
4720 const char *remote_server
;
4723 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4725 return TEST_SKIPPED
;
4728 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4730 memcached_st
* mc
= memcached_create(NULL
);
4731 memcached_return rc
;
4733 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4734 if (rc
!= MEMCACHED_SUCCESS
)
4736 die_message(mc
, rc
, "memcached_behavior_set", x
);
4739 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4740 if (rc
!= MEMCACHED_SUCCESS
)
4742 die_message(mc
, rc
, "memcached_behavior_set", x
);
4745 rc
= memcached_server_add(mc
, remote_server
, 0);
4746 if (rc
!= MEMCACHED_SUCCESS
)
4748 die_message(mc
, rc
, "memcached_server_add", x
);
4751 const char *set_key
= "akey";
4752 const size_t set_key_len
= strlen(set_key
);
4753 const char *set_value
= "a value";
4754 const size_t set_value_len
= strlen(set_value
);
4756 if (rc
== MEMCACHED_SUCCESS
)
4760 size_t get_value_len
;
4762 uint32_t get_value_flags
;
4764 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
4765 &get_value_flags
, &rc
);
4766 if (rc
!= MEMCACHED_SUCCESS
)
4768 die_message(mc
, rc
, "memcached_get", x
);
4774 (get_value_len
!= set_value_len
4775 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
4777 fprintf(stderr
, "Values don't match?\n");
4778 rc
= MEMCACHED_FAILURE
;
4784 rc
= memcached_set(mc
,
4785 set_key
, set_key_len
,
4786 set_value
, set_value_len
,
4790 if (rc
!= MEMCACHED_SUCCESS
)
4792 die_message(mc
, rc
, "memcached_set", x
);
4799 if (rc
!= MEMCACHED_SUCCESS
)
4805 return TEST_SUCCESS
;
4808 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
4810 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
4813 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4816 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
4817 memcached_server_port(instance
), NULL
)) > -1);
4820 test_compare(MEMCACHED_SUCCESS
,
4822 test_literal_param(__func__
), // Keys
4823 test_literal_param(__func__
), // Values
4825 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
4827 test_compare(MEMCACHED_CONNECTION_FAILURE
,
4829 test_literal_param(__func__
), // Keys
4830 test_literal_param(__func__
), // Values
4833 memcached_free(memc
);
4835 return TEST_SUCCESS
;