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 memcached_return_t rc
;
1193 size_t string_length
;
1196 uint64_t query_id
= memcached_query_id(memc
);
1197 rc
= memcached_delete(memc
,
1198 test_literal_param(__func__
),
1200 test_true_got(rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_NOTFOUND
, memcached_last_error_message(memc
));
1201 test_compare(query_id
+1, memcached_query_id(memc
));
1203 string
= memcached_get(memc
,
1204 test_literal_param(__func__
),
1205 &string_length
, &flags
, &rc
);
1207 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1208 test_false(string_length
);
1211 return TEST_SUCCESS
;
1214 test_return_t
get_test2(memcached_st
*memc
)
1216 const char *value
= "when we sanitize";
1218 uint64_t query_id
= memcached_query_id(memc
);
1219 test_compare(return_value_based_on_buffering(memc
),
1221 test_literal_param(__func__
),
1222 value
, strlen(value
),
1223 time_t(0), uint32_t(0)));
1224 test_compare(query_id
+1, memcached_query_id(memc
));
1226 query_id
= memcached_query_id(memc
);
1227 test_true(query_id
);
1230 size_t string_length
;
1231 memcached_return_t rc
;
1232 char *string
= memcached_get(memc
,
1233 test_literal_param(__func__
),
1234 &string_length
, &flags
, &rc
);
1235 test_compare(query_id
+1, memcached_query_id(memc
));
1237 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1238 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1240 test_compare(strlen(value
), string_length
);
1241 test_memcmp(string
, value
, string_length
);
1245 return TEST_SUCCESS
;
1248 test_return_t
set_test2(memcached_st
*memc
)
1250 for (uint32_t x
= 0; x
< 10; x
++)
1252 test_compare(return_value_based_on_buffering(memc
),
1254 test_literal_param("foo"),
1255 test_literal_param("train in the brain"),
1256 time_t(0), uint32_t(0)));
1259 return TEST_SUCCESS
;
1262 test_return_t
set_test3(memcached_st
*memc
)
1264 size_t value_length
= 8191;
1266 libtest::vchar_t value
;
1267 value
.reserve(value_length
);
1268 for (uint32_t x
= 0; x
< value_length
; x
++)
1270 value
.push_back(char(x
% 127));
1273 /* The dump test relies on there being at least 32 items in memcached */
1274 for (uint32_t x
= 0; x
< 32; x
++)
1278 snprintf(key
, sizeof(key
), "foo%u", x
);
1280 uint64_t query_id
= memcached_query_id(memc
);
1281 test_compare_hint(return_value_based_on_buffering(memc
),
1282 memcached_set(memc
, key
, strlen(key
),
1283 &value
[0], value
.size(),
1284 time_t(0), uint32_t(0)),
1285 memcached_last_error_message(memc
));
1286 test_compare(query_id
+1, memcached_query_id(memc
));
1289 return TEST_SUCCESS
;
1292 test_return_t
get_test3(memcached_st
*memc
)
1294 size_t value_length
= 8191;
1296 libtest::vchar_t value
;
1297 value
.reserve(value_length
);
1298 for (uint32_t x
= 0; x
< value_length
; x
++)
1300 value
.push_back(char(x
% 127));
1303 test_compare_hint(return_value_based_on_buffering(memc
),
1305 test_literal_param(__func__
),
1306 &value
[0], value
.size(),
1307 time_t(0), uint32_t(0)),
1308 memcached_last_error_message(memc
));
1310 size_t string_length
;
1312 memcached_return_t rc
;
1313 char *string
= memcached_get(memc
,
1314 test_literal_param(__func__
),
1315 &string_length
, &flags
, &rc
);
1317 test_compare(MEMCACHED_SUCCESS
, rc
);
1319 test_compare(value
.size(), string_length
);
1320 test_memcmp(string
, &value
[0], string_length
);
1324 return TEST_SUCCESS
;
1327 test_return_t
get_test4(memcached_st
*memc
)
1329 size_t value_length
= 8191;
1331 libtest::vchar_t value
;
1332 value
.reserve(value_length
);
1333 for (uint32_t x
= 0; x
< value_length
; x
++)
1335 value
.push_back(char(x
% 127));
1338 test_compare_hint(return_value_based_on_buffering(memc
),
1340 test_literal_param(__func__
),
1341 &value
[0], value
.size(),
1342 time_t(0), uint32_t(0)),
1343 memcached_last_error_message(memc
));
1345 for (uint32_t x
= 0; x
< 10; x
++)
1348 size_t string_length
;
1349 memcached_return_t rc
;
1350 char *string
= memcached_get(memc
,
1351 test_literal_param(__func__
),
1352 &string_length
, &flags
, &rc
);
1354 test_compare(MEMCACHED_SUCCESS
, rc
);
1356 test_compare(value
.size(), string_length
);
1357 test_memcmp(string
, &value
[0], string_length
);
1361 return TEST_SUCCESS
;
1365 * This test verifies that memcached_read_one_response doesn't try to
1366 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1367 * responses before you execute a storage command.
1369 test_return_t
get_test5(memcached_st
*memc
)
1372 ** Request the same key twice, to ensure that we hash to the same server
1373 ** (so that we have multiple response values queued up) ;-)
1375 const char *keys
[]= { "key", "key" };
1376 size_t lengths
[]= { 3, 3 };
1380 test_compare_hint(return_value_based_on_buffering(memc
),
1381 memcached_set(memc
, keys
[0], lengths
[0],
1382 keys
[0], lengths
[0],
1383 time_t(0), uint32_t(0)),
1384 memcached_last_error_message(memc
));
1385 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1387 memcached_result_st results_obj
;
1388 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1391 memcached_return_t rc
;
1392 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1395 memcached_result_free(&results_obj
);
1397 /* Don't read out the second result, but issue a set instead.. */
1398 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1400 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1401 &rlen
, &flags
, &rc
);
1403 test_compare(MEMCACHED_NOTFOUND
, rc
);
1404 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1406 test_compare(MEMCACHED_SUCCESS
, rc
);
1409 return TEST_SUCCESS
;
1412 test_return_t
mget_end(memcached_st
*memc
)
1414 const char *keys
[]= { "foo", "foo2" };
1415 size_t lengths
[]= { 3, 4 };
1416 const char *values
[]= { "fjord", "41" };
1419 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1421 test_compare(MEMCACHED_SUCCESS
,
1423 keys
[x
], lengths
[x
],
1424 values
[x
], strlen(values
[x
]),
1425 time_t(0), uint32_t(0)));
1429 size_t string_length
;
1432 // retrieve both via mget
1433 test_compare(MEMCACHED_SUCCESS
,
1434 memcached_mget(memc
,
1436 test_array_length(keys
)));
1438 char key
[MEMCACHED_MAX_KEY
];
1440 memcached_return_t rc
;
1442 // this should get both
1443 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1445 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1447 test_compare(MEMCACHED_SUCCESS
, rc
);
1449 if (key_length
== 4)
1454 test_compare(string_length
, strlen(values
[val
]));
1455 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1459 // this should indicate end
1460 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1461 test_compare(MEMCACHED_END
, rc
);
1465 test_compare(MEMCACHED_SUCCESS
,
1466 memcached_mget(memc
, keys
, lengths
, 1));
1468 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1469 test_compare(key_length
, lengths
[0]);
1470 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1471 test_compare(string_length
, strlen(values
[0]));
1472 test_true(strncmp(values
[0], string
, string_length
) == 0);
1473 test_compare(MEMCACHED_SUCCESS
, rc
);
1476 // this should indicate end
1477 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1478 test_compare(MEMCACHED_END
, rc
);
1481 return TEST_SUCCESS
;
1484 /* Do not copy the style of this code, I just access hosts to testthis function */
1485 test_return_t
stats_servername_test(memcached_st
*memc
)
1487 memcached_stat_st memc_stat
;
1488 memcached_server_instance_st instance
=
1489 memcached_server_instance_by_position(memc
, 0);
1491 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1493 return TEST_SKIPPED
;
1496 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1497 memcached_server_name(instance
),
1498 memcached_server_port(instance
)));
1500 return TEST_SUCCESS
;
1503 test_return_t
increment_test(memcached_st
*memc
)
1505 uint64_t new_number
;
1507 test_compare(MEMCACHED_SUCCESS
,
1509 test_literal_param("number"),
1510 test_literal_param("0"),
1511 (time_t)0, (uint32_t)0));
1513 test_compare(MEMCACHED_SUCCESS
,
1514 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1515 test_compare(uint64_t(1), new_number
);
1517 test_compare(MEMCACHED_SUCCESS
,
1518 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1519 test_compare(uint64_t(2), new_number
);
1521 return TEST_SUCCESS
;
1524 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1526 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1528 uint64_t new_number
;
1529 uint64_t initial
= 0;
1531 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1533 test_compare(MEMCACHED_SUCCESS
,
1534 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1535 test_compare(new_number
, initial
);
1537 test_compare(MEMCACHED_SUCCESS
,
1538 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1539 test_compare(new_number
, (initial
+1));
1541 return TEST_SUCCESS
;
1544 test_return_t
decrement_test(memcached_st
*memc
)
1546 test_compare(return_value_based_on_buffering(memc
),
1548 test_literal_param(__func__
),
1549 test_literal_param("3"),
1550 time_t(0), uint32_t(0)));
1551 // Make sure we flush the value we just set
1552 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1554 uint64_t new_number
;
1555 test_compare(MEMCACHED_SUCCESS
,
1556 memcached_decrement(memc
,
1557 test_literal_param(__func__
),
1559 test_compare(uint64_t(2), new_number
);
1561 test_compare(MEMCACHED_SUCCESS
,
1562 memcached_decrement(memc
,
1563 test_literal_param(__func__
),
1565 test_compare(uint64_t(1), new_number
);
1567 return TEST_SUCCESS
;
1570 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1572 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1574 uint64_t initial
= 3;
1576 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1578 uint64_t new_number
;
1579 test_compare(MEMCACHED_SUCCESS
,
1580 memcached_decrement_with_initial(memc
,
1581 test_literal_param(__func__
),
1584 test_compare(new_number
, initial
);
1586 test_compare(MEMCACHED_SUCCESS
,
1587 memcached_decrement_with_initial(memc
,
1588 test_literal_param(__func__
),
1591 test_compare(new_number
, (initial
- 1));
1593 return TEST_SUCCESS
;
1596 test_return_t
increment_by_key_test(memcached_st
*memc
)
1598 const char *master_key
= "foo";
1599 const char *key
= "number";
1600 const char *value
= "0";
1602 test_compare(return_value_based_on_buffering(memc
),
1603 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1605 value
, strlen(value
),
1606 time_t(0), uint32_t(0)));
1608 // Make sure we flush the value we just set
1609 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1611 uint64_t new_number
;
1612 test_compare(MEMCACHED_SUCCESS
,
1613 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1614 key
, strlen(key
), 1, &new_number
));
1615 test_compare(uint64_t(1), new_number
);
1617 test_compare(MEMCACHED_SUCCESS
,
1618 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1619 key
, strlen(key
), 1, &new_number
));
1620 test_compare(uint64_t(2), new_number
);
1622 return TEST_SUCCESS
;
1625 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1627 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1629 uint64_t new_number
;
1630 const char *master_key
= "foo";
1631 const char *key
= "number";
1632 uint64_t initial
= 0;
1634 test_compare(MEMCACHED_SUCCESS
,
1635 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1637 1, initial
, 0, &new_number
));
1638 test_compare(new_number
, initial
);
1640 test_compare(MEMCACHED_SUCCESS
,
1641 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1643 1, initial
, 0, &new_number
));
1644 test_compare(new_number
, (initial
+1));
1646 return TEST_SUCCESS
;
1649 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1651 uint64_t new_number
;
1652 const char *value
= "3";
1654 test_compare(return_value_based_on_buffering(memc
),
1655 memcached_set_by_key(memc
,
1656 test_literal_param("foo"),
1657 test_literal_param("number"),
1658 value
, strlen(value
),
1659 (time_t)0, (uint32_t)0));
1661 test_compare(MEMCACHED_SUCCESS
,
1662 memcached_decrement_by_key(memc
,
1663 test_literal_param("foo"),
1664 test_literal_param("number"),
1666 test_compare(uint64_t(2), new_number
);
1668 test_compare(MEMCACHED_SUCCESS
,
1669 memcached_decrement_by_key(memc
,
1670 test_literal_param("foo"),
1671 test_literal_param("number"),
1673 test_compare(uint64_t(1), new_number
);
1675 return TEST_SUCCESS
;
1678 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1680 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1682 uint64_t new_number
;
1683 uint64_t initial
= 3;
1685 test_compare(MEMCACHED_SUCCESS
,
1686 memcached_decrement_with_initial_by_key(memc
,
1687 test_literal_param("foo"),
1688 test_literal_param("number"),
1689 1, initial
, 0, &new_number
));
1690 test_compare(new_number
, initial
);
1692 test_compare(MEMCACHED_SUCCESS
,
1693 memcached_decrement_with_initial_by_key(memc
,
1694 test_literal_param("foo"),
1695 test_literal_param("number"),
1696 1, initial
, 0, &new_number
));
1697 test_compare(new_number
, (initial
- 1));
1699 return TEST_SUCCESS
;
1701 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1703 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1705 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1707 test_compare(return_value_based_on_buffering(memc
),
1709 test_literal_param("number"),
1710 test_literal_param("0"),
1711 (time_t)0, (uint32_t)0));
1713 uint64_t new_number
;
1714 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1715 test_literal_param("number"),
1717 test_compare(uint64_t(1), new_number
);
1719 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1720 test_literal_param("number"),
1722 test_compare(uint64_t(2), new_number
);
1724 return TEST_SUCCESS
;
1727 test_return_t
quit_test(memcached_st
*memc
)
1729 const char *value
= "sanford and sun";
1731 test_compare(return_value_based_on_buffering(memc
),
1733 test_literal_param(__func__
),
1734 value
, strlen(value
),
1735 (time_t)10, (uint32_t)3));
1736 memcached_quit(memc
);
1738 test_compare(return_value_based_on_buffering(memc
),
1740 test_literal_param(__func__
),
1741 value
, strlen(value
),
1742 (time_t)50, (uint32_t)9));
1744 return TEST_SUCCESS
;
1747 test_return_t
mget_result_test(memcached_st
*memc
)
1749 const char *keys
[]= {"fudge", "son", "food"};
1750 size_t key_length
[]= {5, 3, 4};
1752 memcached_result_st results_obj
;
1753 memcached_result_st
*results
;
1755 results
= memcached_result_create(memc
, &results_obj
);
1757 test_true(&results_obj
== results
);
1759 /* We need to empty the server before continueing test */
1760 test_compare(MEMCACHED_SUCCESS
,
1761 memcached_flush(memc
, 0));
1763 test_compare(MEMCACHED_SUCCESS
,
1764 memcached_mget(memc
, keys
, key_length
, 3));
1766 memcached_return_t rc
;
1767 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1772 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1773 test_false(results
);
1774 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1776 for (uint32_t x
= 0; x
< 3; x
++)
1778 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1779 keys
[x
], key_length
[x
],
1780 (time_t)50, (uint32_t)9);
1781 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1784 test_compare(MEMCACHED_SUCCESS
,
1785 memcached_mget(memc
, keys
, key_length
, 3));
1787 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1790 test_true(&results_obj
== results
);
1791 test_compare(MEMCACHED_SUCCESS
, rc
);
1792 test_memcmp(memcached_result_key_value(results
),
1793 memcached_result_value(results
),
1794 memcached_result_length(results
));
1795 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1798 memcached_result_free(&results_obj
);
1800 return TEST_SUCCESS
;
1803 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1805 const char *keys
[]= {"fudge", "son", "food"};
1806 size_t key_length
[]= {5, 3, 4};
1808 memcached_result_st
*results
;
1810 /* We need to empty the server before continueing test */
1811 test_compare(MEMCACHED_SUCCESS
,
1812 memcached_flush(memc
, 0));
1814 test_compare(MEMCACHED_SUCCESS
,
1815 memcached_mget(memc
, keys
, key_length
, 3));
1817 memcached_return_t rc
;
1818 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1822 test_false(results
);
1823 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1825 for (uint32_t x
= 0; x
< 3; x
++)
1827 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1828 keys
[x
], key_length
[x
],
1829 (time_t)50, (uint32_t)9);
1830 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1833 test_compare(MEMCACHED_SUCCESS
,
1834 memcached_mget(memc
, keys
, key_length
, 3));
1837 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1840 test_compare(MEMCACHED_SUCCESS
, rc
);
1841 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1842 test_memcmp(memcached_result_key_value(results
),
1843 memcached_result_value(results
),
1844 memcached_result_length(results
));
1845 memcached_result_free(results
);
1849 return TEST_SUCCESS
;
1852 test_return_t
mget_result_function(memcached_st
*memc
)
1854 const char *keys
[]= {"fudge", "son", "food"};
1855 size_t key_length
[]= {5, 3, 4};
1857 memcached_execute_fn callbacks
[1];
1859 for (uint32_t x
= 0; x
< 3; x
++)
1861 test_compare(return_value_based_on_buffering(memc
),
1862 memcached_set(memc
, keys
[x
], key_length
[x
],
1863 keys
[x
], key_length
[x
],
1864 time_t(50), uint32_t(9)));
1866 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1867 memcached_quit(memc
);
1869 test_compare(MEMCACHED_SUCCESS
,
1870 memcached_mget(memc
, keys
, key_length
, 3));
1872 callbacks
[0]= &callback_counter
;
1875 test_compare(MEMCACHED_SUCCESS
,
1876 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1878 test_compare(size_t(3), counter
);
1880 return TEST_SUCCESS
;
1883 test_return_t
mget_test(memcached_st
*memc
)
1885 const char *keys
[]= {"fudge", "son", "food"};
1886 size_t key_length
[]= {5, 3, 4};
1888 char return_key
[MEMCACHED_MAX_KEY
];
1889 size_t return_key_length
;
1891 size_t return_value_length
;
1893 test_compare(MEMCACHED_SUCCESS
,
1894 memcached_mget(memc
, keys
, key_length
, 3));
1897 memcached_return_t rc
;
1898 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1899 &return_value_length
, &flags
, &rc
)))
1901 test_true(return_value
);
1903 test_false(return_value
);
1904 test_zero(return_value_length
);
1905 test_compare(MEMCACHED_NOTFOUND
, rc
);
1907 for (uint32_t x
= 0; x
< 3; x
++)
1909 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1910 keys
[x
], key_length
[x
],
1911 (time_t)50, (uint32_t)9);
1912 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1914 test_compare(MEMCACHED_SUCCESS
,
1915 memcached_mget(memc
, keys
, key_length
, 3));
1918 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1919 &return_value_length
, &flags
, &rc
)))
1921 test_true(return_value
);
1922 test_compare(MEMCACHED_SUCCESS
, rc
);
1923 if (not memc
->_namespace
)
1925 test_compare(return_key_length
, return_value_length
);
1926 test_memcmp(return_value
, return_key
, return_value_length
);
1932 return TEST_SUCCESS
;
1935 test_return_t
mget_execute(memcached_st
*original_memc
)
1937 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1939 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1942 keys_st
keys(20480);
1944 /* First add all of the items.. */
1945 char blob
[1024] = {0};
1947 for (size_t x
= 0; x
< keys
.size(); ++x
)
1949 uint64_t query_id
= memcached_query_id(memc
);
1950 memcached_return_t rc
= memcached_add(memc
,
1951 keys
.key_at(x
), keys
.length_at(x
),
1954 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
,
1955 memcached_strerror(NULL
, rc
));
1956 test_compare(query_id
+1, memcached_query_id(memc
));
1959 /* Try to get all of them with a large multiget */
1961 memcached_execute_fn callbacks
[]= { &callback_counter
};
1962 test_compare(MEMCACHED_SUCCESS
,
1963 memcached_mget_execute(memc
,
1964 keys
.keys_ptr(), keys
.lengths_ptr(),
1965 keys
.size(), callbacks
, &counter
, 1));
1968 uint64_t query_id
= memcached_query_id(memc
);
1969 test_compare(MEMCACHED_SUCCESS
,
1970 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1971 test_compare(query_id
, memcached_query_id(memc
));
1973 /* Verify that we got all of the items */
1974 test_compare(keys
.size(), counter
);
1977 memcached_free(memc
);
1979 return TEST_SUCCESS
;
1982 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1983 static pairs_st
*global_pairs
;
1985 test_return_t
key_setup(memcached_st
*memc
)
1987 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1989 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1991 return TEST_SUCCESS
;
1994 test_return_t
key_teardown(memcached_st
*)
1996 pairs_free(global_pairs
);
1998 return TEST_SUCCESS
;
2001 test_return_t
block_add_regression(memcached_st
*memc
)
2003 /* First add all of the items.. */
2004 for (ptrdiff_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
2006 char blob
[1024] = {0};
2008 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);
2009 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
, memcached_strerror(NULL
, rc
));
2012 return TEST_SUCCESS
;
2015 test_return_t
binary_add_regression(memcached_st
*memc
)
2017 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2018 test_return_t rc
= block_add_regression(memc
);
2023 test_return_t
get_stats_keys(memcached_st
*memc
)
2027 memcached_stat_st memc_stat
;
2028 memcached_return_t rc
;
2030 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
2031 test_compare(MEMCACHED_SUCCESS
, rc
);
2032 for (ptr
= stat_list
; *ptr
; ptr
++)
2037 return TEST_SUCCESS
;
2040 test_return_t
version_string_test(memcached_st
*)
2042 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
2044 return TEST_SUCCESS
;
2047 test_return_t
get_stats(memcached_st
*memc
)
2049 memcached_return_t rc
;
2051 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
2052 test_compare(MEMCACHED_SUCCESS
, rc
);
2053 test_true(memc_stat
);
2055 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
2057 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
2058 test_compare(MEMCACHED_SUCCESS
, rc
);
2059 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
2064 memcached_stat_free(NULL
, memc_stat
);
2066 return TEST_SUCCESS
;
2069 test_return_t
add_host_test(memcached_st
*memc
)
2071 char servername
[]= "0.example.com";
2073 memcached_return_t rc
;
2074 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2075 test_compare(1U, memcached_server_list_count(servers
));
2077 for (unsigned int x
= 2; x
< 20; x
++)
2079 char buffer
[SMALL_STRING_LEN
];
2081 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2082 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2084 test_compare(MEMCACHED_SUCCESS
, rc
);
2085 test_compare(x
, memcached_server_list_count(servers
));
2088 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2089 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2091 memcached_server_list_free(servers
);
2093 return TEST_SUCCESS
;
2096 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
2098 memcached_return_t rc
;
2100 const char *key
= "not_found";
2101 size_t key_length
= test_literal_param_size("not_found");
2103 test_compare(MEMCACHED_SUCCESS
,
2104 memcached_mget(memc
, &key
, &key_length
, 1));
2106 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
2108 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2110 memcached_result_free(result
);
2112 return TEST_SUCCESS
;
2115 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
2117 return MEMCACHED_SUCCESS
;
2120 static memcached_return_t
cleanup_test_callback(memcached_st
*)
2122 return MEMCACHED_SUCCESS
;
2125 test_return_t
callback_test(memcached_st
*memc
)
2127 /* Test User Data */
2131 memcached_return_t rc
;
2133 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
2134 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
2135 test_true(*test_ptr
== x
);
2138 /* Test Clone Callback */
2140 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2141 void *clone_cb_ptr
= *(void **)&clone_cb
;
2142 void *temp_function
= NULL
;
2144 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
2145 memcached_return_t rc
;
2146 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2147 test_true(temp_function
== clone_cb_ptr
);
2148 test_compare(MEMCACHED_SUCCESS
, rc
);
2151 /* Test Cleanup Callback */
2153 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2154 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2155 void *temp_function
= NULL
;
2156 memcached_return_t rc
;
2158 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2159 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2160 test_true(temp_function
== cleanup_cb_ptr
);
2163 return TEST_SUCCESS
;
2166 /* We don't test the behavior itself, we test the switches */
2167 test_return_t
behavior_test(memcached_st
*memc
)
2169 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2170 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2172 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2173 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2175 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2176 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2178 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2179 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2181 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2182 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2184 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2185 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2187 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2188 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2190 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2192 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2194 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2195 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2196 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2198 return TEST_SUCCESS
;
2201 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2203 test_compare(MEMCACHED_DEPRECATED
,
2204 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2206 // Platform dependent
2208 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2212 return TEST_SUCCESS
;
2216 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2218 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2219 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2221 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2223 if (memcached_success(rc
))
2232 return TEST_SUCCESS
;
2236 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2238 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2239 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2241 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2243 if (memcached_success(rc
))
2252 return TEST_SUCCESS
;
2255 /* Make sure we behave properly if server list has no values */
2256 test_return_t
user_supplied_bug4(memcached_st
*memc
)
2258 const char *keys
[]= {"fudge", "son", "food"};
2259 size_t key_length
[]= {5, 3, 4};
2261 /* Here we free everything before running a bunch of mget tests */
2262 memcached_servers_reset(memc
);
2265 /* We need to empty the server before continueing test */
2266 test_compare(MEMCACHED_NO_SERVERS
,
2267 memcached_flush(memc
, 0));
2269 test_compare(MEMCACHED_NO_SERVERS
,
2270 memcached_mget(memc
, keys
, key_length
, 3));
2273 unsigned int keys_returned
;
2274 memcached_return_t rc
;
2275 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2276 test_compare(MEMCACHED_NOTFOUND
, rc
);
2277 test_zero(keys_returned
);
2280 for (uint32_t x
= 0; x
< 3; x
++)
2282 test_compare(MEMCACHED_NO_SERVERS
,
2283 memcached_set(memc
, keys
[x
], key_length
[x
],
2284 keys
[x
], key_length
[x
],
2285 (time_t)50, (uint32_t)9));
2288 test_compare(MEMCACHED_NO_SERVERS
,
2289 memcached_mget(memc
, keys
, key_length
, 3));
2293 char return_key
[MEMCACHED_MAX_KEY
];
2294 memcached_return_t rc
;
2295 size_t return_key_length
;
2296 size_t return_value_length
;
2299 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2300 &return_value_length
, &flags
, &rc
)))
2302 test_true(return_value
);
2303 test_compare(MEMCACHED_SUCCESS
, rc
);
2304 test_true(return_key_length
== return_value_length
);
2305 test_memcmp(return_value
, return_key
, return_value_length
);
2311 return TEST_SUCCESS
;
2314 #define VALUE_SIZE_BUG5 1048064
2315 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2317 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2318 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2320 size_t value_length
;
2322 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2324 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2326 insert_data
[x
]= (signed char)rand();
2329 test_compare(MEMCACHED_SUCCESS
,
2330 memcached_flush(memc
, 0));
2332 memcached_return_t rc
;
2333 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2334 test_compare(MEMCACHED_SUCCESS
,
2335 memcached_mget(memc
, keys
, key_length
, 4));
2338 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2339 test_compare(MEMCACHED_NOTFOUND
, rc
);
2342 for (uint32_t x
= 0; x
< 4; x
++)
2344 test_compare(MEMCACHED_SUCCESS
,
2345 memcached_set(memc
, keys
[x
], key_length
[x
],
2346 insert_data
, VALUE_SIZE_BUG5
,
2347 (time_t)0, (uint32_t)0));
2350 for (uint32_t x
= 0; x
< 10; x
++)
2352 value
= memcached_get(memc
, keys
[0], key_length
[0],
2353 &value_length
, &flags
, &rc
);
2354 test_compare(rc
, MEMCACHED_SUCCESS
);
2358 test_compare(MEMCACHED_SUCCESS
,
2359 memcached_mget(memc
, keys
, key_length
, 4));
2361 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2362 test_compare(4U, count
);
2364 delete [] insert_data
;
2366 return TEST_SUCCESS
;
2369 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2371 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2372 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2373 char return_key
[MEMCACHED_MAX_KEY
];
2374 size_t return_key_length
;
2376 size_t value_length
;
2378 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2380 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2382 insert_data
[x
]= (signed char)rand();
2385 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2387 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2389 // We will now confirm that memcached_mget() returns success, but we will
2390 // then check to make sure that no actual keys are returned.
2391 test_compare(MEMCACHED_SUCCESS
,
2392 memcached_mget(memc
, keys
, key_length
, 4));
2394 memcached_return_t rc
;
2396 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2397 &value_length
, &flags
, &rc
)))
2402 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2404 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2406 test_compare(MEMCACHED_SUCCESS
,
2407 memcached_set(memc
, keys
[x
], key_length
[x
],
2408 insert_data
, VALUE_SIZE_BUG5
,
2409 (time_t)0, (uint32_t)0));
2411 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2413 for (uint32_t x
= 0; x
< 2; x
++)
2415 value
= memcached_get(memc
, keys
[0], key_length
[0],
2416 &value_length
, &flags
, &rc
);
2420 test_compare(MEMCACHED_SUCCESS
,
2421 memcached_mget(memc
, keys
, key_length
, 4));
2422 /* We test for purge of partial complete fetches */
2423 for (count
= 3; count
; count
--)
2425 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2426 &value_length
, &flags
, &rc
);
2427 test_compare(MEMCACHED_SUCCESS
, rc
);
2428 test_memcmp(value
, insert_data
, value_length
);
2429 test_true(value_length
);
2433 delete [] insert_data
;
2435 return TEST_SUCCESS
;
2438 test_return_t
user_supplied_bug8(memcached_st
*)
2440 memcached_return_t rc
;
2442 memcached_st
*memc_clone
;
2444 memcached_server_st
*servers
;
2445 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";
2447 servers
= memcached_servers_parse(server_list
);
2450 mine
= memcached_create(NULL
);
2451 rc
= memcached_server_push(mine
, servers
);
2452 test_compare(MEMCACHED_SUCCESS
, rc
);
2453 memcached_server_list_free(servers
);
2456 memc_clone
= memcached_clone(NULL
, mine
);
2458 memcached_quit(mine
);
2459 memcached_quit(memc_clone
);
2462 memcached_free(mine
);
2463 memcached_free(memc_clone
);
2465 return TEST_SUCCESS
;
2468 /* Test flag store/retrieve */
2469 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2471 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2472 test_true(insert_data
);
2474 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2476 insert_data
[x
]= (signed char)rand();
2479 memcached_flush(memc
, 0);
2481 const char *keys
= "036790384900";
2482 size_t key_length
= strlen(keys
);
2483 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2484 insert_data
, VALUE_SIZE_BUG5
,
2486 memcached_last_error_message(memc
));
2488 memcached_return_t rc
;
2489 size_t value_length
;
2491 char *value
= memcached_get(memc
, keys
, key_length
,
2492 &value_length
, &flags
, &rc
);
2493 test_compare(245U, flags
);
2497 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2499 char return_key
[MEMCACHED_MAX_KEY
];
2500 size_t return_key_length
;
2502 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2503 &value_length
, &flags
, &rc
);
2504 test_compare(uint32_t(245), flags
);
2507 delete [] insert_data
;
2510 return TEST_SUCCESS
;
2513 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2515 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2516 size_t key_length
[3];
2520 char return_key
[MEMCACHED_MAX_KEY
];
2521 size_t return_key_length
;
2523 size_t return_value_length
;
2526 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2527 key_length
[1]= strlen("fudge&*@#");
2528 key_length
[2]= strlen("for^#@&$not");
2531 for (unsigned int x
= 0; x
< 3; x
++)
2533 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2534 keys
[x
], key_length
[x
],
2535 (time_t)50, (uint32_t)9);
2536 test_compare(MEMCACHED_SUCCESS
, rc
);
2539 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2540 test_compare(MEMCACHED_SUCCESS
, rc
);
2542 /* We need to empty the server before continueing test */
2543 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2544 &return_value_length
, &flags
, &rc
)) != NULL
)
2546 test_true(return_value
);
2550 test_compare(3U, count
);
2552 return TEST_SUCCESS
;
2555 /* We are testing with aggressive timeout to get failures */
2556 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2558 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
2560 size_t value_length
= 512;
2561 unsigned int set
= 1;
2562 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2564 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2565 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2566 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2568 libtest::vchar_t value
;
2569 value
.reserve(value_length
);
2570 for (uint32_t x
= 0; x
< value_length
; x
++)
2572 value
.push_back(char(x
% 127));
2575 for (unsigned int x
= 1; x
<= 100000; ++x
)
2577 memcached_return_t rc
= memcached_set(mclone
,
2578 test_literal_param("foo"),
2579 &value
[0], value
.size(),
2582 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2583 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2584 memcached_strerror(NULL
, rc
));
2586 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2592 memcached_free(mclone
);
2594 return TEST_SUCCESS
;
2598 We are looking failures in the async protocol
2600 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2602 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2604 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2605 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2606 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2608 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2611 libtest::vchar_t value
;
2613 for (unsigned int x
= 0; x
< 512; x
++)
2615 value
.push_back(char(x
% 127));
2618 for (unsigned int x
= 1; x
<= 100000; ++x
)
2620 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2624 memcached_free(mclone
);
2626 return TEST_SUCCESS
;
2630 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2632 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2634 memcached_return_t rc
;
2636 size_t value_length
;
2638 uint64_t number_value
;
2640 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2641 &value_length
, &flags
, &rc
);
2643 test_compare(MEMCACHED_NOTFOUND
, rc
);
2645 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2648 /* The binary protocol will set the key if it doesn't exist */
2649 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2651 test_compare(MEMCACHED_SUCCESS
, rc
);
2655 test_compare(MEMCACHED_NOTFOUND
, rc
);
2658 test_compare(MEMCACHED_SUCCESS
,
2659 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2661 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2665 test_compare(MEMCACHED_SUCCESS
,
2666 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2667 test_compare(2UL, number_value
);
2669 return TEST_SUCCESS
;
2673 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2674 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2676 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2678 char key
[] = "key34567890";
2680 char commandFirst
[]= "set key34567890 0 0 ";
2681 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2682 size_t commandLength
;
2684 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2686 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2688 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2690 char *overflow
= new (std::nothrow
) char[testSize
];
2691 test_true(overflow
);
2693 memset(overflow
, 'x', testSize
);
2694 test_compare(MEMCACHED_SUCCESS
,
2695 memcached_set(memc
, key
, strlen(key
),
2696 overflow
, testSize
, 0, 0));
2700 return TEST_SUCCESS
;
2705 Test values of many different sizes
2706 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2707 set key34567890 0 0 8169 \r\n
2708 is sent followed by buffer of size 8169, followed by 8169
2710 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2712 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2714 libtest::vchar_t value
;
2715 value
.reserve(18000);
2716 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2718 value
.push_back((char) (x
% 127));
2721 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2723 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2724 &value
[0], current_length
,
2725 (time_t)0, (uint32_t)0);
2726 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2728 size_t string_length
;
2730 char *string
= memcached_get(memc
, test_literal_param("foo"),
2731 &string_length
, &flags
, &rc
);
2733 test_compare(MEMCACHED_SUCCESS
, rc
);
2734 test_compare(string_length
, current_length
);
2736 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2737 test_memcmp_hint(string
, &value
[0], string_length
, buffer
);
2742 return TEST_SUCCESS
;
2746 Look for zero length value problems
2748 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2750 for (uint32_t x
= 0; x
< 2; x
++)
2752 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2754 (time_t)0, (uint32_t)0);
2756 test_compare(MEMCACHED_SUCCESS
, rc
);
2760 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2761 &length
, &flags
, &rc
);
2763 test_compare(MEMCACHED_SUCCESS
, rc
);
2768 value
= memcached_get(memc
, test_literal_param("mykey"),
2769 &length
, &flags
, &rc
);
2771 test_compare(MEMCACHED_SUCCESS
, rc
);
2777 return TEST_SUCCESS
;
2780 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2781 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2783 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2785 (time_t)0, UINT32_MAX
),
2786 memcached_last_error_message(memc
));
2791 memcached_return_t rc
;
2792 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2793 &length
, &flags
, &rc
);
2795 test_compare(MEMCACHED_SUCCESS
, rc
);
2798 test_compare(flags
, UINT32_MAX
);
2800 return TEST_SUCCESS
;
2803 #if !defined(__sun) && !defined(__OpenBSD__)
2804 /* Check the validity of chinese key*/
2805 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2807 const char *key
= "豆瓣";
2808 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2809 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2810 value
, strlen(value
),
2813 test_compare(MEMCACHED_SUCCESS
, rc
);
2817 char *value2
= memcached_get(memc
, key
, strlen(key
),
2818 &length
, &flags
, &rc
);
2820 test_true(length
==strlen(value
));
2821 test_compare(MEMCACHED_SUCCESS
, rc
);
2822 test_memcmp(value
, value2
, length
);
2825 return TEST_SUCCESS
;
2833 test_return_t
user_supplied_bug19(memcached_st
*)
2835 memcached_return_t res
;
2837 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2839 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2842 memcached_free(memc
);
2844 return TEST_SUCCESS
;
2847 /* CAS test from Andei */
2848 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2850 const char *key
= "abc";
2851 size_t key_len
= strlen("abc");
2853 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2855 test_compare(MEMCACHED_SUCCESS
,
2857 test_literal_param("abc"),
2858 test_literal_param("foobar"),
2859 (time_t)0, (uint32_t)0));
2861 test_compare(MEMCACHED_SUCCESS
,
2862 memcached_mget(memc
, &key
, &key_len
, 1));
2864 memcached_result_st result_obj
;
2865 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2868 memcached_result_create(memc
, &result_obj
);
2869 memcached_return_t status
;
2870 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2873 test_compare(MEMCACHED_SUCCESS
, status
);
2875 memcached_result_free(result
);
2877 return TEST_SUCCESS
;
2880 /* Large mget() of missing keys with binary proto
2882 * If many binary quiet commands (such as getq's in an mget) fill the output
2883 * buffer and the server chooses not to respond, memcached_flush hangs. See
2884 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2887 /* sighandler_t function that always asserts false */
2888 static void fail(int)
2894 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2899 return TEST_SKIPPED
;
2901 void (*oldalarm
)(int);
2903 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2904 test_true(memc_clone
);
2906 /* only binproto uses getq for mget */
2907 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2909 /* empty the cache to ensure misses (hence non-responses) */
2910 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2912 keys_st
keys(key_count
);
2914 oldalarm
= signal(SIGALRM
, fail
);
2917 test_compare_got(MEMCACHED_SUCCESS
,
2918 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2919 memcached_last_error_message(memc_clone
));
2922 signal(SIGALRM
, oldalarm
);
2924 memcached_return_t rc
;
2926 char return_key
[MEMCACHED_MAX_KEY
];
2927 size_t return_key_length
;
2929 size_t return_value_length
;
2930 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2931 &return_value_length
, &flags
, &rc
)))
2933 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2935 test_compare(MEMCACHED_NOTFOUND
, rc
);
2936 test_zero(return_value_length
);
2937 test_zero(return_key_length
);
2938 test_false(return_key
[0]);
2939 test_false(return_value
);
2941 memcached_free(memc_clone
);
2943 return TEST_SUCCESS
;
2947 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2949 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2951 /* should work as of r580 */
2952 test_compare(TEST_SUCCESS
,
2953 _user_supplied_bug21(memc
, 10));
2955 /* should fail as of r580 */
2956 test_compare(TEST_SUCCESS
,
2957 _user_supplied_bug21(memc
, 1000));
2959 return TEST_SUCCESS
;
2962 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2964 memcached_st
*memc
= memcached_create(NULL
);
2968 test_compare(MEMCACHED_SUCCESS
,
2969 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2971 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2972 test_compare(value
, uint64_t(1));
2974 test_compare(MEMCACHED_SUCCESS
,
2975 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2977 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2978 test_true(value
== MEMCACHED_HASH_MD5
);
2981 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2983 memcached_server_st
*server_pool
;
2984 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");
2985 memcached_server_push(memc
, server_pool
);
2987 // @todo this needs to be refactored to actually test something.
2990 if ((fp
= fopen("ketama_keys.txt", "w")))
2994 printf("cannot write to file ketama_keys.txt");
2995 return TEST_FAILURE
;
2998 for (int x
= 0; x
< 10000; x
++)
3001 snprintf(key
, sizeof(key
), "%d", x
);
3003 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3004 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3005 in_port_t port
= memc
->hosts
[server_idx
].port
;
3006 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3007 memcached_server_instance_st instance
=
3008 memcached_server_instance_by_position(memc
, host_index
);
3012 memcached_server_list_free(server_pool
);
3013 memcached_free(memc
);
3015 return TEST_SUCCESS
;
3019 test_return_t
result_static(memcached_st
*memc
)
3021 memcached_result_st result
;
3022 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3023 test_false(result
.options
.is_allocated
);
3024 test_true(memcached_is_initialized(&result
));
3025 test_true(result_ptr
);
3026 test_true(result_ptr
== &result
);
3028 memcached_result_free(&result
);
3030 test_false(result
.options
.is_allocated
);
3031 test_false(memcached_is_initialized(&result
));
3033 return TEST_SUCCESS
;
3036 test_return_t
result_alloc(memcached_st
*memc
)
3038 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3039 test_true(result_ptr
);
3040 test_true(result_ptr
->options
.is_allocated
);
3041 test_true(memcached_is_initialized(result_ptr
));
3042 memcached_result_free(result_ptr
);
3044 return TEST_SUCCESS
;
3048 test_return_t
add_host_test1(memcached_st
*memc
)
3050 memcached_return_t rc
;
3051 char servername
[]= "0.example.com";
3053 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3055 test_compare(1U, memcached_server_list_count(servers
));
3057 for (uint32_t x
= 2; x
< 20; x
++)
3059 char buffer
[SMALL_STRING_LEN
];
3061 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3062 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3064 test_compare(MEMCACHED_SUCCESS
, rc
);
3065 test_compare(x
, memcached_server_list_count(servers
));
3068 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3069 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3071 memcached_server_list_free(servers
);
3073 return TEST_SUCCESS
;
3077 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3081 #ifdef HARD_MALLOC_TESTS
3082 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3090 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3094 #ifdef HARD_MALLOC_TESTS
3095 void *ret
= malloc(size
+ 8);
3098 ret
= (void*)((caddr_t
)ret
+ 8);
3101 void *ret
= malloc(size
);
3106 memset(ret
, 0xff, size
);
3113 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3115 #ifdef HARD_MALLOC_TESTS
3116 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3117 void *nmem
= realloc(real_ptr
, size
+ 8);
3122 ret
= (void*)((caddr_t
)nmem
+ 8);
3128 return realloc(mem
, size
);
3133 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3135 #ifdef HARD_MALLOC_TESTS
3136 void *mem
= my_malloc(ptr
, nelem
* size
);
3139 memset(mem
, 0, nelem
* size
);
3145 return calloc(nelem
, size
);
3149 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3151 memcached_return_t rc
;
3152 const char *key
= "mine";
3155 /* Make sure be default none exists */
3156 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3158 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3160 /* Test a clean set */
3161 test_compare(MEMCACHED_SUCCESS
,
3162 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3164 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3166 test_memcmp(value
, key
, 4);
3167 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3169 /* Test that we can turn it off */
3170 test_compare(MEMCACHED_SUCCESS
,
3171 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3173 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3175 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3177 /* Now setup for main test */
3178 test_compare(MEMCACHED_SUCCESS
,
3179 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3181 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3183 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3184 test_memcmp(value
, key
, 4);
3186 /* Set to Zero, and then Set to something too large */
3189 memset(long_key
, 0, 255);
3191 test_compare(MEMCACHED_SUCCESS
,
3192 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3194 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3196 test_compare(MEMCACHED_SUCCESS
, rc
);
3198 /* Test a long key for failure */
3199 /* TODO, extend test to determine based on setting, what result should be */
3200 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3201 test_compare(MEMCACHED_SUCCESS
,
3202 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3204 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3205 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3206 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3207 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3209 /* Test for a bad prefix, but with a short key */
3210 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3211 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3213 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3214 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3217 return TEST_SUCCESS
;
3220 test_return_t
set_namespace(memcached_st
*memc
)
3222 memcached_return_t rc
;
3223 const char *key
= "mine";
3226 // Make sure we default to a null namespace
3227 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3229 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3231 /* Test a clean set */
3232 test_compare(MEMCACHED_SUCCESS
,
3233 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3235 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3237 test_memcmp(value
, key
, 4);
3238 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3240 return TEST_SUCCESS
;
3243 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3245 test_return_if(pre_binary(memc
));
3246 test_return_if(set_namespace(memc
));
3248 return TEST_SUCCESS
;
3251 #ifdef MEMCACHED_ENABLE_DEPRECATED
3252 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3254 void *test_ptr
= NULL
;
3257 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
3258 cb_ptr
= *(void **)&malloc_cb
;
3259 memcached_return_t rc
;
3261 test_compare(MEMCACHED_SUCCESS
,
3262 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3263 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3264 test_compare(MEMCACHED_SUCCESS
, rc
);
3265 test_true(test_ptr
== cb_ptr
);
3269 memcached_realloc_fn realloc_cb
=
3270 (memcached_realloc_fn
)my_realloc
;
3271 cb_ptr
= *(void **)&realloc_cb
;
3272 memcached_return_t rc
;
3274 test_compare(MEMCACHED_SUCCESS
,
3275 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3276 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3277 test_compare(MEMCACHED_SUCCESS
, rc
);
3278 test_true(test_ptr
== cb_ptr
);
3282 memcached_free_fn free_cb
=
3283 (memcached_free_fn
)my_free
;
3284 cb_ptr
= *(void **)&free_cb
;
3285 memcached_return_t rc
;
3287 test_compare(MEMCACHED_SUCCESS
,
3288 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3289 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3290 test_compare(MEMCACHED_SUCCESS
, rc
);
3291 test_true(test_ptr
== cb_ptr
);
3294 return TEST_SUCCESS
;
3299 test_return_t
set_memory_alloc(memcached_st
*memc
)
3301 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3302 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3303 my_realloc
, my_calloc
, NULL
));
3305 test_compare(MEMCACHED_SUCCESS
,
3306 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3307 my_realloc
, my_calloc
, NULL
));
3309 memcached_malloc_fn mem_malloc
;
3310 memcached_free_fn mem_free
;
3311 memcached_realloc_fn mem_realloc
;
3312 memcached_calloc_fn mem_calloc
;
3313 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3314 &mem_realloc
, &mem_calloc
);
3316 test_true(mem_malloc
== my_malloc
);
3317 test_true(mem_realloc
== my_realloc
);
3318 test_true(mem_calloc
== my_calloc
);
3319 test_true(mem_free
== my_free
);
3321 return TEST_SUCCESS
;
3324 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3327 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3328 memcached_hash_t hash
;
3329 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3330 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3333 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3334 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3336 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3338 if (hash
!= MEMCACHED_HASH_CRC
)
3339 return TEST_SKIPPED
;
3341 return TEST_SUCCESS
;
3344 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3347 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3348 memcached_hash_t hash
;
3349 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3350 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3355 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3356 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3358 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3360 if (hash
!= MEMCACHED_HASH_HSIEH
)
3361 return TEST_SKIPPED
;
3364 return TEST_SUCCESS
;
3367 test_return_t
enable_cas(memcached_st
*memc
)
3369 unsigned int set
= 1;
3371 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3373 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3375 return TEST_SUCCESS
;
3378 return TEST_SKIPPED
;
3381 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3383 memcached_version(memc
);
3385 memcached_server_instance_st instance
=
3386 memcached_server_instance_by_position(memc
, 0);
3388 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3389 or instance
->minor_version
> 2)
3391 return TEST_SUCCESS
;
3394 return TEST_SKIPPED
;
3397 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3399 const uint64_t timeout
= 100; // Not using, just checking that it sets
3401 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3403 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3405 return TEST_SUCCESS
;
3408 test_return_t
noreply_test(memcached_st
*memc
)
3410 test_compare(MEMCACHED_SUCCESS
,
3411 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3412 test_compare(MEMCACHED_SUCCESS
,
3413 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3414 test_compare(MEMCACHED_SUCCESS
,
3415 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3416 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3417 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3418 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3420 memcached_return_t ret
;
3421 for (int count
= 0; count
< 5; ++count
)
3423 for (size_t x
= 0; x
< 100; ++x
)
3425 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3426 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3427 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3429 size_t len
= (size_t)check_length
;
3434 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3437 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3440 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3443 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3446 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3452 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3453 memcached_strerror(NULL
, ret
));
3457 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3458 ** API and is _ONLY_ done this way to verify that the library works the
3459 ** way it is supposed to do!!!!
3463 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3465 memcached_server_instance_st instance
=
3466 memcached_server_instance_by_position(memc
, x
);
3467 no_msg
+=(int)(instance
->cursor_active
);
3470 test_true(no_msg
== 0);
3472 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3475 ** Now validate that all items was set properly!
3477 for (size_t x
= 0; x
< 100; ++x
)
3481 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3483 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3485 size_t len
= (size_t)check_length
;
3488 char* value
=memcached_get(memc
, key
, strlen(key
),
3489 &length
, &flags
, &ret
);
3490 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
3493 case 0: /* FALLTHROUGH */
3494 case 1: /* FALLTHROUGH */
3496 test_true(strncmp(value
, key
, len
) == 0);
3497 test_true(len
== length
);
3500 test_true(length
== len
* 2);
3503 test_true(length
== len
* 3);
3513 /* Try setting an illegal cas value (should not return an error to
3514 * the caller (because we don't expect a return message from the server)
3516 const char* keys
[]= {"0"};
3517 size_t lengths
[]= {1};
3520 memcached_result_st results_obj
;
3521 memcached_result_st
*results
;
3522 test_compare(MEMCACHED_SUCCESS
,
3523 memcached_mget(memc
, keys
, lengths
, 1));
3525 results
= memcached_result_create(memc
, &results_obj
);
3527 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3529 test_compare(MEMCACHED_SUCCESS
, ret
);
3530 uint64_t cas
= memcached_result_cas(results
);
3531 memcached_result_free(&results_obj
);
3533 test_compare(MEMCACHED_SUCCESS
,
3534 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3537 * The item will have a new cas value, so try to set it again with the old
3538 * value. This should fail!
3540 test_compare(MEMCACHED_SUCCESS
,
3541 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3542 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3543 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3544 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3547 return TEST_SUCCESS
;
3550 test_return_t
analyzer_test(memcached_st
*memc
)
3552 memcached_analysis_st
*report
;
3553 memcached_return_t rc
;
3555 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3556 test_compare(MEMCACHED_SUCCESS
, rc
);
3557 test_true(memc_stat
);
3559 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3560 test_compare(MEMCACHED_SUCCESS
, rc
);
3564 memcached_stat_free(NULL
, memc_stat
);
3566 return TEST_SUCCESS
;
3569 test_return_t
util_version_test(memcached_st
*memc
)
3571 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
3572 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3574 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3576 // We expect failure
3579 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3580 fprintf(stderr
, "\nDumping Server Information\n\n");
3581 memcached_server_fn callbacks
[1];
3583 callbacks
[0]= dump_server_information
;
3584 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3585 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3587 test_true(if_successful
== false);
3589 memcached_server_instance_st instance
=
3590 memcached_server_instance_by_position(memc
, 0);
3592 memcached_version(memc
);
3594 // We only use one binary when we test, so this should be just fine.
3595 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3596 test_true(if_successful
== true);
3598 if (instance
->micro_version
> 0)
3600 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3602 else if (instance
->minor_version
> 0)
3604 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3606 else if (instance
->major_version
> 0)
3608 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3611 test_true(if_successful
== true);
3613 if (instance
->micro_version
> 0)
3615 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3617 else if (instance
->minor_version
> 0)
3619 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3621 else if (instance
->major_version
> 0)
3623 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3626 test_true(if_successful
== false);
3628 return TEST_SUCCESS
;
3631 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3633 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3634 memcached_return_t rc
;
3635 memcached_server_instance_st instance
=
3636 memcached_server_instance_by_position(memc
, 0);
3638 // Test both the version that returns a code, and the one that does not.
3639 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3640 memcached_server_port(instance
) -1, NULL
) == -1);
3642 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3643 memcached_server_port(instance
) -1, &rc
) == -1);
3644 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3646 return TEST_SUCCESS
;
3650 test_return_t
getpid_test(memcached_st
*memc
)
3652 memcached_return_t rc
;
3653 memcached_server_instance_st instance
=
3654 memcached_server_instance_by_position(memc
, 0);
3656 // Test both the version that returns a code, and the one that does not.
3657 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3658 memcached_server_port(instance
), NULL
) > -1);
3660 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3661 memcached_server_port(instance
), &rc
) > -1);
3662 test_compare(MEMCACHED_SUCCESS
, rc
);
3664 return TEST_SUCCESS
;
3667 test_return_t
ping_test(memcached_st
*memc
)
3669 memcached_return_t rc
;
3670 memcached_server_instance_st instance
=
3671 memcached_server_instance_by_position(memc
, 0);
3673 // Test both the version that returns a code, and the one that does not.
3674 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3675 memcached_server_port(instance
), NULL
));
3677 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3678 memcached_server_port(instance
), &rc
));
3680 test_compare(MEMCACHED_SUCCESS
, rc
);
3682 return TEST_SUCCESS
;
3687 test_return_t
hash_sanity_test (memcached_st
*memc
)
3691 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3692 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3693 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3694 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3695 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3696 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3697 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3698 #ifdef HAVE_HSIEH_HASH
3699 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3701 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3702 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3703 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3705 return TEST_SUCCESS
;
3709 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3711 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3713 test_compare(MEMCACHED_SUCCESS
,
3714 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3715 (uint64_t)MEMCACHED_HASH_HSIEH
));
3717 return TEST_SUCCESS
;
3720 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3722 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3724 test_compare(MEMCACHED_SUCCESS
,
3725 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3727 return TEST_SUCCESS
;
3730 test_return_t
one_at_a_time_run (memcached_st
*)
3735 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3737 test_compare(one_at_a_time_values
[x
],
3738 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3741 return TEST_SUCCESS
;
3744 test_return_t
md5_run (memcached_st
*)
3749 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3751 test_compare(md5_values
[x
],
3752 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3755 return TEST_SUCCESS
;
3758 test_return_t
crc_run (memcached_st
*)
3763 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3765 test_compare(crc_values
[x
],
3766 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3769 return TEST_SUCCESS
;
3772 test_return_t
fnv1_64_run (memcached_st
*)
3774 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3779 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3781 test_compare(fnv1_64_values
[x
],
3782 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3785 return TEST_SUCCESS
;
3788 test_return_t
fnv1a_64_run (memcached_st
*)
3790 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3795 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3797 test_compare(fnv1a_64_values
[x
],
3798 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3801 return TEST_SUCCESS
;
3804 test_return_t
fnv1_32_run (memcached_st
*)
3809 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3811 test_compare(fnv1_32_values
[x
],
3812 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3815 return TEST_SUCCESS
;
3818 test_return_t
fnv1a_32_run (memcached_st
*)
3823 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3825 test_compare(fnv1a_32_values
[x
],
3826 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3829 return TEST_SUCCESS
;
3832 test_return_t
hsieh_run (memcached_st
*)
3834 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3839 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3841 test_compare(hsieh_values
[x
],
3842 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3845 return TEST_SUCCESS
;
3848 test_return_t
murmur_run (memcached_st
*)
3850 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3852 #ifdef WORDS_BIGENDIAN
3853 (void)murmur_values
;
3854 return TEST_SKIPPED
;
3859 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3861 test_compare(murmur_values
[x
],
3862 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3865 return TEST_SUCCESS
;
3869 test_return_t
jenkins_run (memcached_st
*)
3874 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3876 test_compare(jenkins_values
[x
],
3877 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3880 return TEST_SUCCESS
;
3883 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3885 return libhashkit_md5(string
, string_length
);
3888 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3890 return libhashkit_crc32(string
, string_length
);
3893 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3899 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3901 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};
3902 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};
3904 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3906 hashkit_clone(&new_kit
, kit
);
3907 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3909 memcached_set_hashkit(memc
, &new_kit
);
3912 Verify Setting the hash.
3914 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3918 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3919 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3924 Now check memcached_st.
3926 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3930 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3931 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3934 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3936 memcached_set_hashkit(memc
, &new_kit
);
3939 Verify Setting the hash.
3941 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3945 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3946 test_true(crc_values
[x
] == hash_val
);
3949 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3953 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3954 test_compare(crc_hosts
[x
], hash_val
);
3957 memcached_free(memc
);
3959 return TEST_SUCCESS
;
3963 Test case adapted from John Gorman <johngorman2@gmail.com>
3965 We are testing the error condition when we connect to a server via memcached_get()
3966 but find that the server is not available.
3968 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3972 memcached_return rc
;
3975 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3977 // See if memcached is reachable.
3978 char *value
= memcached_get(tl_memc_h
,
3979 test_literal_param(__func__
),
3984 test_true(memcached_failed(rc
));
3986 memcached_free(tl_memc_h
);
3988 return TEST_SUCCESS
;
3992 We connect to a server which exists, but search for a key that does not exist.
3994 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3998 memcached_return rc
;
4000 // See if memcached is reachable.
4001 char *value
= memcached_get(memc
,
4002 test_literal_param(__func__
),
4007 test_compare(MEMCACHED_NOTFOUND
, rc
);
4009 return TEST_SUCCESS
;
4013 Test case adapted from John Gorman <johngorman2@gmail.com>
4015 We are testing the error condition when we connect to a server via memcached_get_by_key()
4016 but find that the server is not available.
4018 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
4022 memcached_return rc
;
4025 memcached_st
*tl_memc_h
= memcached_create(NULL
);
4026 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4027 memcached_server_push(tl_memc_h
, servers
);
4028 memcached_server_list_free(servers
);
4030 // See if memcached is reachable.
4031 char *value
= memcached_get_by_key(tl_memc_h
,
4032 test_literal_param(__func__
), // Key
4033 test_literal_param(__func__
), // Value
4038 test_true(memcached_failed(rc
));
4040 memcached_free(tl_memc_h
);
4042 return TEST_SUCCESS
;
4046 We connect to a server which exists, but search for a key that does not exist.
4048 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4052 memcached_return rc
;
4054 // See if memcached is reachable.
4055 char *value
= memcached_get_by_key(memc
,
4056 test_literal_param(__func__
), // Key
4057 test_literal_param(__func__
), // Value
4062 test_compare(MEMCACHED_NOTFOUND
, rc
);
4064 return TEST_SUCCESS
;
4067 test_return_t
regression_bug_434484(memcached_st
*memc
)
4069 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4071 test_compare(MEMCACHED_NOTSTORED
,
4072 memcached_append(memc
,
4073 test_literal_param(__func__
), // Key
4074 test_literal_param(__func__
), // Value
4077 libtest::vchar_t data
;
4078 data
.resize(2048 * 1024);
4079 test_compare(MEMCACHED_E2BIG
,
4081 test_literal_param(__func__
), // Key
4082 &data
[0], data
.size(), 0, 0));
4084 return TEST_SUCCESS
;
4087 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4089 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4091 memcached_return_t rc
;
4093 memcached_execute_fn callbacks
[]= { &callback_counter
};
4096 * I only want to hit only _one_ server so I know the number of requests I'm
4097 * sending in the pipleine to the server. Let's try to do a multiget of
4098 * 1024 (that should satisfy most users don't you think?). Future versions
4099 * will include a mget_execute function call if you need a higher number.
4101 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4106 * Run two times.. the first time we should have 100% cache miss,
4107 * and the second time we should have 100% cache hits
4109 for (ptrdiff_t y
= 0; y
< 2; y
++)
4111 test_compare(MEMCACHED_SUCCESS
,
4112 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4114 // One the first run we should get a NOT_FOUND, but on the second some data
4115 // should be returned.
4116 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4117 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4121 /* The first iteration should give me a 100% cache miss. verify that*/
4122 char blob
[1024]= { 0 };
4124 test_false(counter
);
4126 for (size_t x
= 0; x
< keys
.size(); ++x
)
4128 rc
= memcached_add(memc
,
4129 keys
.key_at(x
), keys
.length_at(x
),
4130 blob
, sizeof(blob
), 0, 0);
4131 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4136 /* Verify that we received all of the key/value pairs */
4137 test_compare(counter
, keys
.size());
4141 memcached_free(memc
);
4143 return TEST_SUCCESS
;
4146 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4148 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
4150 return regression_bug_434843(memc
);
4153 test_return_t
regression_bug_421108(memcached_st
*memc
)
4155 memcached_return_t rc
;
4156 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4157 test_compare(MEMCACHED_SUCCESS
, rc
);
4159 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4160 test_compare(MEMCACHED_SUCCESS
, rc
);
4161 test_true(bytes_str
);
4162 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4164 test_compare(MEMCACHED_SUCCESS
, rc
);
4165 test_true(bytes_read_str
);
4167 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4168 "bytes_written", &rc
);
4169 test_compare(MEMCACHED_SUCCESS
, rc
);
4170 test_true(bytes_written_str
);
4172 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4173 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4174 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4176 test_true(bytes
!= bytes_read
);
4177 test_true(bytes
!= bytes_written
);
4179 /* Release allocated resources */
4181 free(bytes_read_str
);
4182 free(bytes_written_str
);
4183 memcached_stat_free(NULL
, memc_stat
);
4185 return TEST_SUCCESS
;
4189 * The test case isn't obvious so I should probably document why
4190 * it works the way it does. Bug 442914 was caused by a bug
4191 * in the logic in memcached_purge (it did not handle the case
4192 * where the number of bytes sent was equal to the watermark).
4193 * In this test case, create messages so that we hit that case
4194 * and then disable noreply mode and issue a new command to
4195 * verify that it isn't stuck. If we change the format for the
4196 * delete command or the watermarks, we need to update this
4199 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
4201 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
4203 for (uint32_t x
= 0; x
< 250; ++x
)
4206 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
4207 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4208 char error_buffer
[2048]= { 0 };
4209 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
4210 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
4213 // Delete, and then delete again to look for not found
4216 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
4217 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4218 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4220 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
4221 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
4224 memcached_free(memc
);
4226 return TEST_SUCCESS
;
4229 test_return_t
regression_bug_447342(memcached_st
*memc
)
4231 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4233 return TEST_SKIPPED
;
4236 test_compare(MEMCACHED_SUCCESS
,
4237 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4241 for (size_t x
= 0; x
< keys
.size(); ++x
)
4243 test_compare(MEMCACHED_SUCCESS
,
4245 keys
.key_at(x
), keys
.length_at(x
), // Keys
4246 keys
.key_at(x
), keys
.length_at(x
), // Values
4251 ** We are using the quiet commands to store the replicas, so we need
4252 ** to ensure that all of them are processed before we can continue.
4253 ** In the test we go directly from storing the object to trying to
4254 ** receive the object from all of the different servers, so we
4255 ** could end up in a race condition (the memcached server hasn't yet
4256 ** processed the quiet command from the replication set when it process
4257 ** the request from the other client (created by the clone)). As a
4258 ** workaround for that we call memcached_quit to send the quit command
4259 ** to the server and wait for the response ;-) If you use the test code
4260 ** as an example for your own code, please note that you shouldn't need
4263 memcached_quit(memc
);
4265 /* Verify that all messages are stored, and we didn't stuff too much
4268 test_compare(MEMCACHED_SUCCESS
,
4269 memcached_mget(memc
,
4270 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4272 unsigned int counter
= 0;
4273 memcached_execute_fn callbacks
[]= { &callback_counter
};
4274 test_compare(MEMCACHED_SUCCESS
,
4275 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4277 /* Verify that we received all of the key/value pairs */
4278 test_compare(counter
, keys
.size());
4280 memcached_quit(memc
);
4282 * Don't do the following in your code. I am abusing the internal details
4283 * within the library, and this is not a supported interface.
4284 * This is to verify correct behavior in the library. Fake that two servers
4287 memcached_server_instance_st instance_one
= memcached_server_instance_by_position(memc
, 0);
4288 memcached_server_instance_st instance_two
= memcached_server_instance_by_position(memc
, 2);
4289 in_port_t port0
= instance_one
->port
;
4290 in_port_t port2
= instance_two
->port
;
4292 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4293 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4295 test_compare(MEMCACHED_SUCCESS
,
4296 memcached_mget(memc
,
4297 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4300 test_compare(MEMCACHED_SUCCESS
,
4301 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4302 test_compare(counter
, keys
.size());
4304 /* restore the memc handle */
4305 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4306 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4308 memcached_quit(memc
);
4310 /* Remove half of the objects */
4311 for (size_t x
= 0; x
< keys
.size(); ++x
)
4315 test_compare(MEMCACHED_SUCCESS
,
4316 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4320 memcached_quit(memc
);
4321 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4322 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4324 /* now retry the command, this time we should have cache misses */
4325 test_compare(MEMCACHED_SUCCESS
,
4326 memcached_mget(memc
,
4327 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4330 test_compare(MEMCACHED_SUCCESS
,
4331 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4332 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4334 /* restore the memc handle */
4335 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4336 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4338 return TEST_SUCCESS
;
4341 test_return_t
regression_bug_463297(memcached_st
*memc
)
4343 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4345 // Since we blocked timed delete, this test is no longer valid.
4347 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4348 test_true(memc_clone
);
4349 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4351 memcached_server_instance_st instance
=
4352 memcached_server_instance_by_position(memc_clone
, 0);
4354 if (instance
->major_version
> 1 ||
4355 (instance
->major_version
== 1 &&
4356 instance
->minor_version
> 2))
4358 /* Binary protocol doesn't support deferred delete */
4359 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4360 test_true(bin_clone
);
4361 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4362 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4363 memcached_free(bin_clone
);
4365 memcached_quit(memc_clone
);
4367 /* If we know the server version, deferred delete should fail
4368 * with invalid arguments */
4369 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4371 /* If we don't know the server version, we should get a protocol error */
4372 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4374 /* but there is a bug in some of the memcached servers (1.4) that treats
4375 * the counter as noreply so it doesn't send the proper error message
4377 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4379 /* And buffered mode should be disabled and we should get protocol error */
4380 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4381 rc
= memcached_delete(memc
, "foo", 3, 1);
4382 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4384 /* Same goes for noreply... */
4385 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4386 rc
= memcached_delete(memc
, "foo", 3, 1);
4387 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4389 /* but a normal request should go through (and be buffered) */
4390 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4391 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4393 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4394 /* unbuffered noreply should be success */
4395 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4396 /* unbuffered with reply should be not found... */
4397 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4398 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4401 memcached_free(memc_clone
);
4404 return TEST_SUCCESS
;
4408 /* Test memcached_server_get_last_disconnect
4409 * For a working server set, shall be NULL
4410 * For a set of non existing server, shall not be NULL
4412 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4414 memcached_return_t rc
;
4415 memcached_server_instance_st disconnected_server
;
4417 /* With the working set of server */
4418 const char *key
= "marmotte";
4419 const char *value
= "milka";
4421 memcached_reset_last_disconnected_server(memc
);
4422 test_false(memc
->last_disconnected_server
);
4423 rc
= memcached_set(memc
, key
, strlen(key
),
4424 value
, strlen(value
),
4425 (time_t)0, (uint32_t)0);
4426 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4428 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4429 test_false(disconnected_server
);
4431 /* With a non existing server */
4433 memcached_server_st
*servers
;
4435 const char *server_list
= "localhost:9";
4437 servers
= memcached_servers_parse(server_list
);
4439 mine
= memcached_create(NULL
);
4440 rc
= memcached_server_push(mine
, servers
);
4441 test_compare(MEMCACHED_SUCCESS
, rc
);
4442 memcached_server_list_free(servers
);
4445 rc
= memcached_set(mine
, key
, strlen(key
),
4446 value
, strlen(value
),
4447 (time_t)0, (uint32_t)0);
4448 test_true(memcached_failed(rc
));
4450 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4451 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4452 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4453 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4455 memcached_quit(mine
);
4456 memcached_free(mine
);
4458 return TEST_SUCCESS
;
4461 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4463 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4464 char buffer
[BUFSIZ
];
4466 test_compare(MEMCACHED_SUCCESS
,
4467 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4469 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4472 // We will just use the error strings as our keys
4473 uint32_t counter
= 100;
4476 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4478 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4479 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4480 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4482 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
4483 test_true(disconnected_server
);
4484 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4485 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4489 memcached_reset_last_disconnected_server(memc
);
4494 memcached_free(memc
);
4496 return TEST_SUCCESS
;
4499 test_return_t
test_verbosity(memcached_st
*memc
)
4501 memcached_verbosity(memc
, 3);
4503 return TEST_SUCCESS
;
4507 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
4508 const char *key
, size_t key_length
,
4509 const char *value
, size_t value_length
,
4519 return MEMCACHED_SUCCESS
;
4522 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4524 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4525 test_compare(MEMCACHED_SUCCESS
, rc
);
4527 test_compare(MEMCACHED_SUCCESS
,
4528 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4530 test_compare(MEMCACHED_SUCCESS
,
4531 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4533 test_compare(MEMCACHED_SUCCESS
,
4534 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4536 return TEST_SUCCESS
;
4540 * This test ensures that the failure counter isn't incremented during
4541 * normal termination of the memcached instance.
4543 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4545 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4547 /* Ensure that we are connected to the server by setting a value */
4548 memcached_return_t rc
= memcached_set(memc
,
4549 test_literal_param(__func__
), // Key
4550 test_literal_param(__func__
), // Value
4551 time_t(0), uint32_t(0));
4552 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4555 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4557 /* The test is to see that the memcached_quit doesn't increase the
4558 * the server failure conter, so let's ensure that it is zero
4559 * before sending quit
4561 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4563 memcached_quit(memc
);
4565 /* Verify that it memcached_quit didn't increment the failure counter
4566 * Please note that this isn't bullet proof, because an error could
4569 test_zero(instance
->server_failure_counter
);
4571 memcached_free(memc
);
4573 return TEST_SUCCESS
;
4577 * This tests ensures expected disconnections (for some behavior changes
4578 * for instance) do not wrongly increase failure counter
4580 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4582 /* Set value to force connection to the server */
4583 const char *key
= "marmotte";
4584 const char *value
= "milka";
4586 test_compare_hint(MEMCACHED_SUCCESS
,
4587 memcached_set(memc
, key
, strlen(key
),
4588 value
, strlen(value
),
4589 (time_t)0, (uint32_t)0),
4590 memcached_last_error_message(memc
));
4593 /* put failure limit to 1 */
4594 test_compare(MEMCACHED_SUCCESS
,
4595 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4597 /* Put a retry timeout to effectively activate failure_limit effect */
4598 test_compare(MEMCACHED_SUCCESS
,
4599 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4601 /* change behavior that triggers memcached_quit()*/
4602 test_compare(MEMCACHED_SUCCESS
,
4603 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4606 /* Check if we still are connected */
4608 size_t string_length
;
4609 memcached_return rc
;
4610 char *string
= memcached_get(memc
, key
, strlen(key
),
4611 &string_length
, &flags
, &rc
);
4613 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4617 return TEST_SUCCESS
;
4622 * Test that ensures mget_execute does not end into recursive calls that finally fails
4624 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4628 return TEST_SKIPPED
; // My MAC can't handle this test
4631 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4634 * I only want to hit _one_ server so I know the number of requests I'm
4635 * sending in the pipeline.
4637 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4640 keys_st
keys(20480);
4642 /* First add all of the items.. */
4643 char blob
[1024]= { 0 };
4644 for (size_t x
= 0; x
< keys
.size(); ++x
)
4646 memcached_return rc
= memcached_set(memc
,
4647 keys
.key_at(x
), keys
.length_at(x
),
4648 blob
, sizeof(blob
), 0, 0);
4649 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4654 /* Try to get all of them with a large multiget */
4656 memcached_execute_function callbacks
[]= { &callback_counter
};
4657 memcached_return_t rc
= memcached_mget_execute(memc
,
4658 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4659 callbacks
, &counter
, 1);
4660 test_compare(MEMCACHED_SUCCESS
, rc
);
4662 char* the_value
= NULL
;
4663 char the_key
[MEMCACHED_MAX_KEY
];
4664 size_t the_key_length
;
4665 size_t the_value_length
;
4669 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4671 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4677 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4680 test_compare(MEMCACHED_END
, rc
);
4682 /* Verify that we got all of the items */
4683 test_compare(counter
, keys
.size());
4686 memcached_free(memc
);
4688 return TEST_SUCCESS
;
4691 test_return_t
regression_bug_583031(memcached_st
*)
4693 memcached_st
*memc
= memcached_create(NULL
);
4695 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
4697 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
4698 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4699 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4700 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4701 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4702 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4704 memcached_return_t rc
;
4708 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4712 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
4714 memcached_free(memc
);
4716 return TEST_SUCCESS
;
4719 test_return_t
regression_bug_581030(memcached_st
*)
4722 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4723 test_false(local_stat
);
4725 memcached_stat_free(NULL
, NULL
);
4728 return TEST_SUCCESS
;
4731 #define regression_bug_655423_COUNT 6000
4732 test_return_t
regression_bug_655423(memcached_st
*memc
)
4734 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4735 memc
= NULL
; // Just to make sure it is not used
4740 return TEST_SKIPPED
;
4743 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4744 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4745 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4746 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4748 memset(payload
, int('x'), sizeof(payload
));
4750 keys_st
keys(regression_bug_655423_COUNT
);
4752 for (size_t x
= 0; x
< keys
.size(); x
++)
4754 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4757 payload
, sizeof(payload
), 0, 0));
4760 for (size_t x
= 0; x
< keys
.size(); x
++)
4762 size_t value_length
;
4763 memcached_return_t rc
;
4764 char *value
= memcached_get(clone
,
4767 &value_length
, NULL
, &rc
);
4769 if (rc
== MEMCACHED_NOTFOUND
)
4772 test_zero(value_length
);
4776 test_compare(MEMCACHED_SUCCESS
, rc
);
4778 test_compare(100LLU, value_length
);
4782 test_compare(MEMCACHED_SUCCESS
,
4783 memcached_mget(clone
,
4784 keys
.keys_ptr(), keys
.lengths_ptr(),
4788 memcached_result_st
*result
= NULL
;
4789 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4791 test_compare(size_t(100), memcached_result_length(result
));
4795 test_true(count
> 100); // If we don't get back atleast this, something is up
4797 memcached_free(clone
);
4799 return TEST_SUCCESS
;
4803 * Test that ensures that buffered set to not trigger problems during io_flush
4805 #define regression_bug_490520_COUNT 200480
4806 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4808 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4810 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4811 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4812 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4813 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4814 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4816 /* First add all of the items.. */
4817 char blob
[3333] = {0};
4818 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4821 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4823 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4824 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4827 memcached_free(memc
);
4829 return TEST_SUCCESS
;
4833 test_return_t
regression_bug_854604(memcached_st
*)
4837 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4839 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4841 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4842 test_compare(buffer
[0], 0);
4844 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4845 test_true(strlen(buffer
));
4847 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4848 test_true(strlen(buffer
));
4850 return TEST_SUCCESS
;
4853 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4855 fprintf(stderr
, "Iteration #%u: ", it
);
4857 if (error
== MEMCACHED_ERRNO
)
4859 fprintf(stderr
, "system error %d from %s: %s\n",
4860 errno
, what
, strerror(errno
));
4864 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4865 memcached_strerror(mc
, error
));
4869 #define TEST_CONSTANT_CREATION 200
4871 test_return_t
regression_bug_(memcached_st
*memc
)
4873 const char *remote_server
;
4876 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4878 return TEST_SKIPPED
;
4881 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4883 memcached_st
* mc
= memcached_create(NULL
);
4884 memcached_return rc
;
4886 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4887 if (rc
!= MEMCACHED_SUCCESS
)
4889 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
4892 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4893 if (rc
!= MEMCACHED_SUCCESS
)
4895 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
4898 rc
= memcached_server_add(mc
, remote_server
, 0);
4899 if (rc
!= MEMCACHED_SUCCESS
)
4901 memcached_die(mc
, rc
, "memcached_server_add", x
);
4904 const char *set_key
= "akey";
4905 const size_t set_key_len
= strlen(set_key
);
4906 const char *set_value
= "a value";
4907 const size_t set_value_len
= strlen(set_value
);
4909 if (rc
== MEMCACHED_SUCCESS
)
4913 size_t get_value_len
;
4915 uint32_t get_value_flags
;
4917 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
4918 &get_value_flags
, &rc
);
4919 if (rc
!= MEMCACHED_SUCCESS
)
4921 memcached_die(mc
, rc
, "memcached_get", x
);
4927 (get_value_len
!= set_value_len
4928 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
4930 fprintf(stderr
, "Values don't match?\n");
4931 rc
= MEMCACHED_FAILURE
;
4937 rc
= memcached_set(mc
,
4938 set_key
, set_key_len
,
4939 set_value
, set_value_len
,
4943 if (rc
!= MEMCACHED_SUCCESS
)
4945 memcached_die(mc
, rc
, "memcached_set", x
);
4952 if (rc
!= MEMCACHED_SUCCESS
)
4958 return TEST_SUCCESS
;
4961 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
4963 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
4966 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4969 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
4970 memcached_server_port(instance
), NULL
)) > -1);
4973 test_compare(MEMCACHED_SUCCESS
,
4975 test_literal_param(__func__
), // Keys
4976 test_literal_param(__func__
), // Values
4978 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
4980 test_compare(MEMCACHED_SUCCESS
,
4982 test_literal_param(__func__
), // Keys
4983 test_literal_param(__func__
), // Values
4986 memcached_free(memc
);
4988 return TEST_SUCCESS
;