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>
59 #include <semaphore.h>
63 #include <sys/types.h>
68 #include <libtest/server.h>
70 #include "clients/generator.h"
72 #define SMALL_STRING_LEN 1024
74 #include <libtest/test.hpp>
76 using namespace libtest
;
78 #include <libmemcached/util.h>
80 #include "tests/hash_results.h"
82 #include "tests/libmemcached-1.0/callback_counter.h"
83 #include "tests/libmemcached-1.0/fetch_all_results.h"
84 #include "tests/libmemcached-1.0/mem_functions.h"
85 #include "tests/libmemcached-1.0/setup_and_teardowns.h"
86 #include "tests/print.h"
87 #include "tests/debug.h"
89 #define UUID_STRING_MAXLENGTH 36
95 init(arg
, UUID_STRING_MAXLENGTH
);
98 keys_st(size_t arg
, size_t padding
)
103 void init(size_t arg
, size_t padding
)
105 _lengths
.resize(arg
);
108 for (size_t x
= 0; x
< _keys
.size(); x
++)
110 libtest::vchar_t key_buffer
;
111 key_buffer
.resize(padding
+1);
112 memset(&key_buffer
[0], 'x', padding
);
116 #if defined(HAVE_LIBUUID) && HAVE_LIBUUID
120 uuid_unparse(out
, &key_buffer
[0]);
121 _keys
[x
]= strdup(&key_buffer
[0]);
122 (_keys
[x
])[UUID_STRING_MAXLENGTH
]= 'x';
125 else // We just use a number and pad the string if UUID is not available
127 char int_buffer
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
128 int key_length
= snprintf(int_buffer
, sizeof(int_buffer
), "%u", uint32_t(x
));
129 memcpy(&key_buffer
[0], int_buffer
, key_length
);
130 _keys
[x
]= strdup(&key_buffer
[0]);
132 _lengths
[x
]= padding
;
138 for (libtest::vchar_ptr_t::iterator iter
= _keys
.begin();
146 libtest::vchar_ptr_t::iterator
begin()
148 return _keys
.begin();
151 libtest::vchar_ptr_t::iterator
end()
161 std::vector
<size_t>& lengths()
166 libtest::vchar_ptr_t
& keys()
171 size_t* lengths_ptr()
181 char* key_at(size_t arg
)
186 size_t length_at(size_t arg
)
188 return _lengths
[arg
];
192 libtest::vchar_ptr_t _keys
;
193 std::vector
<size_t> _lengths
;
196 static memcached_return_t
return_value_based_on_buffering(memcached_st
*memc
)
198 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
))
200 return MEMCACHED_BUFFERED
;
203 return MEMCACHED_SUCCESS
;
206 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
209 If no options are given, copy over at least the binary flag.
211 char options_buffer
[1024]= { 0 };
214 if (memcached_is_binary(original_memc
))
216 snprintf(options_buffer
, sizeof(options_buffer
), "--BINARY");
221 * I only want to hit _one_ server so I know the number of requests I'm
222 * sending in the pipeline.
224 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
226 char server_string
[1024];
227 int server_string_length
;
228 if (instance
->type
== MEMCACHED_CONNECTION_UNIX_SOCKET
)
232 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\" %s",
233 memcached_server_name(instance
), options
);
237 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\"",
238 memcached_server_name(instance
));
245 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
246 memcached_server_name(instance
), int(memcached_server_port(instance
)),
251 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
252 memcached_server_name(instance
), int(memcached_server_port(instance
)));
256 if (server_string_length
<= 0)
261 char errror_buffer
[1024];
262 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, errror_buffer
, sizeof(errror_buffer
))))
264 Error
<< "Failed to parse (" << server_string
<< ") " << errror_buffer
;
268 return memcached(server_string
, server_string_length
);
272 test_return_t
init_test(memcached_st
*not_used
)
277 (void)memcached_create(&memc
);
278 memcached_free(&memc
);
283 #define TEST_PORT_COUNT 7
284 in_port_t test_ports
[TEST_PORT_COUNT
];
286 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
287 const memcached_server_st
*server
,
291 size_t bigger
= *((size_t *)(context
));
293 assert(bigger
<= memcached_server_port(server
));
294 *((size_t *)(context
))= memcached_server_port(server
);
296 return MEMCACHED_SUCCESS
;
299 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
300 const memcached_server_st
*instance
,
304 FILE *stream
= (FILE *)context
;
307 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
308 memcached_server_name(instance
),
309 memcached_server_port(instance
),
310 instance
->major_version
,
311 instance
->minor_version
,
312 instance
->micro_version
);
314 return MEMCACHED_SUCCESS
;
317 test_return_t
server_sort_test(memcached_st
*ptr
)
319 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
321 memcached_return_t rc
;
322 memcached_server_fn callbacks
[1];
323 memcached_st
*local_memc
;
326 local_memc
= memcached_create(NULL
);
327 test_true(local_memc
);
328 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
330 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
332 test_ports
[x
]= (in_port_t
)random() % 64000;
333 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
334 test_compare(memcached_server_count(local_memc
), x
+1);
336 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
338 test_compare(MEMCACHED_SUCCESS
, rc
);
341 callbacks
[0]= server_display_function
;
342 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
345 memcached_free(local_memc
);
350 test_return_t
server_sort2_test(memcached_st
*ptr
)
352 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
353 memcached_server_fn callbacks
[1];
354 memcached_st
*local_memc
;
355 memcached_server_instance_st instance
;
358 local_memc
= memcached_create(NULL
);
359 test_true(local_memc
);
360 test_compare(MEMCACHED_SUCCESS
,
361 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
363 test_compare(MEMCACHED_SUCCESS
,
364 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
365 instance
= memcached_server_instance_by_position(local_memc
, 0);
366 test_compare(in_port_t(43043), memcached_server_port(instance
));
368 test_compare(MEMCACHED_SUCCESS
,
369 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
371 instance
= memcached_server_instance_by_position(local_memc
, 0);
372 test_compare(in_port_t(43042), memcached_server_port(instance
));
374 instance
= memcached_server_instance_by_position(local_memc
, 1);
375 test_compare(in_port_t(43043), memcached_server_port(instance
));
377 callbacks
[0]= server_display_function
;
378 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
381 memcached_free(local_memc
);
386 test_return_t
memcached_server_remove_test(memcached_st
*)
388 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";
391 test_compare(MEMCACHED_SUCCESS
,
392 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
393 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
396 memcached_server_fn callbacks
[1];
397 callbacks
[0]= server_print_callback
;
398 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
400 memcached_free(memc
);
405 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
406 const memcached_server_st
*server
,
410 uint32_t x
= *((uint32_t *)(context
));
412 if (! (test_ports
[x
] == server
->port
))
414 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
415 return MEMCACHED_FAILURE
;
418 *((uint32_t *)(context
))= ++x
;
420 return MEMCACHED_SUCCESS
;
423 test_return_t
server_unsort_test(memcached_st
*ptr
)
425 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
426 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
427 memcached_server_fn callbacks
[1];
428 memcached_st
*local_memc
;
431 local_memc
= memcached_create(NULL
);
432 test_true(local_memc
);
434 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
436 test_ports
[x
]= (in_port_t
)(random() % 64000);
437 test_compare(MEMCACHED_SUCCESS
,
438 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
439 test_compare(memcached_server_count(local_memc
), x
+1);
441 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
445 callbacks
[0]= server_display_unsort_function
;
446 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
448 /* Now we sort old data! */
449 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
450 callbacks
[0]= server_display_function
;
451 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
454 memcached_free(local_memc
);
459 test_return_t
allocation_test(memcached_st
*not_used
)
463 memc
= memcached_create(NULL
);
465 memcached_free(memc
);
470 test_return_t
clone_test(memcached_st
*memc
)
474 memcached_st
*memc_clone
;
475 memc_clone
= memcached_clone(NULL
, NULL
);
476 test_true(memc_clone
);
477 memcached_free(memc_clone
);
480 /* Can we init from null? */
482 memcached_st
*memc_clone
;
483 memc_clone
= memcached_clone(NULL
, memc
);
484 test_true(memc_clone
);
487 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
488 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
489 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
490 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
493 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
494 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
495 test_true(memc_clone
->distribution
== memc
->distribution
);
496 { // Test all of the flags
497 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
498 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
499 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
500 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
501 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
502 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
503 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
504 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
505 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
506 test_true(memc_clone
->flags
.reply
== memc
->flags
.reply
);
507 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
508 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
509 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
511 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
512 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
513 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
514 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
515 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
516 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
517 test_true(memc_clone
->on_clone
== memc
->on_clone
);
518 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
519 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
520 test_true(memc_clone
->recv_size
== memc
->recv_size
);
521 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
522 test_true(memc_clone
->send_size
== memc
->send_size
);
523 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
524 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
525 test_true(memc_clone
->user_data
== memc
->user_data
);
527 memcached_free(memc_clone
);
530 /* Can we init from struct? */
532 memcached_st declared_clone
;
533 memcached_st
*memc_clone
;
534 memset(&declared_clone
, 0 , sizeof(memcached_st
));
535 memc_clone
= memcached_clone(&declared_clone
, NULL
);
536 test_true(memc_clone
);
537 memcached_free(memc_clone
);
540 /* Can we init from struct? */
542 memcached_st declared_clone
;
543 memcached_st
*memc_clone
;
544 memset(&declared_clone
, 0 , sizeof(memcached_st
));
545 memc_clone
= memcached_clone(&declared_clone
, memc
);
546 test_true(memc_clone
);
547 memcached_free(memc_clone
);
553 test_return_t
userdata_test(memcached_st
*memc
)
556 test_false(memcached_set_user_data(memc
, foo
));
557 test_true(memcached_get_user_data(memc
) == foo
);
558 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
563 test_return_t
connection_test(memcached_st
*memc
)
565 test_compare(MEMCACHED_SUCCESS
,
566 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
571 test_return_t
libmemcached_string_behavior_test(memcached_st
*)
573 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
575 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
577 test_compare(37, int(MEMCACHED_BEHAVIOR_MAX
));
582 test_return_t
libmemcached_string_distribution_test(memcached_st
*)
584 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
586 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
588 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
593 test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
595 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
596 982370485U, 1263635348U, 4242906218U, 3829656100U,
597 1891735253U, 334139633U, 2257084983U, 3351789013U,
598 13199785U, 2542027183U, 1097051614U, 199566778U,
599 2748246961U, 2465192557U, 1664094137U, 2405439045U,
600 1842224848U, 692413798U, 3479807801U, 919913813U,
601 4269430871U, 610793021U, 527273862U, 1437122909U,
602 2300930706U, 2943759320U, 674306647U, 2400528935U,
603 54481931U, 4186304426U, 1741088401U, 2979625118U,
604 4159057246U, 3425930182U, 2593724503U, 1868899624U,
605 1769812374U, 2302537950U, 1110330676U, 3365377466U,
606 1336171666U, 3021258493U, 2334992265U, 3861994737U,
607 3582734124U, 3365377466U };
609 // You have updated the memcache_error messages but not updated docs/tests.
610 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
613 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
614 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
615 MEMCACHED_HASH_JENKINS
);
616 if (values
[rc
] != hash_val
)
618 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
619 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
621 test_compare(values
[rc
], hash_val
);
623 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
628 test_return_t
set_test(memcached_st
*memc
)
630 memcached_return_t rc
= memcached_set(memc
,
631 test_literal_param("foo"),
632 test_literal_param("when we sanitize"),
633 time_t(0), (uint32_t)0);
634 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
639 test_return_t
append_test(memcached_st
*memc
)
641 memcached_return_t rc
;
642 const char *in_value
= "we";
646 test_compare(MEMCACHED_SUCCESS
,
647 memcached_flush(memc
, 0));
649 test_compare(MEMCACHED_SUCCESS
,
651 test_literal_param(__func__
),
652 in_value
, strlen(in_value
),
653 time_t(0), uint32_t(0)));
655 test_compare(MEMCACHED_SUCCESS
,
656 memcached_append(memc
,
657 test_literal_param(__func__
),
658 " the", strlen(" the"),
659 time_t(0), uint32_t(0)));
661 test_compare(MEMCACHED_SUCCESS
,
662 memcached_append(memc
,
663 test_literal_param(__func__
),
664 " people", strlen(" people"),
665 time_t(0), uint32_t(0)));
667 char *out_value
= memcached_get(memc
,
668 test_literal_param(__func__
),
669 &value_length
, &flags
, &rc
);
670 test_memcmp(out_value
, "we the people", strlen("we the people"));
671 test_compare(strlen("we the people"), value_length
);
672 test_compare(MEMCACHED_SUCCESS
, rc
);
678 test_return_t
append_binary_test(memcached_st
*memc
)
680 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
682 test_compare(MEMCACHED_SUCCESS
,
683 memcached_flush(memc
, 0));
685 test_compare(MEMCACHED_SUCCESS
,
687 test_literal_param(__func__
),
689 time_t(0), uint32_t(0)));
692 for (uint32_t x
= 0; store_list
[x
] ; x
++)
694 test_compare(MEMCACHED_SUCCESS
,
695 memcached_append(memc
,
696 test_literal_param(__func__
),
697 (char *)&store_list
[x
], sizeof(uint32_t),
698 time_t(0), uint32_t(0)));
704 memcached_return_t rc
;
705 uint32_t *value
= (uint32_t *)memcached_get(memc
,
706 test_literal_param(__func__
),
707 &value_length
, &flags
, &rc
);
708 test_compare(value_length
, sizeof(uint32_t) * count
);
709 test_compare(MEMCACHED_SUCCESS
, rc
);
711 for (uint32_t counter
= count
, *ptr
= value
; counter
; counter
--)
713 test_compare(*ptr
, store_list
[count
- counter
]);
721 test_return_t
memcached_mget_mixed_memcached_get_TEST(memcached_st
*memc
)
725 for (libtest::vchar_ptr_t::iterator iter
= keys
.begin();
729 test_compare(MEMCACHED_SUCCESS
,
733 time_t(0), uint32_t(0)));
736 for (ptrdiff_t loop
= 0; loop
< 20; loop
++)
740 test_compare(MEMCACHED_SUCCESS
,
741 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
743 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
746 size_t result_count
= 0;
747 memcached_return_t rc
;
748 while (memcached_fetch_result(memc
, results
, &rc
))
752 test_compare(keys
.size(), result_count
);
756 int which_key
= random() %keys
.size();
759 memcached_return_t rc
;
760 char *out_value
= memcached_get(memc
, keys
.key_at(which_key
), keys
.length_at(which_key
),
761 &value_length
, &flags
, &rc
);
762 test_compare(MEMCACHED_SUCCESS
, rc
);
763 test_null(out_value
);
764 test_zero(value_length
);
772 test_return_t
cas2_test(memcached_st
*memc
)
774 const char *keys
[]= {"fudge", "son", "food"};
775 size_t key_length
[]= {5, 3, 4};
776 const char *value
= "we the people";
777 size_t value_length
= strlen("we the people");
779 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
781 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
783 for (uint32_t x
= 0; x
< 3; x
++)
785 test_compare(MEMCACHED_SUCCESS
,
786 memcached_set(memc
, keys
[x
], key_length
[x
],
787 keys
[x
], key_length
[x
],
788 time_t(50), uint32_t(9)));
791 test_compare(MEMCACHED_SUCCESS
,
792 memcached_mget(memc
, keys
, key_length
, 3));
794 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
797 memcached_return_t rc
;
798 results
= memcached_fetch_result(memc
, results
, &rc
);
800 test_true(results
->item_cas
);
801 test_compare(MEMCACHED_SUCCESS
, rc
);
802 test_true(memcached_result_cas(results
));
804 test_memcmp(value
, "we the people", strlen("we the people"));
805 test_compare(strlen("we the people"), value_length
);
806 test_compare(MEMCACHED_SUCCESS
, rc
);
808 memcached_result_free(results
);
813 test_return_t
cas_test(memcached_st
*memc
)
815 const char* keys
[2] = { __func__
, NULL
};
816 size_t keylengths
[2] = { strlen(__func__
), 0 };
818 memcached_result_st results_obj
;
820 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
822 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
824 test_compare(MEMCACHED_SUCCESS
,
826 test_literal_param(__func__
),
827 test_literal_param("we the people"),
828 (time_t)0, (uint32_t)0));
830 test_compare(MEMCACHED_SUCCESS
,
831 memcached_mget(memc
, keys
, keylengths
, 1));
833 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
836 memcached_return_t rc
;
837 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
839 test_compare(MEMCACHED_SUCCESS
, rc
);
840 test_true(memcached_result_cas(results
));
841 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
842 test_compare(test_literal_param_size("we the people"),
843 strlen(memcached_result_value(results
)));
845 uint64_t cas
= memcached_result_cas(results
);
848 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
849 test_true(rc
== MEMCACHED_END
);
850 test_true(results
== NULL
);
853 test_compare(MEMCACHED_SUCCESS
,
855 test_literal_param(__func__
),
856 test_literal_param("change the value"),
860 * The item will have a new cas value, so try to set it again with the old
861 * value. This should fail!
863 test_compare(MEMCACHED_DATA_EXISTS
,
865 test_literal_param(__func__
),
866 test_literal_param("change the value"),
869 memcached_result_free(&results_obj
);
875 test_return_t
prepend_test(memcached_st
*memc
)
877 const char *key
= "fig";
878 const char *value
= "people";
880 test_compare(MEMCACHED_SUCCESS
,
881 memcached_flush(memc
, 0));
883 test_compare(MEMCACHED_SUCCESS
,
884 memcached_set(memc
, key
, strlen(key
),
885 value
, strlen(value
),
886 time_t(0), uint32_t(0)));
888 test_compare(MEMCACHED_SUCCESS
,
889 memcached_prepend(memc
, key
, strlen(key
),
890 "the ", strlen("the "),
891 time_t(0), uint32_t(0)));
893 test_compare(MEMCACHED_SUCCESS
,
894 memcached_prepend(memc
, key
, strlen(key
),
895 "we ", strlen("we "),
896 time_t(0), uint32_t(0)));
900 memcached_return_t rc
;
901 char *out_value
= memcached_get(memc
, key
, strlen(key
),
902 &value_length
, &flags
, &rc
);
903 test_memcmp(out_value
, "we the people", strlen("we the people"));
904 test_compare(strlen("we the people"), value_length
);
905 test_compare(MEMCACHED_SUCCESS
, rc
);
912 Set the value, then quit to make sure it is flushed.
913 Come back in and test that add fails.
915 test_return_t
add_test(memcached_st
*memc
)
917 test_compare_hint(return_value_based_on_buffering(memc
),
919 test_literal_param(__func__
),
920 test_literal_param("when we sanitize"),
921 time_t(0), uint32_t(0)),
922 memcached_last_error_message(memc
));
924 memcached_quit(memc
);
926 test_compare_hint(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
928 test_literal_param(__func__
),
929 test_literal_param("try something else"),
930 time_t(0), uint32_t(0)),
931 memcached_last_error_message(memc
));
937 ** There was a problem of leaking filedescriptors in the initial release
938 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
939 ** systems it seems that the kernel is slow on reclaiming the resources
940 ** because the connects starts to time out (the test doesn't do much
941 ** anyway, so just loop 10 iterations)
943 test_return_t
add_wrapper(memcached_st
*memc
)
945 unsigned int max
= 10000;
953 for (uint32_t x
= 0; x
< max
; x
++)
959 test_return_t
replace_test(memcached_st
*memc
)
961 test_compare(return_value_based_on_buffering(memc
),
963 test_literal_param(__func__
),
964 test_literal_param("when we sanitize"),
965 time_t(0), uint32_t(0)));
967 test_compare(MEMCACHED_SUCCESS
,
968 memcached_replace(memc
,
969 test_literal_param(__func__
),
970 test_literal_param("first we insert some data"),
971 time_t(0), uint32_t(0)));
976 test_return_t
delete_test(memcached_st
*memc
)
978 test_compare(return_value_based_on_buffering(memc
),
980 test_literal_param(__func__
),
981 test_literal_param("when we sanitize"),
982 time_t(0), uint32_t(0)));
984 test_compare_hint(return_value_based_on_buffering(memc
),
985 memcached_delete(memc
,
986 test_literal_param(__func__
),
988 memcached_last_error_message(memc
));
993 test_return_t
flush_test(memcached_st
*memc
)
995 uint64_t query_id
= memcached_query_id(memc
);
996 test_compare(MEMCACHED_SUCCESS
,
997 memcached_flush(memc
, 0));
998 test_compare(query_id
+1, memcached_query_id(memc
));
1000 return TEST_SUCCESS
;
1003 static memcached_return_t
server_function(const memcached_st
*,
1004 const memcached_server_st
*,
1008 return MEMCACHED_SUCCESS
;
1011 test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
1014 strncpy(context
, "foo bad", sizeof(context
));
1015 memcached_server_fn callbacks
[1];
1017 callbacks
[0]= server_function
;
1018 memcached_server_cursor(memc
, callbacks
, context
, 1);
1019 return TEST_SUCCESS
;
1022 test_return_t
bad_key_test(memcached_st
*memc
)
1024 memcached_return_t rc
;
1025 const char *key
= "foo bad";
1028 uint64_t query_id
= memcached_query_id(memc
);
1030 // Just skip if we are in binary mode.
1031 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1033 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
1035 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
1036 test_true(memc_clone
);
1038 query_id
= memcached_query_id(memc_clone
);
1039 test_compare(MEMCACHED_SUCCESS
,
1040 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1041 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
1043 /* All keys are valid in the binary protocol (except for length) */
1044 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == false)
1046 uint64_t before_query_id
= memcached_query_id(memc_clone
);
1048 size_t string_length
;
1049 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1050 &string_length
, &flags
, &rc
);
1051 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1052 test_zero(string_length
);
1055 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
1057 query_id
= memcached_query_id(memc_clone
);
1058 test_compare(MEMCACHED_SUCCESS
,
1059 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
1060 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
1062 size_t string_length
;
1063 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1064 &string_length
, &flags
, &rc
);
1065 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1066 test_zero(string_length
);
1070 /* Test multi key for bad keys */
1071 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
1072 size_t key_lengths
[] = { 7, 7, 7 };
1073 query_id
= memcached_query_id(memc_clone
);
1074 test_compare(MEMCACHED_SUCCESS
,
1075 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1076 test_compare(query_id
, memcached_query_id(memc_clone
));
1078 query_id
= memcached_query_id(memc_clone
);
1079 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
1080 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
1081 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1083 query_id
= memcached_query_id(memc_clone
);
1084 // Grouping keys are not required to follow normal key behaviors
1085 test_compare(MEMCACHED_SUCCESS
,
1086 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
1087 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1089 /* The following test should be moved to the end of this function when the
1090 memcached server is updated to allow max size length of the keys in the
1093 test_compare(MEMCACHED_SUCCESS
,
1094 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
1096 libtest::vchar_t longkey
;
1098 libtest::vchar_t::iterator it
= longkey
.begin();
1099 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
1102 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
1104 size_t string_length
;
1106 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
1107 test_compare(MEMCACHED_NOTFOUND
, rc
);
1108 test_zero(string_length
);
1110 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
1111 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1112 test_zero(string_length
);
1116 /* Make sure zero length keys are marked as bad */
1118 test_compare(MEMCACHED_SUCCESS
,
1119 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1120 size_t string_length
;
1121 char *string
= memcached_get(memc_clone
, key
, 0,
1122 &string_length
, &flags
, &rc
);
1123 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1124 test_zero(string_length
);
1128 memcached_free(memc_clone
);
1130 return TEST_SUCCESS
;
1133 #define READ_THROUGH_VALUE "set for me"
1134 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
1137 memcached_result_st
*result
)
1139 (void)memc
;(void)key
;(void)key_length
;
1140 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
1143 #ifndef __INTEL_COMPILER
1144 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1147 test_return_t
read_through(memcached_st
*memc
)
1149 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1151 size_t string_length
;
1153 memcached_return_t rc
;
1154 char *string
= memcached_get(memc
,
1155 test_literal_param(__func__
),
1156 &string_length
, &flags
, &rc
);
1158 test_compare(MEMCACHED_NOTFOUND
, rc
);
1159 test_false(string_length
);
1162 test_compare(MEMCACHED_SUCCESS
,
1163 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1165 string
= memcached_get(memc
,
1166 test_literal_param(__func__
),
1167 &string_length
, &flags
, &rc
);
1169 test_compare(MEMCACHED_SUCCESS
, rc
);
1170 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1171 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1172 test_strcmp(READ_THROUGH_VALUE
, string
);
1175 string
= memcached_get(memc
,
1176 test_literal_param(__func__
),
1177 &string_length
, &flags
, &rc
);
1179 test_compare(MEMCACHED_SUCCESS
, rc
);
1181 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1182 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1183 test_strcmp(READ_THROUGH_VALUE
, string
);
1186 return TEST_SUCCESS
;
1189 test_return_t
get_test(memcached_st
*memc
)
1191 uint64_t query_id
= memcached_query_id(memc
);
1192 memcached_return_t rc
= memcached_delete(memc
,
1193 test_literal_param(__func__
),
1195 test_true_hint(rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_NOTFOUND
, memcached_last_error_message(memc
));
1196 test_compare(query_id
+1, memcached_query_id(memc
));
1198 size_t string_length
;
1200 char *string
= memcached_get(memc
,
1201 test_literal_param(__func__
),
1202 &string_length
, &flags
, &rc
);
1204 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_last_error_message(memc
));
1205 test_false(string_length
);
1208 return TEST_SUCCESS
;
1211 test_return_t
get_test2(memcached_st
*memc
)
1213 const char *value
= "when we sanitize";
1215 uint64_t query_id
= memcached_query_id(memc
);
1216 test_compare(return_value_based_on_buffering(memc
),
1218 test_literal_param(__func__
),
1219 value
, strlen(value
),
1220 time_t(0), uint32_t(0)));
1221 test_compare(query_id
+1, memcached_query_id(memc
));
1223 query_id
= memcached_query_id(memc
);
1224 test_true(query_id
);
1227 size_t string_length
;
1228 memcached_return_t rc
;
1229 char *string
= memcached_get(memc
,
1230 test_literal_param(__func__
),
1231 &string_length
, &flags
, &rc
);
1232 test_compare(query_id
+1, memcached_query_id(memc
));
1234 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1235 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1237 test_compare(strlen(value
), string_length
);
1238 test_memcmp(string
, value
, string_length
);
1242 return TEST_SUCCESS
;
1245 test_return_t
set_test2(memcached_st
*memc
)
1247 for (uint32_t x
= 0; x
< 10; x
++)
1249 test_compare(return_value_based_on_buffering(memc
),
1251 test_literal_param("foo"),
1252 test_literal_param("train in the brain"),
1253 time_t(0), uint32_t(0)));
1256 return TEST_SUCCESS
;
1259 test_return_t
set_test3(memcached_st
*memc
)
1261 size_t value_length
= 8191;
1263 libtest::vchar_t value
;
1264 value
.reserve(value_length
);
1265 for (uint32_t x
= 0; x
< value_length
; x
++)
1267 value
.push_back(char(x
% 127));
1270 /* The dump test relies on there being at least 32 items in memcached */
1271 for (uint32_t x
= 0; x
< 32; x
++)
1275 snprintf(key
, sizeof(key
), "foo%u", x
);
1277 uint64_t query_id
= memcached_query_id(memc
);
1278 test_compare_hint(return_value_based_on_buffering(memc
),
1279 memcached_set(memc
, key
, strlen(key
),
1280 &value
[0], value
.size(),
1281 time_t(0), uint32_t(0)),
1282 memcached_last_error_message(memc
));
1283 test_compare(query_id
+1, memcached_query_id(memc
));
1286 return TEST_SUCCESS
;
1289 test_return_t
get_test3(memcached_st
*memc
)
1291 size_t value_length
= 8191;
1293 libtest::vchar_t value
;
1294 value
.reserve(value_length
);
1295 for (uint32_t x
= 0; x
< value_length
; x
++)
1297 value
.push_back(char(x
% 127));
1300 test_compare_hint(return_value_based_on_buffering(memc
),
1302 test_literal_param(__func__
),
1303 &value
[0], value
.size(),
1304 time_t(0), uint32_t(0)),
1305 memcached_last_error_message(memc
));
1307 size_t string_length
;
1309 memcached_return_t rc
;
1310 char *string
= memcached_get(memc
,
1311 test_literal_param(__func__
),
1312 &string_length
, &flags
, &rc
);
1314 test_compare(MEMCACHED_SUCCESS
, rc
);
1316 test_compare(value
.size(), string_length
);
1317 test_memcmp(string
, &value
[0], string_length
);
1321 return TEST_SUCCESS
;
1324 test_return_t
get_test4(memcached_st
*memc
)
1326 size_t value_length
= 8191;
1328 libtest::vchar_t value
;
1329 value
.reserve(value_length
);
1330 for (uint32_t x
= 0; x
< value_length
; x
++)
1332 value
.push_back(char(x
% 127));
1335 test_compare_hint(return_value_based_on_buffering(memc
),
1337 test_literal_param(__func__
),
1338 &value
[0], value
.size(),
1339 time_t(0), uint32_t(0)),
1340 memcached_last_error_message(memc
));
1342 for (uint32_t x
= 0; x
< 10; x
++)
1345 size_t string_length
;
1346 memcached_return_t rc
;
1347 char *string
= memcached_get(memc
,
1348 test_literal_param(__func__
),
1349 &string_length
, &flags
, &rc
);
1351 test_compare(MEMCACHED_SUCCESS
, rc
);
1353 test_compare(value
.size(), string_length
);
1354 test_memcmp(string
, &value
[0], string_length
);
1358 return TEST_SUCCESS
;
1362 * This test verifies that memcached_read_one_response doesn't try to
1363 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1364 * responses before you execute a storage command.
1366 test_return_t
get_test5(memcached_st
*memc
)
1369 ** Request the same key twice, to ensure that we hash to the same server
1370 ** (so that we have multiple response values queued up) ;-)
1372 const char *keys
[]= { "key", "key" };
1373 size_t lengths
[]= { 3, 3 };
1377 test_compare_hint(return_value_based_on_buffering(memc
),
1378 memcached_set(memc
, keys
[0], lengths
[0],
1379 keys
[0], lengths
[0],
1380 time_t(0), uint32_t(0)),
1381 memcached_last_error_message(memc
));
1382 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1384 memcached_result_st results_obj
;
1385 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1388 memcached_return_t rc
;
1389 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1392 memcached_result_free(&results_obj
);
1394 /* Don't read out the second result, but issue a set instead.. */
1395 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1397 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1398 &rlen
, &flags
, &rc
);
1400 test_compare(MEMCACHED_NOTFOUND
, rc
);
1401 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1403 test_compare(MEMCACHED_SUCCESS
, rc
);
1406 return TEST_SUCCESS
;
1409 test_return_t
mget_end(memcached_st
*memc
)
1411 const char *keys
[]= { "foo", "foo2" };
1412 size_t lengths
[]= { 3, 4 };
1413 const char *values
[]= { "fjord", "41" };
1416 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1418 test_compare(MEMCACHED_SUCCESS
,
1420 keys
[x
], lengths
[x
],
1421 values
[x
], strlen(values
[x
]),
1422 time_t(0), uint32_t(0)));
1426 size_t string_length
;
1429 // retrieve both via mget
1430 test_compare(MEMCACHED_SUCCESS
,
1431 memcached_mget(memc
,
1433 test_array_length(keys
)));
1435 char key
[MEMCACHED_MAX_KEY
];
1437 memcached_return_t rc
;
1439 // this should get both
1440 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1442 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1444 test_compare(MEMCACHED_SUCCESS
, rc
);
1446 if (key_length
== 4)
1451 test_compare(string_length
, strlen(values
[val
]));
1452 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1456 // this should indicate end
1457 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1458 test_compare(MEMCACHED_END
, rc
);
1462 test_compare(MEMCACHED_SUCCESS
,
1463 memcached_mget(memc
, keys
, lengths
, 1));
1465 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1466 test_compare(key_length
, lengths
[0]);
1467 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1468 test_compare(string_length
, strlen(values
[0]));
1469 test_true(strncmp(values
[0], string
, string_length
) == 0);
1470 test_compare(MEMCACHED_SUCCESS
, rc
);
1473 // this should indicate end
1474 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1475 test_compare(MEMCACHED_END
, rc
);
1478 return TEST_SUCCESS
;
1481 /* Do not copy the style of this code, I just access hosts to testthis function */
1482 test_return_t
stats_servername_test(memcached_st
*memc
)
1484 memcached_stat_st memc_stat
;
1485 memcached_server_instance_st instance
=
1486 memcached_server_instance_by_position(memc
, 0);
1488 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1490 return TEST_SKIPPED
;
1493 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1494 memcached_server_name(instance
),
1495 memcached_server_port(instance
)));
1497 return TEST_SUCCESS
;
1500 test_return_t
increment_test(memcached_st
*memc
)
1502 uint64_t new_number
;
1504 test_compare(MEMCACHED_SUCCESS
,
1506 test_literal_param("number"),
1507 test_literal_param("0"),
1508 (time_t)0, (uint32_t)0));
1510 test_compare(MEMCACHED_SUCCESS
,
1511 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1512 test_compare(uint64_t(1), new_number
);
1514 test_compare(MEMCACHED_SUCCESS
,
1515 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1516 test_compare(uint64_t(2), new_number
);
1518 return TEST_SUCCESS
;
1521 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1523 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1525 uint64_t new_number
;
1526 uint64_t initial
= 0;
1528 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1530 test_compare(MEMCACHED_SUCCESS
,
1531 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1532 test_compare(new_number
, initial
);
1534 test_compare(MEMCACHED_SUCCESS
,
1535 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1536 test_compare(new_number
, (initial
+1));
1538 return TEST_SUCCESS
;
1541 test_return_t
decrement_test(memcached_st
*memc
)
1543 test_compare(return_value_based_on_buffering(memc
),
1545 test_literal_param(__func__
),
1546 test_literal_param("3"),
1547 time_t(0), uint32_t(0)));
1548 // Make sure we flush the value we just set
1549 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1551 uint64_t new_number
;
1552 test_compare(MEMCACHED_SUCCESS
,
1553 memcached_decrement(memc
,
1554 test_literal_param(__func__
),
1556 test_compare(uint64_t(2), new_number
);
1558 test_compare(MEMCACHED_SUCCESS
,
1559 memcached_decrement(memc
,
1560 test_literal_param(__func__
),
1562 test_compare(uint64_t(1), new_number
);
1564 return TEST_SUCCESS
;
1567 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1569 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1571 uint64_t initial
= 3;
1573 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1575 uint64_t new_number
;
1576 test_compare(MEMCACHED_SUCCESS
,
1577 memcached_decrement_with_initial(memc
,
1578 test_literal_param(__func__
),
1581 test_compare(new_number
, initial
);
1583 test_compare(MEMCACHED_SUCCESS
,
1584 memcached_decrement_with_initial(memc
,
1585 test_literal_param(__func__
),
1588 test_compare(new_number
, (initial
- 1));
1590 return TEST_SUCCESS
;
1593 test_return_t
increment_by_key_test(memcached_st
*memc
)
1595 const char *master_key
= "foo";
1596 const char *key
= "number";
1597 const char *value
= "0";
1599 test_compare(return_value_based_on_buffering(memc
),
1600 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1602 value
, strlen(value
),
1603 time_t(0), uint32_t(0)));
1605 // Make sure we flush the value we just set
1606 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1608 uint64_t new_number
;
1609 test_compare(MEMCACHED_SUCCESS
,
1610 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1611 key
, strlen(key
), 1, &new_number
));
1612 test_compare(uint64_t(1), new_number
);
1614 test_compare(MEMCACHED_SUCCESS
,
1615 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1616 key
, strlen(key
), 1, &new_number
));
1617 test_compare(uint64_t(2), new_number
);
1619 return TEST_SUCCESS
;
1622 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1624 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1626 uint64_t new_number
;
1627 const char *master_key
= "foo";
1628 const char *key
= "number";
1629 uint64_t initial
= 0;
1631 test_compare(MEMCACHED_SUCCESS
,
1632 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1634 1, initial
, 0, &new_number
));
1635 test_compare(new_number
, initial
);
1637 test_compare(MEMCACHED_SUCCESS
,
1638 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1640 1, initial
, 0, &new_number
));
1641 test_compare(new_number
, (initial
+1));
1643 return TEST_SUCCESS
;
1646 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1648 uint64_t new_number
;
1649 const char *value
= "3";
1651 test_compare(return_value_based_on_buffering(memc
),
1652 memcached_set_by_key(memc
,
1653 test_literal_param("foo"),
1654 test_literal_param("number"),
1655 value
, strlen(value
),
1656 (time_t)0, (uint32_t)0));
1658 test_compare(MEMCACHED_SUCCESS
,
1659 memcached_decrement_by_key(memc
,
1660 test_literal_param("foo"),
1661 test_literal_param("number"),
1663 test_compare(uint64_t(2), new_number
);
1665 test_compare(MEMCACHED_SUCCESS
,
1666 memcached_decrement_by_key(memc
,
1667 test_literal_param("foo"),
1668 test_literal_param("number"),
1670 test_compare(uint64_t(1), new_number
);
1672 return TEST_SUCCESS
;
1675 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1677 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1679 uint64_t new_number
;
1680 uint64_t initial
= 3;
1682 test_compare(MEMCACHED_SUCCESS
,
1683 memcached_decrement_with_initial_by_key(memc
,
1684 test_literal_param("foo"),
1685 test_literal_param("number"),
1686 1, initial
, 0, &new_number
));
1687 test_compare(new_number
, initial
);
1689 test_compare(MEMCACHED_SUCCESS
,
1690 memcached_decrement_with_initial_by_key(memc
,
1691 test_literal_param("foo"),
1692 test_literal_param("number"),
1693 1, initial
, 0, &new_number
));
1694 test_compare(new_number
, (initial
- 1));
1696 return TEST_SUCCESS
;
1698 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1700 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1702 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1704 test_compare(return_value_based_on_buffering(memc
),
1706 test_literal_param("number"),
1707 test_literal_param("0"),
1708 (time_t)0, (uint32_t)0));
1710 uint64_t new_number
;
1711 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1712 test_literal_param("number"),
1714 test_compare(uint64_t(1), new_number
);
1716 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1717 test_literal_param("number"),
1719 test_compare(uint64_t(2), new_number
);
1721 return TEST_SUCCESS
;
1724 test_return_t
quit_test(memcached_st
*memc
)
1726 const char *value
= "sanford and sun";
1728 test_compare(return_value_based_on_buffering(memc
),
1730 test_literal_param(__func__
),
1731 value
, strlen(value
),
1732 (time_t)10, (uint32_t)3));
1733 memcached_quit(memc
);
1735 test_compare(return_value_based_on_buffering(memc
),
1737 test_literal_param(__func__
),
1738 value
, strlen(value
),
1739 (time_t)50, (uint32_t)9));
1741 return TEST_SUCCESS
;
1744 test_return_t
mget_result_test(memcached_st
*memc
)
1746 const char *keys
[]= {"fudge", "son", "food"};
1747 size_t key_length
[]= {5, 3, 4};
1749 memcached_result_st results_obj
;
1750 memcached_result_st
*results
;
1752 results
= memcached_result_create(memc
, &results_obj
);
1754 test_true(&results_obj
== results
);
1756 /* We need to empty the server before continueing test */
1757 test_compare(MEMCACHED_SUCCESS
,
1758 memcached_flush(memc
, 0));
1760 test_compare(MEMCACHED_SUCCESS
,
1761 memcached_mget(memc
, keys
, key_length
, 3));
1763 memcached_return_t rc
;
1764 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1769 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1770 test_false(results
);
1771 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1773 for (uint32_t x
= 0; x
< 3; x
++)
1775 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1776 keys
[x
], key_length
[x
],
1777 (time_t)50, (uint32_t)9);
1778 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1781 test_compare(MEMCACHED_SUCCESS
,
1782 memcached_mget(memc
, keys
, key_length
, 3));
1784 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1787 test_true(&results_obj
== results
);
1788 test_compare(MEMCACHED_SUCCESS
, rc
);
1789 test_memcmp(memcached_result_key_value(results
),
1790 memcached_result_value(results
),
1791 memcached_result_length(results
));
1792 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1795 memcached_result_free(&results_obj
);
1797 return TEST_SUCCESS
;
1800 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1802 const char *keys
[]= {"fudge", "son", "food"};
1803 size_t key_length
[]= {5, 3, 4};
1805 memcached_result_st
*results
;
1807 /* We need to empty the server before continueing test */
1808 test_compare(MEMCACHED_SUCCESS
,
1809 memcached_flush(memc
, 0));
1811 test_compare(MEMCACHED_SUCCESS
,
1812 memcached_mget(memc
, keys
, key_length
, 3));
1814 memcached_return_t rc
;
1815 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1819 test_false(results
);
1820 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1822 for (uint32_t x
= 0; x
< 3; x
++)
1824 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1825 keys
[x
], key_length
[x
],
1826 (time_t)50, (uint32_t)9);
1827 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1830 test_compare(MEMCACHED_SUCCESS
,
1831 memcached_mget(memc
, keys
, key_length
, 3));
1834 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1837 test_compare(MEMCACHED_SUCCESS
, rc
);
1838 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1839 test_memcmp(memcached_result_key_value(results
),
1840 memcached_result_value(results
),
1841 memcached_result_length(results
));
1842 memcached_result_free(results
);
1846 return TEST_SUCCESS
;
1849 test_return_t
mget_result_function(memcached_st
*memc
)
1851 const char *keys
[]= {"fudge", "son", "food"};
1852 size_t key_length
[]= {5, 3, 4};
1854 memcached_execute_fn callbacks
[1];
1856 for (uint32_t x
= 0; x
< 3; x
++)
1858 test_compare(return_value_based_on_buffering(memc
),
1859 memcached_set(memc
, keys
[x
], key_length
[x
],
1860 keys
[x
], key_length
[x
],
1861 time_t(50), uint32_t(9)));
1863 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1864 memcached_quit(memc
);
1866 test_compare(MEMCACHED_SUCCESS
,
1867 memcached_mget(memc
, keys
, key_length
, 3));
1869 callbacks
[0]= &callback_counter
;
1872 test_compare(MEMCACHED_SUCCESS
,
1873 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1875 test_compare(size_t(3), counter
);
1877 return TEST_SUCCESS
;
1880 test_return_t
mget_test(memcached_st
*memc
)
1882 const char *keys
[]= {"fudge", "son", "food"};
1883 size_t key_length
[]= {5, 3, 4};
1885 char return_key
[MEMCACHED_MAX_KEY
];
1886 size_t return_key_length
;
1888 size_t return_value_length
;
1890 test_compare(MEMCACHED_SUCCESS
,
1891 memcached_mget(memc
, keys
, key_length
, 3));
1894 memcached_return_t rc
;
1895 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1896 &return_value_length
, &flags
, &rc
)))
1898 test_true(return_value
);
1900 test_false(return_value
);
1901 test_zero(return_value_length
);
1902 test_compare(MEMCACHED_NOTFOUND
, rc
);
1904 for (uint32_t x
= 0; x
< 3; x
++)
1906 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1907 keys
[x
], key_length
[x
],
1908 (time_t)50, (uint32_t)9);
1909 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1911 test_compare(MEMCACHED_SUCCESS
,
1912 memcached_mget(memc
, keys
, key_length
, 3));
1915 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1916 &return_value_length
, &flags
, &rc
)))
1918 test_true(return_value
);
1919 test_compare(MEMCACHED_SUCCESS
, rc
);
1920 if (not memc
->_namespace
)
1922 test_compare(return_key_length
, return_value_length
);
1923 test_memcmp(return_value
, return_key
, return_value_length
);
1929 return TEST_SUCCESS
;
1932 test_return_t
mget_execute(memcached_st
*original_memc
)
1934 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1936 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1939 keys_st
keys(20480);
1941 /* First add all of the items.. */
1942 char blob
[1024] = {0};
1944 for (size_t x
= 0; x
< keys
.size(); ++x
)
1946 uint64_t query_id
= memcached_query_id(memc
);
1947 memcached_return_t rc
= memcached_add(memc
,
1948 keys
.key_at(x
), keys
.length_at(x
),
1951 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
,
1952 memcached_strerror(NULL
, rc
));
1953 test_compare(query_id
+1, memcached_query_id(memc
));
1956 /* Try to get all of them with a large multiget */
1958 memcached_execute_fn callbacks
[]= { &callback_counter
};
1959 test_compare(MEMCACHED_SUCCESS
,
1960 memcached_mget_execute(memc
,
1961 keys
.keys_ptr(), keys
.lengths_ptr(),
1962 keys
.size(), callbacks
, &counter
, 1));
1965 uint64_t query_id
= memcached_query_id(memc
);
1966 test_compare(MEMCACHED_SUCCESS
,
1967 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1968 test_compare(query_id
, memcached_query_id(memc
));
1970 /* Verify that we got all of the items */
1971 test_compare(keys
.size(), counter
);
1974 memcached_free(memc
);
1976 return TEST_SUCCESS
;
1979 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1980 static pairs_st
*global_pairs
;
1982 test_return_t
key_setup(memcached_st
*memc
)
1984 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1986 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1988 return TEST_SUCCESS
;
1991 test_return_t
key_teardown(memcached_st
*)
1993 pairs_free(global_pairs
);
1995 return TEST_SUCCESS
;
1998 test_return_t
block_add_regression(memcached_st
*memc
)
2000 /* First add all of the items.. */
2001 for (ptrdiff_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
2003 char blob
[1024] = {0};
2005 memcached_return_t rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
2006 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
, memcached_strerror(NULL
, rc
));
2009 return TEST_SUCCESS
;
2012 test_return_t
binary_add_regression(memcached_st
*memc
)
2014 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2015 test_return_t rc
= block_add_regression(memc
);
2020 test_return_t
get_stats_keys(memcached_st
*memc
)
2024 memcached_stat_st memc_stat
;
2025 memcached_return_t rc
;
2027 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
2028 test_compare(MEMCACHED_SUCCESS
, rc
);
2029 for (ptr
= stat_list
; *ptr
; ptr
++)
2034 return TEST_SUCCESS
;
2037 test_return_t
version_string_test(memcached_st
*)
2039 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
2041 return TEST_SUCCESS
;
2044 test_return_t
get_stats(memcached_st
*memc
)
2046 memcached_return_t rc
;
2048 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
2049 test_compare(MEMCACHED_SUCCESS
, rc
);
2050 test_true(memc_stat
);
2052 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
2054 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
2055 test_compare(MEMCACHED_SUCCESS
, rc
);
2056 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
2061 memcached_stat_free(NULL
, memc_stat
);
2063 return TEST_SUCCESS
;
2066 test_return_t
add_host_test(memcached_st
*memc
)
2068 char servername
[]= "0.example.com";
2070 memcached_return_t rc
;
2071 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2072 test_compare(1U, memcached_server_list_count(servers
));
2074 for (unsigned int x
= 2; x
< 20; x
++)
2076 char buffer
[SMALL_STRING_LEN
];
2078 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2079 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2081 test_compare(MEMCACHED_SUCCESS
, rc
);
2082 test_compare(x
, memcached_server_list_count(servers
));
2085 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2086 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2088 memcached_server_list_free(servers
);
2090 return TEST_SUCCESS
;
2093 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
2095 memcached_return_t rc
;
2097 const char *key
= "not_found";
2098 size_t key_length
= test_literal_param_size("not_found");
2100 test_compare(MEMCACHED_SUCCESS
,
2101 memcached_mget(memc
, &key
, &key_length
, 1));
2103 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
2105 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2107 memcached_result_free(result
);
2109 return TEST_SUCCESS
;
2112 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
2114 return MEMCACHED_SUCCESS
;
2117 static memcached_return_t
cleanup_test_callback(memcached_st
*)
2119 return MEMCACHED_SUCCESS
;
2122 test_return_t
callback_test(memcached_st
*memc
)
2124 /* Test User Data */
2128 memcached_return_t rc
;
2130 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
2131 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
2132 test_true(*test_ptr
== x
);
2135 /* Test Clone Callback */
2137 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2138 void *clone_cb_ptr
= *(void **)&clone_cb
;
2139 void *temp_function
= NULL
;
2141 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
2142 memcached_return_t rc
;
2143 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2144 test_true(temp_function
== clone_cb_ptr
);
2145 test_compare(MEMCACHED_SUCCESS
, rc
);
2148 /* Test Cleanup Callback */
2150 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2151 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2152 void *temp_function
= NULL
;
2153 memcached_return_t rc
;
2155 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2156 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2157 test_true(temp_function
== cleanup_cb_ptr
);
2160 return TEST_SUCCESS
;
2163 /* We don't test the behavior itself, we test the switches */
2164 test_return_t
behavior_test(memcached_st
*memc
)
2166 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2167 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2169 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2170 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2172 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2173 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2175 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2176 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2178 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2179 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2181 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2182 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2184 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2185 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2187 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2189 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2191 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2192 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2193 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2195 return TEST_SUCCESS
;
2198 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2200 test_compare(MEMCACHED_DEPRECATED
,
2201 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2203 // Platform dependent
2205 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2209 return TEST_SUCCESS
;
2213 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2215 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2216 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2218 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2220 if (memcached_success(rc
))
2229 return TEST_SUCCESS
;
2233 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2235 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2236 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2238 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2240 if (memcached_success(rc
))
2249 return TEST_SUCCESS
;
2252 /* Make sure we behave properly if server list has no values */
2253 test_return_t
user_supplied_bug4(memcached_st
*memc
)
2255 const char *keys
[]= {"fudge", "son", "food"};
2256 size_t key_length
[]= {5, 3, 4};
2258 /* Here we free everything before running a bunch of mget tests */
2259 memcached_servers_reset(memc
);
2262 /* We need to empty the server before continueing test */
2263 test_compare(MEMCACHED_NO_SERVERS
,
2264 memcached_flush(memc
, 0));
2266 test_compare(MEMCACHED_NO_SERVERS
,
2267 memcached_mget(memc
, keys
, key_length
, 3));
2270 unsigned int keys_returned
;
2271 memcached_return_t rc
;
2272 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2273 test_compare(MEMCACHED_NOTFOUND
, rc
);
2274 test_zero(keys_returned
);
2277 for (uint32_t x
= 0; x
< 3; x
++)
2279 test_compare(MEMCACHED_NO_SERVERS
,
2280 memcached_set(memc
, keys
[x
], key_length
[x
],
2281 keys
[x
], key_length
[x
],
2282 (time_t)50, (uint32_t)9));
2285 test_compare(MEMCACHED_NO_SERVERS
,
2286 memcached_mget(memc
, keys
, key_length
, 3));
2290 char return_key
[MEMCACHED_MAX_KEY
];
2291 memcached_return_t rc
;
2292 size_t return_key_length
;
2293 size_t return_value_length
;
2296 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2297 &return_value_length
, &flags
, &rc
)))
2299 test_true(return_value
);
2300 test_compare(MEMCACHED_SUCCESS
, rc
);
2301 test_true(return_key_length
== return_value_length
);
2302 test_memcmp(return_value
, return_key
, return_value_length
);
2308 return TEST_SUCCESS
;
2311 #define VALUE_SIZE_BUG5 1048064
2312 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2314 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2315 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2317 size_t value_length
;
2319 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2321 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2323 insert_data
[x
]= (signed char)rand();
2326 test_compare(MEMCACHED_SUCCESS
,
2327 memcached_flush(memc
, 0));
2329 memcached_return_t rc
;
2330 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2331 test_compare(MEMCACHED_SUCCESS
,
2332 memcached_mget(memc
, keys
, key_length
, 4));
2335 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2336 test_compare(MEMCACHED_NOTFOUND
, rc
);
2339 for (uint32_t x
= 0; x
< 4; x
++)
2341 test_compare(MEMCACHED_SUCCESS
,
2342 memcached_set(memc
, keys
[x
], key_length
[x
],
2343 insert_data
, VALUE_SIZE_BUG5
,
2344 (time_t)0, (uint32_t)0));
2347 for (uint32_t x
= 0; x
< 10; x
++)
2349 value
= memcached_get(memc
, keys
[0], key_length
[0],
2350 &value_length
, &flags
, &rc
);
2351 test_compare(rc
, MEMCACHED_SUCCESS
);
2355 test_compare(MEMCACHED_SUCCESS
,
2356 memcached_mget(memc
, keys
, key_length
, 4));
2358 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2359 test_compare(4U, count
);
2361 delete [] insert_data
;
2363 return TEST_SUCCESS
;
2366 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2368 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2369 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2370 char return_key
[MEMCACHED_MAX_KEY
];
2371 size_t return_key_length
;
2373 size_t value_length
;
2375 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2377 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2379 insert_data
[x
]= (signed char)rand();
2382 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2384 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2386 // We will now confirm that memcached_mget() returns success, but we will
2387 // then check to make sure that no actual keys are returned.
2388 test_compare(MEMCACHED_SUCCESS
,
2389 memcached_mget(memc
, keys
, key_length
, 4));
2391 memcached_return_t rc
;
2393 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2394 &value_length
, &flags
, &rc
)))
2399 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2401 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2403 test_compare(MEMCACHED_SUCCESS
,
2404 memcached_set(memc
, keys
[x
], key_length
[x
],
2405 insert_data
, VALUE_SIZE_BUG5
,
2406 (time_t)0, (uint32_t)0));
2408 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2410 for (uint32_t x
= 0; x
< 2; x
++)
2412 value
= memcached_get(memc
, keys
[0], key_length
[0],
2413 &value_length
, &flags
, &rc
);
2417 test_compare(MEMCACHED_SUCCESS
,
2418 memcached_mget(memc
, keys
, key_length
, 4));
2419 /* We test for purge of partial complete fetches */
2420 for (count
= 3; count
; count
--)
2422 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2423 &value_length
, &flags
, &rc
);
2424 test_compare(MEMCACHED_SUCCESS
, rc
);
2425 test_memcmp(value
, insert_data
, value_length
);
2426 test_true(value_length
);
2430 delete [] insert_data
;
2432 return TEST_SUCCESS
;
2435 test_return_t
user_supplied_bug8(memcached_st
*)
2437 memcached_return_t rc
;
2439 memcached_st
*memc_clone
;
2441 memcached_server_st
*servers
;
2442 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";
2444 servers
= memcached_servers_parse(server_list
);
2447 mine
= memcached_create(NULL
);
2448 rc
= memcached_server_push(mine
, servers
);
2449 test_compare(MEMCACHED_SUCCESS
, rc
);
2450 memcached_server_list_free(servers
);
2453 memc_clone
= memcached_clone(NULL
, mine
);
2455 memcached_quit(mine
);
2456 memcached_quit(memc_clone
);
2459 memcached_free(mine
);
2460 memcached_free(memc_clone
);
2462 return TEST_SUCCESS
;
2465 /* Test flag store/retrieve */
2466 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2468 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2469 test_true(insert_data
);
2471 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2473 insert_data
[x
]= (signed char)rand();
2476 memcached_flush(memc
, 0);
2478 const char *keys
= "036790384900";
2479 size_t key_length
= strlen(keys
);
2480 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2481 insert_data
, VALUE_SIZE_BUG5
,
2483 memcached_last_error_message(memc
));
2485 memcached_return_t rc
;
2486 size_t value_length
;
2488 char *value
= memcached_get(memc
, keys
, key_length
,
2489 &value_length
, &flags
, &rc
);
2490 test_compare(245U, flags
);
2494 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2496 char return_key
[MEMCACHED_MAX_KEY
];
2497 size_t return_key_length
;
2499 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2500 &value_length
, &flags
, &rc
);
2501 test_compare(uint32_t(245), flags
);
2504 delete [] insert_data
;
2507 return TEST_SUCCESS
;
2510 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2512 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2513 size_t key_length
[3];
2517 char return_key
[MEMCACHED_MAX_KEY
];
2518 size_t return_key_length
;
2520 size_t return_value_length
;
2523 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2524 key_length
[1]= strlen("fudge&*@#");
2525 key_length
[2]= strlen("for^#@&$not");
2528 for (unsigned int x
= 0; x
< 3; x
++)
2530 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2531 keys
[x
], key_length
[x
],
2532 (time_t)50, (uint32_t)9);
2533 test_compare(MEMCACHED_SUCCESS
, rc
);
2536 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2537 test_compare(MEMCACHED_SUCCESS
, rc
);
2539 /* We need to empty the server before continueing test */
2540 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2541 &return_value_length
, &flags
, &rc
)) != NULL
)
2543 test_true(return_value
);
2547 test_compare(3U, count
);
2549 return TEST_SUCCESS
;
2552 /* We are testing with aggressive timeout to get failures */
2553 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2555 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
2557 size_t value_length
= 512;
2558 unsigned int set
= 1;
2559 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2561 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2562 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2563 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2565 libtest::vchar_t value
;
2566 value
.reserve(value_length
);
2567 for (uint32_t x
= 0; x
< value_length
; x
++)
2569 value
.push_back(char(x
% 127));
2572 for (unsigned int x
= 1; x
<= 100000; ++x
)
2574 memcached_return_t rc
= memcached_set(mclone
,
2575 test_literal_param("foo"),
2576 &value
[0], value
.size(),
2579 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2580 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2581 memcached_strerror(NULL
, rc
));
2583 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2589 memcached_free(mclone
);
2591 return TEST_SUCCESS
;
2595 We are looking failures in the async protocol
2597 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2599 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2601 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2602 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2603 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2605 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2608 libtest::vchar_t value
;
2610 for (unsigned int x
= 0; x
< 512; x
++)
2612 value
.push_back(char(x
% 127));
2615 for (unsigned int x
= 1; x
<= 100000; ++x
)
2617 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2621 memcached_free(mclone
);
2623 return TEST_SUCCESS
;
2627 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2629 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2631 memcached_return_t rc
;
2633 size_t value_length
;
2635 uint64_t number_value
;
2637 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2638 &value_length
, &flags
, &rc
);
2640 test_compare(MEMCACHED_NOTFOUND
, rc
);
2642 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2645 /* The binary protocol will set the key if it doesn't exist */
2646 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2648 test_compare(MEMCACHED_SUCCESS
, rc
);
2652 test_compare(MEMCACHED_NOTFOUND
, rc
);
2655 test_compare(MEMCACHED_SUCCESS
,
2656 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2658 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2662 test_compare(MEMCACHED_SUCCESS
,
2663 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2664 test_compare(2UL, number_value
);
2666 return TEST_SUCCESS
;
2670 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2671 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2673 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2675 char key
[] = "key34567890";
2677 char commandFirst
[]= "set key34567890 0 0 ";
2678 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2679 size_t commandLength
;
2681 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2683 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2685 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2687 char *overflow
= new (std::nothrow
) char[testSize
];
2688 test_true(overflow
);
2690 memset(overflow
, 'x', testSize
);
2691 test_compare(MEMCACHED_SUCCESS
,
2692 memcached_set(memc
, key
, strlen(key
),
2693 overflow
, testSize
, 0, 0));
2697 return TEST_SUCCESS
;
2702 Test values of many different sizes
2703 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2704 set key34567890 0 0 8169 \r\n
2705 is sent followed by buffer of size 8169, followed by 8169
2707 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2709 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2711 libtest::vchar_t value
;
2712 value
.reserve(18000);
2713 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2715 value
.push_back((char) (x
% 127));
2718 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2720 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2721 &value
[0], current_length
,
2722 (time_t)0, (uint32_t)0);
2723 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2725 size_t string_length
;
2727 char *string
= memcached_get(memc
, test_literal_param("foo"),
2728 &string_length
, &flags
, &rc
);
2730 test_compare(MEMCACHED_SUCCESS
, rc
);
2731 test_compare(string_length
, current_length
);
2733 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2734 test_memcmp_hint(string
, &value
[0], string_length
, buffer
);
2739 return TEST_SUCCESS
;
2743 Look for zero length value problems
2745 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2747 for (uint32_t x
= 0; x
< 2; x
++)
2749 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2751 (time_t)0, (uint32_t)0);
2753 test_compare(MEMCACHED_SUCCESS
, rc
);
2757 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2758 &length
, &flags
, &rc
);
2760 test_compare(MEMCACHED_SUCCESS
, rc
);
2765 value
= memcached_get(memc
, test_literal_param("mykey"),
2766 &length
, &flags
, &rc
);
2768 test_compare(MEMCACHED_SUCCESS
, rc
);
2774 return TEST_SUCCESS
;
2777 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2778 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2780 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2782 (time_t)0, UINT32_MAX
),
2783 memcached_last_error_message(memc
));
2788 memcached_return_t rc
;
2789 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2790 &length
, &flags
, &rc
);
2792 test_compare(MEMCACHED_SUCCESS
, rc
);
2795 test_compare(flags
, UINT32_MAX
);
2797 return TEST_SUCCESS
;
2800 #if !defined(__sun) && !defined(__OpenBSD__)
2801 /* Check the validity of chinese key*/
2802 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2804 const char *key
= "豆瓣";
2805 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2806 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2807 value
, strlen(value
),
2810 test_compare(MEMCACHED_SUCCESS
, rc
);
2814 char *value2
= memcached_get(memc
, key
, strlen(key
),
2815 &length
, &flags
, &rc
);
2817 test_true(length
==strlen(value
));
2818 test_compare(MEMCACHED_SUCCESS
, rc
);
2819 test_memcmp(value
, value2
, length
);
2822 return TEST_SUCCESS
;
2830 test_return_t
user_supplied_bug19(memcached_st
*)
2832 memcached_return_t res
;
2834 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2836 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2839 memcached_free(memc
);
2841 return TEST_SUCCESS
;
2844 /* CAS test from Andei */
2845 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2847 const char *key
= "abc";
2848 size_t key_len
= strlen("abc");
2850 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2852 test_compare(MEMCACHED_SUCCESS
,
2854 test_literal_param("abc"),
2855 test_literal_param("foobar"),
2856 (time_t)0, (uint32_t)0));
2858 test_compare(MEMCACHED_SUCCESS
,
2859 memcached_mget(memc
, &key
, &key_len
, 1));
2861 memcached_result_st result_obj
;
2862 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2865 memcached_result_create(memc
, &result_obj
);
2866 memcached_return_t status
;
2867 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2870 test_compare(MEMCACHED_SUCCESS
, status
);
2872 memcached_result_free(result
);
2874 return TEST_SUCCESS
;
2877 /* Large mget() of missing keys with binary proto
2879 * If many binary quiet commands (such as getq's in an mget) fill the output
2880 * buffer and the server chooses not to respond, memcached_flush hangs. See
2881 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2884 /* sighandler_t function that always asserts false */
2885 static void fail(int)
2891 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2896 return TEST_SKIPPED
;
2898 void (*oldalarm
)(int);
2900 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2901 test_true(memc_clone
);
2903 /* only binproto uses getq for mget */
2904 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2906 /* empty the cache to ensure misses (hence non-responses) */
2907 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2909 keys_st
keys(key_count
);
2911 oldalarm
= signal(SIGALRM
, fail
);
2914 test_compare_got(MEMCACHED_SUCCESS
,
2915 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2916 memcached_last_error_message(memc_clone
));
2919 signal(SIGALRM
, oldalarm
);
2921 memcached_return_t rc
;
2923 char return_key
[MEMCACHED_MAX_KEY
];
2924 size_t return_key_length
;
2926 size_t return_value_length
;
2927 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2928 &return_value_length
, &flags
, &rc
)))
2930 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2932 test_compare(MEMCACHED_NOTFOUND
, rc
);
2933 test_zero(return_value_length
);
2934 test_zero(return_key_length
);
2935 test_false(return_key
[0]);
2936 test_false(return_value
);
2938 memcached_free(memc_clone
);
2940 return TEST_SUCCESS
;
2944 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2946 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2948 /* should work as of r580 */
2949 test_compare(TEST_SUCCESS
,
2950 _user_supplied_bug21(memc
, 10));
2952 /* should fail as of r580 */
2953 test_compare(TEST_SUCCESS
,
2954 _user_supplied_bug21(memc
, 1000));
2956 return TEST_SUCCESS
;
2959 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2961 memcached_st
*memc
= memcached_create(NULL
);
2965 test_compare(MEMCACHED_SUCCESS
,
2966 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2968 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2969 test_compare(value
, uint64_t(1));
2971 test_compare(MEMCACHED_SUCCESS
,
2972 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2974 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2975 test_true(value
== MEMCACHED_HASH_MD5
);
2978 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2980 memcached_server_st
*server_pool
;
2981 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");
2982 memcached_server_push(memc
, server_pool
);
2984 // @todo this needs to be refactored to actually test something.
2987 if ((fp
= fopen("ketama_keys.txt", "w")))
2991 printf("cannot write to file ketama_keys.txt");
2992 return TEST_FAILURE
;
2995 for (int x
= 0; x
< 10000; x
++)
2998 snprintf(key
, sizeof(key
), "%d", x
);
3000 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3001 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3002 in_port_t port
= memc
->hosts
[server_idx
].port
;
3003 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3004 memcached_server_instance_st instance
=
3005 memcached_server_instance_by_position(memc
, host_index
);
3009 memcached_server_list_free(server_pool
);
3010 memcached_free(memc
);
3012 return TEST_SUCCESS
;
3016 test_return_t
result_static(memcached_st
*memc
)
3018 memcached_result_st result
;
3019 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3020 test_false(result
.options
.is_allocated
);
3021 test_true(memcached_is_initialized(&result
));
3022 test_true(result_ptr
);
3023 test_true(result_ptr
== &result
);
3025 memcached_result_free(&result
);
3027 test_false(result
.options
.is_allocated
);
3028 test_false(memcached_is_initialized(&result
));
3030 return TEST_SUCCESS
;
3033 test_return_t
result_alloc(memcached_st
*memc
)
3035 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3036 test_true(result_ptr
);
3037 test_true(result_ptr
->options
.is_allocated
);
3038 test_true(memcached_is_initialized(result_ptr
));
3039 memcached_result_free(result_ptr
);
3041 return TEST_SUCCESS
;
3045 test_return_t
add_host_test1(memcached_st
*memc
)
3047 memcached_return_t rc
;
3048 char servername
[]= "0.example.com";
3050 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3052 test_compare(1U, memcached_server_list_count(servers
));
3054 for (uint32_t x
= 2; x
< 20; x
++)
3056 char buffer
[SMALL_STRING_LEN
];
3058 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3059 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3061 test_compare(MEMCACHED_SUCCESS
, rc
);
3062 test_compare(x
, memcached_server_list_count(servers
));
3065 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3066 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3068 memcached_server_list_free(servers
);
3070 return TEST_SUCCESS
;
3074 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3078 #ifdef HARD_MALLOC_TESTS
3079 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3087 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3091 #ifdef HARD_MALLOC_TESTS
3092 void *ret
= malloc(size
+ 8);
3095 ret
= (void*)((caddr_t
)ret
+ 8);
3098 void *ret
= malloc(size
);
3103 memset(ret
, 0xff, size
);
3110 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3112 #ifdef HARD_MALLOC_TESTS
3113 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3114 void *nmem
= realloc(real_ptr
, size
+ 8);
3119 ret
= (void*)((caddr_t
)nmem
+ 8);
3125 return realloc(mem
, size
);
3130 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3132 #ifdef HARD_MALLOC_TESTS
3133 void *mem
= my_malloc(ptr
, nelem
* size
);
3136 memset(mem
, 0, nelem
* size
);
3142 return calloc(nelem
, size
);
3146 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3148 memcached_return_t rc
;
3149 const char *key
= "mine";
3152 /* Make sure be default none exists */
3153 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3155 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3157 /* Test a clean set */
3158 test_compare(MEMCACHED_SUCCESS
,
3159 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3161 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3163 test_memcmp(value
, key
, 4);
3164 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3166 /* Test that we can turn it off */
3167 test_compare(MEMCACHED_SUCCESS
,
3168 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3170 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3172 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3174 /* Now setup for main test */
3175 test_compare(MEMCACHED_SUCCESS
,
3176 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3178 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3180 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3181 test_memcmp(value
, key
, 4);
3183 /* Set to Zero, and then Set to something too large */
3186 memset(long_key
, 0, 255);
3188 test_compare(MEMCACHED_SUCCESS
,
3189 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3191 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3193 test_compare(MEMCACHED_SUCCESS
, rc
);
3195 /* Test a long key for failure */
3196 /* TODO, extend test to determine based on setting, what result should be */
3197 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3198 test_compare(MEMCACHED_SUCCESS
,
3199 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3201 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3202 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3203 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3204 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3206 /* Test for a bad prefix, but with a short key */
3207 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3208 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3210 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3211 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3214 return TEST_SUCCESS
;
3217 test_return_t
set_namespace(memcached_st
*memc
)
3219 memcached_return_t rc
;
3220 const char *key
= "mine";
3223 // Make sure we default to a null namespace
3224 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3226 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3228 /* Test a clean set */
3229 test_compare(MEMCACHED_SUCCESS
,
3230 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3232 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3234 test_memcmp(value
, key
, 4);
3235 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3237 return TEST_SUCCESS
;
3240 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3242 test_return_if(pre_binary(memc
));
3243 test_return_if(set_namespace(memc
));
3245 return TEST_SUCCESS
;
3248 #ifdef MEMCACHED_ENABLE_DEPRECATED
3249 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3251 void *test_ptr
= NULL
;
3254 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
3255 cb_ptr
= *(void **)&malloc_cb
;
3256 memcached_return_t rc
;
3258 test_compare(MEMCACHED_SUCCESS
,
3259 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3260 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3261 test_compare(MEMCACHED_SUCCESS
, rc
);
3262 test_true(test_ptr
== cb_ptr
);
3266 memcached_realloc_fn realloc_cb
=
3267 (memcached_realloc_fn
)my_realloc
;
3268 cb_ptr
= *(void **)&realloc_cb
;
3269 memcached_return_t rc
;
3271 test_compare(MEMCACHED_SUCCESS
,
3272 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3273 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3274 test_compare(MEMCACHED_SUCCESS
, rc
);
3275 test_true(test_ptr
== cb_ptr
);
3279 memcached_free_fn free_cb
=
3280 (memcached_free_fn
)my_free
;
3281 cb_ptr
= *(void **)&free_cb
;
3282 memcached_return_t rc
;
3284 test_compare(MEMCACHED_SUCCESS
,
3285 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3286 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3287 test_compare(MEMCACHED_SUCCESS
, rc
);
3288 test_true(test_ptr
== cb_ptr
);
3291 return TEST_SUCCESS
;
3296 test_return_t
set_memory_alloc(memcached_st
*memc
)
3298 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3299 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3300 my_realloc
, my_calloc
, NULL
));
3302 test_compare(MEMCACHED_SUCCESS
,
3303 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3304 my_realloc
, my_calloc
, NULL
));
3306 memcached_malloc_fn mem_malloc
;
3307 memcached_free_fn mem_free
;
3308 memcached_realloc_fn mem_realloc
;
3309 memcached_calloc_fn mem_calloc
;
3310 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3311 &mem_realloc
, &mem_calloc
);
3313 test_true(mem_malloc
== my_malloc
);
3314 test_true(mem_realloc
== my_realloc
);
3315 test_true(mem_calloc
== my_calloc
);
3316 test_true(mem_free
== my_free
);
3318 return TEST_SUCCESS
;
3321 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3324 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3325 memcached_hash_t hash
;
3326 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3327 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3330 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3331 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3333 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3335 if (hash
!= MEMCACHED_HASH_CRC
)
3336 return TEST_SKIPPED
;
3338 return TEST_SUCCESS
;
3341 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3344 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3345 memcached_hash_t hash
;
3346 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3347 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3352 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3353 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3355 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3357 if (hash
!= MEMCACHED_HASH_HSIEH
)
3358 return TEST_SKIPPED
;
3361 return TEST_SUCCESS
;
3364 test_return_t
enable_cas(memcached_st
*memc
)
3366 unsigned int set
= 1;
3368 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3370 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3372 return TEST_SUCCESS
;
3375 return TEST_SKIPPED
;
3378 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3380 memcached_version(memc
);
3382 memcached_server_instance_st instance
=
3383 memcached_server_instance_by_position(memc
, 0);
3385 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3386 or instance
->minor_version
> 2)
3388 return TEST_SUCCESS
;
3391 return TEST_SKIPPED
;
3394 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3396 const uint64_t timeout
= 100; // Not using, just checking that it sets
3398 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3400 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3402 return TEST_SUCCESS
;
3405 test_return_t
noreply_test(memcached_st
*memc
)
3407 test_compare(MEMCACHED_SUCCESS
,
3408 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3409 test_compare(MEMCACHED_SUCCESS
,
3410 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3411 test_compare(MEMCACHED_SUCCESS
,
3412 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3413 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3414 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3415 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3417 memcached_return_t ret
;
3418 for (int count
= 0; count
< 5; ++count
)
3420 for (size_t x
= 0; x
< 100; ++x
)
3422 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3423 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3424 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3426 size_t len
= (size_t)check_length
;
3431 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3434 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3437 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3440 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3443 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3449 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3450 memcached_strerror(NULL
, ret
));
3454 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3455 ** API and is _ONLY_ done this way to verify that the library works the
3456 ** way it is supposed to do!!!!
3460 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3462 memcached_server_instance_st instance
=
3463 memcached_server_instance_by_position(memc
, x
);
3464 no_msg
+=(int)(instance
->cursor_active
);
3467 test_true(no_msg
== 0);
3469 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3472 ** Now validate that all items was set properly!
3474 for (size_t x
= 0; x
< 100; ++x
)
3478 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3480 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3482 size_t len
= (size_t)check_length
;
3485 char* value
=memcached_get(memc
, key
, strlen(key
),
3486 &length
, &flags
, &ret
);
3487 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
3490 case 0: /* FALLTHROUGH */
3491 case 1: /* FALLTHROUGH */
3493 test_true(strncmp(value
, key
, len
) == 0);
3494 test_true(len
== length
);
3497 test_true(length
== len
* 2);
3500 test_true(length
== len
* 3);
3510 /* Try setting an illegal cas value (should not return an error to
3511 * the caller (because we don't expect a return message from the server)
3513 const char* keys
[]= {"0"};
3514 size_t lengths
[]= {1};
3517 memcached_result_st results_obj
;
3518 memcached_result_st
*results
;
3519 test_compare(MEMCACHED_SUCCESS
,
3520 memcached_mget(memc
, keys
, lengths
, 1));
3522 results
= memcached_result_create(memc
, &results_obj
);
3524 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3526 test_compare(MEMCACHED_SUCCESS
, ret
);
3527 uint64_t cas
= memcached_result_cas(results
);
3528 memcached_result_free(&results_obj
);
3530 test_compare(MEMCACHED_SUCCESS
,
3531 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3534 * The item will have a new cas value, so try to set it again with the old
3535 * value. This should fail!
3537 test_compare(MEMCACHED_SUCCESS
,
3538 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3539 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3540 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3541 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3544 return TEST_SUCCESS
;
3547 test_return_t
analyzer_test(memcached_st
*memc
)
3549 memcached_analysis_st
*report
;
3550 memcached_return_t rc
;
3552 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3553 test_compare(MEMCACHED_SUCCESS
, rc
);
3554 test_true(memc_stat
);
3556 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3557 test_compare(MEMCACHED_SUCCESS
, rc
);
3561 memcached_stat_free(NULL
, memc_stat
);
3563 return TEST_SUCCESS
;
3566 test_return_t
util_version_test(memcached_st
*memc
)
3568 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
3569 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3571 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3573 // We expect failure
3576 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3577 fprintf(stderr
, "\nDumping Server Information\n\n");
3578 memcached_server_fn callbacks
[1];
3580 callbacks
[0]= dump_server_information
;
3581 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3582 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3584 test_true(if_successful
== false);
3586 memcached_server_instance_st instance
=
3587 memcached_server_instance_by_position(memc
, 0);
3589 memcached_version(memc
);
3591 // We only use one binary when we test, so this should be just fine.
3592 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3593 test_true(if_successful
== true);
3595 if (instance
->micro_version
> 0)
3597 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3599 else if (instance
->minor_version
> 0)
3601 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3603 else if (instance
->major_version
> 0)
3605 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3608 test_true(if_successful
== true);
3610 if (instance
->micro_version
> 0)
3612 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3614 else if (instance
->minor_version
> 0)
3616 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3618 else if (instance
->major_version
> 0)
3620 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3623 test_true(if_successful
== false);
3625 return TEST_SUCCESS
;
3628 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3630 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3631 memcached_return_t rc
;
3632 memcached_server_instance_st instance
=
3633 memcached_server_instance_by_position(memc
, 0);
3635 // Test both the version that returns a code, and the one that does not.
3636 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3637 memcached_server_port(instance
) -1, NULL
) == -1);
3639 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3640 memcached_server_port(instance
) -1, &rc
) == -1);
3641 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3643 return TEST_SUCCESS
;
3647 test_return_t
getpid_test(memcached_st
*memc
)
3649 memcached_return_t rc
;
3650 memcached_server_instance_st instance
=
3651 memcached_server_instance_by_position(memc
, 0);
3653 // Test both the version that returns a code, and the one that does not.
3654 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3655 memcached_server_port(instance
), NULL
) > -1);
3657 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3658 memcached_server_port(instance
), &rc
) > -1);
3659 test_compare(MEMCACHED_SUCCESS
, rc
);
3661 return TEST_SUCCESS
;
3664 test_return_t
ping_test(memcached_st
*memc
)
3666 memcached_return_t rc
;
3667 memcached_server_instance_st instance
=
3668 memcached_server_instance_by_position(memc
, 0);
3670 // Test both the version that returns a code, and the one that does not.
3671 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3672 memcached_server_port(instance
), NULL
));
3674 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3675 memcached_server_port(instance
), &rc
));
3677 test_compare(MEMCACHED_SUCCESS
, rc
);
3679 return TEST_SUCCESS
;
3684 test_return_t
hash_sanity_test (memcached_st
*memc
)
3688 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3689 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3690 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3691 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3692 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3693 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3694 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3695 #ifdef HAVE_HSIEH_HASH
3696 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3698 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3699 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3700 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3702 return TEST_SUCCESS
;
3706 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3708 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3710 test_compare(MEMCACHED_SUCCESS
,
3711 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3712 (uint64_t)MEMCACHED_HASH_HSIEH
));
3714 return TEST_SUCCESS
;
3717 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3719 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3721 test_compare(MEMCACHED_SUCCESS
,
3722 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3724 return TEST_SUCCESS
;
3727 test_return_t
one_at_a_time_run (memcached_st
*)
3732 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3734 test_compare(one_at_a_time_values
[x
],
3735 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3738 return TEST_SUCCESS
;
3741 test_return_t
md5_run (memcached_st
*)
3746 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3748 test_compare(md5_values
[x
],
3749 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3752 return TEST_SUCCESS
;
3755 test_return_t
crc_run (memcached_st
*)
3760 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3762 test_compare(crc_values
[x
],
3763 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3766 return TEST_SUCCESS
;
3769 test_return_t
fnv1_64_run (memcached_st
*)
3771 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3776 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3778 test_compare(fnv1_64_values
[x
],
3779 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3782 return TEST_SUCCESS
;
3785 test_return_t
fnv1a_64_run (memcached_st
*)
3787 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3792 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3794 test_compare(fnv1a_64_values
[x
],
3795 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3798 return TEST_SUCCESS
;
3801 test_return_t
fnv1_32_run (memcached_st
*)
3806 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3808 test_compare(fnv1_32_values
[x
],
3809 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3812 return TEST_SUCCESS
;
3815 test_return_t
fnv1a_32_run (memcached_st
*)
3820 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3822 test_compare(fnv1a_32_values
[x
],
3823 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3826 return TEST_SUCCESS
;
3829 test_return_t
hsieh_run (memcached_st
*)
3831 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3836 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3838 test_compare(hsieh_values
[x
],
3839 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3842 return TEST_SUCCESS
;
3845 test_return_t
murmur_run (memcached_st
*)
3847 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3849 #ifdef WORDS_BIGENDIAN
3850 (void)murmur_values
;
3851 return TEST_SKIPPED
;
3856 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3858 test_compare(murmur_values
[x
],
3859 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3862 return TEST_SUCCESS
;
3866 test_return_t
jenkins_run (memcached_st
*)
3871 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3873 test_compare(jenkins_values
[x
],
3874 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3877 return TEST_SUCCESS
;
3880 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3882 return libhashkit_md5(string
, string_length
);
3885 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3887 return libhashkit_crc32(string
, string_length
);
3890 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3896 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3898 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};
3899 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};
3901 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3903 hashkit_clone(&new_kit
, kit
);
3904 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3906 memcached_set_hashkit(memc
, &new_kit
);
3909 Verify Setting the hash.
3911 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3915 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3916 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3921 Now check memcached_st.
3923 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3927 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3928 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3931 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3933 memcached_set_hashkit(memc
, &new_kit
);
3936 Verify Setting the hash.
3938 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3942 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3943 test_true(crc_values
[x
] == hash_val
);
3946 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3950 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3951 test_compare(crc_hosts
[x
], hash_val
);
3954 memcached_free(memc
);
3956 return TEST_SUCCESS
;
3960 Test case adapted from John Gorman <johngorman2@gmail.com>
3962 We are testing the error condition when we connect to a server via memcached_get()
3963 but find that the server is not available.
3965 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3969 memcached_return rc
;
3972 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3974 // See if memcached is reachable.
3975 char *value
= memcached_get(tl_memc_h
,
3976 test_literal_param(__func__
),
3981 test_true(memcached_failed(rc
));
3983 memcached_free(tl_memc_h
);
3985 return TEST_SUCCESS
;
3989 We connect to a server which exists, but search for a key that does not exist.
3991 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3995 memcached_return rc
;
3997 // See if memcached is reachable.
3998 char *value
= memcached_get(memc
,
3999 test_literal_param(__func__
),
4004 test_compare(MEMCACHED_NOTFOUND
, rc
);
4006 return TEST_SUCCESS
;
4010 Test case adapted from John Gorman <johngorman2@gmail.com>
4012 We are testing the error condition when we connect to a server via memcached_get_by_key()
4013 but find that the server is not available.
4015 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
4019 memcached_return rc
;
4022 memcached_st
*tl_memc_h
= memcached_create(NULL
);
4023 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4024 memcached_server_push(tl_memc_h
, servers
);
4025 memcached_server_list_free(servers
);
4027 // See if memcached is reachable.
4028 char *value
= memcached_get_by_key(tl_memc_h
,
4029 test_literal_param(__func__
), // Key
4030 test_literal_param(__func__
), // Value
4035 test_true(memcached_failed(rc
));
4037 memcached_free(tl_memc_h
);
4039 return TEST_SUCCESS
;
4043 We connect to a server which exists, but search for a key that does not exist.
4045 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4049 memcached_return rc
;
4051 // See if memcached is reachable.
4052 char *value
= memcached_get_by_key(memc
,
4053 test_literal_param(__func__
), // Key
4054 test_literal_param(__func__
), // Value
4059 test_compare(MEMCACHED_NOTFOUND
, rc
);
4061 return TEST_SUCCESS
;
4064 test_return_t
regression_bug_434484(memcached_st
*memc
)
4066 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4068 test_compare(MEMCACHED_NOTSTORED
,
4069 memcached_append(memc
,
4070 test_literal_param(__func__
), // Key
4071 test_literal_param(__func__
), // Value
4074 libtest::vchar_t data
;
4075 data
.resize(2048 * 1024);
4076 test_compare(MEMCACHED_E2BIG
,
4078 test_literal_param(__func__
), // Key
4079 &data
[0], data
.size(), 0, 0));
4081 return TEST_SUCCESS
;
4084 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4086 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4088 memcached_return_t rc
;
4090 memcached_execute_fn callbacks
[]= { &callback_counter
};
4093 * I only want to hit only _one_ server so I know the number of requests I'm
4094 * sending in the pipleine to the server. Let's try to do a multiget of
4095 * 1024 (that should satisfy most users don't you think?). Future versions
4096 * will include a mget_execute function call if you need a higher number.
4098 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4103 * Run two times.. the first time we should have 100% cache miss,
4104 * and the second time we should have 100% cache hits
4106 for (ptrdiff_t y
= 0; y
< 2; y
++)
4108 test_compare(MEMCACHED_SUCCESS
,
4109 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4111 // One the first run we should get a NOT_FOUND, but on the second some data
4112 // should be returned.
4113 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4114 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4118 /* The first iteration should give me a 100% cache miss. verify that*/
4119 char blob
[1024]= { 0 };
4121 test_false(counter
);
4123 for (size_t x
= 0; x
< keys
.size(); ++x
)
4125 rc
= memcached_add(memc
,
4126 keys
.key_at(x
), keys
.length_at(x
),
4127 blob
, sizeof(blob
), 0, 0);
4128 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4133 /* Verify that we received all of the key/value pairs */
4134 test_compare(counter
, keys
.size());
4138 memcached_free(memc
);
4140 return TEST_SUCCESS
;
4143 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4145 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
4147 return regression_bug_434843(memc
);
4150 test_return_t
regression_bug_421108(memcached_st
*memc
)
4152 memcached_return_t rc
;
4153 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4154 test_compare(MEMCACHED_SUCCESS
, rc
);
4156 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4157 test_compare(MEMCACHED_SUCCESS
, rc
);
4158 test_true(bytes_str
);
4159 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4161 test_compare(MEMCACHED_SUCCESS
, rc
);
4162 test_true(bytes_read_str
);
4164 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4165 "bytes_written", &rc
);
4166 test_compare(MEMCACHED_SUCCESS
, rc
);
4167 test_true(bytes_written_str
);
4169 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4170 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4171 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4173 test_true(bytes
!= bytes_read
);
4174 test_true(bytes
!= bytes_written
);
4176 /* Release allocated resources */
4178 free(bytes_read_str
);
4179 free(bytes_written_str
);
4180 memcached_stat_free(NULL
, memc_stat
);
4182 return TEST_SUCCESS
;
4186 * The test case isn't obvious so I should probably document why
4187 * it works the way it does. Bug 442914 was caused by a bug
4188 * in the logic in memcached_purge (it did not handle the case
4189 * where the number of bytes sent was equal to the watermark).
4190 * In this test case, create messages so that we hit that case
4191 * and then disable noreply mode and issue a new command to
4192 * verify that it isn't stuck. If we change the format for the
4193 * delete command or the watermarks, we need to update this
4196 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
4198 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
4200 for (uint32_t x
= 0; x
< 250; ++x
)
4203 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
4204 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4205 char error_buffer
[2048]= { 0 };
4206 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
4207 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
4210 // Delete, and then delete again to look for not found
4213 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
4214 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4215 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4217 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
4218 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
4221 memcached_free(memc
);
4223 return TEST_SUCCESS
;
4226 test_return_t
regression_bug_447342(memcached_st
*memc
)
4228 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4230 return TEST_SKIPPED
;
4233 test_compare(MEMCACHED_SUCCESS
,
4234 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4238 for (size_t x
= 0; x
< keys
.size(); ++x
)
4240 test_compare(MEMCACHED_SUCCESS
,
4242 keys
.key_at(x
), keys
.length_at(x
), // Keys
4243 keys
.key_at(x
), keys
.length_at(x
), // Values
4248 ** We are using the quiet commands to store the replicas, so we need
4249 ** to ensure that all of them are processed before we can continue.
4250 ** In the test we go directly from storing the object to trying to
4251 ** receive the object from all of the different servers, so we
4252 ** could end up in a race condition (the memcached server hasn't yet
4253 ** processed the quiet command from the replication set when it process
4254 ** the request from the other client (created by the clone)). As a
4255 ** workaround for that we call memcached_quit to send the quit command
4256 ** to the server and wait for the response ;-) If you use the test code
4257 ** as an example for your own code, please note that you shouldn't need
4260 memcached_quit(memc
);
4262 /* Verify that all messages are stored, and we didn't stuff too much
4265 test_compare(MEMCACHED_SUCCESS
,
4266 memcached_mget(memc
,
4267 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4269 unsigned int counter
= 0;
4270 memcached_execute_fn callbacks
[]= { &callback_counter
};
4271 test_compare(MEMCACHED_SUCCESS
,
4272 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4274 /* Verify that we received all of the key/value pairs */
4275 test_compare(counter
, keys
.size());
4277 memcached_quit(memc
);
4279 * Don't do the following in your code. I am abusing the internal details
4280 * within the library, and this is not a supported interface.
4281 * This is to verify correct behavior in the library. Fake that two servers
4284 memcached_server_instance_st instance_one
= memcached_server_instance_by_position(memc
, 0);
4285 memcached_server_instance_st instance_two
= memcached_server_instance_by_position(memc
, 2);
4286 in_port_t port0
= instance_one
->port
;
4287 in_port_t port2
= instance_two
->port
;
4289 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4290 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4292 test_compare(MEMCACHED_SUCCESS
,
4293 memcached_mget(memc
,
4294 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4297 test_compare(MEMCACHED_SUCCESS
,
4298 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4299 test_compare(counter
, keys
.size());
4301 /* restore the memc handle */
4302 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4303 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4305 memcached_quit(memc
);
4307 /* Remove half of the objects */
4308 for (size_t x
= 0; x
< keys
.size(); ++x
)
4312 test_compare(MEMCACHED_SUCCESS
,
4313 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4317 memcached_quit(memc
);
4318 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4319 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4321 /* now retry the command, this time we should have cache misses */
4322 test_compare(MEMCACHED_SUCCESS
,
4323 memcached_mget(memc
,
4324 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4327 test_compare(MEMCACHED_SUCCESS
,
4328 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4329 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4331 /* restore the memc handle */
4332 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4333 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4335 return TEST_SUCCESS
;
4338 test_return_t
regression_bug_463297(memcached_st
*memc
)
4340 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4342 // Since we blocked timed delete, this test is no longer valid.
4344 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4345 test_true(memc_clone
);
4346 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4348 memcached_server_instance_st instance
=
4349 memcached_server_instance_by_position(memc_clone
, 0);
4351 if (instance
->major_version
> 1 ||
4352 (instance
->major_version
== 1 &&
4353 instance
->minor_version
> 2))
4355 /* Binary protocol doesn't support deferred delete */
4356 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4357 test_true(bin_clone
);
4358 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4359 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4360 memcached_free(bin_clone
);
4362 memcached_quit(memc_clone
);
4364 /* If we know the server version, deferred delete should fail
4365 * with invalid arguments */
4366 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4368 /* If we don't know the server version, we should get a protocol error */
4369 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4371 /* but there is a bug in some of the memcached servers (1.4) that treats
4372 * the counter as noreply so it doesn't send the proper error message
4374 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4376 /* And buffered mode should be disabled and we should get protocol error */
4377 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4378 rc
= memcached_delete(memc
, "foo", 3, 1);
4379 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4381 /* Same goes for noreply... */
4382 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4383 rc
= memcached_delete(memc
, "foo", 3, 1);
4384 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4386 /* but a normal request should go through (and be buffered) */
4387 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4388 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4390 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4391 /* unbuffered noreply should be success */
4392 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4393 /* unbuffered with reply should be not found... */
4394 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4395 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4398 memcached_free(memc_clone
);
4401 return TEST_SUCCESS
;
4405 /* Test memcached_server_get_last_disconnect
4406 * For a working server set, shall be NULL
4407 * For a set of non existing server, shall not be NULL
4409 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4411 memcached_return_t rc
;
4412 memcached_server_instance_st disconnected_server
;
4414 /* With the working set of server */
4415 const char *key
= "marmotte";
4416 const char *value
= "milka";
4418 memcached_reset_last_disconnected_server(memc
);
4419 test_false(memc
->last_disconnected_server
);
4420 rc
= memcached_set(memc
, key
, strlen(key
),
4421 value
, strlen(value
),
4422 (time_t)0, (uint32_t)0);
4423 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4425 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4426 test_false(disconnected_server
);
4428 /* With a non existing server */
4430 memcached_server_st
*servers
;
4432 const char *server_list
= "localhost:9";
4434 servers
= memcached_servers_parse(server_list
);
4436 mine
= memcached_create(NULL
);
4437 rc
= memcached_server_push(mine
, servers
);
4438 test_compare(MEMCACHED_SUCCESS
, rc
);
4439 memcached_server_list_free(servers
);
4442 rc
= memcached_set(mine
, key
, strlen(key
),
4443 value
, strlen(value
),
4444 (time_t)0, (uint32_t)0);
4445 test_true(memcached_failed(rc
));
4447 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4448 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4449 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4450 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4452 memcached_quit(mine
);
4453 memcached_free(mine
);
4455 return TEST_SUCCESS
;
4458 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4460 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4461 char buffer
[BUFSIZ
];
4463 test_compare(MEMCACHED_SUCCESS
,
4464 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4466 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4469 // We will just use the error strings as our keys
4470 uint32_t counter
= 100;
4473 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4475 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4476 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4477 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4479 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
4480 test_true(disconnected_server
);
4481 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4482 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4486 memcached_reset_last_disconnected_server(memc
);
4491 memcached_free(memc
);
4493 return TEST_SUCCESS
;
4496 test_return_t
test_verbosity(memcached_st
*memc
)
4498 memcached_verbosity(memc
, 3);
4500 return TEST_SUCCESS
;
4504 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
4505 const char *key
, size_t key_length
,
4506 const char *value
, size_t value_length
,
4516 return MEMCACHED_SUCCESS
;
4519 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4521 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4522 test_compare(MEMCACHED_SUCCESS
, rc
);
4524 test_compare(MEMCACHED_SUCCESS
,
4525 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4527 test_compare(MEMCACHED_SUCCESS
,
4528 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4530 test_compare(MEMCACHED_SUCCESS
,
4531 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4533 return TEST_SUCCESS
;
4537 * This test ensures that the failure counter isn't incremented during
4538 * normal termination of the memcached instance.
4540 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4542 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4544 /* Ensure that we are connected to the server by setting a value */
4545 memcached_return_t rc
= memcached_set(memc
,
4546 test_literal_param(__func__
), // Key
4547 test_literal_param(__func__
), // Value
4548 time_t(0), uint32_t(0));
4549 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4552 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4554 /* The test is to see that the memcached_quit doesn't increase the
4555 * the server failure conter, so let's ensure that it is zero
4556 * before sending quit
4558 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4560 memcached_quit(memc
);
4562 /* Verify that it memcached_quit didn't increment the failure counter
4563 * Please note that this isn't bullet proof, because an error could
4566 test_zero(instance
->server_failure_counter
);
4568 memcached_free(memc
);
4570 return TEST_SUCCESS
;
4574 * This tests ensures expected disconnections (for some behavior changes
4575 * for instance) do not wrongly increase failure counter
4577 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4579 /* Set value to force connection to the server */
4580 const char *key
= "marmotte";
4581 const char *value
= "milka";
4583 test_compare_hint(MEMCACHED_SUCCESS
,
4584 memcached_set(memc
, key
, strlen(key
),
4585 value
, strlen(value
),
4586 (time_t)0, (uint32_t)0),
4587 memcached_last_error_message(memc
));
4590 /* put failure limit to 1 */
4591 test_compare(MEMCACHED_SUCCESS
,
4592 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4594 /* Put a retry timeout to effectively activate failure_limit effect */
4595 test_compare(MEMCACHED_SUCCESS
,
4596 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4598 /* change behavior that triggers memcached_quit()*/
4599 test_compare(MEMCACHED_SUCCESS
,
4600 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4603 /* Check if we still are connected */
4605 size_t string_length
;
4606 memcached_return rc
;
4607 char *string
= memcached_get(memc
, key
, strlen(key
),
4608 &string_length
, &flags
, &rc
);
4610 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4614 return TEST_SUCCESS
;
4619 * Test that ensures mget_execute does not end into recursive calls that finally fails
4621 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4625 return TEST_SKIPPED
; // My MAC can't handle this test
4628 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4631 * I only want to hit _one_ server so I know the number of requests I'm
4632 * sending in the pipeline.
4634 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4637 keys_st
keys(20480);
4639 /* First add all of the items.. */
4640 char blob
[1024]= { 0 };
4641 for (size_t x
= 0; x
< keys
.size(); ++x
)
4643 memcached_return rc
= memcached_set(memc
,
4644 keys
.key_at(x
), keys
.length_at(x
),
4645 blob
, sizeof(blob
), 0, 0);
4646 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4651 /* Try to get all of them with a large multiget */
4653 memcached_execute_function callbacks
[]= { &callback_counter
};
4654 memcached_return_t rc
= memcached_mget_execute(memc
,
4655 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4656 callbacks
, &counter
, 1);
4657 test_compare(MEMCACHED_SUCCESS
, rc
);
4659 char* the_value
= NULL
;
4660 char the_key
[MEMCACHED_MAX_KEY
];
4661 size_t the_key_length
;
4662 size_t the_value_length
;
4666 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4668 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4674 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4677 test_compare(MEMCACHED_END
, rc
);
4679 /* Verify that we got all of the items */
4680 test_compare(counter
, keys
.size());
4683 memcached_free(memc
);
4685 return TEST_SUCCESS
;
4688 test_return_t
regression_bug_583031(memcached_st
*)
4690 memcached_st
*memc
= memcached_create(NULL
);
4692 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
4694 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
4695 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4696 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4697 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4698 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4699 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4701 memcached_return_t rc
;
4705 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4709 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
4711 memcached_free(memc
);
4713 return TEST_SUCCESS
;
4716 test_return_t
regression_bug_581030(memcached_st
*)
4719 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4720 test_false(local_stat
);
4722 memcached_stat_free(NULL
, NULL
);
4725 return TEST_SUCCESS
;
4728 #define regression_bug_655423_COUNT 6000
4729 test_return_t
regression_bug_655423(memcached_st
*memc
)
4731 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4732 memc
= NULL
; // Just to make sure it is not used
4737 return TEST_SKIPPED
;
4740 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4741 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4742 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4743 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4745 memset(payload
, int('x'), sizeof(payload
));
4747 keys_st
keys(regression_bug_655423_COUNT
);
4749 for (size_t x
= 0; x
< keys
.size(); x
++)
4751 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4754 payload
, sizeof(payload
), 0, 0));
4757 for (size_t x
= 0; x
< keys
.size(); x
++)
4759 size_t value_length
;
4760 memcached_return_t rc
;
4761 char *value
= memcached_get(clone
,
4764 &value_length
, NULL
, &rc
);
4766 if (rc
== MEMCACHED_NOTFOUND
)
4769 test_zero(value_length
);
4773 test_compare(MEMCACHED_SUCCESS
, rc
);
4775 test_compare(100LLU, value_length
);
4779 test_compare(MEMCACHED_SUCCESS
,
4780 memcached_mget(clone
,
4781 keys
.keys_ptr(), keys
.lengths_ptr(),
4785 memcached_result_st
*result
= NULL
;
4786 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4788 test_compare(size_t(100), memcached_result_length(result
));
4792 test_true(count
> 100); // If we don't get back atleast this, something is up
4794 memcached_free(clone
);
4796 return TEST_SUCCESS
;
4800 * Test that ensures that buffered set to not trigger problems during io_flush
4802 #define regression_bug_490520_COUNT 200480
4803 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4805 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4807 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4808 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4809 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4810 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4811 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4813 /* First add all of the items.. */
4814 char blob
[3333] = {0};
4815 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4818 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4820 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4821 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4824 memcached_free(memc
);
4826 return TEST_SUCCESS
;
4830 test_return_t
regression_bug_854604(memcached_st
*)
4834 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4836 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4838 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4839 test_compare(buffer
[0], 0);
4841 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4842 test_true(strlen(buffer
));
4844 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4845 test_true(strlen(buffer
));
4847 return TEST_SUCCESS
;
4850 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4852 fprintf(stderr
, "Iteration #%u: ", it
);
4854 if (error
== MEMCACHED_ERRNO
)
4856 fprintf(stderr
, "system error %d from %s: %s\n",
4857 errno
, what
, strerror(errno
));
4861 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4862 memcached_strerror(mc
, error
));
4866 #define TEST_CONSTANT_CREATION 200
4868 test_return_t
regression_bug_(memcached_st
*memc
)
4870 const char *remote_server
;
4873 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4875 return TEST_SKIPPED
;
4878 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4880 memcached_st
* mc
= memcached_create(NULL
);
4881 memcached_return rc
;
4883 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4884 if (rc
!= MEMCACHED_SUCCESS
)
4886 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
4889 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4890 if (rc
!= MEMCACHED_SUCCESS
)
4892 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
4895 rc
= memcached_server_add(mc
, remote_server
, 0);
4896 if (rc
!= MEMCACHED_SUCCESS
)
4898 memcached_die(mc
, rc
, "memcached_server_add", x
);
4901 const char *set_key
= "akey";
4902 const size_t set_key_len
= strlen(set_key
);
4903 const char *set_value
= "a value";
4904 const size_t set_value_len
= strlen(set_value
);
4906 if (rc
== MEMCACHED_SUCCESS
)
4910 size_t get_value_len
;
4912 uint32_t get_value_flags
;
4914 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
4915 &get_value_flags
, &rc
);
4916 if (rc
!= MEMCACHED_SUCCESS
)
4918 memcached_die(mc
, rc
, "memcached_get", x
);
4924 (get_value_len
!= set_value_len
4925 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
4927 fprintf(stderr
, "Values don't match?\n");
4928 rc
= MEMCACHED_FAILURE
;
4934 rc
= memcached_set(mc
,
4935 set_key
, set_key_len
,
4936 set_value
, set_value_len
,
4940 if (rc
!= MEMCACHED_SUCCESS
)
4942 memcached_die(mc
, rc
, "memcached_set", x
);
4949 if (rc
!= MEMCACHED_SUCCESS
)
4955 return TEST_SUCCESS
;
4958 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
4960 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
4963 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4966 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
4967 memcached_server_port(instance
), NULL
)) > -1);
4970 test_compare(MEMCACHED_SUCCESS
,
4972 test_literal_param(__func__
), // Keys
4973 test_literal_param(__func__
), // Values
4975 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
4977 test_compare(MEMCACHED_SUCCESS
,
4979 test_literal_param(__func__
), // Keys
4980 test_literal_param(__func__
), // Values
4983 memcached_free(memc
);
4985 return TEST_SUCCESS
;