1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 #include <libtest/test.hpp>
41 #if defined(HAVE_LIBUUID) && HAVE_LIBUUID
42 #include <uuid/uuid.h>
49 #include <libmemcached-1.0/memcached.h>
50 #include <libmemcached/is.h>
51 #include <libmemcached/server_instance.h>
53 #include <libhashkit-1.0/hashkit.h>
58 #include <semaphore.h>
62 #include <sys/types.h>
67 #include <libtest/server.h>
69 #include "clients/generator.h"
71 #define SMALL_STRING_LEN 1024
73 #include <libtest/test.hpp>
75 using namespace libtest
;
77 #include <libmemcached/util.h>
79 #include "tests/hash_results.h"
81 #include "tests/libmemcached-1.0/callback_counter.h"
82 #include "tests/libmemcached-1.0/fetch_all_results.h"
83 #include "tests/libmemcached-1.0/mem_functions.h"
84 #include "tests/libmemcached-1.0/setup_and_teardowns.h"
85 #include "tests/print.h"
86 #include "tests/debug.h"
88 #define UUID_STRING_MAXLENGTH 36
94 init(arg
, UUID_STRING_MAXLENGTH
);
97 keys_st(size_t arg
, size_t padding
)
102 void init(size_t arg
, size_t padding
)
104 _lengths
.resize(arg
);
107 for (size_t x
= 0; x
< _keys
.size(); x
++)
109 libtest::vchar_t key_buffer
;
110 key_buffer
.resize(padding
+1);
111 memset(&key_buffer
[0], 'x', padding
);
115 #if defined(HAVE_LIBUUID) && HAVE_LIBUUID
119 uuid_unparse(out
, &key_buffer
[0]);
120 _keys
[x
]= strdup(&key_buffer
[0]);
121 (_keys
[x
])[UUID_STRING_MAXLENGTH
]= 'x';
124 else // We just use a number and pad the string if UUID is not available
126 char int_buffer
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
127 int key_length
= snprintf(int_buffer
, sizeof(int_buffer
), "%u", uint32_t(x
));
128 memcpy(&key_buffer
[0], int_buffer
, key_length
);
129 _keys
[x
]= strdup(&key_buffer
[0]);
131 _lengths
[x
]= padding
;
137 for (libtest::vchar_ptr_t::iterator iter
= _keys
.begin();
145 libtest::vchar_ptr_t::iterator
begin()
147 return _keys
.begin();
150 libtest::vchar_ptr_t::iterator
end()
160 std::vector
<size_t>& lengths()
165 libtest::vchar_ptr_t
& keys()
170 size_t* lengths_ptr()
180 char* key_at(size_t arg
)
185 size_t length_at(size_t arg
)
187 return _lengths
[arg
];
191 libtest::vchar_ptr_t _keys
;
192 std::vector
<size_t> _lengths
;
195 static memcached_return_t
return_value_based_on_buffering(memcached_st
*memc
)
197 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
))
199 return MEMCACHED_BUFFERED
;
202 return MEMCACHED_SUCCESS
;
205 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
208 If no options are given, copy over at least the binary flag.
210 char options_buffer
[1024]= { 0 };
213 if (memcached_is_binary(original_memc
))
215 snprintf(options_buffer
, sizeof(options_buffer
), "--BINARY");
220 * I only want to hit _one_ server so I know the number of requests I'm
221 * sending in the pipeline.
223 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
225 char server_string
[1024];
226 int server_string_length
;
227 if (instance
->type
== MEMCACHED_CONNECTION_UNIX_SOCKET
)
231 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\" %s",
232 memcached_server_name(instance
), options
);
236 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\"",
237 memcached_server_name(instance
));
244 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
245 memcached_server_name(instance
), int(memcached_server_port(instance
)),
250 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
251 memcached_server_name(instance
), int(memcached_server_port(instance
)));
255 if (server_string_length
<= 0)
260 char errror_buffer
[1024];
261 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, errror_buffer
, sizeof(errror_buffer
))))
263 Error
<< "Failed to parse (" << server_string
<< ") " << errror_buffer
;
267 return memcached(server_string
, server_string_length
);
271 test_return_t
init_test(memcached_st
*not_used
)
276 (void)memcached_create(&memc
);
277 memcached_free(&memc
);
282 #define TEST_PORT_COUNT 7
283 in_port_t test_ports
[TEST_PORT_COUNT
];
285 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
286 const memcached_server_st
*server
,
290 size_t bigger
= *((size_t *)(context
));
292 fatal_assert(bigger
<= memcached_server_port(server
));
293 *((size_t *)(context
))= memcached_server_port(server
);
295 return MEMCACHED_SUCCESS
;
298 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
299 const memcached_server_st
*instance
,
303 FILE *stream
= (FILE *)context
;
306 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
307 memcached_server_name(instance
),
308 memcached_server_port(instance
),
309 instance
->major_version
,
310 instance
->minor_version
,
311 instance
->micro_version
);
313 return MEMCACHED_SUCCESS
;
316 test_return_t
server_sort_test(memcached_st
*ptr
)
318 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
320 memcached_return_t rc
;
321 memcached_server_fn callbacks
[1];
322 memcached_st
*local_memc
;
325 local_memc
= memcached_create(NULL
);
326 test_true(local_memc
);
327 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
329 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
331 test_ports
[x
]= (in_port_t
)random() % 64000;
332 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
333 test_compare(memcached_server_count(local_memc
), x
+1);
335 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
337 test_compare(MEMCACHED_SUCCESS
, rc
);
340 callbacks
[0]= server_display_function
;
341 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
344 memcached_free(local_memc
);
349 test_return_t
server_sort2_test(memcached_st
*ptr
)
351 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
352 memcached_server_fn callbacks
[1];
353 memcached_st
*local_memc
;
354 memcached_server_instance_st instance
;
357 local_memc
= memcached_create(NULL
);
358 test_true(local_memc
);
359 test_compare(MEMCACHED_SUCCESS
,
360 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
362 test_compare(MEMCACHED_SUCCESS
,
363 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
364 instance
= memcached_server_instance_by_position(local_memc
, 0);
365 test_compare(in_port_t(43043), memcached_server_port(instance
));
367 test_compare(MEMCACHED_SUCCESS
,
368 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
370 instance
= memcached_server_instance_by_position(local_memc
, 0);
371 test_compare(in_port_t(43042), memcached_server_port(instance
));
373 instance
= memcached_server_instance_by_position(local_memc
, 1);
374 test_compare(in_port_t(43043), memcached_server_port(instance
));
376 callbacks
[0]= server_display_function
;
377 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
380 memcached_free(local_memc
);
385 test_return_t
memcached_server_remove_test(memcached_st
*)
387 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";
390 test_compare(MEMCACHED_SUCCESS
,
391 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
392 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
395 memcached_server_fn callbacks
[1];
396 callbacks
[0]= server_print_callback
;
397 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
399 memcached_free(memc
);
404 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
405 const memcached_server_st
*server
,
409 uint32_t x
= *((uint32_t *)(context
));
411 if (! (test_ports
[x
] == server
->port
))
413 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
414 return MEMCACHED_FAILURE
;
417 *((uint32_t *)(context
))= ++x
;
419 return MEMCACHED_SUCCESS
;
422 test_return_t
server_unsort_test(memcached_st
*ptr
)
424 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
425 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
426 memcached_server_fn callbacks
[1];
427 memcached_st
*local_memc
;
430 local_memc
= memcached_create(NULL
);
431 test_true(local_memc
);
433 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
435 test_ports
[x
]= (in_port_t
)(random() % 64000);
436 test_compare(MEMCACHED_SUCCESS
,
437 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
438 test_compare(memcached_server_count(local_memc
), x
+1);
440 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
444 callbacks
[0]= server_display_unsort_function
;
445 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
447 /* Now we sort old data! */
448 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
449 callbacks
[0]= server_display_function
;
450 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
453 memcached_free(local_memc
);
458 test_return_t
allocation_test(memcached_st
*not_used
)
462 memc
= memcached_create(NULL
);
464 memcached_free(memc
);
469 test_return_t
clone_test(memcached_st
*memc
)
473 memcached_st
*memc_clone
;
474 memc_clone
= memcached_clone(NULL
, NULL
);
475 test_true(memc_clone
);
476 memcached_free(memc_clone
);
479 /* Can we init from null? */
481 memcached_st
*memc_clone
;
482 memc_clone
= memcached_clone(NULL
, memc
);
483 test_true(memc_clone
);
486 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
487 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
488 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
489 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
492 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
493 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
494 test_true(memc_clone
->distribution
== memc
->distribution
);
495 { // Test all of the flags
496 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
497 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
498 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
499 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
500 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
501 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
502 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
503 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
504 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
505 test_true(memc_clone
->flags
.reply
== memc
->flags
.reply
);
506 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
507 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
508 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
510 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
511 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
512 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
513 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
514 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
515 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
516 test_true(memc_clone
->on_clone
== memc
->on_clone
);
517 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
518 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
519 test_true(memc_clone
->recv_size
== memc
->recv_size
);
520 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
521 test_true(memc_clone
->send_size
== memc
->send_size
);
522 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
523 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
524 test_true(memc_clone
->user_data
== memc
->user_data
);
526 memcached_free(memc_clone
);
529 /* Can we init from struct? */
531 memcached_st declared_clone
;
532 memcached_st
*memc_clone
;
533 memset(&declared_clone
, 0 , sizeof(memcached_st
));
534 memc_clone
= memcached_clone(&declared_clone
, NULL
);
535 test_true(memc_clone
);
536 memcached_free(memc_clone
);
539 /* Can we init from struct? */
541 memcached_st declared_clone
;
542 memcached_st
*memc_clone
;
543 memset(&declared_clone
, 0 , sizeof(memcached_st
));
544 memc_clone
= memcached_clone(&declared_clone
, memc
);
545 test_true(memc_clone
);
546 memcached_free(memc_clone
);
552 test_return_t
userdata_test(memcached_st
*memc
)
555 test_false(memcached_set_user_data(memc
, foo
));
556 test_true(memcached_get_user_data(memc
) == foo
);
557 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
562 test_return_t
connection_test(memcached_st
*memc
)
564 test_compare(MEMCACHED_SUCCESS
,
565 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
570 test_return_t
libmemcached_string_behavior_test(memcached_st
*)
572 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
574 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
576 test_compare(37, int(MEMCACHED_BEHAVIOR_MAX
));
581 test_return_t
libmemcached_string_distribution_test(memcached_st
*)
583 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
585 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
587 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
592 test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
594 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
595 982370485U, 1263635348U, 4242906218U, 3829656100U,
596 1891735253U, 334139633U, 2257084983U, 3351789013U,
597 13199785U, 2542027183U, 1097051614U, 199566778U,
598 2748246961U, 2465192557U, 1664094137U, 2405439045U,
599 1842224848U, 692413798U, 3479807801U, 919913813U,
600 4269430871U, 610793021U, 527273862U, 1437122909U,
601 2300930706U, 2943759320U, 674306647U, 2400528935U,
602 54481931U, 4186304426U, 1741088401U, 2979625118U,
603 4159057246U, 3425930182U, 2593724503U, 1868899624U,
604 1769812374U, 2302537950U, 1110330676U, 3365377466U,
605 1336171666U, 3021258493U, 2334992265U, 3861994737U,
606 3582734124U, 3365377466U };
608 // You have updated the memcache_error messages but not updated docs/tests.
609 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
612 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
613 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
614 MEMCACHED_HASH_JENKINS
);
615 if (values
[rc
] != hash_val
)
617 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
618 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
620 test_compare(values
[rc
], hash_val
);
622 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
627 test_return_t
set_test(memcached_st
*memc
)
629 memcached_return_t rc
= memcached_set(memc
,
630 test_literal_param("foo"),
631 test_literal_param("when we sanitize"),
632 time_t(0), (uint32_t)0);
633 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
638 test_return_t
append_test(memcached_st
*memc
)
640 memcached_return_t rc
;
641 const char *in_value
= "we";
645 test_compare(MEMCACHED_SUCCESS
,
646 memcached_flush(memc
, 0));
648 test_compare(MEMCACHED_SUCCESS
,
650 test_literal_param(__func__
),
651 in_value
, strlen(in_value
),
652 time_t(0), uint32_t(0)));
654 test_compare(MEMCACHED_SUCCESS
,
655 memcached_append(memc
,
656 test_literal_param(__func__
),
657 " the", strlen(" the"),
658 time_t(0), uint32_t(0)));
660 test_compare(MEMCACHED_SUCCESS
,
661 memcached_append(memc
,
662 test_literal_param(__func__
),
663 " people", strlen(" people"),
664 time_t(0), uint32_t(0)));
666 char *out_value
= memcached_get(memc
,
667 test_literal_param(__func__
),
668 &value_length
, &flags
, &rc
);
669 test_memcmp(out_value
, "we the people", strlen("we the people"));
670 test_compare(strlen("we the people"), value_length
);
671 test_compare(MEMCACHED_SUCCESS
, rc
);
677 test_return_t
append_binary_test(memcached_st
*memc
)
679 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
681 test_compare(MEMCACHED_SUCCESS
,
682 memcached_flush(memc
, 0));
684 test_compare(MEMCACHED_SUCCESS
,
686 test_literal_param(__func__
),
688 time_t(0), uint32_t(0)));
691 for (uint32_t x
= 0; store_list
[x
] ; x
++)
693 test_compare(MEMCACHED_SUCCESS
,
694 memcached_append(memc
,
695 test_literal_param(__func__
),
696 (char *)&store_list
[x
], sizeof(uint32_t),
697 time_t(0), uint32_t(0)));
703 memcached_return_t rc
;
704 uint32_t *value
= (uint32_t *)memcached_get(memc
,
705 test_literal_param(__func__
),
706 &value_length
, &flags
, &rc
);
707 test_compare(value_length
, sizeof(uint32_t) * count
);
708 test_compare(MEMCACHED_SUCCESS
, rc
);
710 for (uint32_t counter
= count
, *ptr
= value
; counter
; counter
--)
712 test_compare(*ptr
, store_list
[count
- counter
]);
720 test_return_t
memcached_mget_mixed_memcached_get_TEST(memcached_st
*memc
)
724 for (libtest::vchar_ptr_t::iterator iter
= keys
.begin();
728 test_compare(MEMCACHED_SUCCESS
,
732 time_t(0), uint32_t(0)));
735 for (ptrdiff_t loop
= 0; loop
< 20; loop
++)
739 test_compare(MEMCACHED_SUCCESS
,
740 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
742 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
745 size_t result_count
= 0;
746 memcached_return_t rc
;
747 while (memcached_fetch_result(memc
, results
, &rc
))
751 test_compare(keys
.size(), result_count
);
755 int which_key
= random() %keys
.size();
758 memcached_return_t rc
;
759 char *out_value
= memcached_get(memc
, keys
.key_at(which_key
), keys
.length_at(which_key
),
760 &value_length
, &flags
, &rc
);
761 test_compare(MEMCACHED_SUCCESS
, rc
);
762 test_null(out_value
);
763 test_zero(value_length
);
771 test_return_t
cas2_test(memcached_st
*memc
)
773 const char *keys
[]= {"fudge", "son", "food"};
774 size_t key_length
[]= {5, 3, 4};
775 const char *value
= "we the people";
776 size_t value_length
= strlen("we the people");
778 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
780 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
782 for (uint32_t x
= 0; x
< 3; x
++)
784 test_compare(MEMCACHED_SUCCESS
,
785 memcached_set(memc
, keys
[x
], key_length
[x
],
786 keys
[x
], key_length
[x
],
787 time_t(50), uint32_t(9)));
790 test_compare(MEMCACHED_SUCCESS
,
791 memcached_mget(memc
, keys
, key_length
, 3));
793 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
796 memcached_return_t rc
;
797 results
= memcached_fetch_result(memc
, results
, &rc
);
799 test_true(results
->item_cas
);
800 test_compare(MEMCACHED_SUCCESS
, rc
);
801 test_true(memcached_result_cas(results
));
803 test_memcmp(value
, "we the people", strlen("we the people"));
804 test_compare(strlen("we the people"), value_length
);
805 test_compare(MEMCACHED_SUCCESS
, rc
);
807 memcached_result_free(results
);
812 test_return_t
cas_test(memcached_st
*memc
)
814 const char* keys
[2] = { __func__
, NULL
};
815 size_t keylengths
[2] = { strlen(__func__
), 0 };
817 memcached_result_st results_obj
;
819 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
821 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
823 test_compare(MEMCACHED_SUCCESS
,
825 test_literal_param(__func__
),
826 test_literal_param("we the people"),
827 (time_t)0, (uint32_t)0));
829 test_compare(MEMCACHED_SUCCESS
,
830 memcached_mget(memc
, keys
, keylengths
, 1));
832 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
835 memcached_return_t rc
;
836 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
838 test_compare(MEMCACHED_SUCCESS
, rc
);
839 test_true(memcached_result_cas(results
));
840 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
841 test_compare(test_literal_param_size("we the people"),
842 strlen(memcached_result_value(results
)));
844 uint64_t cas
= memcached_result_cas(results
);
847 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
848 test_true(rc
== MEMCACHED_END
);
849 test_true(results
== NULL
);
852 test_compare(MEMCACHED_SUCCESS
,
854 test_literal_param(__func__
),
855 test_literal_param("change the value"),
859 * The item will have a new cas value, so try to set it again with the old
860 * value. This should fail!
862 test_compare(MEMCACHED_DATA_EXISTS
,
864 test_literal_param(__func__
),
865 test_literal_param("change the value"),
868 memcached_result_free(&results_obj
);
874 test_return_t
prepend_test(memcached_st
*memc
)
876 const char *key
= "fig";
877 const char *value
= "people";
879 test_compare(MEMCACHED_SUCCESS
,
880 memcached_flush(memc
, 0));
882 test_compare(MEMCACHED_SUCCESS
,
883 memcached_set(memc
, key
, strlen(key
),
884 value
, strlen(value
),
885 time_t(0), uint32_t(0)));
887 test_compare(MEMCACHED_SUCCESS
,
888 memcached_prepend(memc
, key
, strlen(key
),
889 "the ", strlen("the "),
890 time_t(0), uint32_t(0)));
892 test_compare(MEMCACHED_SUCCESS
,
893 memcached_prepend(memc
, key
, strlen(key
),
894 "we ", strlen("we "),
895 time_t(0), uint32_t(0)));
899 memcached_return_t rc
;
900 char *out_value
= memcached_get(memc
, key
, strlen(key
),
901 &value_length
, &flags
, &rc
);
902 test_memcmp(out_value
, "we the people", strlen("we the people"));
903 test_compare(strlen("we the people"), value_length
);
904 test_compare(MEMCACHED_SUCCESS
, rc
);
911 Set the value, then quit to make sure it is flushed.
912 Come back in and test that add fails.
914 test_return_t
add_test(memcached_st
*memc
)
916 test_compare_hint(return_value_based_on_buffering(memc
),
918 test_literal_param(__func__
),
919 test_literal_param("when we sanitize"),
920 time_t(0), uint32_t(0)),
921 memcached_last_error_message(memc
));
923 memcached_quit(memc
);
925 test_compare_hint(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
927 test_literal_param(__func__
),
928 test_literal_param("try something else"),
929 time_t(0), uint32_t(0)),
930 memcached_last_error_message(memc
));
936 ** There was a problem of leaking filedescriptors in the initial release
937 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
938 ** systems it seems that the kernel is slow on reclaiming the resources
939 ** because the connects starts to time out (the test doesn't do much
940 ** anyway, so just loop 10 iterations)
942 test_return_t
add_wrapper(memcached_st
*memc
)
944 unsigned int max
= 10000;
952 for (uint32_t x
= 0; x
< max
; x
++)
958 test_return_t
replace_test(memcached_st
*memc
)
960 test_compare(return_value_based_on_buffering(memc
),
962 test_literal_param(__func__
),
963 test_literal_param("when we sanitize"),
964 time_t(0), uint32_t(0)));
966 test_compare(MEMCACHED_SUCCESS
,
967 memcached_replace(memc
,
968 test_literal_param(__func__
),
969 test_literal_param("first we insert some data"),
970 time_t(0), uint32_t(0)));
975 test_return_t
delete_test(memcached_st
*memc
)
977 test_compare(return_value_based_on_buffering(memc
),
979 test_literal_param(__func__
),
980 test_literal_param("when we sanitize"),
981 time_t(0), uint32_t(0)));
983 test_compare_hint(return_value_based_on_buffering(memc
),
984 memcached_delete(memc
,
985 test_literal_param(__func__
),
987 memcached_last_error_message(memc
));
992 test_return_t
flush_test(memcached_st
*memc
)
994 uint64_t query_id
= memcached_query_id(memc
);
995 test_compare(MEMCACHED_SUCCESS
,
996 memcached_flush(memc
, 0));
997 test_compare(query_id
+1, memcached_query_id(memc
));
1002 static memcached_return_t
server_function(const memcached_st
*,
1003 const memcached_server_st
*,
1007 return MEMCACHED_SUCCESS
;
1010 test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
1013 strncpy(context
, "foo bad", sizeof(context
));
1014 memcached_server_fn callbacks
[1];
1016 callbacks
[0]= server_function
;
1017 memcached_server_cursor(memc
, callbacks
, context
, 1);
1018 return TEST_SUCCESS
;
1021 test_return_t
bad_key_test(memcached_st
*memc
)
1023 memcached_return_t rc
;
1024 const char *key
= "foo bad";
1027 uint64_t query_id
= memcached_query_id(memc
);
1029 // Just skip if we are in binary mode.
1030 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1032 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
1034 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
1035 test_true(memc_clone
);
1037 query_id
= memcached_query_id(memc_clone
);
1038 test_compare(MEMCACHED_SUCCESS
,
1039 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1040 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
1042 /* All keys are valid in the binary protocol (except for length) */
1043 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == false)
1045 uint64_t before_query_id
= memcached_query_id(memc_clone
);
1047 size_t string_length
;
1048 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1049 &string_length
, &flags
, &rc
);
1050 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1051 test_zero(string_length
);
1054 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
1056 query_id
= memcached_query_id(memc_clone
);
1057 test_compare(MEMCACHED_SUCCESS
,
1058 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
1059 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
1061 size_t string_length
;
1062 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1063 &string_length
, &flags
, &rc
);
1064 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1065 test_zero(string_length
);
1069 /* Test multi key for bad keys */
1070 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
1071 size_t key_lengths
[] = { 7, 7, 7 };
1072 query_id
= memcached_query_id(memc_clone
);
1073 test_compare(MEMCACHED_SUCCESS
,
1074 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1075 test_compare(query_id
, memcached_query_id(memc_clone
));
1077 query_id
= memcached_query_id(memc_clone
);
1078 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
1079 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
1080 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1082 query_id
= memcached_query_id(memc_clone
);
1083 // Grouping keys are not required to follow normal key behaviors
1084 test_compare(MEMCACHED_SUCCESS
,
1085 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
1086 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1088 /* The following test should be moved to the end of this function when the
1089 memcached server is updated to allow max size length of the keys in the
1092 test_compare(MEMCACHED_SUCCESS
,
1093 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
1095 libtest::vchar_t longkey
;
1097 libtest::vchar_t::iterator it
= longkey
.begin();
1098 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
1101 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
1103 size_t string_length
;
1105 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
1106 test_compare(MEMCACHED_NOTFOUND
, rc
);
1107 test_zero(string_length
);
1109 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
1110 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1111 test_zero(string_length
);
1115 /* Make sure zero length keys are marked as bad */
1117 test_compare(MEMCACHED_SUCCESS
,
1118 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1119 size_t string_length
;
1120 char *string
= memcached_get(memc_clone
, key
, 0,
1121 &string_length
, &flags
, &rc
);
1122 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1123 test_zero(string_length
);
1127 memcached_free(memc_clone
);
1129 return TEST_SUCCESS
;
1132 #define READ_THROUGH_VALUE "set for me"
1133 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
1136 memcached_result_st
*result
)
1138 (void)memc
;(void)key
;(void)key_length
;
1139 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
1142 #ifndef __INTEL_COMPILER
1143 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1146 test_return_t
read_through(memcached_st
*memc
)
1148 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1150 size_t string_length
;
1152 memcached_return_t rc
;
1153 char *string
= memcached_get(memc
,
1154 test_literal_param(__func__
),
1155 &string_length
, &flags
, &rc
);
1157 test_compare(MEMCACHED_NOTFOUND
, rc
);
1158 test_false(string_length
);
1161 test_compare(MEMCACHED_SUCCESS
,
1162 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1164 string
= memcached_get(memc
,
1165 test_literal_param(__func__
),
1166 &string_length
, &flags
, &rc
);
1168 test_compare(MEMCACHED_SUCCESS
, rc
);
1169 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1170 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1171 test_strcmp(READ_THROUGH_VALUE
, string
);
1174 string
= memcached_get(memc
,
1175 test_literal_param(__func__
),
1176 &string_length
, &flags
, &rc
);
1178 test_compare(MEMCACHED_SUCCESS
, rc
);
1180 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1181 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1182 test_strcmp(READ_THROUGH_VALUE
, string
);
1185 return TEST_SUCCESS
;
1188 test_return_t
get_test(memcached_st
*memc
)
1190 uint64_t query_id
= memcached_query_id(memc
);
1191 memcached_return_t rc
= memcached_delete(memc
,
1192 test_literal_param(__func__
),
1194 test_true_hint(rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_NOTFOUND
, memcached_last_error_message(memc
));
1195 test_compare(query_id
+1, memcached_query_id(memc
));
1197 size_t string_length
;
1199 char *string
= memcached_get(memc
,
1200 test_literal_param(__func__
),
1201 &string_length
, &flags
, &rc
);
1203 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_last_error_message(memc
));
1204 test_false(string_length
);
1207 return TEST_SUCCESS
;
1210 test_return_t
get_test2(memcached_st
*memc
)
1212 const char *value
= "when we sanitize";
1214 uint64_t query_id
= memcached_query_id(memc
);
1215 test_compare(return_value_based_on_buffering(memc
),
1217 test_literal_param(__func__
),
1218 value
, strlen(value
),
1219 time_t(0), uint32_t(0)));
1220 test_compare(query_id
+1, memcached_query_id(memc
));
1222 query_id
= memcached_query_id(memc
);
1223 test_true(query_id
);
1226 size_t string_length
;
1227 memcached_return_t rc
;
1228 char *string
= memcached_get(memc
,
1229 test_literal_param(__func__
),
1230 &string_length
, &flags
, &rc
);
1231 test_compare(query_id
+1, memcached_query_id(memc
));
1233 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1234 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1236 test_compare(strlen(value
), string_length
);
1237 test_memcmp(string
, value
, string_length
);
1241 return TEST_SUCCESS
;
1244 test_return_t
set_test2(memcached_st
*memc
)
1246 for (uint32_t x
= 0; x
< 10; x
++)
1248 test_compare(return_value_based_on_buffering(memc
),
1250 test_literal_param("foo"),
1251 test_literal_param("train in the brain"),
1252 time_t(0), uint32_t(0)));
1255 return TEST_SUCCESS
;
1258 test_return_t
set_test3(memcached_st
*memc
)
1260 size_t value_length
= 8191;
1262 libtest::vchar_t value
;
1263 value
.reserve(value_length
);
1264 for (uint32_t x
= 0; x
< value_length
; x
++)
1266 value
.push_back(char(x
% 127));
1269 /* The dump test relies on there being at least 32 items in memcached */
1270 for (uint32_t x
= 0; x
< 32; x
++)
1274 snprintf(key
, sizeof(key
), "foo%u", x
);
1276 uint64_t query_id
= memcached_query_id(memc
);
1277 test_compare_hint(return_value_based_on_buffering(memc
),
1278 memcached_set(memc
, key
, strlen(key
),
1279 &value
[0], value
.size(),
1280 time_t(0), uint32_t(0)),
1281 memcached_last_error_message(memc
));
1282 test_compare(query_id
+1, memcached_query_id(memc
));
1285 return TEST_SUCCESS
;
1288 test_return_t
get_test3(memcached_st
*memc
)
1290 size_t value_length
= 8191;
1292 libtest::vchar_t value
;
1293 value
.reserve(value_length
);
1294 for (uint32_t x
= 0; x
< value_length
; x
++)
1296 value
.push_back(char(x
% 127));
1299 test_compare_hint(return_value_based_on_buffering(memc
),
1301 test_literal_param(__func__
),
1302 &value
[0], value
.size(),
1303 time_t(0), uint32_t(0)),
1304 memcached_last_error_message(memc
));
1306 size_t string_length
;
1308 memcached_return_t rc
;
1309 char *string
= memcached_get(memc
,
1310 test_literal_param(__func__
),
1311 &string_length
, &flags
, &rc
);
1313 test_compare(MEMCACHED_SUCCESS
, rc
);
1315 test_compare(value
.size(), string_length
);
1316 test_memcmp(string
, &value
[0], string_length
);
1320 return TEST_SUCCESS
;
1323 test_return_t
get_test4(memcached_st
*memc
)
1325 size_t value_length
= 8191;
1327 libtest::vchar_t value
;
1328 value
.reserve(value_length
);
1329 for (uint32_t x
= 0; x
< value_length
; x
++)
1331 value
.push_back(char(x
% 127));
1334 test_compare_hint(return_value_based_on_buffering(memc
),
1336 test_literal_param(__func__
),
1337 &value
[0], value
.size(),
1338 time_t(0), uint32_t(0)),
1339 memcached_last_error_message(memc
));
1341 for (uint32_t x
= 0; x
< 10; x
++)
1344 size_t string_length
;
1345 memcached_return_t rc
;
1346 char *string
= memcached_get(memc
,
1347 test_literal_param(__func__
),
1348 &string_length
, &flags
, &rc
);
1350 test_compare(MEMCACHED_SUCCESS
, rc
);
1352 test_compare(value
.size(), string_length
);
1353 test_memcmp(string
, &value
[0], string_length
);
1357 return TEST_SUCCESS
;
1361 * This test verifies that memcached_read_one_response doesn't try to
1362 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1363 * responses before you execute a storage command.
1365 test_return_t
get_test5(memcached_st
*memc
)
1368 ** Request the same key twice, to ensure that we hash to the same server
1369 ** (so that we have multiple response values queued up) ;-)
1371 const char *keys
[]= { "key", "key" };
1372 size_t lengths
[]= { 3, 3 };
1376 test_compare_hint(return_value_based_on_buffering(memc
),
1377 memcached_set(memc
, keys
[0], lengths
[0],
1378 keys
[0], lengths
[0],
1379 time_t(0), uint32_t(0)),
1380 memcached_last_error_message(memc
));
1381 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1383 memcached_result_st results_obj
;
1384 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1387 memcached_return_t rc
;
1388 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1391 memcached_result_free(&results_obj
);
1393 /* Don't read out the second result, but issue a set instead.. */
1394 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1396 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1397 &rlen
, &flags
, &rc
);
1399 test_compare(MEMCACHED_NOTFOUND
, rc
);
1400 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1402 test_compare(MEMCACHED_SUCCESS
, rc
);
1405 return TEST_SUCCESS
;
1408 test_return_t
mget_end(memcached_st
*memc
)
1410 const char *keys
[]= { "foo", "foo2" };
1411 size_t lengths
[]= { 3, 4 };
1412 const char *values
[]= { "fjord", "41" };
1415 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1417 test_compare(MEMCACHED_SUCCESS
,
1419 keys
[x
], lengths
[x
],
1420 values
[x
], strlen(values
[x
]),
1421 time_t(0), uint32_t(0)));
1425 size_t string_length
;
1428 // retrieve both via mget
1429 test_compare(MEMCACHED_SUCCESS
,
1430 memcached_mget(memc
,
1432 test_array_length(keys
)));
1434 char key
[MEMCACHED_MAX_KEY
];
1436 memcached_return_t rc
;
1438 // this should get both
1439 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1441 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1443 test_compare(MEMCACHED_SUCCESS
, rc
);
1445 if (key_length
== 4)
1450 test_compare(string_length
, strlen(values
[val
]));
1451 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1455 // this should indicate end
1456 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1457 test_compare(MEMCACHED_END
, rc
);
1461 test_compare(MEMCACHED_SUCCESS
,
1462 memcached_mget(memc
, keys
, lengths
, 1));
1464 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1465 test_compare(key_length
, lengths
[0]);
1466 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1467 test_compare(string_length
, strlen(values
[0]));
1468 test_true(strncmp(values
[0], string
, string_length
) == 0);
1469 test_compare(MEMCACHED_SUCCESS
, rc
);
1472 // this should indicate end
1473 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1474 test_compare(MEMCACHED_END
, rc
);
1477 return TEST_SUCCESS
;
1480 /* Do not copy the style of this code, I just access hosts to testthis function */
1481 test_return_t
stats_servername_test(memcached_st
*memc
)
1483 memcached_stat_st memc_stat
;
1484 memcached_server_instance_st instance
=
1485 memcached_server_instance_by_position(memc
, 0);
1487 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1489 return TEST_SKIPPED
;
1492 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1493 memcached_server_name(instance
),
1494 memcached_server_port(instance
)));
1496 return TEST_SUCCESS
;
1499 test_return_t
increment_test(memcached_st
*memc
)
1501 uint64_t new_number
;
1503 test_compare(MEMCACHED_SUCCESS
,
1505 test_literal_param("number"),
1506 test_literal_param("0"),
1507 (time_t)0, (uint32_t)0));
1509 test_compare(MEMCACHED_SUCCESS
,
1510 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1511 test_compare(uint64_t(1), new_number
);
1513 test_compare(MEMCACHED_SUCCESS
,
1514 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1515 test_compare(uint64_t(2), new_number
);
1517 return TEST_SUCCESS
;
1520 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1522 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1524 uint64_t new_number
;
1525 uint64_t initial
= 0;
1527 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1529 test_compare(MEMCACHED_SUCCESS
,
1530 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1531 test_compare(new_number
, initial
);
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
+1));
1537 return TEST_SUCCESS
;
1540 test_return_t
decrement_test(memcached_st
*memc
)
1542 test_compare(return_value_based_on_buffering(memc
),
1544 test_literal_param(__func__
),
1545 test_literal_param("3"),
1546 time_t(0), uint32_t(0)));
1547 // Make sure we flush the value we just set
1548 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1550 uint64_t new_number
;
1551 test_compare(MEMCACHED_SUCCESS
,
1552 memcached_decrement(memc
,
1553 test_literal_param(__func__
),
1555 test_compare(uint64_t(2), new_number
);
1557 test_compare(MEMCACHED_SUCCESS
,
1558 memcached_decrement(memc
,
1559 test_literal_param(__func__
),
1561 test_compare(uint64_t(1), new_number
);
1563 return TEST_SUCCESS
;
1566 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1568 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1570 uint64_t initial
= 3;
1572 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1574 uint64_t new_number
;
1575 test_compare(MEMCACHED_SUCCESS
,
1576 memcached_decrement_with_initial(memc
,
1577 test_literal_param(__func__
),
1580 test_compare(new_number
, initial
);
1582 test_compare(MEMCACHED_SUCCESS
,
1583 memcached_decrement_with_initial(memc
,
1584 test_literal_param(__func__
),
1587 test_compare(new_number
, (initial
- 1));
1589 return TEST_SUCCESS
;
1592 test_return_t
increment_by_key_test(memcached_st
*memc
)
1594 const char *master_key
= "foo";
1595 const char *key
= "number";
1596 const char *value
= "0";
1598 test_compare(return_value_based_on_buffering(memc
),
1599 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1601 value
, strlen(value
),
1602 time_t(0), uint32_t(0)));
1604 // Make sure we flush the value we just set
1605 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1607 uint64_t new_number
;
1608 test_compare(MEMCACHED_SUCCESS
,
1609 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1610 key
, strlen(key
), 1, &new_number
));
1611 test_compare(uint64_t(1), new_number
);
1613 test_compare(MEMCACHED_SUCCESS
,
1614 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1615 key
, strlen(key
), 1, &new_number
));
1616 test_compare(uint64_t(2), new_number
);
1618 return TEST_SUCCESS
;
1621 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1623 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1625 uint64_t new_number
;
1626 const char *master_key
= "foo";
1627 const char *key
= "number";
1628 uint64_t initial
= 0;
1630 test_compare(MEMCACHED_SUCCESS
,
1631 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1633 1, initial
, 0, &new_number
));
1634 test_compare(new_number
, initial
);
1636 test_compare(MEMCACHED_SUCCESS
,
1637 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1639 1, initial
, 0, &new_number
));
1640 test_compare(new_number
, (initial
+1));
1642 return TEST_SUCCESS
;
1645 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1647 uint64_t new_number
;
1648 const char *value
= "3";
1650 test_compare(return_value_based_on_buffering(memc
),
1651 memcached_set_by_key(memc
,
1652 test_literal_param("foo"),
1653 test_literal_param("number"),
1654 value
, strlen(value
),
1655 (time_t)0, (uint32_t)0));
1657 test_compare(MEMCACHED_SUCCESS
,
1658 memcached_decrement_by_key(memc
,
1659 test_literal_param("foo"),
1660 test_literal_param("number"),
1662 test_compare(uint64_t(2), new_number
);
1664 test_compare(MEMCACHED_SUCCESS
,
1665 memcached_decrement_by_key(memc
,
1666 test_literal_param("foo"),
1667 test_literal_param("number"),
1669 test_compare(uint64_t(1), new_number
);
1671 return TEST_SUCCESS
;
1674 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1676 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1678 uint64_t new_number
;
1679 uint64_t initial
= 3;
1681 test_compare(MEMCACHED_SUCCESS
,
1682 memcached_decrement_with_initial_by_key(memc
,
1683 test_literal_param("foo"),
1684 test_literal_param("number"),
1685 1, initial
, 0, &new_number
));
1686 test_compare(new_number
, initial
);
1688 test_compare(MEMCACHED_SUCCESS
,
1689 memcached_decrement_with_initial_by_key(memc
,
1690 test_literal_param("foo"),
1691 test_literal_param("number"),
1692 1, initial
, 0, &new_number
));
1693 test_compare(new_number
, (initial
- 1));
1695 return TEST_SUCCESS
;
1697 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1699 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1701 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1703 test_compare(return_value_based_on_buffering(memc
),
1705 test_literal_param("number"),
1706 test_literal_param("0"),
1707 (time_t)0, (uint32_t)0));
1709 uint64_t new_number
;
1710 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1711 test_literal_param("number"),
1713 test_compare(uint64_t(1), new_number
);
1715 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1716 test_literal_param("number"),
1718 test_compare(uint64_t(2), new_number
);
1720 return TEST_SUCCESS
;
1723 test_return_t
quit_test(memcached_st
*memc
)
1725 const char *value
= "sanford and sun";
1727 test_compare(return_value_based_on_buffering(memc
),
1729 test_literal_param(__func__
),
1730 value
, strlen(value
),
1731 (time_t)10, (uint32_t)3));
1732 memcached_quit(memc
);
1734 test_compare(return_value_based_on_buffering(memc
),
1736 test_literal_param(__func__
),
1737 value
, strlen(value
),
1738 (time_t)50, (uint32_t)9));
1740 return TEST_SUCCESS
;
1743 test_return_t
mget_result_test(memcached_st
*memc
)
1745 const char *keys
[]= {"fudge", "son", "food"};
1746 size_t key_length
[]= {5, 3, 4};
1748 memcached_result_st results_obj
;
1749 memcached_result_st
*results
;
1751 results
= memcached_result_create(memc
, &results_obj
);
1753 test_true(&results_obj
== results
);
1755 /* We need to empty the server before continueing test */
1756 test_compare(MEMCACHED_SUCCESS
,
1757 memcached_flush(memc
, 0));
1759 test_compare(MEMCACHED_SUCCESS
,
1760 memcached_mget(memc
, keys
, key_length
, 3));
1762 memcached_return_t rc
;
1763 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1768 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1769 test_false(results
);
1770 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1772 for (uint32_t x
= 0; x
< 3; x
++)
1774 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1775 keys
[x
], key_length
[x
],
1776 (time_t)50, (uint32_t)9);
1777 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1780 test_compare(MEMCACHED_SUCCESS
,
1781 memcached_mget(memc
, keys
, key_length
, 3));
1783 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1786 test_true(&results_obj
== results
);
1787 test_compare(MEMCACHED_SUCCESS
, rc
);
1788 test_memcmp(memcached_result_key_value(results
),
1789 memcached_result_value(results
),
1790 memcached_result_length(results
));
1791 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1794 memcached_result_free(&results_obj
);
1796 return TEST_SUCCESS
;
1799 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1801 const char *keys
[]= {"fudge", "son", "food"};
1802 size_t key_length
[]= {5, 3, 4};
1804 memcached_result_st
*results
;
1806 /* We need to empty the server before continueing test */
1807 test_compare(MEMCACHED_SUCCESS
,
1808 memcached_flush(memc
, 0));
1810 test_compare(MEMCACHED_SUCCESS
,
1811 memcached_mget(memc
, keys
, key_length
, 3));
1813 memcached_return_t rc
;
1814 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1818 test_false(results
);
1819 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1821 for (uint32_t x
= 0; x
< 3; x
++)
1823 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1824 keys
[x
], key_length
[x
],
1825 (time_t)50, (uint32_t)9);
1826 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1829 test_compare(MEMCACHED_SUCCESS
,
1830 memcached_mget(memc
, keys
, key_length
, 3));
1833 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1836 test_compare(MEMCACHED_SUCCESS
, rc
);
1837 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1838 test_memcmp(memcached_result_key_value(results
),
1839 memcached_result_value(results
),
1840 memcached_result_length(results
));
1841 memcached_result_free(results
);
1845 return TEST_SUCCESS
;
1848 test_return_t
mget_result_function(memcached_st
*memc
)
1850 const char *keys
[]= {"fudge", "son", "food"};
1851 size_t key_length
[]= {5, 3, 4};
1853 memcached_execute_fn callbacks
[1];
1855 for (uint32_t x
= 0; x
< 3; x
++)
1857 test_compare(return_value_based_on_buffering(memc
),
1858 memcached_set(memc
, keys
[x
], key_length
[x
],
1859 keys
[x
], key_length
[x
],
1860 time_t(50), uint32_t(9)));
1862 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1863 memcached_quit(memc
);
1865 test_compare(MEMCACHED_SUCCESS
,
1866 memcached_mget(memc
, keys
, key_length
, 3));
1868 callbacks
[0]= &callback_counter
;
1871 test_compare(MEMCACHED_SUCCESS
,
1872 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1874 test_compare(size_t(3), counter
);
1876 return TEST_SUCCESS
;
1879 test_return_t
mget_test(memcached_st
*memc
)
1881 const char *keys
[]= {"fudge", "son", "food"};
1882 size_t key_length
[]= {5, 3, 4};
1884 char return_key
[MEMCACHED_MAX_KEY
];
1885 size_t return_key_length
;
1887 size_t return_value_length
;
1889 test_compare(MEMCACHED_SUCCESS
,
1890 memcached_mget(memc
, keys
, key_length
, 3));
1893 memcached_return_t rc
;
1894 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1895 &return_value_length
, &flags
, &rc
)))
1897 test_true(return_value
);
1899 test_false(return_value
);
1900 test_zero(return_value_length
);
1901 test_compare(MEMCACHED_NOTFOUND
, rc
);
1903 for (uint32_t x
= 0; x
< 3; x
++)
1905 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1906 keys
[x
], key_length
[x
],
1907 (time_t)50, (uint32_t)9);
1908 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1910 test_compare(MEMCACHED_SUCCESS
,
1911 memcached_mget(memc
, keys
, key_length
, 3));
1914 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1915 &return_value_length
, &flags
, &rc
)))
1917 test_true(return_value
);
1918 test_compare(MEMCACHED_SUCCESS
, rc
);
1919 if (not memc
->_namespace
)
1921 test_compare(return_key_length
, return_value_length
);
1922 test_memcmp(return_value
, return_key
, return_value_length
);
1928 return TEST_SUCCESS
;
1931 test_return_t
mget_execute(memcached_st
*original_memc
)
1933 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1935 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1938 keys_st
keys(20480);
1940 /* First add all of the items.. */
1941 char blob
[1024] = {0};
1943 for (size_t x
= 0; x
< keys
.size(); ++x
)
1945 uint64_t query_id
= memcached_query_id(memc
);
1946 memcached_return_t rc
= memcached_add(memc
,
1947 keys
.key_at(x
), keys
.length_at(x
),
1950 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
,
1951 memcached_strerror(NULL
, rc
));
1952 test_compare(query_id
+1, memcached_query_id(memc
));
1955 /* Try to get all of them with a large multiget */
1957 memcached_execute_fn callbacks
[]= { &callback_counter
};
1958 test_compare(MEMCACHED_SUCCESS
,
1959 memcached_mget_execute(memc
,
1960 keys
.keys_ptr(), keys
.lengths_ptr(),
1961 keys
.size(), callbacks
, &counter
, 1));
1964 uint64_t query_id
= memcached_query_id(memc
);
1965 test_compare(MEMCACHED_SUCCESS
,
1966 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1967 test_compare(query_id
, memcached_query_id(memc
));
1969 /* Verify that we got all of the items */
1970 test_compare(keys
.size(), counter
);
1973 memcached_free(memc
);
1975 return TEST_SUCCESS
;
1978 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1979 static pairs_st
*global_pairs
;
1981 test_return_t
key_setup(memcached_st
*memc
)
1983 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1985 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1987 return TEST_SUCCESS
;
1990 test_return_t
key_teardown(memcached_st
*)
1992 pairs_free(global_pairs
);
1994 return TEST_SUCCESS
;
1997 test_return_t
block_add_regression(memcached_st
*memc
)
1999 /* First add all of the items.. */
2000 for (ptrdiff_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
2002 char blob
[1024] = {0};
2004 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);
2005 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
, memcached_strerror(NULL
, rc
));
2008 return TEST_SUCCESS
;
2011 test_return_t
binary_add_regression(memcached_st
*memc
)
2013 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2014 test_return_t rc
= block_add_regression(memc
);
2019 test_return_t
get_stats_keys(memcached_st
*memc
)
2023 memcached_stat_st memc_stat
;
2024 memcached_return_t rc
;
2026 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
2027 test_compare(MEMCACHED_SUCCESS
, rc
);
2028 for (ptr
= stat_list
; *ptr
; ptr
++)
2033 return TEST_SUCCESS
;
2036 test_return_t
version_string_test(memcached_st
*)
2038 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
2040 return TEST_SUCCESS
;
2043 test_return_t
get_stats(memcached_st
*memc
)
2045 memcached_return_t rc
;
2047 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
2048 test_compare(MEMCACHED_SUCCESS
, rc
);
2049 test_true(memc_stat
);
2051 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
2053 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
2054 test_compare(MEMCACHED_SUCCESS
, rc
);
2055 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
2060 memcached_stat_free(NULL
, memc_stat
);
2062 return TEST_SUCCESS
;
2065 test_return_t
add_host_test(memcached_st
*memc
)
2067 char servername
[]= "0.example.com";
2069 memcached_return_t rc
;
2070 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2071 test_compare(1U, memcached_server_list_count(servers
));
2073 for (unsigned int x
= 2; x
< 20; x
++)
2075 char buffer
[SMALL_STRING_LEN
];
2077 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2078 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2080 test_compare(MEMCACHED_SUCCESS
, rc
);
2081 test_compare(x
, memcached_server_list_count(servers
));
2084 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2085 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2087 memcached_server_list_free(servers
);
2089 return TEST_SUCCESS
;
2092 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
2094 memcached_return_t rc
;
2096 const char *key
= "not_found";
2097 size_t key_length
= test_literal_param_size("not_found");
2099 test_compare(MEMCACHED_SUCCESS
,
2100 memcached_mget(memc
, &key
, &key_length
, 1));
2102 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
2104 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2106 memcached_result_free(result
);
2108 return TEST_SUCCESS
;
2111 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
2113 return MEMCACHED_SUCCESS
;
2116 static memcached_return_t
cleanup_test_callback(memcached_st
*)
2118 return MEMCACHED_SUCCESS
;
2121 test_return_t
callback_test(memcached_st
*memc
)
2123 /* Test User Data */
2127 memcached_return_t rc
;
2129 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
2130 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
2131 test_true(*test_ptr
== x
);
2134 /* Test Clone Callback */
2136 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2137 void *clone_cb_ptr
= *(void **)&clone_cb
;
2138 void *temp_function
= NULL
;
2140 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
2141 memcached_return_t rc
;
2142 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2143 test_true(temp_function
== clone_cb_ptr
);
2144 test_compare(MEMCACHED_SUCCESS
, rc
);
2147 /* Test Cleanup Callback */
2149 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2150 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2151 void *temp_function
= NULL
;
2152 memcached_return_t rc
;
2154 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2155 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2156 test_true(temp_function
== cleanup_cb_ptr
);
2159 return TEST_SUCCESS
;
2162 /* We don't test the behavior itself, we test the switches */
2163 test_return_t
behavior_test(memcached_st
*memc
)
2165 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2166 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2168 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2169 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2171 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2172 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2174 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2175 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2177 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2178 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2180 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2181 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2183 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2184 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2186 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2188 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2190 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2191 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2192 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2194 return TEST_SUCCESS
;
2197 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2199 test_compare(MEMCACHED_DEPRECATED
,
2200 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2202 // Platform dependent
2204 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2208 return TEST_SUCCESS
;
2212 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2214 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2215 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2217 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2219 if (memcached_success(rc
))
2228 return TEST_SUCCESS
;
2232 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2234 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2235 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2237 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2239 if (memcached_success(rc
))
2248 return TEST_SUCCESS
;
2251 /* Make sure we behave properly if server list has no values */
2252 test_return_t
user_supplied_bug4(memcached_st
*memc
)
2254 const char *keys
[]= {"fudge", "son", "food"};
2255 size_t key_length
[]= {5, 3, 4};
2257 /* Here we free everything before running a bunch of mget tests */
2258 memcached_servers_reset(memc
);
2261 /* We need to empty the server before continueing test */
2262 test_compare(MEMCACHED_NO_SERVERS
,
2263 memcached_flush(memc
, 0));
2265 test_compare(MEMCACHED_NO_SERVERS
,
2266 memcached_mget(memc
, keys
, key_length
, 3));
2269 unsigned int keys_returned
;
2270 memcached_return_t rc
;
2271 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2272 test_compare(MEMCACHED_NOTFOUND
, rc
);
2273 test_zero(keys_returned
);
2276 for (uint32_t x
= 0; x
< 3; x
++)
2278 test_compare(MEMCACHED_NO_SERVERS
,
2279 memcached_set(memc
, keys
[x
], key_length
[x
],
2280 keys
[x
], key_length
[x
],
2281 (time_t)50, (uint32_t)9));
2284 test_compare(MEMCACHED_NO_SERVERS
,
2285 memcached_mget(memc
, keys
, key_length
, 3));
2289 char return_key
[MEMCACHED_MAX_KEY
];
2290 memcached_return_t rc
;
2291 size_t return_key_length
;
2292 size_t return_value_length
;
2295 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2296 &return_value_length
, &flags
, &rc
)))
2298 test_true(return_value
);
2299 test_compare(MEMCACHED_SUCCESS
, rc
);
2300 test_true(return_key_length
== return_value_length
);
2301 test_memcmp(return_value
, return_key
, return_value_length
);
2307 return TEST_SUCCESS
;
2310 #define VALUE_SIZE_BUG5 1048064
2311 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2313 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2314 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2316 size_t value_length
;
2318 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2320 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2322 insert_data
[x
]= (signed char)rand();
2325 test_compare(MEMCACHED_SUCCESS
,
2326 memcached_flush(memc
, 0));
2328 memcached_return_t rc
;
2329 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2330 test_compare(MEMCACHED_SUCCESS
,
2331 memcached_mget(memc
, keys
, key_length
, 4));
2334 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2335 test_compare(MEMCACHED_NOTFOUND
, rc
);
2338 for (uint32_t x
= 0; x
< 4; x
++)
2340 test_compare(MEMCACHED_SUCCESS
,
2341 memcached_set(memc
, keys
[x
], key_length
[x
],
2342 insert_data
, VALUE_SIZE_BUG5
,
2343 (time_t)0, (uint32_t)0));
2346 for (uint32_t x
= 0; x
< 10; x
++)
2348 value
= memcached_get(memc
, keys
[0], key_length
[0],
2349 &value_length
, &flags
, &rc
);
2350 test_compare(rc
, MEMCACHED_SUCCESS
);
2354 test_compare(MEMCACHED_SUCCESS
,
2355 memcached_mget(memc
, keys
, key_length
, 4));
2357 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2358 test_compare(4U, count
);
2360 delete [] insert_data
;
2362 return TEST_SUCCESS
;
2365 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2367 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2368 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2369 char return_key
[MEMCACHED_MAX_KEY
];
2370 size_t return_key_length
;
2372 size_t value_length
;
2374 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2376 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2378 insert_data
[x
]= (signed char)rand();
2381 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2383 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2385 // We will now confirm that memcached_mget() returns success, but we will
2386 // then check to make sure that no actual keys are returned.
2387 test_compare(MEMCACHED_SUCCESS
,
2388 memcached_mget(memc
, keys
, key_length
, 4));
2390 memcached_return_t rc
;
2392 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2393 &value_length
, &flags
, &rc
)))
2398 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2400 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2402 test_compare(MEMCACHED_SUCCESS
,
2403 memcached_set(memc
, keys
[x
], key_length
[x
],
2404 insert_data
, VALUE_SIZE_BUG5
,
2405 (time_t)0, (uint32_t)0));
2407 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2409 for (uint32_t x
= 0; x
< 2; x
++)
2411 value
= memcached_get(memc
, keys
[0], key_length
[0],
2412 &value_length
, &flags
, &rc
);
2416 test_compare(MEMCACHED_SUCCESS
,
2417 memcached_mget(memc
, keys
, key_length
, 4));
2418 /* We test for purge of partial complete fetches */
2419 for (count
= 3; count
; count
--)
2421 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2422 &value_length
, &flags
, &rc
);
2423 test_compare(MEMCACHED_SUCCESS
, rc
);
2424 test_memcmp(value
, insert_data
, value_length
);
2425 test_true(value_length
);
2429 delete [] insert_data
;
2431 return TEST_SUCCESS
;
2434 test_return_t
user_supplied_bug8(memcached_st
*)
2436 memcached_return_t rc
;
2438 memcached_st
*memc_clone
;
2440 memcached_server_st
*servers
;
2441 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";
2443 servers
= memcached_servers_parse(server_list
);
2446 mine
= memcached_create(NULL
);
2447 rc
= memcached_server_push(mine
, servers
);
2448 test_compare(MEMCACHED_SUCCESS
, rc
);
2449 memcached_server_list_free(servers
);
2452 memc_clone
= memcached_clone(NULL
, mine
);
2454 memcached_quit(mine
);
2455 memcached_quit(memc_clone
);
2458 memcached_free(mine
);
2459 memcached_free(memc_clone
);
2461 return TEST_SUCCESS
;
2464 /* Test flag store/retrieve */
2465 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2467 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2468 test_true(insert_data
);
2470 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2472 insert_data
[x
]= (signed char)rand();
2475 memcached_flush(memc
, 0);
2477 const char *keys
= "036790384900";
2478 size_t key_length
= strlen(keys
);
2479 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2480 insert_data
, VALUE_SIZE_BUG5
,
2482 memcached_last_error_message(memc
));
2484 memcached_return_t rc
;
2485 size_t value_length
;
2487 char *value
= memcached_get(memc
, keys
, key_length
,
2488 &value_length
, &flags
, &rc
);
2489 test_compare(245U, flags
);
2493 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2495 char return_key
[MEMCACHED_MAX_KEY
];
2496 size_t return_key_length
;
2498 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2499 &value_length
, &flags
, &rc
);
2500 test_compare(uint32_t(245), flags
);
2503 delete [] insert_data
;
2506 return TEST_SUCCESS
;
2509 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2511 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2512 size_t key_length
[3];
2516 char return_key
[MEMCACHED_MAX_KEY
];
2517 size_t return_key_length
;
2519 size_t return_value_length
;
2522 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2523 key_length
[1]= strlen("fudge&*@#");
2524 key_length
[2]= strlen("for^#@&$not");
2527 for (unsigned int x
= 0; x
< 3; x
++)
2529 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2530 keys
[x
], key_length
[x
],
2531 (time_t)50, (uint32_t)9);
2532 test_compare(MEMCACHED_SUCCESS
, rc
);
2535 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2536 test_compare(MEMCACHED_SUCCESS
, rc
);
2538 /* We need to empty the server before continueing test */
2539 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2540 &return_value_length
, &flags
, &rc
)) != NULL
)
2542 test_true(return_value
);
2546 test_compare(3U, count
);
2548 return TEST_SUCCESS
;
2551 /* We are testing with aggressive timeout to get failures */
2552 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2554 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
2556 size_t value_length
= 512;
2557 unsigned int set
= 1;
2558 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2560 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2561 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2562 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2564 libtest::vchar_t value
;
2565 value
.reserve(value_length
);
2566 for (uint32_t x
= 0; x
< value_length
; x
++)
2568 value
.push_back(char(x
% 127));
2571 for (unsigned int x
= 1; x
<= 100000; ++x
)
2573 memcached_return_t rc
= memcached_set(mclone
,
2574 test_literal_param("foo"),
2575 &value
[0], value
.size(),
2578 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2579 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2580 memcached_strerror(NULL
, rc
));
2582 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2588 memcached_free(mclone
);
2590 return TEST_SUCCESS
;
2594 We are looking failures in the async protocol
2596 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2598 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2600 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2601 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2602 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2604 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2607 libtest::vchar_t value
;
2609 for (unsigned int x
= 0; x
< 512; x
++)
2611 value
.push_back(char(x
% 127));
2614 for (unsigned int x
= 1; x
<= 100000; ++x
)
2616 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2620 memcached_free(mclone
);
2622 return TEST_SUCCESS
;
2626 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2628 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2630 memcached_return_t rc
;
2632 size_t value_length
;
2634 uint64_t number_value
;
2636 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2637 &value_length
, &flags
, &rc
);
2639 test_compare(MEMCACHED_NOTFOUND
, rc
);
2641 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2644 /* The binary protocol will set the key if it doesn't exist */
2645 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2647 test_compare(MEMCACHED_SUCCESS
, rc
);
2651 test_compare(MEMCACHED_NOTFOUND
, rc
);
2654 test_compare(MEMCACHED_SUCCESS
,
2655 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2657 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2661 test_compare(MEMCACHED_SUCCESS
,
2662 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2663 test_compare(2UL, number_value
);
2665 return TEST_SUCCESS
;
2669 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2670 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2672 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2674 char key
[] = "key34567890";
2676 char commandFirst
[]= "set key34567890 0 0 ";
2677 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2678 size_t commandLength
;
2680 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2682 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2684 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2686 char *overflow
= new (std::nothrow
) char[testSize
];
2687 test_true(overflow
);
2689 memset(overflow
, 'x', testSize
);
2690 test_compare(MEMCACHED_SUCCESS
,
2691 memcached_set(memc
, key
, strlen(key
),
2692 overflow
, testSize
, 0, 0));
2696 return TEST_SUCCESS
;
2701 Test values of many different sizes
2702 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2703 set key34567890 0 0 8169 \r\n
2704 is sent followed by buffer of size 8169, followed by 8169
2706 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2708 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2710 libtest::vchar_t value
;
2711 value
.reserve(18000);
2712 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2714 value
.push_back((char) (x
% 127));
2717 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2719 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2720 &value
[0], current_length
,
2721 (time_t)0, (uint32_t)0);
2722 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2724 size_t string_length
;
2726 char *string
= memcached_get(memc
, test_literal_param("foo"),
2727 &string_length
, &flags
, &rc
);
2729 test_compare(MEMCACHED_SUCCESS
, rc
);
2730 test_compare(string_length
, current_length
);
2732 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2733 test_memcmp_hint(string
, &value
[0], string_length
, buffer
);
2738 return TEST_SUCCESS
;
2742 Look for zero length value problems
2744 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2746 for (uint32_t x
= 0; x
< 2; x
++)
2748 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2750 (time_t)0, (uint32_t)0);
2752 test_compare(MEMCACHED_SUCCESS
, rc
);
2756 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2757 &length
, &flags
, &rc
);
2759 test_compare(MEMCACHED_SUCCESS
, rc
);
2764 value
= memcached_get(memc
, test_literal_param("mykey"),
2765 &length
, &flags
, &rc
);
2767 test_compare(MEMCACHED_SUCCESS
, rc
);
2773 return TEST_SUCCESS
;
2776 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2777 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2779 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2781 (time_t)0, UINT32_MAX
),
2782 memcached_last_error_message(memc
));
2787 memcached_return_t rc
;
2788 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2789 &length
, &flags
, &rc
);
2791 test_compare(MEMCACHED_SUCCESS
, rc
);
2794 test_compare(flags
, UINT32_MAX
);
2796 return TEST_SUCCESS
;
2799 #if !defined(__sun) && !defined(__OpenBSD__)
2800 /* Check the validity of chinese key*/
2801 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2803 const char *key
= "豆瓣";
2804 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2805 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2806 value
, strlen(value
),
2809 test_compare(MEMCACHED_SUCCESS
, rc
);
2813 char *value2
= memcached_get(memc
, key
, strlen(key
),
2814 &length
, &flags
, &rc
);
2816 test_true(length
==strlen(value
));
2817 test_compare(MEMCACHED_SUCCESS
, rc
);
2818 test_memcmp(value
, value2
, length
);
2821 return TEST_SUCCESS
;
2829 test_return_t
user_supplied_bug19(memcached_st
*)
2831 memcached_return_t res
;
2833 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2835 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2838 memcached_free(memc
);
2840 return TEST_SUCCESS
;
2843 /* CAS test from Andei */
2844 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2846 const char *key
= "abc";
2847 size_t key_len
= strlen("abc");
2849 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2851 test_compare(MEMCACHED_SUCCESS
,
2853 test_literal_param("abc"),
2854 test_literal_param("foobar"),
2855 (time_t)0, (uint32_t)0));
2857 test_compare(MEMCACHED_SUCCESS
,
2858 memcached_mget(memc
, &key
, &key_len
, 1));
2860 memcached_result_st result_obj
;
2861 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2864 memcached_result_create(memc
, &result_obj
);
2865 memcached_return_t status
;
2866 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2869 test_compare(MEMCACHED_SUCCESS
, status
);
2871 memcached_result_free(result
);
2873 return TEST_SUCCESS
;
2876 /* Large mget() of missing keys with binary proto
2878 * If many binary quiet commands (such as getq's in an mget) fill the output
2879 * buffer and the server chooses not to respond, memcached_flush hangs. See
2880 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2883 /* sighandler_t function that always asserts false */
2884 static void fail(int)
2890 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2895 return TEST_SKIPPED
;
2897 void (*oldalarm
)(int);
2899 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2900 test_true(memc_clone
);
2902 /* only binproto uses getq for mget */
2903 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2905 /* empty the cache to ensure misses (hence non-responses) */
2906 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2908 keys_st
keys(key_count
);
2910 oldalarm
= signal(SIGALRM
, fail
);
2913 test_compare_got(MEMCACHED_SUCCESS
,
2914 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2915 memcached_last_error_message(memc_clone
));
2918 signal(SIGALRM
, oldalarm
);
2920 memcached_return_t rc
;
2922 char return_key
[MEMCACHED_MAX_KEY
];
2923 size_t return_key_length
;
2925 size_t return_value_length
;
2926 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2927 &return_value_length
, &flags
, &rc
)))
2929 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2931 test_compare(MEMCACHED_NOTFOUND
, rc
);
2932 test_zero(return_value_length
);
2933 test_zero(return_key_length
);
2934 test_false(return_key
[0]);
2935 test_false(return_value
);
2937 memcached_free(memc_clone
);
2939 return TEST_SUCCESS
;
2943 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2945 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2947 /* should work as of r580 */
2948 test_compare(TEST_SUCCESS
,
2949 _user_supplied_bug21(memc
, 10));
2951 /* should fail as of r580 */
2952 test_compare(TEST_SUCCESS
,
2953 _user_supplied_bug21(memc
, 1000));
2955 return TEST_SUCCESS
;
2958 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2960 memcached_st
*memc
= memcached_create(NULL
);
2964 test_compare(MEMCACHED_SUCCESS
,
2965 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2967 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2968 test_compare(value
, uint64_t(1));
2970 test_compare(MEMCACHED_SUCCESS
,
2971 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2973 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2974 test_true(value
== MEMCACHED_HASH_MD5
);
2977 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2979 memcached_server_st
*server_pool
;
2980 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");
2981 memcached_server_push(memc
, server_pool
);
2983 // @todo this needs to be refactored to actually test something.
2986 if ((fp
= fopen("ketama_keys.txt", "w")))
2990 printf("cannot write to file ketama_keys.txt");
2991 return TEST_FAILURE
;
2994 for (int x
= 0; x
< 10000; x
++)
2997 snprintf(key
, sizeof(key
), "%d", x
);
2999 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3000 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3001 in_port_t port
= memc
->hosts
[server_idx
].port
;
3002 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3003 memcached_server_instance_st instance
=
3004 memcached_server_instance_by_position(memc
, host_index
);
3008 memcached_server_list_free(server_pool
);
3009 memcached_free(memc
);
3011 return TEST_SUCCESS
;
3015 test_return_t
result_static(memcached_st
*memc
)
3017 memcached_result_st result
;
3018 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3019 test_false(result
.options
.is_allocated
);
3020 test_true(memcached_is_initialized(&result
));
3021 test_true(result_ptr
);
3022 test_true(result_ptr
== &result
);
3024 memcached_result_free(&result
);
3026 test_false(result
.options
.is_allocated
);
3027 test_false(memcached_is_initialized(&result
));
3029 return TEST_SUCCESS
;
3032 test_return_t
result_alloc(memcached_st
*memc
)
3034 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3035 test_true(result_ptr
);
3036 test_true(result_ptr
->options
.is_allocated
);
3037 test_true(memcached_is_initialized(result_ptr
));
3038 memcached_result_free(result_ptr
);
3040 return TEST_SUCCESS
;
3044 test_return_t
add_host_test1(memcached_st
*memc
)
3046 memcached_return_t rc
;
3047 char servername
[]= "0.example.com";
3049 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3051 test_compare(1U, memcached_server_list_count(servers
));
3053 for (uint32_t x
= 2; x
< 20; x
++)
3055 char buffer
[SMALL_STRING_LEN
];
3057 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3058 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3060 test_compare(MEMCACHED_SUCCESS
, rc
);
3061 test_compare(x
, memcached_server_list_count(servers
));
3064 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3065 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3067 memcached_server_list_free(servers
);
3069 return TEST_SUCCESS
;
3073 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3077 #ifdef HARD_MALLOC_TESTS
3078 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3086 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3090 #ifdef HARD_MALLOC_TESTS
3091 void *ret
= malloc(size
+ 8);
3094 ret
= (void*)((caddr_t
)ret
+ 8);
3097 void *ret
= malloc(size
);
3102 memset(ret
, 0xff, size
);
3109 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3111 #ifdef HARD_MALLOC_TESTS
3112 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3113 void *nmem
= realloc(real_ptr
, size
+ 8);
3118 ret
= (void*)((caddr_t
)nmem
+ 8);
3124 return realloc(mem
, size
);
3129 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3131 #ifdef HARD_MALLOC_TESTS
3132 void *mem
= my_malloc(ptr
, nelem
* size
);
3135 memset(mem
, 0, nelem
* size
);
3141 return calloc(nelem
, size
);
3145 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3147 memcached_return_t rc
;
3148 const char *key
= "mine";
3151 /* Make sure be default none exists */
3152 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3154 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3156 /* Test a clean set */
3157 test_compare(MEMCACHED_SUCCESS
,
3158 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3160 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3162 test_memcmp(value
, key
, 4);
3163 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3165 /* Test that we can turn it off */
3166 test_compare(MEMCACHED_SUCCESS
,
3167 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3169 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3171 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3173 /* Now setup for main test */
3174 test_compare(MEMCACHED_SUCCESS
,
3175 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3177 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3179 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3180 test_memcmp(value
, key
, 4);
3182 /* Set to Zero, and then Set to something too large */
3185 memset(long_key
, 0, 255);
3187 test_compare(MEMCACHED_SUCCESS
,
3188 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3190 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3192 test_compare(MEMCACHED_SUCCESS
, rc
);
3194 /* Test a long key for failure */
3195 /* TODO, extend test to determine based on setting, what result should be */
3196 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3197 test_compare(MEMCACHED_SUCCESS
,
3198 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3200 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3201 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3202 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3203 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3205 /* Test for a bad prefix, but with a short key */
3206 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3207 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3209 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3210 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3213 return TEST_SUCCESS
;
3216 test_return_t
set_namespace(memcached_st
*memc
)
3218 memcached_return_t rc
;
3219 const char *key
= "mine";
3222 // Make sure we default to a null namespace
3223 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3225 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3227 /* Test a clean set */
3228 test_compare(MEMCACHED_SUCCESS
,
3229 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3231 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3233 test_memcmp(value
, key
, 4);
3234 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3236 return TEST_SUCCESS
;
3239 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3241 test_return_if(pre_binary(memc
));
3242 test_return_if(set_namespace(memc
));
3244 return TEST_SUCCESS
;
3247 #ifdef MEMCACHED_ENABLE_DEPRECATED
3248 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3250 void *test_ptr
= NULL
;
3253 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
3254 cb_ptr
= *(void **)&malloc_cb
;
3255 memcached_return_t rc
;
3257 test_compare(MEMCACHED_SUCCESS
,
3258 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3259 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3260 test_compare(MEMCACHED_SUCCESS
, rc
);
3261 test_true(test_ptr
== cb_ptr
);
3265 memcached_realloc_fn realloc_cb
=
3266 (memcached_realloc_fn
)my_realloc
;
3267 cb_ptr
= *(void **)&realloc_cb
;
3268 memcached_return_t rc
;
3270 test_compare(MEMCACHED_SUCCESS
,
3271 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3272 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3273 test_compare(MEMCACHED_SUCCESS
, rc
);
3274 test_true(test_ptr
== cb_ptr
);
3278 memcached_free_fn free_cb
=
3279 (memcached_free_fn
)my_free
;
3280 cb_ptr
= *(void **)&free_cb
;
3281 memcached_return_t rc
;
3283 test_compare(MEMCACHED_SUCCESS
,
3284 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3285 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3286 test_compare(MEMCACHED_SUCCESS
, rc
);
3287 test_true(test_ptr
== cb_ptr
);
3290 return TEST_SUCCESS
;
3295 test_return_t
set_memory_alloc(memcached_st
*memc
)
3297 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3298 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3299 my_realloc
, my_calloc
, NULL
));
3301 test_compare(MEMCACHED_SUCCESS
,
3302 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3303 my_realloc
, my_calloc
, NULL
));
3305 memcached_malloc_fn mem_malloc
;
3306 memcached_free_fn mem_free
;
3307 memcached_realloc_fn mem_realloc
;
3308 memcached_calloc_fn mem_calloc
;
3309 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3310 &mem_realloc
, &mem_calloc
);
3312 test_true(mem_malloc
== my_malloc
);
3313 test_true(mem_realloc
== my_realloc
);
3314 test_true(mem_calloc
== my_calloc
);
3315 test_true(mem_free
== my_free
);
3317 return TEST_SUCCESS
;
3320 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3323 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3324 memcached_hash_t hash
;
3325 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3326 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3329 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3330 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3332 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3334 if (hash
!= MEMCACHED_HASH_CRC
)
3335 return TEST_SKIPPED
;
3337 return TEST_SUCCESS
;
3340 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3343 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3344 memcached_hash_t hash
;
3345 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3346 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3351 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3352 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3354 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3356 if (hash
!= MEMCACHED_HASH_HSIEH
)
3357 return TEST_SKIPPED
;
3360 return TEST_SUCCESS
;
3363 test_return_t
enable_cas(memcached_st
*memc
)
3365 unsigned int set
= 1;
3367 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3369 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3371 return TEST_SUCCESS
;
3374 return TEST_SKIPPED
;
3377 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3379 memcached_version(memc
);
3381 memcached_server_instance_st instance
=
3382 memcached_server_instance_by_position(memc
, 0);
3384 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3385 or instance
->minor_version
> 2)
3387 return TEST_SUCCESS
;
3390 return TEST_SKIPPED
;
3393 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3395 const uint64_t timeout
= 100; // Not using, just checking that it sets
3397 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3399 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3401 return TEST_SUCCESS
;
3404 test_return_t
noreply_test(memcached_st
*memc
)
3406 test_compare(MEMCACHED_SUCCESS
,
3407 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3408 test_compare(MEMCACHED_SUCCESS
,
3409 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3410 test_compare(MEMCACHED_SUCCESS
,
3411 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3412 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3413 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3414 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3416 memcached_return_t ret
;
3417 for (int count
= 0; count
< 5; ++count
)
3419 for (size_t x
= 0; x
< 100; ++x
)
3421 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3422 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3423 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3425 size_t len
= (size_t)check_length
;
3430 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3433 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3436 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3439 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3442 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3448 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3449 memcached_strerror(NULL
, ret
));
3453 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3454 ** API and is _ONLY_ done this way to verify that the library works the
3455 ** way it is supposed to do!!!!
3459 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3461 memcached_server_instance_st instance
=
3462 memcached_server_instance_by_position(memc
, x
);
3463 no_msg
+=(int)(instance
->cursor_active
);
3466 test_true(no_msg
== 0);
3468 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3471 ** Now validate that all items was set properly!
3473 for (size_t x
= 0; x
< 100; ++x
)
3477 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3479 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3481 size_t len
= (size_t)check_length
;
3484 char* value
=memcached_get(memc
, key
, strlen(key
),
3485 &length
, &flags
, &ret
);
3486 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
3489 case 0: /* FALLTHROUGH */
3490 case 1: /* FALLTHROUGH */
3492 test_true(strncmp(value
, key
, len
) == 0);
3493 test_true(len
== length
);
3496 test_true(length
== len
* 2);
3499 test_true(length
== len
* 3);
3509 /* Try setting an illegal cas value (should not return an error to
3510 * the caller (because we don't expect a return message from the server)
3512 const char* keys
[]= {"0"};
3513 size_t lengths
[]= {1};
3516 memcached_result_st results_obj
;
3517 memcached_result_st
*results
;
3518 test_compare(MEMCACHED_SUCCESS
,
3519 memcached_mget(memc
, keys
, lengths
, 1));
3521 results
= memcached_result_create(memc
, &results_obj
);
3523 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3525 test_compare(MEMCACHED_SUCCESS
, ret
);
3526 uint64_t cas
= memcached_result_cas(results
);
3527 memcached_result_free(&results_obj
);
3529 test_compare(MEMCACHED_SUCCESS
,
3530 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3533 * The item will have a new cas value, so try to set it again with the old
3534 * value. This should fail!
3536 test_compare(MEMCACHED_SUCCESS
,
3537 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3538 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3539 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3540 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3543 return TEST_SUCCESS
;
3546 test_return_t
analyzer_test(memcached_st
*memc
)
3548 memcached_analysis_st
*report
;
3549 memcached_return_t rc
;
3551 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3552 test_compare(MEMCACHED_SUCCESS
, rc
);
3553 test_true(memc_stat
);
3555 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3556 test_compare(MEMCACHED_SUCCESS
, rc
);
3560 memcached_stat_free(NULL
, memc_stat
);
3562 return TEST_SUCCESS
;
3565 test_return_t
util_version_test(memcached_st
*memc
)
3567 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
3568 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3570 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3572 // We expect failure
3575 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3576 fprintf(stderr
, "\nDumping Server Information\n\n");
3577 memcached_server_fn callbacks
[1];
3579 callbacks
[0]= dump_server_information
;
3580 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3581 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3583 test_true(if_successful
== false);
3585 memcached_server_instance_st instance
=
3586 memcached_server_instance_by_position(memc
, 0);
3588 memcached_version(memc
);
3590 // We only use one binary when we test, so this should be just fine.
3591 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3592 test_true(if_successful
== true);
3594 if (instance
->micro_version
> 0)
3596 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3598 else if (instance
->minor_version
> 0)
3600 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3602 else if (instance
->major_version
> 0)
3604 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3607 test_true(if_successful
== true);
3609 if (instance
->micro_version
> 0)
3611 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3613 else if (instance
->minor_version
> 0)
3615 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3617 else if (instance
->major_version
> 0)
3619 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3622 test_true(if_successful
== false);
3624 return TEST_SUCCESS
;
3627 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3629 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3630 memcached_return_t rc
;
3631 memcached_server_instance_st instance
=
3632 memcached_server_instance_by_position(memc
, 0);
3634 // Test both the version that returns a code, and the one that does not.
3635 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3636 memcached_server_port(instance
) -1, NULL
) == -1);
3638 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3639 memcached_server_port(instance
) -1, &rc
) == -1);
3640 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3642 return TEST_SUCCESS
;
3646 test_return_t
getpid_test(memcached_st
*memc
)
3648 memcached_return_t rc
;
3649 memcached_server_instance_st instance
=
3650 memcached_server_instance_by_position(memc
, 0);
3652 // Test both the version that returns a code, and the one that does not.
3653 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3654 memcached_server_port(instance
), NULL
) > -1);
3656 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3657 memcached_server_port(instance
), &rc
) > -1);
3658 test_compare(MEMCACHED_SUCCESS
, rc
);
3660 return TEST_SUCCESS
;
3663 test_return_t
ping_test(memcached_st
*memc
)
3665 memcached_return_t rc
;
3666 memcached_server_instance_st instance
=
3667 memcached_server_instance_by_position(memc
, 0);
3669 // Test both the version that returns a code, and the one that does not.
3670 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3671 memcached_server_port(instance
), NULL
));
3673 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3674 memcached_server_port(instance
), &rc
));
3676 test_compare(MEMCACHED_SUCCESS
, rc
);
3678 return TEST_SUCCESS
;
3683 test_return_t
hash_sanity_test (memcached_st
*memc
)
3687 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3688 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3689 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3690 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3691 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3692 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3693 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3694 #ifdef HAVE_HSIEH_HASH
3695 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3697 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3698 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3699 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3701 return TEST_SUCCESS
;
3705 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3707 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3709 test_compare(MEMCACHED_SUCCESS
,
3710 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3711 (uint64_t)MEMCACHED_HASH_HSIEH
));
3713 return TEST_SUCCESS
;
3716 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3718 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3720 test_compare(MEMCACHED_SUCCESS
,
3721 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3723 return TEST_SUCCESS
;
3726 test_return_t
one_at_a_time_run (memcached_st
*)
3731 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3733 test_compare(one_at_a_time_values
[x
],
3734 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3737 return TEST_SUCCESS
;
3740 test_return_t
md5_run (memcached_st
*)
3745 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3747 test_compare(md5_values
[x
],
3748 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3751 return TEST_SUCCESS
;
3754 test_return_t
crc_run (memcached_st
*)
3759 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3761 test_compare(crc_values
[x
],
3762 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3765 return TEST_SUCCESS
;
3768 test_return_t
fnv1_64_run (memcached_st
*)
3770 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3775 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3777 test_compare(fnv1_64_values
[x
],
3778 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3781 return TEST_SUCCESS
;
3784 test_return_t
fnv1a_64_run (memcached_st
*)
3786 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3791 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3793 test_compare(fnv1a_64_values
[x
],
3794 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3797 return TEST_SUCCESS
;
3800 test_return_t
fnv1_32_run (memcached_st
*)
3805 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3807 test_compare(fnv1_32_values
[x
],
3808 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3811 return TEST_SUCCESS
;
3814 test_return_t
fnv1a_32_run (memcached_st
*)
3819 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3821 test_compare(fnv1a_32_values
[x
],
3822 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3825 return TEST_SUCCESS
;
3828 test_return_t
hsieh_run (memcached_st
*)
3830 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3835 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3837 test_compare(hsieh_values
[x
],
3838 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3841 return TEST_SUCCESS
;
3844 test_return_t
murmur_run (memcached_st
*)
3846 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3848 #ifdef WORDS_BIGENDIAN
3849 (void)murmur_values
;
3850 return TEST_SKIPPED
;
3855 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3857 test_compare(murmur_values
[x
],
3858 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3861 return TEST_SUCCESS
;
3865 test_return_t
jenkins_run (memcached_st
*)
3870 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3872 test_compare(jenkins_values
[x
],
3873 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3876 return TEST_SUCCESS
;
3879 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3881 return libhashkit_md5(string
, string_length
);
3884 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3886 return libhashkit_crc32(string
, string_length
);
3889 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3895 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3897 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};
3898 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};
3900 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3902 hashkit_clone(&new_kit
, kit
);
3903 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3905 memcached_set_hashkit(memc
, &new_kit
);
3908 Verify Setting the hash.
3910 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3914 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3915 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3920 Now check memcached_st.
3922 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3926 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3927 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3930 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3932 memcached_set_hashkit(memc
, &new_kit
);
3935 Verify Setting the hash.
3937 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3941 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3942 test_true(crc_values
[x
] == hash_val
);
3945 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3949 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3950 test_compare(crc_hosts
[x
], hash_val
);
3953 memcached_free(memc
);
3955 return TEST_SUCCESS
;
3959 Test case adapted from John Gorman <johngorman2@gmail.com>
3961 We are testing the error condition when we connect to a server via memcached_get()
3962 but find that the server is not available.
3964 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3968 memcached_return rc
;
3971 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3973 // See if memcached is reachable.
3974 char *value
= memcached_get(tl_memc_h
,
3975 test_literal_param(__func__
),
3980 test_true(memcached_failed(rc
));
3982 memcached_free(tl_memc_h
);
3984 return TEST_SUCCESS
;
3988 We connect to a server which exists, but search for a key that does not exist.
3990 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3994 memcached_return rc
;
3996 // See if memcached is reachable.
3997 char *value
= memcached_get(memc
,
3998 test_literal_param(__func__
),
4003 test_compare(MEMCACHED_NOTFOUND
, rc
);
4005 return TEST_SUCCESS
;
4009 Test case adapted from John Gorman <johngorman2@gmail.com>
4011 We are testing the error condition when we connect to a server via memcached_get_by_key()
4012 but find that the server is not available.
4014 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
4018 memcached_return rc
;
4021 memcached_st
*tl_memc_h
= memcached_create(NULL
);
4022 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4023 memcached_server_push(tl_memc_h
, servers
);
4024 memcached_server_list_free(servers
);
4026 // See if memcached is reachable.
4027 char *value
= memcached_get_by_key(tl_memc_h
,
4028 test_literal_param(__func__
), // Key
4029 test_literal_param(__func__
), // Value
4034 test_true(memcached_failed(rc
));
4036 memcached_free(tl_memc_h
);
4038 return TEST_SUCCESS
;
4042 We connect to a server which exists, but search for a key that does not exist.
4044 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4048 memcached_return rc
;
4050 // See if memcached is reachable.
4051 char *value
= memcached_get_by_key(memc
,
4052 test_literal_param(__func__
), // Key
4053 test_literal_param(__func__
), // Value
4058 test_compare(MEMCACHED_NOTFOUND
, rc
);
4060 return TEST_SUCCESS
;
4063 test_return_t
regression_bug_434484(memcached_st
*memc
)
4065 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4067 test_compare(MEMCACHED_NOTSTORED
,
4068 memcached_append(memc
,
4069 test_literal_param(__func__
), // Key
4070 test_literal_param(__func__
), // Value
4073 libtest::vchar_t data
;
4074 data
.resize(2048 * 1024);
4075 test_compare(MEMCACHED_E2BIG
,
4077 test_literal_param(__func__
), // Key
4078 &data
[0], data
.size(), 0, 0));
4080 return TEST_SUCCESS
;
4083 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4085 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4087 memcached_return_t rc
;
4089 memcached_execute_fn callbacks
[]= { &callback_counter
};
4092 * I only want to hit only _one_ server so I know the number of requests I'm
4093 * sending in the pipleine to the server. Let's try to do a multiget of
4094 * 1024 (that should satisfy most users don't you think?). Future versions
4095 * will include a mget_execute function call if you need a higher number.
4097 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4102 * Run two times.. the first time we should have 100% cache miss,
4103 * and the second time we should have 100% cache hits
4105 for (ptrdiff_t y
= 0; y
< 2; y
++)
4107 test_compare(MEMCACHED_SUCCESS
,
4108 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4110 // One the first run we should get a NOT_FOUND, but on the second some data
4111 // should be returned.
4112 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4113 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4117 /* The first iteration should give me a 100% cache miss. verify that*/
4118 char blob
[1024]= { 0 };
4120 test_false(counter
);
4122 for (size_t x
= 0; x
< keys
.size(); ++x
)
4124 rc
= memcached_add(memc
,
4125 keys
.key_at(x
), keys
.length_at(x
),
4126 blob
, sizeof(blob
), 0, 0);
4127 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4132 /* Verify that we received all of the key/value pairs */
4133 test_compare(counter
, keys
.size());
4137 memcached_free(memc
);
4139 return TEST_SUCCESS
;
4142 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4144 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
4146 return regression_bug_434843(memc
);
4149 test_return_t
regression_bug_421108(memcached_st
*memc
)
4151 memcached_return_t rc
;
4152 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4153 test_compare(MEMCACHED_SUCCESS
, rc
);
4155 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4156 test_compare(MEMCACHED_SUCCESS
, rc
);
4157 test_true(bytes_str
);
4158 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4160 test_compare(MEMCACHED_SUCCESS
, rc
);
4161 test_true(bytes_read_str
);
4163 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4164 "bytes_written", &rc
);
4165 test_compare(MEMCACHED_SUCCESS
, rc
);
4166 test_true(bytes_written_str
);
4168 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4169 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4170 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4172 test_true(bytes
!= bytes_read
);
4173 test_true(bytes
!= bytes_written
);
4175 /* Release allocated resources */
4177 free(bytes_read_str
);
4178 free(bytes_written_str
);
4179 memcached_stat_free(NULL
, memc_stat
);
4181 return TEST_SUCCESS
;
4185 * The test case isn't obvious so I should probably document why
4186 * it works the way it does. Bug 442914 was caused by a bug
4187 * in the logic in memcached_purge (it did not handle the case
4188 * where the number of bytes sent was equal to the watermark).
4189 * In this test case, create messages so that we hit that case
4190 * and then disable noreply mode and issue a new command to
4191 * verify that it isn't stuck. If we change the format for the
4192 * delete command or the watermarks, we need to update this
4195 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
4197 test_skip(original_memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
4199 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
4201 for (uint32_t x
= 0; x
< 250; ++x
)
4204 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
4205 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4206 char error_buffer
[2048]= { 0 };
4207 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
4208 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
4211 // Delete, and then delete again to look for not found
4214 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
4215 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4216 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4218 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
4219 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
4222 memcached_free(memc
);
4224 return TEST_SUCCESS
;
4227 test_return_t
regression_bug_447342(memcached_st
*memc
)
4229 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4231 return TEST_SKIPPED
;
4234 test_compare(MEMCACHED_SUCCESS
,
4235 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4239 for (size_t x
= 0; x
< keys
.size(); ++x
)
4241 test_compare(MEMCACHED_SUCCESS
,
4243 keys
.key_at(x
), keys
.length_at(x
), // Keys
4244 keys
.key_at(x
), keys
.length_at(x
), // Values
4249 ** We are using the quiet commands to store the replicas, so we need
4250 ** to ensure that all of them are processed before we can continue.
4251 ** In the test we go directly from storing the object to trying to
4252 ** receive the object from all of the different servers, so we
4253 ** could end up in a race condition (the memcached server hasn't yet
4254 ** processed the quiet command from the replication set when it process
4255 ** the request from the other client (created by the clone)). As a
4256 ** workaround for that we call memcached_quit to send the quit command
4257 ** to the server and wait for the response ;-) If you use the test code
4258 ** as an example for your own code, please note that you shouldn't need
4261 memcached_quit(memc
);
4263 /* Verify that all messages are stored, and we didn't stuff too much
4266 test_compare(MEMCACHED_SUCCESS
,
4267 memcached_mget(memc
,
4268 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4270 unsigned int counter
= 0;
4271 memcached_execute_fn callbacks
[]= { &callback_counter
};
4272 test_compare(MEMCACHED_SUCCESS
,
4273 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4275 /* Verify that we received all of the key/value pairs */
4276 test_compare(counter
, keys
.size());
4278 memcached_quit(memc
);
4280 * Don't do the following in your code. I am abusing the internal details
4281 * within the library, and this is not a supported interface.
4282 * This is to verify correct behavior in the library. Fake that two servers
4285 memcached_server_instance_st instance_one
= memcached_server_instance_by_position(memc
, 0);
4286 memcached_server_instance_st instance_two
= memcached_server_instance_by_position(memc
, 2);
4287 in_port_t port0
= instance_one
->port
;
4288 in_port_t port2
= instance_two
->port
;
4290 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4291 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4293 test_compare(MEMCACHED_SUCCESS
,
4294 memcached_mget(memc
,
4295 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4298 test_compare(MEMCACHED_SUCCESS
,
4299 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4300 test_compare(counter
, keys
.size());
4302 /* restore the memc handle */
4303 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4304 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4306 memcached_quit(memc
);
4308 /* Remove half of the objects */
4309 for (size_t x
= 0; x
< keys
.size(); ++x
)
4313 test_compare(MEMCACHED_SUCCESS
,
4314 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4318 memcached_quit(memc
);
4319 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4320 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4322 /* now retry the command, this time we should have cache misses */
4323 test_compare(MEMCACHED_SUCCESS
,
4324 memcached_mget(memc
,
4325 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4328 test_compare(MEMCACHED_SUCCESS
,
4329 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4330 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4332 /* restore the memc handle */
4333 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4334 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4336 return TEST_SUCCESS
;
4339 test_return_t
regression_bug_463297(memcached_st
*memc
)
4341 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4343 // Since we blocked timed delete, this test is no longer valid.
4345 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4346 test_true(memc_clone
);
4347 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4349 memcached_server_instance_st instance
=
4350 memcached_server_instance_by_position(memc_clone
, 0);
4352 if (instance
->major_version
> 1 ||
4353 (instance
->major_version
== 1 &&
4354 instance
->minor_version
> 2))
4356 /* Binary protocol doesn't support deferred delete */
4357 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4358 test_true(bin_clone
);
4359 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4360 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4361 memcached_free(bin_clone
);
4363 memcached_quit(memc_clone
);
4365 /* If we know the server version, deferred delete should fail
4366 * with invalid arguments */
4367 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4369 /* If we don't know the server version, we should get a protocol error */
4370 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4372 /* but there is a bug in some of the memcached servers (1.4) that treats
4373 * the counter as noreply so it doesn't send the proper error message
4375 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4377 /* And buffered mode should be disabled and we should get protocol error */
4378 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4379 rc
= memcached_delete(memc
, "foo", 3, 1);
4380 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4382 /* Same goes for noreply... */
4383 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4384 rc
= memcached_delete(memc
, "foo", 3, 1);
4385 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4387 /* but a normal request should go through (and be buffered) */
4388 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4389 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4391 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4392 /* unbuffered noreply should be success */
4393 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4394 /* unbuffered with reply should be not found... */
4395 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4396 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4399 memcached_free(memc_clone
);
4402 return TEST_SUCCESS
;
4406 /* Test memcached_server_get_last_disconnect
4407 * For a working server set, shall be NULL
4408 * For a set of non existing server, shall not be NULL
4410 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4412 memcached_return_t rc
;
4413 memcached_server_instance_st disconnected_server
;
4415 /* With the working set of server */
4416 const char *key
= "marmotte";
4417 const char *value
= "milka";
4419 memcached_reset_last_disconnected_server(memc
);
4420 test_false(memc
->last_disconnected_server
);
4421 rc
= memcached_set(memc
, key
, strlen(key
),
4422 value
, strlen(value
),
4423 (time_t)0, (uint32_t)0);
4424 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4426 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4427 test_false(disconnected_server
);
4429 /* With a non existing server */
4431 memcached_server_st
*servers
;
4433 const char *server_list
= "localhost:9";
4435 servers
= memcached_servers_parse(server_list
);
4437 mine
= memcached_create(NULL
);
4438 rc
= memcached_server_push(mine
, servers
);
4439 test_compare(MEMCACHED_SUCCESS
, rc
);
4440 memcached_server_list_free(servers
);
4443 rc
= memcached_set(mine
, key
, strlen(key
),
4444 value
, strlen(value
),
4445 (time_t)0, (uint32_t)0);
4446 test_true(memcached_failed(rc
));
4448 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4449 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4450 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4451 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4453 memcached_quit(mine
);
4454 memcached_free(mine
);
4456 return TEST_SUCCESS
;
4459 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4461 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4462 char buffer
[BUFSIZ
];
4464 test_compare(MEMCACHED_SUCCESS
,
4465 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4467 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4470 // We will just use the error strings as our keys
4471 uint32_t counter
= 100;
4474 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4476 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4477 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4478 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4480 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
4481 test_true(disconnected_server
);
4482 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4483 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4487 memcached_reset_last_disconnected_server(memc
);
4492 memcached_free(memc
);
4494 return TEST_SUCCESS
;
4497 test_return_t
test_verbosity(memcached_st
*memc
)
4499 memcached_verbosity(memc
, 3);
4501 return TEST_SUCCESS
;
4505 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
4506 const char *key
, size_t key_length
,
4507 const char *value
, size_t value_length
,
4517 return MEMCACHED_SUCCESS
;
4520 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4522 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4523 test_compare(MEMCACHED_SUCCESS
, rc
);
4525 test_compare(MEMCACHED_SUCCESS
,
4526 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4528 test_compare(MEMCACHED_SUCCESS
,
4529 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4531 test_compare(MEMCACHED_SUCCESS
,
4532 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4534 return TEST_SUCCESS
;
4538 * This test ensures that the failure counter isn't incremented during
4539 * normal termination of the memcached instance.
4541 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4543 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4545 /* Ensure that we are connected to the server by setting a value */
4546 memcached_return_t rc
= memcached_set(memc
,
4547 test_literal_param(__func__
), // Key
4548 test_literal_param(__func__
), // Value
4549 time_t(0), uint32_t(0));
4550 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4553 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4555 /* The test is to see that the memcached_quit doesn't increase the
4556 * the server failure conter, so let's ensure that it is zero
4557 * before sending quit
4559 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4561 memcached_quit(memc
);
4563 /* Verify that it memcached_quit didn't increment the failure counter
4564 * Please note that this isn't bullet proof, because an error could
4567 test_zero(instance
->server_failure_counter
);
4569 memcached_free(memc
);
4571 return TEST_SUCCESS
;
4575 * This tests ensures expected disconnections (for some behavior changes
4576 * for instance) do not wrongly increase failure counter
4578 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4580 /* Set value to force connection to the server */
4581 const char *key
= "marmotte";
4582 const char *value
= "milka";
4584 test_compare_hint(MEMCACHED_SUCCESS
,
4585 memcached_set(memc
, key
, strlen(key
),
4586 value
, strlen(value
),
4587 (time_t)0, (uint32_t)0),
4588 memcached_last_error_message(memc
));
4591 /* put failure limit to 1 */
4592 test_compare(MEMCACHED_SUCCESS
,
4593 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4595 /* Put a retry timeout to effectively activate failure_limit effect */
4596 test_compare(MEMCACHED_SUCCESS
,
4597 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4599 /* change behavior that triggers memcached_quit()*/
4600 test_compare(MEMCACHED_SUCCESS
,
4601 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4604 /* Check if we still are connected */
4606 size_t string_length
;
4607 memcached_return rc
;
4608 char *string
= memcached_get(memc
, key
, strlen(key
),
4609 &string_length
, &flags
, &rc
);
4611 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4615 return TEST_SUCCESS
;
4620 * Test that ensures mget_execute does not end into recursive calls that finally fails
4622 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4626 return TEST_SKIPPED
; // My MAC can't handle this test
4629 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4632 * I only want to hit _one_ server so I know the number of requests I'm
4633 * sending in the pipeline.
4635 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4638 keys_st
keys(20480);
4640 /* First add all of the items.. */
4641 char blob
[1024]= { 0 };
4642 for (size_t x
= 0; x
< keys
.size(); ++x
)
4644 memcached_return rc
= memcached_set(memc
,
4645 keys
.key_at(x
), keys
.length_at(x
),
4646 blob
, sizeof(blob
), 0, 0);
4647 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4652 /* Try to get all of them with a large multiget */
4654 memcached_execute_function callbacks
[]= { &callback_counter
};
4655 memcached_return_t rc
= memcached_mget_execute(memc
,
4656 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4657 callbacks
, &counter
, 1);
4658 test_compare(MEMCACHED_SUCCESS
, rc
);
4660 char* the_value
= NULL
;
4661 char the_key
[MEMCACHED_MAX_KEY
];
4662 size_t the_key_length
;
4663 size_t the_value_length
;
4667 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4669 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4675 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4678 test_compare(MEMCACHED_END
, rc
);
4680 /* Verify that we got all of the items */
4681 test_compare(counter
, keys
.size());
4684 memcached_free(memc
);
4686 return TEST_SUCCESS
;
4689 test_return_t
regression_bug_583031(memcached_st
*)
4691 memcached_st
*memc
= memcached_create(NULL
);
4693 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
4695 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
4696 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4697 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4698 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4699 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4700 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4702 memcached_return_t rc
;
4706 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4710 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
4712 memcached_free(memc
);
4714 return TEST_SUCCESS
;
4717 test_return_t
regression_bug_581030(memcached_st
*)
4720 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4721 test_false(local_stat
);
4723 memcached_stat_free(NULL
, NULL
);
4726 return TEST_SUCCESS
;
4729 #define regression_bug_655423_COUNT 6000
4730 test_return_t
regression_bug_655423(memcached_st
*memc
)
4732 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4733 memc
= NULL
; // Just to make sure it is not used
4738 return TEST_SKIPPED
;
4741 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4742 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4743 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4744 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4746 memset(payload
, int('x'), sizeof(payload
));
4748 keys_st
keys(regression_bug_655423_COUNT
);
4750 for (size_t x
= 0; x
< keys
.size(); x
++)
4752 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4755 payload
, sizeof(payload
), 0, 0));
4758 for (size_t x
= 0; x
< keys
.size(); x
++)
4760 size_t value_length
;
4761 memcached_return_t rc
;
4762 char *value
= memcached_get(clone
,
4765 &value_length
, NULL
, &rc
);
4767 if (rc
== MEMCACHED_NOTFOUND
)
4770 test_zero(value_length
);
4774 test_compare(MEMCACHED_SUCCESS
, rc
);
4776 test_compare(100LLU, value_length
);
4780 test_compare(MEMCACHED_SUCCESS
,
4781 memcached_mget(clone
,
4782 keys
.keys_ptr(), keys
.lengths_ptr(),
4786 memcached_result_st
*result
= NULL
;
4787 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4789 test_compare(size_t(100), memcached_result_length(result
));
4793 test_true(count
> 100); // If we don't get back atleast this, something is up
4795 memcached_free(clone
);
4797 return TEST_SUCCESS
;
4801 * Test that ensures that buffered set to not trigger problems during io_flush
4803 #define regression_bug_490520_COUNT 200480
4804 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4806 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4808 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4809 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4810 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4811 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4812 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4814 /* First add all of the items.. */
4815 char blob
[3333] = {0};
4816 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4819 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4821 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4822 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4825 memcached_free(memc
);
4827 return TEST_SUCCESS
;
4831 test_return_t
regression_bug_854604(memcached_st
*)
4835 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4837 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4839 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4840 test_compare(buffer
[0], 0);
4842 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4843 test_true(strlen(buffer
));
4845 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4846 test_true(strlen(buffer
));
4848 return TEST_SUCCESS
;
4851 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4853 fprintf(stderr
, "Iteration #%u: ", it
);
4855 if (error
== MEMCACHED_ERRNO
)
4857 fprintf(stderr
, "system error %d from %s: %s\n",
4858 errno
, what
, strerror(errno
));
4862 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4863 memcached_strerror(mc
, error
));
4867 #define TEST_CONSTANT_CREATION 200
4869 test_return_t
regression_bug_(memcached_st
*memc
)
4871 const char *remote_server
;
4874 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4876 return TEST_SKIPPED
;
4879 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4881 memcached_st
* mc
= memcached_create(NULL
);
4882 memcached_return rc
;
4884 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4885 if (rc
!= MEMCACHED_SUCCESS
)
4887 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
4890 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4891 if (rc
!= MEMCACHED_SUCCESS
)
4893 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
4896 rc
= memcached_server_add(mc
, remote_server
, 0);
4897 if (rc
!= MEMCACHED_SUCCESS
)
4899 memcached_die(mc
, rc
, "memcached_server_add", x
);
4902 const char *set_key
= "akey";
4903 const size_t set_key_len
= strlen(set_key
);
4904 const char *set_value
= "a value";
4905 const size_t set_value_len
= strlen(set_value
);
4907 if (rc
== MEMCACHED_SUCCESS
)
4911 size_t get_value_len
;
4913 uint32_t get_value_flags
;
4915 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
4916 &get_value_flags
, &rc
);
4917 if (rc
!= MEMCACHED_SUCCESS
)
4919 memcached_die(mc
, rc
, "memcached_get", x
);
4925 (get_value_len
!= set_value_len
4926 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
4928 fprintf(stderr
, "Values don't match?\n");
4929 rc
= MEMCACHED_FAILURE
;
4935 rc
= memcached_set(mc
,
4936 set_key
, set_key_len
,
4937 set_value
, set_value_len
,
4941 if (rc
!= MEMCACHED_SUCCESS
)
4943 memcached_die(mc
, rc
, "memcached_set", x
);
4950 if (rc
!= MEMCACHED_SUCCESS
)
4956 return TEST_SUCCESS
;
4959 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
4961 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
4964 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4967 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
4968 memcached_server_port(instance
), NULL
)) > -1);
4971 test_compare(MEMCACHED_SUCCESS
,
4973 test_literal_param(__func__
), // Keys
4974 test_literal_param(__func__
), // Values
4976 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
4978 test_compare(MEMCACHED_SUCCESS
,
4980 test_literal_param(__func__
), // Keys
4981 test_literal_param(__func__
), // Values
4984 memcached_free(memc
);
4986 return TEST_SUCCESS
;