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.
38 #include <mem_config.h>
39 #include <libtest/test.hpp>
41 #if defined(HAVE_LIBUUID) && HAVE_LIBUUID
42 #include <uuid/uuid.h>
49 #include <libmemcached-1.0/memcached.h>
50 #include <libmemcached/is.h>
51 #include <libmemcached/server_instance.h>
53 #include <libhashkit-1.0/hashkit.h>
55 #include <libtest/memcached.hpp>
60 #include <semaphore.h>
64 #include <sys/types.h>
69 #include <libtest/server.h>
71 #include "clients/generator.h"
73 #define SMALL_STRING_LEN 1024
75 #include <libtest/test.hpp>
77 using namespace libtest
;
79 #include <libmemcachedutil-1.0/util.h>
81 #include "tests/hash_results.h"
83 #include "tests/libmemcached-1.0/callback_counter.h"
84 #include "tests/libmemcached-1.0/fetch_all_results.h"
85 #include "tests/libmemcached-1.0/mem_functions.h"
86 #include "tests/libmemcached-1.0/setup_and_teardowns.h"
87 #include "tests/print.h"
88 #include "tests/debug.h"
90 #define UUID_STRING_MAXLENGTH 36
92 #include "tests/keys.hpp"
94 #include "libmemcached/instance.h"
96 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
99 If no options are given, copy over at least the binary flag.
101 char options_buffer
[1024]= { 0 };
104 if (memcached_is_binary(original_memc
))
106 snprintf(options_buffer
, sizeof(options_buffer
), "--BINARY");
111 * I only want to hit _one_ server so I know the number of requests I'm
112 * sending in the pipeline.
114 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
116 char server_string
[1024];
117 int server_string_length
;
118 if (instance
->type
== MEMCACHED_CONNECTION_UNIX_SOCKET
)
122 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\" %s",
123 memcached_server_name(instance
), options
);
127 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\"",
128 memcached_server_name(instance
));
135 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
136 memcached_server_name(instance
), int(memcached_server_port(instance
)),
141 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
142 memcached_server_name(instance
), int(memcached_server_port(instance
)));
146 if (server_string_length
<= 0)
151 char errror_buffer
[1024];
152 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, errror_buffer
, sizeof(errror_buffer
))))
154 Error
<< "Failed to parse (" << server_string
<< ") " << errror_buffer
;
158 return memcached(server_string
, server_string_length
);
162 test_return_t
init_test(memcached_st
*not_used
)
167 (void)memcached_create(&memc
);
168 memcached_free(&memc
);
173 #define TEST_PORT_COUNT 7
174 in_port_t test_ports
[TEST_PORT_COUNT
];
176 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
177 memcached_server_instance_st server
,
181 size_t bigger
= *((size_t *)(context
));
183 fatal_assert(bigger
<= memcached_server_port(server
));
184 *((size_t *)(context
))= memcached_server_port(server
);
186 return MEMCACHED_SUCCESS
;
189 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
190 memcached_server_instance_st instance
,
194 FILE *stream
= (FILE *)context
;
197 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
198 memcached_server_name(instance
),
199 memcached_server_port(instance
),
200 instance
->major_version
,
201 instance
->minor_version
,
202 instance
->micro_version
);
204 return MEMCACHED_SUCCESS
;
207 test_return_t
server_sort_test(memcached_st
*ptr
)
209 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
211 memcached_return_t rc
;
212 memcached_server_fn callbacks
[1];
213 memcached_st
*local_memc
;
216 local_memc
= memcached_create(NULL
);
217 test_true(local_memc
);
218 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
220 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
222 test_ports
[x
]= (in_port_t
)random() % 64000;
223 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
224 test_compare(memcached_server_count(local_memc
), x
+1);
226 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
228 test_compare(MEMCACHED_SUCCESS
, rc
);
231 callbacks
[0]= server_display_function
;
232 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
235 memcached_free(local_memc
);
240 test_return_t
server_sort2_test(memcached_st
*ptr
)
242 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
243 memcached_server_fn callbacks
[1];
244 memcached_st
*local_memc
;
245 memcached_server_instance_st instance
;
248 local_memc
= memcached_create(NULL
);
249 test_true(local_memc
);
250 test_compare(MEMCACHED_SUCCESS
,
251 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
253 test_compare(MEMCACHED_SUCCESS
,
254 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
255 instance
= memcached_server_instance_by_position(local_memc
, 0);
256 test_compare(in_port_t(43043), memcached_server_port(instance
));
258 test_compare(MEMCACHED_SUCCESS
,
259 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
261 instance
= memcached_server_instance_by_position(local_memc
, 0);
262 test_compare(in_port_t(43042), memcached_server_port(instance
));
264 instance
= memcached_server_instance_by_position(local_memc
, 1);
265 test_compare(in_port_t(43043), memcached_server_port(instance
));
267 callbacks
[0]= server_display_function
;
268 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
271 memcached_free(local_memc
);
276 test_return_t
memcached_server_remove_test(memcached_st
*)
278 const char *server_string
= "--server=localhost:4444 --server=localhost:4445 --server=localhost:4446 --server=localhost:4447 --server=localhost --server=memcache1.memcache.bk.sapo.pt:11211 --server=memcache1.memcache.bk.sapo.pt:11212 --server=memcache1.memcache.bk.sapo.pt:11213 --server=memcache1.memcache.bk.sapo.pt:11214 --server=memcache2.memcache.bk.sapo.pt:11211 --server=memcache2.memcache.bk.sapo.pt:11212 --server=memcache2.memcache.bk.sapo.pt:11213 --server=memcache2.memcache.bk.sapo.pt:11214";
281 test_compare(MEMCACHED_SUCCESS
,
282 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
283 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
286 memcached_server_fn callbacks
[1];
287 callbacks
[0]= server_print_callback
;
288 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
290 memcached_free(memc
);
295 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
296 memcached_server_instance_st server
,
300 uint32_t x
= *((uint32_t *)(context
));
302 if (! (test_ports
[x
] == memcached_server_port(server
)))
304 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)memcached_server_port(server
));
305 return MEMCACHED_FAILURE
;
308 *((uint32_t *)(context
))= ++x
;
310 return MEMCACHED_SUCCESS
;
313 test_return_t
server_unsort_test(memcached_st
*ptr
)
315 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
316 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
317 memcached_server_fn callbacks
[1];
318 memcached_st
*local_memc
;
321 local_memc
= memcached_create(NULL
);
322 test_true(local_memc
);
324 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
326 test_ports
[x
]= (in_port_t
)(random() % 64000);
327 test_compare(MEMCACHED_SUCCESS
,
328 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
329 test_compare(memcached_server_count(local_memc
), x
+1);
331 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
335 callbacks
[0]= server_display_unsort_function
;
336 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
338 /* Now we sort old data! */
339 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
340 callbacks
[0]= server_display_function
;
341 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
344 memcached_free(local_memc
);
349 test_return_t
allocation_test(memcached_st
*not_used
)
353 memc
= memcached_create(NULL
);
355 memcached_free(memc
);
360 test_return_t
clone_test(memcached_st
*memc
)
364 memcached_st
*memc_clone
;
365 memc_clone
= memcached_clone(NULL
, NULL
);
366 test_true(memc_clone
);
367 memcached_free(memc_clone
);
370 /* Can we init from null? */
372 memcached_st
*memc_clone
;
373 memc_clone
= memcached_clone(NULL
, memc
);
374 test_true(memc_clone
);
377 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
378 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
379 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
380 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
383 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
384 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
385 test_true(memc_clone
->distribution
== memc
->distribution
);
386 { // Test all of the flags
387 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
388 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
389 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
390 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
391 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
392 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
393 test_true(memc_clone
->ketama
.weighted_
== memc
->ketama
.weighted_
);
394 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
395 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
396 test_true(memc_clone
->flags
.reply
== memc
->flags
.reply
);
397 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
398 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
399 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
401 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
402 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
403 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
404 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
405 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
406 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
407 test_true(memc_clone
->on_clone
== memc
->on_clone
);
408 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
409 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
410 test_true(memc_clone
->recv_size
== memc
->recv_size
);
411 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
412 test_true(memc_clone
->send_size
== memc
->send_size
);
413 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
414 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
415 test_true(memc_clone
->user_data
== memc
->user_data
);
417 memcached_free(memc_clone
);
420 /* Can we init from struct? */
422 memcached_st declared_clone
;
423 memcached_st
*memc_clone
;
424 memset(&declared_clone
, 0 , sizeof(memcached_st
));
425 memc_clone
= memcached_clone(&declared_clone
, NULL
);
426 test_true(memc_clone
);
427 memcached_free(memc_clone
);
430 /* Can we init from struct? */
432 memcached_st declared_clone
;
433 memcached_st
*memc_clone
;
434 memset(&declared_clone
, 0 , sizeof(memcached_st
));
435 memc_clone
= memcached_clone(&declared_clone
, memc
);
436 test_true(memc_clone
);
437 memcached_free(memc_clone
);
443 test_return_t
userdata_test(memcached_st
*memc
)
446 test_false(memcached_set_user_data(memc
, foo
));
447 test_true(memcached_get_user_data(memc
) == foo
);
448 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
453 test_return_t
connection_test(memcached_st
*memc
)
455 test_compare(MEMCACHED_SUCCESS
,
456 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
461 test_return_t
libmemcached_string_behavior_test(memcached_st
*)
463 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
465 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
467 test_compare(37, int(MEMCACHED_BEHAVIOR_MAX
));
472 test_return_t
libmemcached_string_distribution_test(memcached_st
*)
474 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
476 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
478 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
483 test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
485 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
486 982370485U, 1263635348U, 4242906218U, 3829656100U,
487 1891735253U, 334139633U, 2257084983U, 3351789013U,
488 13199785U, 2542027183U, 1097051614U, 199566778U,
489 2748246961U, 2465192557U, 1664094137U, 2405439045U,
490 1842224848U, 692413798U, 3479807801U, 919913813U,
491 4269430871U, 610793021U, 527273862U, 1437122909U,
492 2300930706U, 2943759320U, 674306647U, 2400528935U,
493 54481931U, 4186304426U, 1741088401U, 2979625118U,
494 4159057246U, 3425930182U, 2593724503U, 1868899624U,
495 1769812374U, 2302537950U, 1110330676U, 3365377466U,
496 1336171666U, 3021258493U, 2334992265U, 3861994737U,
497 3582734124U, 3365377466U };
499 // You have updated the memcache_error messages but not updated docs/tests.
500 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
503 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
504 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
505 MEMCACHED_HASH_JENKINS
);
506 if (values
[rc
] != hash_val
)
508 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
509 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
511 test_compare(values
[rc
], hash_val
);
513 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
518 test_return_t
set_test(memcached_st
*memc
)
520 memcached_return_t rc
= memcached_set(memc
,
521 test_literal_param("foo"),
522 test_literal_param("when we sanitize"),
523 time_t(0), (uint32_t)0);
524 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
529 test_return_t
append_test(memcached_st
*memc
)
531 memcached_return_t rc
;
532 const char *in_value
= "we";
536 test_compare(MEMCACHED_SUCCESS
,
537 memcached_flush(memc
, 0));
539 test_compare(MEMCACHED_SUCCESS
,
541 test_literal_param(__func__
),
542 in_value
, strlen(in_value
),
543 time_t(0), uint32_t(0)));
545 test_compare(MEMCACHED_SUCCESS
,
546 memcached_append(memc
,
547 test_literal_param(__func__
),
548 " the", strlen(" the"),
549 time_t(0), uint32_t(0)));
551 test_compare(MEMCACHED_SUCCESS
,
552 memcached_append(memc
,
553 test_literal_param(__func__
),
554 " people", strlen(" people"),
555 time_t(0), uint32_t(0)));
557 char *out_value
= memcached_get(memc
,
558 test_literal_param(__func__
),
559 &value_length
, &flags
, &rc
);
560 test_memcmp(out_value
, "we the people", strlen("we the people"));
561 test_compare(strlen("we the people"), value_length
);
562 test_compare(MEMCACHED_SUCCESS
, rc
);
568 test_return_t
append_binary_test(memcached_st
*memc
)
570 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
572 test_compare(MEMCACHED_SUCCESS
,
573 memcached_flush(memc
, 0));
575 test_compare(MEMCACHED_SUCCESS
,
577 test_literal_param(__func__
),
579 time_t(0), uint32_t(0)));
582 for (uint32_t x
= 0; store_list
[x
] ; x
++)
584 test_compare(MEMCACHED_SUCCESS
,
585 memcached_append(memc
,
586 test_literal_param(__func__
),
587 (char *)&store_list
[x
], sizeof(uint32_t),
588 time_t(0), uint32_t(0)));
594 memcached_return_t rc
;
595 uint32_t *value
= (uint32_t *)memcached_get(memc
,
596 test_literal_param(__func__
),
597 &value_length
, &flags
, &rc
);
598 test_compare(value_length
, sizeof(uint32_t) * count
);
599 test_compare(MEMCACHED_SUCCESS
, rc
);
601 for (uint32_t counter
= uint32_t(count
), *ptr
= value
; counter
; counter
--)
603 test_compare(*ptr
, store_list
[count
- counter
]);
611 test_return_t
memcached_mget_mixed_memcached_get_TEST(memcached_st
*memc
)
615 for (libtest::vchar_ptr_t::iterator iter
= keys
.begin();
619 test_compare_hint(MEMCACHED_SUCCESS
,
623 time_t(0), uint32_t(0)),
624 memcached_last_error_message(memc
));
627 for (ptrdiff_t loop
= 0; loop
< 20; loop
++)
631 test_compare(MEMCACHED_SUCCESS
,
632 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
634 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
637 size_t result_count
= 0;
638 memcached_return_t rc
;
639 while (memcached_fetch_result(memc
, results
, &rc
))
643 test_true(keys
.size() >= result_count
);
647 int which_key
= random() % int(keys
.size());
650 memcached_return_t rc
;
651 char *out_value
= memcached_get(memc
, keys
.key_at(which_key
), keys
.length_at(which_key
),
652 &value_length
, &flags
, &rc
);
653 if (rc
== MEMCACHED_NOTFOUND
)
654 { } // It is possible that the value has been purged.
657 test_compare(MEMCACHED_SUCCESS
, rc
);
659 test_null(out_value
);
660 test_zero(value_length
);
668 test_return_t
cas2_test(memcached_st
*memc
)
670 const char *keys
[]= {"fudge", "son", "food"};
671 size_t key_length
[]= {5, 3, 4};
672 const char *value
= "we the people";
673 size_t value_length
= strlen("we the people");
675 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
677 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
679 for (uint32_t x
= 0; x
< 3; x
++)
681 test_compare(MEMCACHED_SUCCESS
,
682 memcached_set(memc
, keys
[x
], key_length
[x
],
683 keys
[x
], key_length
[x
],
684 time_t(50), uint32_t(9)));
687 test_compare(MEMCACHED_SUCCESS
,
688 memcached_mget(memc
, keys
, key_length
, 3));
690 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
693 memcached_return_t rc
;
694 results
= memcached_fetch_result(memc
, results
, &rc
);
696 test_true(results
->item_cas
);
697 test_compare(MEMCACHED_SUCCESS
, rc
);
698 test_true(memcached_result_cas(results
));
700 test_memcmp(value
, "we the people", strlen("we the people"));
701 test_compare(strlen("we the people"), value_length
);
702 test_compare(MEMCACHED_SUCCESS
, rc
);
704 memcached_result_free(results
);
709 test_return_t
cas_test(memcached_st
*memc
)
711 const char* keys
[2] = { __func__
, NULL
};
712 size_t keylengths
[2] = { strlen(__func__
), 0 };
714 memcached_result_st results_obj
;
716 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
718 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
720 test_compare(MEMCACHED_SUCCESS
,
722 test_literal_param(__func__
),
723 test_literal_param("we the people"),
724 (time_t)0, (uint32_t)0));
726 test_compare(MEMCACHED_SUCCESS
,
727 memcached_mget(memc
, keys
, keylengths
, 1));
729 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
732 memcached_return_t rc
;
733 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
735 test_compare(MEMCACHED_SUCCESS
, rc
);
736 test_true(memcached_result_cas(results
));
737 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
738 test_compare(test_literal_param_size("we the people"),
739 strlen(memcached_result_value(results
)));
741 uint64_t cas
= memcached_result_cas(results
);
744 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
745 test_true(rc
== MEMCACHED_END
);
746 test_true(results
== NULL
);
749 test_compare(MEMCACHED_SUCCESS
,
751 test_literal_param(__func__
),
752 test_literal_param("change the value"),
756 * The item will have a new cas value, so try to set it again with the old
757 * value. This should fail!
759 test_compare(MEMCACHED_DATA_EXISTS
,
761 test_literal_param(__func__
),
762 test_literal_param("change the value"),
765 memcached_result_free(&results_obj
);
771 test_return_t
prepend_test(memcached_st
*memc
)
773 const char *key
= "fig";
774 const char *value
= "people";
776 test_compare(MEMCACHED_SUCCESS
,
777 memcached_flush(memc
, 0));
779 test_compare(MEMCACHED_SUCCESS
,
780 memcached_set(memc
, key
, strlen(key
),
781 value
, strlen(value
),
782 time_t(0), uint32_t(0)));
784 test_compare(MEMCACHED_SUCCESS
,
785 memcached_prepend(memc
, key
, strlen(key
),
786 "the ", strlen("the "),
787 time_t(0), uint32_t(0)));
789 test_compare(MEMCACHED_SUCCESS
,
790 memcached_prepend(memc
, key
, strlen(key
),
791 "we ", strlen("we "),
792 time_t(0), uint32_t(0)));
796 memcached_return_t rc
;
797 char *out_value
= memcached_get(memc
, key
, strlen(key
),
798 &value_length
, &flags
, &rc
);
799 test_memcmp(out_value
, "we the people", strlen("we the people"));
800 test_compare(strlen("we the people"), value_length
);
801 test_compare(MEMCACHED_SUCCESS
, rc
);
808 Set the value, then quit to make sure it is flushed.
809 Come back in and test that add fails.
811 test_return_t
memcached_add_SUCCESS_TEST(memcached_st
*memc
)
813 memcached_return_t rc
;
814 test_null(memcached_get(memc
, test_literal_param(__func__
), NULL
, NULL
, &rc
));
815 test_compare(MEMCACHED_NOTFOUND
, rc
);
817 test_compare(MEMCACHED_SUCCESS
,
819 test_literal_param(__func__
),
820 test_literal_param("try something else"),
821 time_t(0), uint32_t(0)));
827 Set the value, then quit to make sure it is flushed.
828 Come back in and test that add fails.
830 test_return_t
add_test(memcached_st
*memc
)
832 test_compare(return_value_based_on_buffering(memc
),
834 test_literal_param(__func__
),
835 test_literal_param("when we sanitize"),
836 time_t(0), uint32_t(0)));
838 memcached_quit(memc
);
842 memcached_return_t rc
;
843 char *check_value
= memcached_get(memc
,
844 test_literal_param(__func__
),
845 &value_length
, &flags
, &rc
);
846 test_memcmp(check_value
, "when we sanitize", strlen("when we sanitize"));
847 test_compare(test_literal_param_size("when we sanitize"), value_length
);
848 test_compare(MEMCACHED_SUCCESS
, rc
);
851 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
853 test_literal_param(__func__
),
854 test_literal_param("try something else"),
855 time_t(0), uint32_t(0)));
861 ** There was a problem of leaking filedescriptors in the initial release
862 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
863 ** systems it seems that the kernel is slow on reclaiming the resources
864 ** because the connects starts to time out (the test doesn't do much
865 ** anyway, so just loop 10 iterations)
867 test_return_t
add_wrapper(memcached_st
*memc
)
869 unsigned int max
= 10000;
877 for (uint32_t x
= 0; x
< max
; x
++)
885 test_return_t
replace_test(memcached_st
*memc
)
887 test_compare(return_value_based_on_buffering(memc
),
889 test_literal_param(__func__
),
890 test_literal_param("when we sanitize"),
891 time_t(0), uint32_t(0)));
893 test_compare(MEMCACHED_SUCCESS
,
894 memcached_replace(memc
,
895 test_literal_param(__func__
),
896 test_literal_param("first we insert some data"),
897 time_t(0), uint32_t(0)));
902 test_return_t
delete_test(memcached_st
*memc
)
904 test_compare(return_value_based_on_buffering(memc
),
906 test_literal_param(__func__
),
907 test_literal_param("when we sanitize"),
908 time_t(0), uint32_t(0)));
910 test_compare(return_value_based_on_buffering(memc
),
911 memcached_delete(memc
,
912 test_literal_param(__func__
),
918 test_return_t
flush_test(memcached_st
*memc
)
920 uint64_t query_id
= memcached_query_id(memc
);
921 test_compare(MEMCACHED_SUCCESS
,
922 memcached_flush(memc
, 0));
923 test_compare(query_id
+1, memcached_query_id(memc
));
928 static memcached_return_t
server_function(const memcached_st
*,
929 memcached_server_instance_st
,
933 return MEMCACHED_SUCCESS
;
936 test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
939 strncpy(context
, "foo bad", sizeof(context
));
940 memcached_server_fn callbacks
[1];
942 callbacks
[0]= server_function
;
943 memcached_server_cursor(memc
, callbacks
, context
, 1);
947 test_return_t
bad_key_test(memcached_st
*memc
)
949 memcached_return_t rc
;
950 const char *key
= "foo bad";
953 uint64_t query_id
= memcached_query_id(memc
);
955 // Just skip if we are in binary mode.
956 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
958 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
960 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
961 test_true(memc_clone
);
963 query_id
= memcached_query_id(memc_clone
);
964 test_compare(MEMCACHED_SUCCESS
,
965 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
966 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
968 /* All keys are valid in the binary protocol (except for length) */
969 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == false)
971 uint64_t before_query_id
= memcached_query_id(memc_clone
);
973 size_t string_length
;
974 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
975 &string_length
, &flags
, &rc
);
976 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
977 test_zero(string_length
);
980 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
982 query_id
= memcached_query_id(memc_clone
);
983 test_compare(MEMCACHED_SUCCESS
,
984 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
985 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
987 size_t string_length
;
988 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
989 &string_length
, &flags
, &rc
);
990 test_compare(MEMCACHED_NOTFOUND
, rc
);
991 test_zero(string_length
);
995 /* Test multi key for bad keys */
996 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
997 size_t key_lengths
[] = { 7, 7, 7 };
998 query_id
= memcached_query_id(memc_clone
);
999 test_compare(MEMCACHED_SUCCESS
,
1000 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1001 test_compare(query_id
, memcached_query_id(memc_clone
));
1003 query_id
= memcached_query_id(memc_clone
);
1004 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
1005 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
1006 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1008 query_id
= memcached_query_id(memc_clone
);
1009 // Grouping keys are not required to follow normal key behaviors
1010 test_compare(MEMCACHED_SUCCESS
,
1011 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
1012 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1014 /* The following test should be moved to the end of this function when the
1015 memcached server is updated to allow max size length of the keys in the
1018 test_compare(MEMCACHED_SUCCESS
,
1019 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
1021 libtest::vchar_t longkey
;
1023 libtest::vchar_t::iterator it
= longkey
.begin();
1024 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
1027 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
1029 size_t string_length
;
1031 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
1032 test_compare(MEMCACHED_NOTFOUND
, rc
);
1033 test_zero(string_length
);
1035 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
1036 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1037 test_zero(string_length
);
1041 /* Make sure zero length keys are marked as bad */
1043 test_compare(MEMCACHED_SUCCESS
,
1044 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1045 size_t string_length
;
1046 char *string
= memcached_get(memc_clone
, key
, 0,
1047 &string_length
, &flags
, &rc
);
1048 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1049 test_zero(string_length
);
1053 memcached_free(memc_clone
);
1055 return TEST_SUCCESS
;
1058 #define READ_THROUGH_VALUE "set for me"
1059 static memcached_return_t
read_through_trigger(memcached_st
*, // memc
1061 size_t, // key_length,
1062 memcached_result_st
*result
)
1064 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
1067 #ifndef __INTEL_COMPILER
1068 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1071 test_return_t
read_through(memcached_st
*memc
)
1073 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1075 size_t string_length
;
1077 memcached_return_t rc
;
1078 char *string
= memcached_get(memc
,
1079 test_literal_param(__func__
),
1080 &string_length
, &flags
, &rc
);
1082 test_compare(MEMCACHED_NOTFOUND
, rc
);
1083 test_false(string_length
);
1086 test_compare(MEMCACHED_SUCCESS
,
1087 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1089 string
= memcached_get(memc
,
1090 test_literal_param(__func__
),
1091 &string_length
, &flags
, &rc
);
1093 test_compare(MEMCACHED_SUCCESS
, rc
);
1094 test_compare(sizeof(READ_THROUGH_VALUE
) -1, string_length
);
1095 test_compare(0, string
[sizeof(READ_THROUGH_VALUE
) -1]);
1096 test_strcmp(READ_THROUGH_VALUE
, string
);
1099 string
= memcached_get(memc
,
1100 test_literal_param(__func__
),
1101 &string_length
, &flags
, &rc
);
1103 test_compare(MEMCACHED_SUCCESS
, rc
);
1105 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1106 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1107 test_strcmp(READ_THROUGH_VALUE
, string
);
1110 return TEST_SUCCESS
;
1113 test_return_t
set_test2(memcached_st
*memc
)
1115 for (uint32_t x
= 0; x
< 10; x
++)
1117 test_compare(return_value_based_on_buffering(memc
),
1119 test_literal_param("foo"),
1120 test_literal_param("train in the brain"),
1121 time_t(0), uint32_t(0)));
1124 return TEST_SUCCESS
;
1127 test_return_t
set_test3(memcached_st
*memc
)
1129 size_t value_length
= 8191;
1131 libtest::vchar_t value
;
1132 value
.reserve(value_length
);
1133 for (uint32_t x
= 0; x
< value_length
; x
++)
1135 value
.push_back(char(x
% 127));
1138 /* The dump test relies on there being at least 32 items in memcached */
1139 for (uint32_t x
= 0; x
< 32; x
++)
1143 snprintf(key
, sizeof(key
), "foo%u", x
);
1145 uint64_t query_id
= memcached_query_id(memc
);
1146 test_compare(return_value_based_on_buffering(memc
),
1147 memcached_set(memc
, key
, strlen(key
),
1148 &value
[0], value
.size(),
1149 time_t(0), uint32_t(0)));
1150 test_compare(query_id
+1, memcached_query_id(memc
));
1153 return TEST_SUCCESS
;
1156 test_return_t
mget_end(memcached_st
*memc
)
1158 const char *keys
[]= { "foo", "foo2" };
1159 size_t lengths
[]= { 3, 4 };
1160 const char *values
[]= { "fjord", "41" };
1163 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1165 test_compare(MEMCACHED_SUCCESS
,
1167 keys
[x
], lengths
[x
],
1168 values
[x
], strlen(values
[x
]),
1169 time_t(0), uint32_t(0)));
1173 size_t string_length
;
1176 // retrieve both via mget
1177 test_compare(MEMCACHED_SUCCESS
,
1178 memcached_mget(memc
,
1180 test_array_length(keys
)));
1182 char key
[MEMCACHED_MAX_KEY
];
1184 memcached_return_t rc
;
1186 // this should get both
1187 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1189 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1191 test_compare(MEMCACHED_SUCCESS
, rc
);
1193 if (key_length
== 4)
1198 test_compare(string_length
, strlen(values
[val
]));
1199 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1203 // this should indicate end
1204 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1205 test_compare(MEMCACHED_END
, rc
);
1209 test_compare(MEMCACHED_SUCCESS
,
1210 memcached_mget(memc
, keys
, lengths
, 1));
1212 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1213 test_compare(key_length
, lengths
[0]);
1214 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1215 test_compare(string_length
, strlen(values
[0]));
1216 test_true(strncmp(values
[0], string
, string_length
) == 0);
1217 test_compare(MEMCACHED_SUCCESS
, rc
);
1220 // this should indicate end
1221 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1222 test_compare(MEMCACHED_END
, rc
);
1225 return TEST_SUCCESS
;
1228 /* Do not copy the style of this code, I just access hosts to testthis function */
1229 test_return_t
stats_servername_test(memcached_st
*memc
)
1231 memcached_stat_st memc_stat
;
1232 memcached_server_instance_st instance
=
1233 memcached_server_instance_by_position(memc
, 0);
1235 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1237 return TEST_SKIPPED
;
1240 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1241 memcached_server_name(instance
),
1242 memcached_server_port(instance
)));
1244 return TEST_SUCCESS
;
1247 test_return_t
increment_test(memcached_st
*memc
)
1249 uint64_t new_number
;
1251 test_compare(MEMCACHED_SUCCESS
,
1253 test_literal_param("number"),
1254 test_literal_param("0"),
1255 (time_t)0, (uint32_t)0));
1257 test_compare(MEMCACHED_SUCCESS
,
1258 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1259 test_compare(uint64_t(1), new_number
);
1261 test_compare(MEMCACHED_SUCCESS
,
1262 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1263 test_compare(uint64_t(2), new_number
);
1265 return TEST_SUCCESS
;
1268 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1270 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1272 uint64_t new_number
;
1273 uint64_t initial
= 0;
1275 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1277 test_compare(MEMCACHED_SUCCESS
,
1278 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1279 test_compare(new_number
, initial
);
1281 test_compare(MEMCACHED_SUCCESS
,
1282 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1283 test_compare(new_number
, (initial
+1));
1285 return TEST_SUCCESS
;
1288 test_return_t
decrement_test(memcached_st
*memc
)
1290 test_compare(return_value_based_on_buffering(memc
),
1292 test_literal_param(__func__
),
1293 test_literal_param("3"),
1294 time_t(0), uint32_t(0)));
1296 // Make sure we flush the value we just set
1297 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1299 uint64_t new_number
;
1300 test_compare(MEMCACHED_SUCCESS
,
1301 memcached_decrement(memc
,
1302 test_literal_param(__func__
),
1304 test_compare(uint64_t(2), new_number
);
1306 test_compare(MEMCACHED_SUCCESS
,
1307 memcached_decrement(memc
,
1308 test_literal_param(__func__
),
1310 test_compare(uint64_t(1), new_number
);
1312 return TEST_SUCCESS
;
1315 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1317 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1319 uint64_t initial
= 3;
1321 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1323 uint64_t new_number
;
1324 test_compare(MEMCACHED_SUCCESS
,
1325 memcached_decrement_with_initial(memc
,
1326 test_literal_param(__func__
),
1329 test_compare(new_number
, initial
);
1331 test_compare(MEMCACHED_SUCCESS
,
1332 memcached_decrement_with_initial(memc
,
1333 test_literal_param(__func__
),
1336 test_compare(new_number
, (initial
- 1));
1338 return TEST_SUCCESS
;
1341 test_return_t
increment_by_key_test(memcached_st
*memc
)
1343 const char *master_key
= "foo";
1344 const char *key
= "number";
1345 const char *value
= "0";
1347 test_compare(return_value_based_on_buffering(memc
),
1348 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1350 value
, strlen(value
),
1351 time_t(0), uint32_t(0)));
1353 // Make sure we flush the value we just set
1354 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1356 uint64_t new_number
;
1357 test_compare(MEMCACHED_SUCCESS
,
1358 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1359 key
, strlen(key
), 1, &new_number
));
1360 test_compare(uint64_t(1), new_number
);
1362 test_compare(MEMCACHED_SUCCESS
,
1363 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1364 key
, strlen(key
), 1, &new_number
));
1365 test_compare(uint64_t(2), new_number
);
1367 return TEST_SUCCESS
;
1370 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1372 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1374 uint64_t new_number
;
1375 const char *master_key
= "foo";
1376 const char *key
= "number";
1377 uint64_t initial
= 0;
1379 test_compare(MEMCACHED_SUCCESS
,
1380 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1382 1, initial
, 0, &new_number
));
1383 test_compare(new_number
, initial
);
1385 test_compare(MEMCACHED_SUCCESS
,
1386 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1388 1, initial
, 0, &new_number
));
1389 test_compare(new_number
, (initial
+1));
1391 return TEST_SUCCESS
;
1394 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1396 uint64_t new_number
;
1397 const char *value
= "3";
1399 test_compare(return_value_based_on_buffering(memc
),
1400 memcached_set_by_key(memc
,
1401 test_literal_param("foo"),
1402 test_literal_param("number"),
1403 value
, strlen(value
),
1404 (time_t)0, (uint32_t)0));
1406 test_compare(MEMCACHED_SUCCESS
,
1407 memcached_decrement_by_key(memc
,
1408 test_literal_param("foo"),
1409 test_literal_param("number"),
1411 test_compare(uint64_t(2), new_number
);
1413 test_compare(MEMCACHED_SUCCESS
,
1414 memcached_decrement_by_key(memc
,
1415 test_literal_param("foo"),
1416 test_literal_param("number"),
1418 test_compare(uint64_t(1), new_number
);
1420 return TEST_SUCCESS
;
1423 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1425 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1427 uint64_t new_number
;
1428 uint64_t initial
= 3;
1430 test_compare(MEMCACHED_SUCCESS
,
1431 memcached_decrement_with_initial_by_key(memc
,
1432 test_literal_param("foo"),
1433 test_literal_param("number"),
1434 1, initial
, 0, &new_number
));
1435 test_compare(new_number
, initial
);
1437 test_compare(MEMCACHED_SUCCESS
,
1438 memcached_decrement_with_initial_by_key(memc
,
1439 test_literal_param("foo"),
1440 test_literal_param("number"),
1441 1, initial
, 0, &new_number
));
1442 test_compare(new_number
, (initial
- 1));
1444 return TEST_SUCCESS
;
1446 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1448 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1450 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1452 test_compare(return_value_based_on_buffering(memc
),
1454 test_literal_param("number"),
1455 test_literal_param("0"),
1456 (time_t)0, (uint32_t)0));
1458 uint64_t new_number
;
1459 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1460 test_literal_param("number"),
1462 test_compare(uint64_t(1), new_number
);
1464 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1465 test_literal_param("number"),
1467 test_compare(uint64_t(2), new_number
);
1469 return TEST_SUCCESS
;
1472 test_return_t
quit_test(memcached_st
*memc
)
1474 const char *value
= "sanford and sun";
1476 test_compare(return_value_based_on_buffering(memc
),
1478 test_literal_param(__func__
),
1479 value
, strlen(value
),
1480 time_t(10), uint32_t(3)));
1481 memcached_quit(memc
);
1483 test_compare(return_value_based_on_buffering(memc
),
1485 test_literal_param(__func__
),
1486 value
, strlen(value
),
1487 time_t(50), uint32_t(9)));
1489 return TEST_SUCCESS
;
1492 test_return_t
mget_result_test(memcached_st
*memc
)
1494 const char *keys
[]= {"fudge", "son", "food"};
1495 size_t key_length
[]= {5, 3, 4};
1497 memcached_result_st results_obj
;
1498 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1500 test_true(&results_obj
== results
);
1502 /* We need to empty the server before continueing test */
1503 test_compare(MEMCACHED_SUCCESS
,
1504 memcached_flush(memc
, 0));
1506 test_compare(MEMCACHED_SUCCESS
,
1507 memcached_mget(memc
, keys
, key_length
, 3));
1509 memcached_return_t rc
;
1510 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1515 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1516 test_false(results
);
1517 test_compare(MEMCACHED_NOTFOUND
, rc
);
1519 for (uint32_t x
= 0; x
< 3; x
++)
1521 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1522 keys
[x
], key_length
[x
],
1523 (time_t)50, (uint32_t)9);
1524 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1527 test_compare(MEMCACHED_SUCCESS
,
1528 memcached_mget(memc
, keys
, key_length
, 3));
1530 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1533 test_true(&results_obj
== results
);
1534 test_compare(MEMCACHED_SUCCESS
, rc
);
1535 test_memcmp(memcached_result_key_value(results
),
1536 memcached_result_value(results
),
1537 memcached_result_length(results
));
1538 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1541 memcached_result_free(&results_obj
);
1543 return TEST_SUCCESS
;
1546 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1548 const char *keys
[]= {"fudge", "son", "food"};
1549 size_t key_length
[]= {5, 3, 4};
1551 memcached_result_st
*results
;
1553 /* We need to empty the server before continueing test */
1554 test_compare(MEMCACHED_SUCCESS
,
1555 memcached_flush(memc
, 0));
1557 test_compare(MEMCACHED_SUCCESS
,
1558 memcached_mget(memc
, keys
, key_length
, 3));
1560 memcached_return_t rc
;
1561 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1565 test_false(results
);
1566 test_compare(MEMCACHED_NOTFOUND
, rc
);
1568 for (uint32_t x
= 0; x
< 3; x
++)
1570 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1571 keys
[x
], key_length
[x
],
1572 (time_t)50, (uint32_t)9);
1573 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1576 test_compare(MEMCACHED_SUCCESS
,
1577 memcached_mget(memc
, keys
, key_length
, 3));
1580 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1583 test_compare(MEMCACHED_SUCCESS
, rc
);
1584 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1585 test_memcmp(memcached_result_key_value(results
),
1586 memcached_result_value(results
),
1587 memcached_result_length(results
));
1588 memcached_result_free(results
);
1592 return TEST_SUCCESS
;
1595 test_return_t
mget_result_function(memcached_st
*memc
)
1597 const char *keys
[]= {"fudge", "son", "food"};
1598 size_t key_length
[]= {5, 3, 4};
1600 memcached_execute_fn callbacks
[1];
1602 for (uint32_t x
= 0; x
< 3; x
++)
1604 test_compare(return_value_based_on_buffering(memc
),
1605 memcached_set(memc
, keys
[x
], key_length
[x
],
1606 keys
[x
], key_length
[x
],
1607 time_t(50), uint32_t(9)));
1609 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1610 memcached_quit(memc
);
1612 test_compare(MEMCACHED_SUCCESS
,
1613 memcached_mget(memc
, keys
, key_length
, 3));
1615 callbacks
[0]= &callback_counter
;
1618 test_compare(MEMCACHED_SUCCESS
,
1619 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1621 test_compare(size_t(3), counter
);
1623 return TEST_SUCCESS
;
1626 test_return_t
mget_test(memcached_st
*memc
)
1628 const char *keys
[]= {"fudge", "son", "food"};
1629 size_t key_length
[]= {5, 3, 4};
1631 char return_key
[MEMCACHED_MAX_KEY
];
1632 size_t return_key_length
;
1634 size_t return_value_length
;
1636 test_compare(MEMCACHED_SUCCESS
,
1637 memcached_mget(memc
, keys
, key_length
, 3));
1640 memcached_return_t rc
;
1641 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1642 &return_value_length
, &flags
, &rc
)))
1644 test_true(return_value
);
1646 test_false(return_value
);
1647 test_zero(return_value_length
);
1648 test_compare(MEMCACHED_NOTFOUND
, rc
);
1650 for (uint32_t x
= 0; x
< 3; x
++)
1652 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1653 keys
[x
], key_length
[x
],
1654 (time_t)50, (uint32_t)9);
1655 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1657 test_compare(MEMCACHED_SUCCESS
,
1658 memcached_mget(memc
, keys
, key_length
, 3));
1661 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1662 &return_value_length
, &flags
, &rc
)))
1664 test_true(return_value
);
1665 test_compare(MEMCACHED_SUCCESS
, rc
);
1666 if (not memc
->_namespace
)
1668 test_compare(return_key_length
, return_value_length
);
1669 test_memcmp(return_value
, return_key
, return_value_length
);
1675 return TEST_SUCCESS
;
1678 test_return_t
mget_execute(memcached_st
*original_memc
)
1680 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1682 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1685 keys_st
keys(20480);
1687 /* First add all of the items.. */
1688 char blob
[1024] = {0};
1690 for (size_t x
= 0; x
< keys
.size(); ++x
)
1692 uint64_t query_id
= memcached_query_id(memc
);
1693 memcached_return_t rc
= memcached_add(memc
,
1694 keys
.key_at(x
), keys
.length_at(x
),
1697 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1698 test_compare(query_id
+1, memcached_query_id(memc
));
1701 /* Try to get all of them with a large multiget */
1703 memcached_execute_fn callbacks
[]= { &callback_counter
};
1704 test_compare(MEMCACHED_SUCCESS
,
1705 memcached_mget_execute(memc
,
1706 keys
.keys_ptr(), keys
.lengths_ptr(),
1707 keys
.size(), callbacks
, &counter
, 1));
1710 uint64_t query_id
= memcached_query_id(memc
);
1711 test_compare(MEMCACHED_SUCCESS
,
1712 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1713 test_compare(query_id
, memcached_query_id(memc
));
1715 /* Verify that we got all of the items */
1716 test_compare(keys
.size(), counter
);
1719 memcached_free(memc
);
1721 return TEST_SUCCESS
;
1724 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1725 static pairs_st
*global_pairs
= NULL
;
1727 test_return_t
key_setup(memcached_st
*memc
)
1729 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1731 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1733 return TEST_SUCCESS
;
1736 test_return_t
key_teardown(memcached_st
*)
1738 pairs_free(global_pairs
);
1741 return TEST_SUCCESS
;
1744 test_return_t
block_add_regression(memcached_st
*memc
)
1746 /* First add all of the items.. */
1747 for (ptrdiff_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1749 libtest::vchar_t blob
;
1750 libtest::vchar::make(blob
, 1024);
1752 memcached_return_t rc
= memcached_add_by_key(memc
,
1753 test_literal_param("bob"),
1754 global_pairs
[x
].key
, global_pairs
[x
].key_length
,
1755 &blob
[0], blob
.size(),
1756 time_t(0), uint32_t(0));
1757 if (rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
)
1759 Error
<< memcached_last_error_message(memc
);
1760 return TEST_SKIPPED
;
1762 test_compare(*memc
, MEMCACHED_SUCCESS
);
1763 test_compare(rc
, MEMCACHED_SUCCESS
);
1766 return TEST_SUCCESS
;
1769 test_return_t
binary_add_regression(memcached_st
*memc
)
1771 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1772 return block_add_regression(memc
);
1775 test_return_t
get_stats_keys(memcached_st
*memc
)
1779 memcached_stat_st memc_stat
;
1780 memcached_return_t rc
;
1782 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1783 test_compare(MEMCACHED_SUCCESS
, rc
);
1784 for (ptr
= stat_list
; *ptr
; ptr
++)
1789 return TEST_SUCCESS
;
1792 test_return_t
version_string_test(memcached_st
*)
1794 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1796 return TEST_SUCCESS
;
1799 test_return_t
get_stats(memcached_st
*memc
)
1801 memcached_return_t rc
;
1803 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1804 test_compare(MEMCACHED_SUCCESS
, rc
);
1805 test_true(memc_stat
);
1807 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1809 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1810 test_compare(MEMCACHED_SUCCESS
, rc
);
1811 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1816 memcached_stat_free(NULL
, memc_stat
);
1818 return TEST_SUCCESS
;
1821 test_return_t
add_host_test(memcached_st
*memc
)
1823 char servername
[]= "0.example.com";
1825 memcached_return_t rc
;
1826 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1827 test_compare(1U, memcached_server_list_count(servers
));
1829 for (unsigned int x
= 2; x
< 20; x
++)
1831 char buffer
[SMALL_STRING_LEN
];
1833 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1834 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1836 test_compare(MEMCACHED_SUCCESS
, rc
);
1837 test_compare(x
, memcached_server_list_count(servers
));
1840 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1841 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1843 memcached_server_list_free(servers
);
1845 return TEST_SUCCESS
;
1848 test_return_t
regression_1048945_TEST(memcached_st
*)
1850 memcached_return status
;
1852 memcached_server_st
* list
= memcached_server_list_append_with_weight(NULL
, "a", 11211, 0, &status
);
1853 test_compare(status
, MEMCACHED_SUCCESS
);
1855 list
= memcached_server_list_append_with_weight(list
, "b", 11211, 0, &status
);
1856 test_compare(status
, MEMCACHED_SUCCESS
);
1858 list
= memcached_server_list_append_with_weight(list
, "c", 11211, 0, &status
);
1859 test_compare(status
, MEMCACHED_SUCCESS
);
1861 memcached_st
* memc
= memcached_create(NULL
);
1863 status
= memcached_server_push(memc
, list
);
1864 memcached_server_list_free(list
);
1865 test_compare(status
, MEMCACHED_SUCCESS
);
1867 memcached_server_instance_st server
= memcached_server_by_key(memc
, test_literal_param(__func__
), &status
);
1869 test_compare(status
, MEMCACHED_SUCCESS
);
1871 memcached_free(memc
);
1873 return TEST_SUCCESS
;
1876 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1878 memcached_return_t rc
;
1880 const char *key
= "not_found";
1881 size_t key_length
= test_literal_param_size("not_found");
1883 test_compare(MEMCACHED_SUCCESS
,
1884 memcached_mget(memc
, &key
, &key_length
, 1));
1886 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1888 test_compare(MEMCACHED_NOTFOUND
, rc
);
1890 memcached_result_free(result
);
1892 return TEST_SUCCESS
;
1895 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1897 return MEMCACHED_SUCCESS
;
1900 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1902 return MEMCACHED_SUCCESS
;
1905 test_return_t
callback_test(memcached_st
*memc
)
1907 /* Test User Data */
1911 memcached_return_t rc
;
1913 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1914 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1915 test_true(*test_ptr
== x
);
1918 /* Test Clone Callback */
1920 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1921 void *clone_cb_ptr
= *(void **)&clone_cb
;
1922 void *temp_function
= NULL
;
1924 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
1925 memcached_return_t rc
;
1926 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1927 test_true(temp_function
== clone_cb_ptr
);
1928 test_compare(MEMCACHED_SUCCESS
, rc
);
1931 /* Test Cleanup Callback */
1933 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
1934 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1935 void *temp_function
= NULL
;
1936 memcached_return_t rc
;
1938 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
1939 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1940 test_true(temp_function
== cleanup_cb_ptr
);
1943 return TEST_SUCCESS
;
1946 /* We don't test the behavior itself, we test the switches */
1947 test_return_t
behavior_test(memcached_st
*memc
)
1949 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
1950 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
1952 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
1953 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
1955 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
1956 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1958 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
1959 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
1961 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
1962 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
1964 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
1965 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1967 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
1968 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1970 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
1972 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
1974 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
1975 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
1976 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
1978 return TEST_SUCCESS
;
1981 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
1983 test_compare(MEMCACHED_DEPRECATED
,
1984 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
1986 // Platform dependent
1988 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
1992 return TEST_SUCCESS
;
1996 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
1998 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
1999 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2001 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2003 if (memcached_success(rc
))
2012 return TEST_SUCCESS
;
2016 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2018 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2019 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2021 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2023 if (memcached_success(rc
))
2032 return TEST_SUCCESS
;
2035 /* Make sure we behave properly if server list has no values */
2036 test_return_t
user_supplied_bug4(memcached_st
*memc
)
2038 const char *keys
[]= {"fudge", "son", "food"};
2039 size_t key_length
[]= {5, 3, 4};
2041 /* Here we free everything before running a bunch of mget tests */
2042 memcached_servers_reset(memc
);
2045 /* We need to empty the server before continueing test */
2046 test_compare(MEMCACHED_NO_SERVERS
,
2047 memcached_flush(memc
, 0));
2049 test_compare(MEMCACHED_NO_SERVERS
,
2050 memcached_mget(memc
, keys
, key_length
, 3));
2053 unsigned int keys_returned
;
2054 memcached_return_t rc
;
2055 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2056 test_compare(MEMCACHED_NOTFOUND
, rc
);
2057 test_zero(keys_returned
);
2060 for (uint32_t x
= 0; x
< 3; x
++)
2062 test_compare(MEMCACHED_NO_SERVERS
,
2063 memcached_set(memc
, keys
[x
], key_length
[x
],
2064 keys
[x
], key_length
[x
],
2065 (time_t)50, (uint32_t)9));
2068 test_compare(MEMCACHED_NO_SERVERS
,
2069 memcached_mget(memc
, keys
, key_length
, 3));
2073 char return_key
[MEMCACHED_MAX_KEY
];
2074 memcached_return_t rc
;
2075 size_t return_key_length
;
2076 size_t return_value_length
;
2079 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2080 &return_value_length
, &flags
, &rc
)))
2082 test_true(return_value
);
2083 test_compare(MEMCACHED_SUCCESS
, rc
);
2084 test_true(return_key_length
== return_value_length
);
2085 test_memcmp(return_value
, return_key
, return_value_length
);
2091 return TEST_SUCCESS
;
2094 #define VALUE_SIZE_BUG5 1048064
2095 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2097 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2098 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2100 size_t value_length
;
2102 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2104 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2106 insert_data
[x
]= (signed char)rand();
2109 test_compare(MEMCACHED_SUCCESS
,
2110 memcached_flush(memc
, 0));
2112 memcached_return_t rc
;
2113 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2114 test_compare(MEMCACHED_SUCCESS
,
2115 memcached_mget(memc
, keys
, key_length
, 4));
2118 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2119 test_compare(MEMCACHED_NOTFOUND
, rc
);
2122 for (uint32_t x
= 0; x
< 4; x
++)
2124 test_compare(MEMCACHED_SUCCESS
,
2125 memcached_set(memc
, keys
[x
], key_length
[x
],
2126 insert_data
, VALUE_SIZE_BUG5
,
2127 (time_t)0, (uint32_t)0));
2130 for (uint32_t x
= 0; x
< 10; x
++)
2132 value
= memcached_get(memc
, keys
[0], key_length
[0],
2133 &value_length
, &flags
, &rc
);
2134 test_compare(rc
, MEMCACHED_SUCCESS
);
2138 test_compare(MEMCACHED_SUCCESS
,
2139 memcached_mget(memc
, keys
, key_length
, 4));
2141 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2142 test_compare(4U, count
);
2144 delete [] insert_data
;
2146 return TEST_SUCCESS
;
2149 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2151 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2152 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2153 char return_key
[MEMCACHED_MAX_KEY
];
2154 size_t return_key_length
;
2156 size_t value_length
;
2158 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2160 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2162 insert_data
[x
]= (signed char)rand();
2165 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2167 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2169 // We will now confirm that memcached_mget() returns success, but we will
2170 // then check to make sure that no actual keys are returned.
2171 test_compare(MEMCACHED_SUCCESS
,
2172 memcached_mget(memc
, keys
, key_length
, 4));
2174 memcached_return_t rc
;
2176 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2177 &value_length
, &flags
, &rc
)))
2182 test_compare(MEMCACHED_NOTFOUND
, rc
);
2184 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2186 test_compare(MEMCACHED_SUCCESS
,
2187 memcached_set(memc
, keys
[x
], key_length
[x
],
2188 insert_data
, VALUE_SIZE_BUG5
,
2189 (time_t)0, (uint32_t)0));
2191 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2193 for (uint32_t x
= 0; x
< 2; x
++)
2195 value
= memcached_get(memc
, keys
[0], key_length
[0],
2196 &value_length
, &flags
, &rc
);
2200 test_compare(MEMCACHED_SUCCESS
,
2201 memcached_mget(memc
, keys
, key_length
, 4));
2202 /* We test for purge of partial complete fetches */
2203 for (count
= 3; count
; count
--)
2205 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2206 &value_length
, &flags
, &rc
);
2207 test_compare(MEMCACHED_SUCCESS
, rc
);
2208 test_memcmp(value
, insert_data
, value_length
);
2209 test_true(value_length
);
2213 delete [] insert_data
;
2215 return TEST_SUCCESS
;
2218 test_return_t
user_supplied_bug8(memcached_st
*)
2220 memcached_return_t rc
;
2222 memcached_st
*memc_clone
;
2224 memcached_server_st
*servers
;
2225 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";
2227 servers
= memcached_servers_parse(server_list
);
2230 mine
= memcached_create(NULL
);
2231 rc
= memcached_server_push(mine
, servers
);
2232 test_compare(MEMCACHED_SUCCESS
, rc
);
2233 memcached_server_list_free(servers
);
2236 memc_clone
= memcached_clone(NULL
, mine
);
2238 memcached_quit(mine
);
2239 memcached_quit(memc_clone
);
2242 memcached_free(mine
);
2243 memcached_free(memc_clone
);
2245 return TEST_SUCCESS
;
2248 /* Test flag store/retrieve */
2249 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2251 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2252 test_true(insert_data
);
2254 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2256 insert_data
[x
]= (signed char)rand();
2259 memcached_flush(memc
, 0);
2261 const char *keys
= "036790384900";
2262 size_t key_length
= strlen(keys
);
2263 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2264 insert_data
, VALUE_SIZE_BUG5
,
2267 memcached_return_t rc
;
2268 size_t value_length
;
2270 char *value
= memcached_get(memc
, keys
, key_length
,
2271 &value_length
, &flags
, &rc
);
2272 test_compare(245U, flags
);
2276 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2278 char return_key
[MEMCACHED_MAX_KEY
];
2279 size_t return_key_length
;
2281 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2282 &value_length
, &flags
, &rc
);
2283 test_compare(uint32_t(245), flags
);
2286 delete [] insert_data
;
2289 return TEST_SUCCESS
;
2292 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2294 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2295 size_t key_length
[3];
2299 char return_key
[MEMCACHED_MAX_KEY
];
2300 size_t return_key_length
;
2302 size_t return_value_length
;
2305 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2306 key_length
[1]= strlen("fudge&*@#");
2307 key_length
[2]= strlen("for^#@&$not");
2310 for (unsigned int x
= 0; x
< 3; x
++)
2312 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2313 keys
[x
], key_length
[x
],
2314 (time_t)50, (uint32_t)9);
2315 test_compare(MEMCACHED_SUCCESS
, rc
);
2318 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2319 test_compare(MEMCACHED_SUCCESS
, rc
);
2321 /* We need to empty the server before continueing test */
2322 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2323 &return_value_length
, &flags
, &rc
)) != NULL
)
2325 test_true(return_value
);
2329 test_compare(3U, count
);
2331 return TEST_SUCCESS
;
2334 /* We are testing with aggressive timeout to get failures */
2335 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2337 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
2339 size_t value_length
= 512;
2340 unsigned int set
= 1;
2341 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2343 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2344 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2345 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2347 libtest::vchar_t value
;
2348 value
.reserve(value_length
);
2349 for (uint32_t x
= 0; x
< value_length
; x
++)
2351 value
.push_back(char(x
% 127));
2354 for (unsigned int x
= 1; x
<= 100000; ++x
)
2356 memcached_return_t rc
= memcached_set(mclone
,
2357 test_literal_param("foo"),
2358 &value
[0], value
.size(),
2361 test_true((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2362 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
));
2364 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2370 memcached_free(mclone
);
2372 return TEST_SUCCESS
;
2376 We are looking failures in the async protocol
2378 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2380 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2382 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2383 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2384 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2386 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2389 libtest::vchar_t value
;
2391 for (unsigned int x
= 0; x
< 512; x
++)
2393 value
.push_back(char(x
% 127));
2396 for (unsigned int x
= 1; x
<= 100000; ++x
)
2398 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2402 memcached_free(mclone
);
2404 return TEST_SUCCESS
;
2408 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2410 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2412 memcached_return_t rc
;
2414 size_t value_length
;
2416 uint64_t number_value
;
2418 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2419 &value_length
, &flags
, &rc
);
2421 test_compare(MEMCACHED_NOTFOUND
, rc
);
2423 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2426 /* The binary protocol will set the key if it doesn't exist */
2427 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2429 test_compare(MEMCACHED_SUCCESS
, rc
);
2433 test_compare(MEMCACHED_NOTFOUND
, rc
);
2436 test_compare(MEMCACHED_SUCCESS
,
2437 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2439 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2443 test_compare(MEMCACHED_SUCCESS
,
2444 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2445 test_compare(2UL, number_value
);
2447 return TEST_SUCCESS
;
2451 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2452 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2454 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2456 char key
[] = "key34567890";
2458 char commandFirst
[]= "set key34567890 0 0 ";
2459 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2460 size_t commandLength
;
2462 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2464 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2466 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2468 char *overflow
= new (std::nothrow
) char[testSize
];
2469 test_true(overflow
);
2471 memset(overflow
, 'x', testSize
);
2472 test_compare(MEMCACHED_SUCCESS
,
2473 memcached_set(memc
, key
, strlen(key
),
2474 overflow
, testSize
, 0, 0));
2478 return TEST_SUCCESS
;
2483 Test values of many different sizes
2484 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2485 set key34567890 0 0 8169 \r\n
2486 is sent followed by buffer of size 8169, followed by 8169
2488 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2490 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2492 libtest::vchar_t value
;
2493 value
.reserve(18000);
2494 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2496 value
.push_back((char) (x
% 127));
2499 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2501 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2502 &value
[0], current_length
,
2503 (time_t)0, (uint32_t)0);
2504 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2506 size_t string_length
;
2508 char *string
= memcached_get(memc
, test_literal_param("foo"),
2509 &string_length
, &flags
, &rc
);
2511 test_compare(MEMCACHED_SUCCESS
, rc
);
2512 test_compare(string_length
, current_length
);
2514 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2515 test_memcmp(string
, &value
[0], string_length
);
2520 return TEST_SUCCESS
;
2524 Look for zero length value problems
2526 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2528 for (uint32_t x
= 0; x
< 2; x
++)
2530 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2532 (time_t)0, (uint32_t)0);
2534 test_compare(MEMCACHED_SUCCESS
, rc
);
2538 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2539 &length
, &flags
, &rc
);
2541 test_compare(MEMCACHED_SUCCESS
, rc
);
2546 value
= memcached_get(memc
, test_literal_param("mykey"),
2547 &length
, &flags
, &rc
);
2549 test_compare(MEMCACHED_SUCCESS
, rc
);
2555 return TEST_SUCCESS
;
2558 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2559 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2561 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2563 (time_t)0, UINT32_MAX
));
2568 memcached_return_t rc
;
2569 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2570 &length
, &flags
, &rc
);
2572 test_compare(MEMCACHED_SUCCESS
, rc
);
2575 test_compare(flags
, UINT32_MAX
);
2577 return TEST_SUCCESS
;
2580 #if !defined(__sun) && !defined(__OpenBSD__)
2581 /* Check the validity of chinese key*/
2582 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2584 const char *key
= "豆瓣";
2585 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2586 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2587 value
, strlen(value
),
2590 test_compare(MEMCACHED_SUCCESS
, rc
);
2594 char *value2
= memcached_get(memc
, key
, strlen(key
),
2595 &length
, &flags
, &rc
);
2597 test_compare(length
, strlen(value
));
2598 test_compare(MEMCACHED_SUCCESS
, rc
);
2599 test_memcmp(value
, value2
, length
);
2602 return TEST_SUCCESS
;
2610 test_return_t
user_supplied_bug19(memcached_st
*)
2612 memcached_return_t res
;
2614 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2616 memcached_server_instance_st server
= memcached_server_by_key(memc
, "a", 1, &res
);
2619 memcached_free(memc
);
2621 return TEST_SUCCESS
;
2624 /* CAS test from Andei */
2625 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2627 const char *key
= "abc";
2628 size_t key_len
= strlen("abc");
2630 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2632 test_compare(MEMCACHED_SUCCESS
,
2634 test_literal_param("abc"),
2635 test_literal_param("foobar"),
2636 (time_t)0, (uint32_t)0));
2638 test_compare(MEMCACHED_SUCCESS
,
2639 memcached_mget(memc
, &key
, &key_len
, 1));
2641 memcached_result_st result_obj
;
2642 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2645 memcached_result_create(memc
, &result_obj
);
2646 memcached_return_t status
;
2647 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2650 test_compare(MEMCACHED_SUCCESS
, status
);
2652 memcached_result_free(result
);
2654 return TEST_SUCCESS
;
2657 /* Large mget() of missing keys with binary proto
2659 * If many binary quiet commands (such as getq's in an mget) fill the output
2660 * buffer and the server chooses not to respond, memcached_flush hangs. See
2661 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2664 /* sighandler_t function that always asserts false */
2665 static __attribute__((noreturn
)) void fail(int)
2671 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2676 return TEST_SKIPPED
;
2678 void (*oldalarm
)(int);
2680 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2681 test_true(memc_clone
);
2683 /* only binproto uses getq for mget */
2684 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2686 /* empty the cache to ensure misses (hence non-responses) */
2687 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2689 keys_st
keys(key_count
);
2691 oldalarm
= signal(SIGALRM
, fail
);
2694 test_compare_got(MEMCACHED_SUCCESS
,
2695 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2696 memcached_last_error_message(memc_clone
));
2699 signal(SIGALRM
, oldalarm
);
2701 memcached_return_t rc
;
2703 char return_key
[MEMCACHED_MAX_KEY
];
2704 size_t return_key_length
;
2706 size_t return_value_length
;
2707 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2708 &return_value_length
, &flags
, &rc
)))
2710 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2712 test_compare(MEMCACHED_NOTFOUND
, rc
);
2713 test_zero(return_value_length
);
2714 test_zero(return_key_length
);
2715 test_false(return_key
[0]);
2716 test_false(return_value
);
2718 memcached_free(memc_clone
);
2720 return TEST_SUCCESS
;
2724 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2726 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2728 /* should work as of r580 */
2729 test_compare(TEST_SUCCESS
,
2730 _user_supplied_bug21(memc
, 10));
2732 /* should fail as of r580 */
2733 test_compare(TEST_SUCCESS
,
2734 _user_supplied_bug21(memc
, 1000));
2736 return TEST_SUCCESS
;
2739 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2741 memcached_st
*memc
= memcached_create(NULL
);
2745 test_compare(MEMCACHED_SUCCESS
,
2746 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2748 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2749 test_compare(value
, uint64_t(1));
2751 test_compare(MEMCACHED_SUCCESS
,
2752 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2754 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2755 test_true(value
== MEMCACHED_HASH_MD5
);
2758 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2760 memcached_server_st
*server_pool
;
2761 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");
2762 memcached_server_push(memc
, server_pool
);
2764 // @todo this needs to be refactored to actually test something.
2767 if ((fp
= fopen("ketama_keys.txt", "w")))
2771 printf("cannot write to file ketama_keys.txt");
2772 return TEST_FAILURE
;
2775 for (int x
= 0; x
< 10000; x
++)
2778 snprintf(key
, sizeof(key
), "%d", x
);
2780 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2781 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2782 in_port_t port
= memc
->hosts
[server_idx
].port
;
2783 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2784 memcached_server_instance_st instance
=
2785 memcached_server_instance_by_position(memc
, host_index
);
2789 memcached_server_list_free(server_pool
);
2790 memcached_free(memc
);
2792 return TEST_SUCCESS
;
2796 test_return_t
result_static(memcached_st
*memc
)
2798 memcached_result_st result
;
2799 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
2800 test_false(result
.options
.is_allocated
);
2801 test_true(memcached_is_initialized(&result
));
2802 test_true(result_ptr
);
2803 test_true(result_ptr
== &result
);
2805 memcached_result_free(&result
);
2807 test_false(result
.options
.is_allocated
);
2808 test_false(memcached_is_initialized(&result
));
2810 return TEST_SUCCESS
;
2813 test_return_t
result_alloc(memcached_st
*memc
)
2815 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
2816 test_true(result_ptr
);
2817 test_true(result_ptr
->options
.is_allocated
);
2818 test_true(memcached_is_initialized(result_ptr
));
2819 memcached_result_free(result_ptr
);
2821 return TEST_SUCCESS
;
2825 test_return_t
add_host_test1(memcached_st
*memc
)
2827 memcached_return_t rc
;
2828 char servername
[]= "0.example.com";
2830 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2832 test_compare(1U, memcached_server_list_count(servers
));
2834 for (uint32_t x
= 2; x
< 20; x
++)
2836 char buffer
[SMALL_STRING_LEN
];
2838 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
2839 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2841 test_compare(MEMCACHED_SUCCESS
, rc
);
2842 test_compare(x
, memcached_server_list_count(servers
));
2845 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2846 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2848 memcached_server_list_free(servers
);
2850 return TEST_SUCCESS
;
2854 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
2858 #ifdef HARD_MALLOC_TESTS
2859 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
2867 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
2871 #ifdef HARD_MALLOC_TESTS
2872 void *ret
= malloc(size
+ 8);
2875 ret
= (void*)((caddr_t
)ret
+ 8);
2878 void *ret
= malloc(size
);
2883 memset(ret
, 0xff, size
);
2890 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
2892 #ifdef HARD_MALLOC_TESTS
2893 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
2894 void *nmem
= realloc(real_ptr
, size
+ 8);
2899 ret
= (void*)((caddr_t
)nmem
+ 8);
2905 return realloc(mem
, size
);
2910 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
2912 #ifdef HARD_MALLOC_TESTS
2913 void *mem
= my_malloc(ptr
, nelem
* size
);
2916 memset(mem
, 0, nelem
* size
);
2922 return calloc(nelem
, size
);
2926 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
2928 memcached_return_t rc
;
2929 const char *key
= "mine";
2932 /* Make sure be default none exists */
2933 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2935 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2937 /* Test a clean set */
2938 test_compare(MEMCACHED_SUCCESS
,
2939 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2941 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2943 test_memcmp(value
, key
, 4);
2944 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2946 /* Test that we can turn it off */
2947 test_compare(MEMCACHED_SUCCESS
,
2948 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
2950 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2952 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2954 /* Now setup for main test */
2955 test_compare(MEMCACHED_SUCCESS
,
2956 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2958 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2960 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2961 test_memcmp(value
, key
, 4);
2963 /* Set to Zero, and then Set to something too large */
2966 memset(long_key
, 0, 255);
2968 test_compare(MEMCACHED_SUCCESS
,
2969 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
2971 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2973 test_compare(MEMCACHED_SUCCESS
, rc
);
2975 /* Test a long key for failure */
2976 /* TODO, extend test to determine based on setting, what result should be */
2977 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
2978 test_compare(MEMCACHED_SUCCESS
,
2979 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
2981 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
2982 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
2983 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
2984 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
2986 /* Test for a bad prefix, but with a short key */
2987 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
2988 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
2990 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
2991 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
2994 return TEST_SUCCESS
;
2997 test_return_t
set_namespace(memcached_st
*memc
)
2999 memcached_return_t rc
;
3000 const char *key
= "mine";
3003 // Make sure we default to a null namespace
3004 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3006 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3008 /* Test a clean set */
3009 test_compare(MEMCACHED_SUCCESS
,
3010 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3012 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3014 test_memcmp(value
, key
, 4);
3015 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3017 return TEST_SUCCESS
;
3020 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3022 test_return_if(pre_binary(memc
));
3023 test_return_if(set_namespace(memc
));
3025 return TEST_SUCCESS
;
3028 #ifdef MEMCACHED_ENABLE_DEPRECATED
3029 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3031 void *test_ptr
= NULL
;
3034 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
3035 cb_ptr
= *(void **)&malloc_cb
;
3036 memcached_return_t rc
;
3038 test_compare(MEMCACHED_SUCCESS
,
3039 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3040 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3041 test_compare(MEMCACHED_SUCCESS
, rc
);
3042 test_true(test_ptr
== cb_ptr
);
3046 memcached_realloc_fn realloc_cb
=
3047 (memcached_realloc_fn
)my_realloc
;
3048 cb_ptr
= *(void **)&realloc_cb
;
3049 memcached_return_t rc
;
3051 test_compare(MEMCACHED_SUCCESS
,
3052 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3053 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3054 test_compare(MEMCACHED_SUCCESS
, rc
);
3055 test_true(test_ptr
== cb_ptr
);
3059 memcached_free_fn free_cb
=
3060 (memcached_free_fn
)my_free
;
3061 cb_ptr
= *(void **)&free_cb
;
3062 memcached_return_t rc
;
3064 test_compare(MEMCACHED_SUCCESS
,
3065 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3066 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3067 test_compare(MEMCACHED_SUCCESS
, rc
);
3068 test_true(test_ptr
== cb_ptr
);
3071 return TEST_SUCCESS
;
3076 test_return_t
set_memory_alloc(memcached_st
*memc
)
3078 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3079 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3080 my_realloc
, my_calloc
, NULL
));
3082 test_compare(MEMCACHED_SUCCESS
,
3083 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3084 my_realloc
, my_calloc
, NULL
));
3086 memcached_malloc_fn mem_malloc
;
3087 memcached_free_fn mem_free
;
3088 memcached_realloc_fn mem_realloc
;
3089 memcached_calloc_fn mem_calloc
;
3090 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3091 &mem_realloc
, &mem_calloc
);
3093 test_true(mem_malloc
== my_malloc
);
3094 test_true(mem_realloc
== my_realloc
);
3095 test_true(mem_calloc
== my_calloc
);
3096 test_true(mem_free
== my_free
);
3098 return TEST_SUCCESS
;
3101 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3103 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
));
3104 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3107 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3112 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3114 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_CRC
)
3116 return TEST_SKIPPED
;
3119 return TEST_SUCCESS
;
3122 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3125 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
);
3126 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3131 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3133 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_HSIEH
)
3135 return TEST_SKIPPED
;
3138 return TEST_SUCCESS
;
3141 test_return_t
enable_cas(memcached_st
*memc
)
3143 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3145 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true);
3147 return TEST_SUCCESS
;
3150 return TEST_SKIPPED
;
3153 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3155 memcached_version(memc
);
3157 memcached_server_instance_st instance
=
3158 memcached_server_instance_by_position(memc
, 0);
3160 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3161 or instance
->minor_version
> 2)
3163 return TEST_SUCCESS
;
3166 return TEST_SKIPPED
;
3169 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3171 const uint64_t timeout
= 100; // Not using, just checking that it sets
3173 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3175 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3177 return TEST_SUCCESS
;
3180 test_return_t
noreply_test(memcached_st
*memc
)
3182 test_compare(MEMCACHED_SUCCESS
,
3183 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3184 test_compare(MEMCACHED_SUCCESS
,
3185 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3186 test_compare(MEMCACHED_SUCCESS
,
3187 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3188 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3189 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3190 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3192 memcached_return_t ret
;
3193 for (int count
= 0; count
< 5; ++count
)
3195 for (size_t x
= 0; x
< 100; ++x
)
3197 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3198 int check_length
= snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3199 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3201 size_t len
= (size_t)check_length
;
3206 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3209 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3212 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3215 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3218 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3224 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3225 memcached_strerror(NULL
, ret
));
3229 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3230 ** API and is _ONLY_ done this way to verify that the library works the
3231 ** way it is supposed to do!!!!
3235 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3237 memcached_server_instance_st instance
=
3238 memcached_server_instance_by_position(memc
, x
);
3239 no_msg
+=(int)(instance
->cursor_active
);
3242 test_true(no_msg
== 0);
3244 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3247 ** Now validate that all items was set properly!
3249 for (size_t x
= 0; x
< 100; ++x
)
3253 int check_length
= snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3255 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3257 size_t len
= (size_t)check_length
;
3260 char* value
=memcached_get(memc
, key
, strlen(key
),
3261 &length
, &flags
, &ret
);
3262 // For the moment we will just go to the next key
3263 if (MEMCACHED_TIMEOUT
== ret
)
3267 test_true(ret
== MEMCACHED_SUCCESS
and value
!= NULL
);
3270 case 0: /* FALLTHROUGH */
3271 case 1: /* FALLTHROUGH */
3273 test_true(strncmp(value
, key
, len
) == 0);
3274 test_true(len
== length
);
3277 test_true(length
== len
* 2);
3280 test_true(length
== len
* 3);
3290 /* Try setting an illegal cas value (should not return an error to
3291 * the caller (because we don't expect a return message from the server)
3293 const char* keys
[]= {"0"};
3294 size_t lengths
[]= {1};
3297 memcached_result_st results_obj
;
3298 memcached_result_st
*results
;
3299 test_compare(MEMCACHED_SUCCESS
,
3300 memcached_mget(memc
, keys
, lengths
, 1));
3302 results
= memcached_result_create(memc
, &results_obj
);
3304 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3306 test_compare(MEMCACHED_SUCCESS
, ret
);
3307 uint64_t cas
= memcached_result_cas(results
);
3308 memcached_result_free(&results_obj
);
3310 test_compare(MEMCACHED_SUCCESS
,
3311 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3314 * The item will have a new cas value, so try to set it again with the old
3315 * value. This should fail!
3317 test_compare(MEMCACHED_SUCCESS
,
3318 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3319 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3320 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3321 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3324 return TEST_SUCCESS
;
3327 test_return_t
analyzer_test(memcached_st
*memc
)
3329 memcached_analysis_st
*report
;
3330 memcached_return_t rc
;
3332 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3333 test_compare(MEMCACHED_SUCCESS
, rc
);
3334 test_true(memc_stat
);
3336 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3337 test_compare(MEMCACHED_SUCCESS
, rc
);
3341 memcached_stat_free(NULL
, memc_stat
);
3343 return TEST_SUCCESS
;
3346 test_return_t
util_version_test(memcached_st
*memc
)
3348 test_compare(memcached_version(memc
), MEMCACHED_SUCCESS
);
3349 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3351 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3353 // We expect failure
3356 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3357 fprintf(stderr
, "\nDumping Server Information\n\n");
3358 memcached_server_fn callbacks
[1];
3360 callbacks
[0]= dump_server_information
;
3361 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3362 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3364 test_true(if_successful
== false);
3366 memcached_server_instance_st instance
=
3367 memcached_server_instance_by_position(memc
, 0);
3369 memcached_version(memc
);
3371 // We only use one binary when we test, so this should be just fine.
3372 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3373 test_true(if_successful
== true);
3375 if (instance
->micro_version
> 0)
3377 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3379 else if (instance
->minor_version
> 0)
3381 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3383 else if (instance
->major_version
> 0)
3385 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3388 test_true(if_successful
== true);
3390 if (instance
->micro_version
> 0)
3392 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3394 else if (instance
->minor_version
> 0)
3396 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3398 else if (instance
->major_version
> 0)
3400 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3403 test_true(if_successful
== false);
3405 return TEST_SUCCESS
;
3408 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3410 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3411 memcached_return_t rc
;
3412 memcached_server_instance_st instance
=
3413 memcached_server_instance_by_position(memc
, 0);
3415 // Test both the version that returns a code, and the one that does not.
3416 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3417 memcached_server_port(instance
) -1, NULL
) == -1);
3419 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3420 memcached_server_port(instance
) -1, &rc
) == -1);
3421 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3423 return TEST_SUCCESS
;
3427 test_return_t
getpid_test(memcached_st
*memc
)
3429 memcached_return_t rc
;
3430 memcached_server_instance_st instance
=
3431 memcached_server_instance_by_position(memc
, 0);
3433 // Test both the version that returns a code, and the one that does not.
3434 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3435 memcached_server_port(instance
), NULL
) > -1);
3437 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3438 memcached_server_port(instance
), &rc
) > -1);
3439 test_compare(MEMCACHED_SUCCESS
, rc
);
3441 return TEST_SUCCESS
;
3444 static memcached_return_t
ping_each_server(const memcached_st
*,
3445 memcached_server_instance_st instance
,
3448 // Test both the version that returns a code, and the one that does not.
3449 memcached_return_t rc
;
3450 if (libmemcached_util_ping(memcached_server_name(instance
),
3451 memcached_server_port(instance
), &rc
) == false)
3453 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d %s", memcached_server_name(instance
),
3454 memcached_server_port(instance
), memcached_strerror(NULL
, rc
));
3457 if (libmemcached_util_ping(memcached_server_name(instance
),
3458 memcached_server_port(instance
), NULL
) == false)
3460 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d", memcached_server_name(instance
), memcached_server_port(instance
));
3463 return MEMCACHED_SUCCESS
;
3466 test_return_t
libmemcached_util_ping_TEST(memcached_st
*memc
)
3468 memcached_server_fn callbacks
[1]= { ping_each_server
};
3469 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
3471 return TEST_SUCCESS
;
3476 test_return_t
hash_sanity_test (memcached_st
*memc
)
3480 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3481 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3482 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3483 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3484 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3485 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3486 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3487 #ifdef HAVE_HSIEH_HASH
3488 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3490 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3491 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3492 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3494 return TEST_SUCCESS
;
3498 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3500 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3502 test_compare(MEMCACHED_SUCCESS
,
3503 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3504 (uint64_t)MEMCACHED_HASH_HSIEH
));
3506 return TEST_SUCCESS
;
3509 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3511 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3513 test_compare(MEMCACHED_SUCCESS
,
3514 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3516 return TEST_SUCCESS
;
3519 test_return_t
one_at_a_time_run (memcached_st
*)
3524 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3526 test_compare(one_at_a_time_values
[x
],
3527 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3530 return TEST_SUCCESS
;
3533 test_return_t
md5_run (memcached_st
*)
3538 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3540 test_compare(md5_values
[x
],
3541 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3544 return TEST_SUCCESS
;
3547 test_return_t
crc_run (memcached_st
*)
3552 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3554 test_compare(crc_values
[x
],
3555 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3558 return TEST_SUCCESS
;
3561 test_return_t
fnv1_64_run (memcached_st
*)
3563 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3568 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3570 test_compare(fnv1_64_values
[x
],
3571 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3574 return TEST_SUCCESS
;
3577 test_return_t
fnv1a_64_run (memcached_st
*)
3579 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3584 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3586 test_compare(fnv1a_64_values
[x
],
3587 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3590 return TEST_SUCCESS
;
3593 test_return_t
fnv1_32_run (memcached_st
*)
3598 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3600 test_compare(fnv1_32_values
[x
],
3601 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3604 return TEST_SUCCESS
;
3607 test_return_t
fnv1a_32_run (memcached_st
*)
3612 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3614 test_compare(fnv1a_32_values
[x
],
3615 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3618 return TEST_SUCCESS
;
3621 test_return_t
hsieh_run (memcached_st
*)
3623 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3628 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3630 test_compare(hsieh_values
[x
],
3631 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3634 return TEST_SUCCESS
;
3637 test_return_t
murmur_run (memcached_st
*)
3639 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3641 #ifdef WORDS_BIGENDIAN
3642 (void)murmur_values
;
3643 return TEST_SKIPPED
;
3648 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3650 test_compare(murmur_values
[x
],
3651 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3654 return TEST_SUCCESS
;
3658 test_return_t
jenkins_run (memcached_st
*)
3663 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3665 test_compare(jenkins_values
[x
],
3666 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3669 return TEST_SUCCESS
;
3672 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3674 return libhashkit_md5(string
, string_length
);
3677 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3679 return libhashkit_crc32(string
, string_length
);
3682 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3688 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3690 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};
3691 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};
3693 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3695 hashkit_clone(&new_kit
, kit
);
3696 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3698 memcached_set_hashkit(memc
, &new_kit
);
3701 Verify Setting the hash.
3703 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3707 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3708 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3713 Now check memcached_st.
3715 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3719 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3720 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3723 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3725 memcached_set_hashkit(memc
, &new_kit
);
3728 Verify Setting the hash.
3730 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3734 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3735 test_true(crc_values
[x
] == hash_val
);
3738 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3742 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3743 test_compare(crc_hosts
[x
], hash_val
);
3746 memcached_free(memc
);
3748 return TEST_SUCCESS
;
3752 Test case adapted from John Gorman <johngorman2@gmail.com>
3754 We are testing the error condition when we connect to a server via memcached_get()
3755 but find that the server is not available.
3757 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3761 memcached_return rc
;
3764 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3766 // See if memcached is reachable.
3767 char *value
= memcached_get(tl_memc_h
,
3768 test_literal_param(__func__
),
3773 test_true(memcached_failed(rc
));
3775 memcached_free(tl_memc_h
);
3777 return TEST_SUCCESS
;
3781 We connect to a server which exists, but search for a key that does not exist.
3783 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3787 memcached_return rc
;
3789 // See if memcached is reachable.
3790 char *value
= memcached_get(memc
,
3791 test_literal_param(__func__
),
3796 test_compare(MEMCACHED_NOTFOUND
, rc
);
3798 return TEST_SUCCESS
;
3802 Test case adapted from John Gorman <johngorman2@gmail.com>
3804 We are testing the error condition when we connect to a server via memcached_get_by_key()
3805 but find that the server is not available.
3807 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
3811 memcached_return rc
;
3814 memcached_st
*tl_memc_h
= memcached_create(NULL
);
3815 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
3816 memcached_server_push(tl_memc_h
, servers
);
3817 memcached_server_list_free(servers
);
3819 // See if memcached is reachable.
3820 char *value
= memcached_get_by_key(tl_memc_h
,
3821 test_literal_param(__func__
), // Key
3822 test_literal_param(__func__
), // Value
3827 test_true(memcached_failed(rc
));
3829 memcached_free(tl_memc_h
);
3831 return TEST_SUCCESS
;
3835 We connect to a server which exists, but search for a key that does not exist.
3837 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3841 memcached_return rc
;
3843 // See if memcached is reachable.
3844 char *value
= memcached_get_by_key(memc
,
3845 test_literal_param(__func__
), // Key
3846 test_literal_param(__func__
), // Value
3851 test_compare(MEMCACHED_NOTFOUND
, rc
);
3853 return TEST_SUCCESS
;
3856 test_return_t
regression_bug_434484(memcached_st
*memc
)
3858 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3860 test_compare(MEMCACHED_NOTSTORED
,
3861 memcached_append(memc
,
3862 test_literal_param(__func__
), // Key
3863 test_literal_param(__func__
), // Value
3866 libtest::vchar_t data
;
3867 data
.resize(2048 * 1024);
3868 test_compare(MEMCACHED_E2BIG
,
3870 test_literal_param(__func__
), // Key
3871 &data
[0], data
.size(), 0, 0));
3873 return TEST_SUCCESS
;
3876 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
3878 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
3880 memcached_return_t rc
;
3882 memcached_execute_fn callbacks
[]= { &callback_counter
};
3885 * I only want to hit only _one_ server so I know the number of requests I'm
3886 * sending in the pipleine to the server. Let's try to do a multiget of
3887 * 1024 (that should satisfy most users don't you think?). Future versions
3888 * will include a mget_execute function call if you need a higher number.
3890 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
3895 * Run two times.. the first time we should have 100% cache miss,
3896 * and the second time we should have 100% cache hits
3898 for (ptrdiff_t y
= 0; y
< 2; y
++)
3900 test_compare(MEMCACHED_SUCCESS
,
3901 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
3903 // One the first run we should get a NOT_FOUND, but on the second some data
3904 // should be returned.
3905 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
3906 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3910 /* The first iteration should give me a 100% cache miss. verify that*/
3911 char blob
[1024]= { 0 };
3913 test_false(counter
);
3915 for (size_t x
= 0; x
< keys
.size(); ++x
)
3917 rc
= memcached_add(memc
,
3918 keys
.key_at(x
), keys
.length_at(x
),
3919 blob
, sizeof(blob
), 0, 0);
3920 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3925 /* Verify that we received all of the key/value pairs */
3926 test_compare(counter
, keys
.size());
3930 memcached_free(memc
);
3932 return TEST_SUCCESS
;
3935 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
3937 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3939 return regression_bug_434843(memc
);
3942 test_return_t
regression_bug_421108(memcached_st
*memc
)
3944 memcached_return_t rc
;
3945 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3946 test_compare(MEMCACHED_SUCCESS
, rc
);
3948 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
3949 test_compare(MEMCACHED_SUCCESS
, rc
);
3950 test_true(bytes_str
);
3951 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
3953 test_compare(MEMCACHED_SUCCESS
, rc
);
3954 test_true(bytes_read_str
);
3956 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
3957 "bytes_written", &rc
);
3958 test_compare(MEMCACHED_SUCCESS
, rc
);
3959 test_true(bytes_written_str
);
3961 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
3962 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
3963 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
3965 test_true(bytes
!= bytes_read
);
3966 test_true(bytes
!= bytes_written
);
3968 /* Release allocated resources */
3970 free(bytes_read_str
);
3971 free(bytes_written_str
);
3972 memcached_stat_free(NULL
, memc_stat
);
3974 return TEST_SUCCESS
;
3978 * The test case isn't obvious so I should probably document why
3979 * it works the way it does. Bug 442914 was caused by a bug
3980 * in the logic in memcached_purge (it did not handle the case
3981 * where the number of bytes sent was equal to the watermark).
3982 * In this test case, create messages so that we hit that case
3983 * and then disable noreply mode and issue a new command to
3984 * verify that it isn't stuck. If we change the format for the
3985 * delete command or the watermarks, we need to update this
3988 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
3990 test_skip(original_memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3992 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
3994 for (uint32_t x
= 0; x
< 250; ++x
)
3997 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
3998 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
3999 char error_buffer
[2048]= { 0 };
4000 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
4001 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
4004 // Delete, and then delete again to look for not found
4007 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
4008 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4009 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4011 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
4012 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
4015 memcached_free(memc
);
4017 return TEST_SUCCESS
;
4020 test_return_t
regression_bug_447342(memcached_st
*memc
)
4022 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4024 return TEST_SKIPPED
;
4027 test_compare(MEMCACHED_SUCCESS
,
4028 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4032 for (size_t x
= 0; x
< keys
.size(); ++x
)
4034 test_compare(MEMCACHED_SUCCESS
,
4036 keys
.key_at(x
), keys
.length_at(x
), // Keys
4037 keys
.key_at(x
), keys
.length_at(x
), // Values
4042 ** We are using the quiet commands to store the replicas, so we need
4043 ** to ensure that all of them are processed before we can continue.
4044 ** In the test we go directly from storing the object to trying to
4045 ** receive the object from all of the different servers, so we
4046 ** could end up in a race condition (the memcached server hasn't yet
4047 ** processed the quiet command from the replication set when it process
4048 ** the request from the other client (created by the clone)). As a
4049 ** workaround for that we call memcached_quit to send the quit command
4050 ** to the server and wait for the response ;-) If you use the test code
4051 ** as an example for your own code, please note that you shouldn't need
4054 memcached_quit(memc
);
4056 /* Verify that all messages are stored, and we didn't stuff too much
4059 test_compare(MEMCACHED_SUCCESS
,
4060 memcached_mget(memc
,
4061 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4063 unsigned int counter
= 0;
4064 memcached_execute_fn callbacks
[]= { &callback_counter
};
4065 test_compare(MEMCACHED_SUCCESS
,
4066 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4068 /* Verify that we received all of the key/value pairs */
4069 test_compare(counter
, keys
.size());
4071 memcached_quit(memc
);
4073 * Don't do the following in your code. I am abusing the internal details
4074 * within the library, and this is not a supported interface.
4075 * This is to verify correct behavior in the library. Fake that two servers
4078 memcached_server_instance_st instance_one
= memcached_server_instance_by_position(memc
, 0);
4079 memcached_server_instance_st instance_two
= memcached_server_instance_by_position(memc
, 2);
4080 in_port_t port0
= instance_one
->port();
4081 in_port_t port2
= instance_two
->port();
4083 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4084 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4086 test_compare(MEMCACHED_SUCCESS
,
4087 memcached_mget(memc
,
4088 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4091 test_compare(MEMCACHED_SUCCESS
,
4092 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4093 test_compare(counter
, keys
.size());
4095 /* restore the memc handle */
4096 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4097 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4099 memcached_quit(memc
);
4101 /* Remove half of the objects */
4102 for (size_t x
= 0; x
< keys
.size(); ++x
)
4106 test_compare(MEMCACHED_SUCCESS
,
4107 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4111 memcached_quit(memc
);
4112 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4113 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4115 /* now retry the command, this time we should have cache misses */
4116 test_compare(MEMCACHED_SUCCESS
,
4117 memcached_mget(memc
,
4118 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4121 test_compare(MEMCACHED_SUCCESS
,
4122 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4123 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4125 /* restore the memc handle */
4126 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4127 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4129 return TEST_SUCCESS
;
4132 test_return_t
regression_bug_463297(memcached_st
*memc
)
4134 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4136 // Since we blocked timed delete, this test is no longer valid.
4138 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4139 test_true(memc_clone
);
4140 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4142 memcached_server_instance_st instance
=
4143 memcached_server_instance_by_position(memc_clone
, 0);
4145 if (instance
->major_version
> 1 ||
4146 (instance
->major_version
== 1 &&
4147 instance
->minor_version
> 2))
4149 /* Binary protocol doesn't support deferred delete */
4150 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4151 test_true(bin_clone
);
4152 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4153 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4154 memcached_free(bin_clone
);
4156 memcached_quit(memc_clone
);
4158 /* If we know the server version, deferred delete should fail
4159 * with invalid arguments */
4160 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4162 /* If we don't know the server version, we should get a protocol error */
4163 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4165 /* but there is a bug in some of the memcached servers (1.4) that treats
4166 * the counter as noreply so it doesn't send the proper error message
4168 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4170 /* And buffered mode should be disabled and we should get protocol error */
4171 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4172 rc
= memcached_delete(memc
, "foo", 3, 1);
4173 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4175 /* Same goes for noreply... */
4176 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4177 rc
= memcached_delete(memc
, "foo", 3, 1);
4178 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4180 /* but a normal request should go through (and be buffered) */
4181 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4182 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4184 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4185 /* unbuffered noreply should be success */
4186 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4187 /* unbuffered with reply should be not found... */
4188 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4189 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4192 memcached_free(memc_clone
);
4195 return TEST_SUCCESS
;
4199 /* Test memcached_server_get_last_disconnect
4200 * For a working server set, shall be NULL
4201 * For a set of non existing server, shall not be NULL
4203 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4205 memcached_return_t rc
;
4206 memcached_server_instance_st disconnected_server
;
4208 /* With the working set of server */
4209 const char *key
= "marmotte";
4210 const char *value
= "milka";
4212 memcached_reset_last_disconnected_server(memc
);
4213 test_false(memc
->last_disconnected_server
);
4214 rc
= memcached_set(memc
, key
, strlen(key
),
4215 value
, strlen(value
),
4216 (time_t)0, (uint32_t)0);
4217 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4219 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4220 test_false(disconnected_server
);
4222 /* With a non existing server */
4224 memcached_server_st
*servers
;
4226 const char *server_list
= "localhost:9";
4228 servers
= memcached_servers_parse(server_list
);
4230 mine
= memcached_create(NULL
);
4231 rc
= memcached_server_push(mine
, servers
);
4232 test_compare(MEMCACHED_SUCCESS
, rc
);
4233 memcached_server_list_free(servers
);
4236 rc
= memcached_set(mine
, key
, strlen(key
),
4237 value
, strlen(value
),
4238 (time_t)0, (uint32_t)0);
4239 test_true(memcached_failed(rc
));
4241 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4242 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4243 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4244 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4246 memcached_quit(mine
);
4247 memcached_free(mine
);
4249 return TEST_SUCCESS
;
4252 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4254 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4255 char buffer
[BUFSIZ
];
4257 test_compare(MEMCACHED_SUCCESS
,
4258 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4260 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4263 // We will just use the error strings as our keys
4264 uint32_t counter
= 100;
4267 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4269 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4270 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4271 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4273 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
4274 test_true(disconnected_server
);
4275 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4276 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4280 memcached_reset_last_disconnected_server(memc
);
4285 memcached_free(memc
);
4287 return TEST_SUCCESS
;
4290 test_return_t
test_verbosity(memcached_st
*memc
)
4292 memcached_verbosity(memc
, 3);
4294 return TEST_SUCCESS
;
4298 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
4299 const char *key
, size_t key_length
,
4300 const char *value
, size_t value_length
,
4310 return MEMCACHED_SUCCESS
;
4313 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4315 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4316 test_compare(MEMCACHED_SUCCESS
, rc
);
4318 test_compare(MEMCACHED_SUCCESS
,
4319 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4321 test_compare(MEMCACHED_SUCCESS
,
4322 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4324 test_compare(MEMCACHED_SUCCESS
,
4325 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4327 return TEST_SUCCESS
;
4331 * This test ensures that the failure counter isn't incremented during
4332 * normal termination of the memcached instance.
4334 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4336 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4338 /* Ensure that we are connected to the server by setting a value */
4339 memcached_return_t rc
= memcached_set(memc
,
4340 test_literal_param(__func__
), // Key
4341 test_literal_param(__func__
), // Value
4342 time_t(0), uint32_t(0));
4343 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4346 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4348 /* The test is to see that the memcached_quit doesn't increase the
4349 * the server failure conter, so let's ensure that it is zero
4350 * before sending quit
4352 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4354 memcached_quit(memc
);
4356 /* Verify that it memcached_quit didn't increment the failure counter
4357 * Please note that this isn't bullet proof, because an error could
4360 test_zero(instance
->server_failure_counter
);
4362 memcached_free(memc
);
4364 return TEST_SUCCESS
;
4368 * This tests ensures expected disconnections (for some behavior changes
4369 * for instance) do not wrongly increase failure counter
4371 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4373 /* Set value to force connection to the server */
4374 const char *key
= "marmotte";
4375 const char *value
= "milka";
4377 test_compare_hint(MEMCACHED_SUCCESS
,
4378 memcached_set(memc
, key
, strlen(key
),
4379 value
, strlen(value
),
4380 (time_t)0, (uint32_t)0),
4381 memcached_last_error_message(memc
));
4384 /* put failure limit to 1 */
4385 test_compare(MEMCACHED_SUCCESS
,
4386 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4388 /* Put a retry timeout to effectively activate failure_limit effect */
4389 test_compare(MEMCACHED_SUCCESS
,
4390 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4392 /* change behavior that triggers memcached_quit()*/
4393 test_compare(MEMCACHED_SUCCESS
,
4394 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4397 /* Check if we still are connected */
4399 size_t string_length
;
4400 memcached_return rc
;
4401 char *string
= memcached_get(memc
, key
, strlen(key
),
4402 &string_length
, &flags
, &rc
);
4404 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4408 return TEST_SUCCESS
;
4411 test_return_t
regression_996813_TEST(memcached_st
*)
4413 memcached_st
* memc
= memcached_create(NULL
);
4415 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
4416 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
4417 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4418 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4419 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1));
4420 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 300));
4421 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 30));
4423 // We will never connect to these servers
4424 in_port_t base_port
= 11211;
4425 for (size_t x
= 0; x
< 17; x
++)
4427 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", base_port
+x
));
4429 test_compare(6U, memcached_generate_hash(memc
, test_literal_param("SZ6hu0SHweFmpwpc0w2R")));
4430 test_compare(1U, memcached_generate_hash(memc
, test_literal_param("SQCK9eiCf53YxHWnYA.o")));
4431 test_compare(9U, memcached_generate_hash(memc
, test_literal_param("SUSDkGXuuZC9t9VhMwa.")));
4432 test_compare(0U, memcached_generate_hash(memc
, test_literal_param("SnnqnJARfaCNT679iAF_")));
4434 memcached_free(memc
);
4436 return TEST_SUCCESS
;
4441 * Test that ensures mget_execute does not end into recursive calls that finally fails
4443 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4447 return TEST_SKIPPED
; // My MAC can't handle this test
4450 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4453 * I only want to hit _one_ server so I know the number of requests I'm
4454 * sending in the pipeline.
4456 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4459 keys_st
keys(20480);
4461 /* First add all of the items.. */
4462 char blob
[1024]= { 0 };
4463 for (size_t x
= 0; x
< keys
.size(); ++x
)
4465 memcached_return rc
= memcached_set(memc
,
4466 keys
.key_at(x
), keys
.length_at(x
),
4467 blob
, sizeof(blob
), 0, 0);
4468 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4473 /* Try to get all of them with a large multiget */
4475 memcached_execute_function callbacks
[]= { &callback_counter
};
4476 memcached_return_t rc
= memcached_mget_execute(memc
,
4477 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4478 callbacks
, &counter
, 1);
4479 test_compare(MEMCACHED_SUCCESS
, rc
);
4481 char* the_value
= NULL
;
4482 char the_key
[MEMCACHED_MAX_KEY
];
4483 size_t the_key_length
;
4484 size_t the_value_length
;
4488 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4490 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4496 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4499 test_compare(MEMCACHED_END
, rc
);
4501 /* Verify that we got all of the items */
4502 test_compare(counter
, keys
.size());
4505 memcached_free(memc
);
4507 return TEST_SUCCESS
;
4510 test_return_t
regression_1021819_TEST(memcached_st
*original
)
4512 memcached_st
*memc
= memcached_clone(NULL
, original
);
4515 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 2000000), MEMCACHED_SUCCESS
);
4516 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 3000000), MEMCACHED_SUCCESS
);
4518 memcached_return_t rc
;
4521 test_literal_param(__func__
),
4524 test_compare(rc
, MEMCACHED_NOTFOUND
);
4526 memcached_free(memc
);
4528 return TEST_SUCCESS
;
4531 test_return_t
regression_bug_583031(memcached_st
*)
4533 memcached_st
*memc
= memcached_create(NULL
);
4535 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
4537 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
4538 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4539 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4540 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4541 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4542 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4544 memcached_return_t rc
;
4548 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4552 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
4554 memcached_free(memc
);
4556 return TEST_SUCCESS
;
4559 test_return_t
regression_bug_581030(memcached_st
*)
4562 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4563 test_false(local_stat
);
4565 memcached_stat_free(NULL
, NULL
);
4568 return TEST_SUCCESS
;
4571 #define regression_bug_655423_COUNT 6000
4572 test_return_t
regression_bug_655423(memcached_st
*memc
)
4574 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4575 memc
= NULL
; // Just to make sure it is not used
4580 return TEST_SKIPPED
;
4583 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4584 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4585 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4586 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4588 memset(payload
, int('x'), sizeof(payload
));
4590 keys_st
keys(regression_bug_655423_COUNT
);
4592 for (size_t x
= 0; x
< keys
.size(); x
++)
4594 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4597 payload
, sizeof(payload
), 0, 0));
4600 for (size_t x
= 0; x
< keys
.size(); x
++)
4602 size_t value_length
;
4603 memcached_return_t rc
;
4604 char *value
= memcached_get(clone
,
4607 &value_length
, NULL
, &rc
);
4609 if (rc
== MEMCACHED_NOTFOUND
)
4612 test_zero(value_length
);
4616 test_compare(MEMCACHED_SUCCESS
, rc
);
4618 test_compare(100LLU, value_length
);
4622 test_compare(MEMCACHED_SUCCESS
,
4623 memcached_mget(clone
,
4624 keys
.keys_ptr(), keys
.lengths_ptr(),
4628 memcached_result_st
*result
= NULL
;
4629 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4631 test_compare(size_t(100), memcached_result_length(result
));
4635 test_true(count
> 100); // If we don't get back atleast this, something is up
4637 memcached_free(clone
);
4639 return TEST_SUCCESS
;
4643 * Test that ensures that buffered set to not trigger problems during io_flush
4645 #define regression_bug_490520_COUNT 200480
4646 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4648 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4650 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4651 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4652 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4653 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4654 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4656 /* First add all of the items.. */
4657 char blob
[3333] = {0};
4658 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4661 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4663 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4664 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4667 memcached_free(memc
);
4669 return TEST_SUCCESS
;
4672 test_return_t
regression_1009493_TEST(memcached_st
*)
4674 memcached_st
* memc
= memcached_create(NULL
);
4676 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, true));
4678 memcached_st
* clone
= memcached_clone(NULL
, memc
);
4681 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
),
4682 memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
4684 memcached_free(memc
);
4685 memcached_free(clone
);
4687 return TEST_SUCCESS
;
4690 test_return_t
regression_994772_TEST(memcached_st
* memc
)
4692 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4694 test_compare(MEMCACHED_SUCCESS
,
4696 test_literal_param(__func__
), // Key
4697 test_literal_param(__func__
), // Value
4698 time_t(0), uint32_t(0)));
4700 const char *keys
[] = { __func__
};
4701 size_t key_length
[]= { strlen(__func__
) };
4702 test_compare(MEMCACHED_SUCCESS
,
4703 memcached_mget(memc
, keys
, key_length
, 1));
4705 memcached_return_t rc
;
4706 memcached_result_st
*results
= memcached_fetch_result(memc
, NULL
, &rc
);
4708 test_compare(MEMCACHED_SUCCESS
, rc
);
4710 test_strcmp(__func__
, memcached_result_value(results
));
4711 uint64_t cas_value
= memcached_result_cas(results
);
4712 test_true(cas_value
);
4714 char* take_value
= memcached_result_take_value(results
);
4715 test_strcmp(__func__
, take_value
);
4718 memcached_result_free(results
);
4720 // Bad cas value, sanity check
4721 test_true(cas_value
!= 9999);
4722 test_compare(MEMCACHED_END
,
4724 test_literal_param(__func__
), // Key
4725 test_literal_param(__FILE__
), // Value
4726 time_t(0), uint32_t(0), 9999));
4728 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
4729 "different", strlen("different"), // Key
4730 test_literal_param(__FILE__
), // Value
4731 time_t(0), uint32_t(0)));
4733 return TEST_SUCCESS
;
4736 test_return_t
regression_bug_854604(memcached_st
*)
4740 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4742 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4744 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4745 test_compare(buffer
[0], 0);
4747 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4748 test_true(strlen(buffer
));
4750 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4751 test_true(strlen(buffer
));
4753 return TEST_SUCCESS
;
4756 static void die_message(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4758 fprintf(stderr
, "Iteration #%u: ", it
);
4760 if (error
== MEMCACHED_ERRNO
)
4762 fprintf(stderr
, "system error %d from %s: %s\n",
4763 errno
, what
, strerror(errno
));
4767 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4768 memcached_strerror(mc
, error
));
4772 #define TEST_CONSTANT_CREATION 200
4774 test_return_t
regression_bug_(memcached_st
*memc
)
4776 const char *remote_server
;
4779 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4781 return TEST_SKIPPED
;
4784 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4786 memcached_st
* mc
= memcached_create(NULL
);
4787 memcached_return rc
;
4789 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4790 if (rc
!= MEMCACHED_SUCCESS
)
4792 die_message(mc
, rc
, "memcached_behavior_set", x
);
4795 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4796 if (rc
!= MEMCACHED_SUCCESS
)
4798 die_message(mc
, rc
, "memcached_behavior_set", x
);
4801 rc
= memcached_server_add(mc
, remote_server
, 0);
4802 if (rc
!= MEMCACHED_SUCCESS
)
4804 die_message(mc
, rc
, "memcached_server_add", x
);
4807 const char *set_key
= "akey";
4808 const size_t set_key_len
= strlen(set_key
);
4809 const char *set_value
= "a value";
4810 const size_t set_value_len
= strlen(set_value
);
4812 if (rc
== MEMCACHED_SUCCESS
)
4816 size_t get_value_len
;
4818 uint32_t get_value_flags
;
4820 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
4821 &get_value_flags
, &rc
);
4822 if (rc
!= MEMCACHED_SUCCESS
)
4824 die_message(mc
, rc
, "memcached_get", x
);
4830 (get_value_len
!= set_value_len
4831 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
4833 fprintf(stderr
, "Values don't match?\n");
4834 rc
= MEMCACHED_FAILURE
;
4840 rc
= memcached_set(mc
,
4841 set_key
, set_key_len
,
4842 set_value
, set_value_len
,
4846 if (rc
!= MEMCACHED_SUCCESS
)
4848 die_message(mc
, rc
, "memcached_set", x
);
4855 if (rc
!= MEMCACHED_SUCCESS
)
4861 return TEST_SUCCESS
;
4864 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
4866 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
4869 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4872 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
4873 memcached_server_port(instance
), NULL
)) > -1);
4876 test_compare(MEMCACHED_SUCCESS
,
4878 test_literal_param(__func__
), // Keys
4879 test_literal_param(__func__
), // Values
4881 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
4883 test_compare(MEMCACHED_CONNECTION_FAILURE
,
4885 test_literal_param(__func__
), // Keys
4886 test_literal_param(__func__
), // Values
4889 memcached_free(memc
);
4891 return TEST_SUCCESS
;