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)));
826 test_return_t
regression_1067242_TEST(memcached_st
*memc
)
828 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
829 test_literal_param(__func__
),
830 test_literal_param("-2"),
833 memcached_return_t rc
;
835 test_true((value
= memcached_get(memc
, test_literal_param(__func__
), NULL
, NULL
, &rc
)));
836 test_compare(MEMCACHED_SUCCESS
, rc
);
839 for (size_t x
= 0; x
< 10; x
++)
842 test_compare(MEMCACHED_CLIENT_ERROR
,
843 memcached_increment(memc
,
844 test_literal_param(__func__
), 1, &new_number
));
845 test_compare(MEMCACHED_CLIENT_ERROR
, memcached_last_error(memc
));
846 test_true((value
= memcached_get(memc
, test_literal_param(__func__
), NULL
, NULL
, &rc
)));
847 test_compare(MEMCACHED_SUCCESS
, rc
);
855 Set the value, then quit to make sure it is flushed.
856 Come back in and test that add fails.
858 test_return_t
add_test(memcached_st
*memc
)
860 test_compare(return_value_based_on_buffering(memc
),
862 test_literal_param(__func__
),
863 test_literal_param("when we sanitize"),
864 time_t(0), uint32_t(0)));
866 memcached_quit(memc
);
870 memcached_return_t rc
;
871 char *check_value
= memcached_get(memc
,
872 test_literal_param(__func__
),
873 &value_length
, &flags
, &rc
);
874 test_memcmp(check_value
, "when we sanitize", strlen("when we sanitize"));
875 test_compare(test_literal_param_size("when we sanitize"), value_length
);
876 test_compare(MEMCACHED_SUCCESS
, rc
);
879 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
881 test_literal_param(__func__
),
882 test_literal_param("try something else"),
883 time_t(0), uint32_t(0)));
889 ** There was a problem of leaking filedescriptors in the initial release
890 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
891 ** systems it seems that the kernel is slow on reclaiming the resources
892 ** because the connects starts to time out (the test doesn't do much
893 ** anyway, so just loop 10 iterations)
895 test_return_t
add_wrapper(memcached_st
*memc
)
897 unsigned int max
= 10000;
905 for (uint32_t x
= 0; x
< max
; x
++)
913 test_return_t
replace_test(memcached_st
*memc
)
915 test_compare(return_value_based_on_buffering(memc
),
917 test_literal_param(__func__
),
918 test_literal_param("when we sanitize"),
919 time_t(0), uint32_t(0)));
921 test_compare(MEMCACHED_SUCCESS
,
922 memcached_replace(memc
,
923 test_literal_param(__func__
),
924 test_literal_param("first we insert some data"),
925 time_t(0), uint32_t(0)));
930 test_return_t
delete_test(memcached_st
*memc
)
932 test_compare(return_value_based_on_buffering(memc
),
934 test_literal_param(__func__
),
935 test_literal_param("when we sanitize"),
936 time_t(0), uint32_t(0)));
938 test_compare(return_value_based_on_buffering(memc
),
939 memcached_delete(memc
,
940 test_literal_param(__func__
),
946 test_return_t
flush_test(memcached_st
*memc
)
948 uint64_t query_id
= memcached_query_id(memc
);
949 test_compare(MEMCACHED_SUCCESS
,
950 memcached_flush(memc
, 0));
951 test_compare(query_id
+1, memcached_query_id(memc
));
956 static memcached_return_t
server_function(const memcached_st
*,
957 memcached_server_instance_st
,
961 return MEMCACHED_SUCCESS
;
964 test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
967 strncpy(context
, "foo bad", sizeof(context
));
968 memcached_server_fn callbacks
[1];
970 callbacks
[0]= server_function
;
971 memcached_server_cursor(memc
, callbacks
, context
, 1);
975 test_return_t
bad_key_test(memcached_st
*memc
)
977 memcached_return_t rc
;
978 const char *key
= "foo bad";
981 uint64_t query_id
= memcached_query_id(memc
);
983 // Just skip if we are in binary mode.
984 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
986 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
988 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
989 test_true(memc_clone
);
991 query_id
= memcached_query_id(memc_clone
);
992 test_compare(MEMCACHED_SUCCESS
,
993 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
994 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
996 /* All keys are valid in the binary protocol (except for length) */
997 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == false)
999 uint64_t before_query_id
= memcached_query_id(memc_clone
);
1001 size_t string_length
;
1002 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1003 &string_length
, &flags
, &rc
);
1004 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1005 test_zero(string_length
);
1008 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
1010 query_id
= memcached_query_id(memc_clone
);
1011 test_compare(MEMCACHED_SUCCESS
,
1012 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
1013 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
1015 size_t string_length
;
1016 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1017 &string_length
, &flags
, &rc
);
1018 test_compare(MEMCACHED_NOTFOUND
, rc
);
1019 test_zero(string_length
);
1023 /* Test multi key for bad keys */
1024 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
1025 size_t key_lengths
[] = { 7, 7, 7 };
1026 query_id
= memcached_query_id(memc_clone
);
1027 test_compare(MEMCACHED_SUCCESS
,
1028 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1029 test_compare(query_id
, memcached_query_id(memc_clone
));
1031 query_id
= memcached_query_id(memc_clone
);
1032 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
1033 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
1034 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1036 query_id
= memcached_query_id(memc_clone
);
1037 // Grouping keys are not required to follow normal key behaviors
1038 test_compare(MEMCACHED_SUCCESS
,
1039 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
1040 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1042 /* The following test should be moved to the end of this function when the
1043 memcached server is updated to allow max size length of the keys in the
1046 test_compare(MEMCACHED_SUCCESS
,
1047 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
1049 libtest::vchar_t longkey
;
1051 libtest::vchar_t::iterator it
= longkey
.begin();
1052 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
1055 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
1057 size_t string_length
;
1059 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
1060 test_compare(MEMCACHED_NOTFOUND
, rc
);
1061 test_zero(string_length
);
1063 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
1064 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1065 test_zero(string_length
);
1069 /* Make sure zero length keys are marked as bad */
1071 test_compare(MEMCACHED_SUCCESS
,
1072 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1073 size_t string_length
;
1074 char *string
= memcached_get(memc_clone
, key
, 0,
1075 &string_length
, &flags
, &rc
);
1076 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1077 test_zero(string_length
);
1081 memcached_free(memc_clone
);
1083 return TEST_SUCCESS
;
1086 #define READ_THROUGH_VALUE "set for me"
1087 static memcached_return_t
read_through_trigger(memcached_st
*, // memc
1089 size_t, // key_length,
1090 memcached_result_st
*result
)
1092 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
1095 #ifndef __INTEL_COMPILER
1096 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1099 test_return_t
read_through(memcached_st
*memc
)
1101 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1103 size_t string_length
;
1105 memcached_return_t rc
;
1106 char *string
= memcached_get(memc
,
1107 test_literal_param(__func__
),
1108 &string_length
, &flags
, &rc
);
1110 test_compare(MEMCACHED_NOTFOUND
, rc
);
1111 test_false(string_length
);
1114 test_compare(MEMCACHED_SUCCESS
,
1115 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1117 string
= memcached_get(memc
,
1118 test_literal_param(__func__
),
1119 &string_length
, &flags
, &rc
);
1121 test_compare(MEMCACHED_SUCCESS
, rc
);
1122 test_compare(sizeof(READ_THROUGH_VALUE
) -1, string_length
);
1123 test_compare(0, string
[sizeof(READ_THROUGH_VALUE
) -1]);
1124 test_strcmp(READ_THROUGH_VALUE
, string
);
1127 string
= memcached_get(memc
,
1128 test_literal_param(__func__
),
1129 &string_length
, &flags
, &rc
);
1131 test_compare(MEMCACHED_SUCCESS
, rc
);
1133 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1134 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1135 test_strcmp(READ_THROUGH_VALUE
, string
);
1138 return TEST_SUCCESS
;
1141 test_return_t
set_test2(memcached_st
*memc
)
1143 for (uint32_t x
= 0; x
< 10; x
++)
1145 test_compare(return_value_based_on_buffering(memc
),
1147 test_literal_param("foo"),
1148 test_literal_param("train in the brain"),
1149 time_t(0), uint32_t(0)));
1152 return TEST_SUCCESS
;
1155 test_return_t
set_test3(memcached_st
*memc
)
1157 size_t value_length
= 8191;
1159 libtest::vchar_t value
;
1160 value
.reserve(value_length
);
1161 for (uint32_t x
= 0; x
< value_length
; x
++)
1163 value
.push_back(char(x
% 127));
1166 /* The dump test relies on there being at least 32 items in memcached */
1167 for (uint32_t x
= 0; x
< 32; x
++)
1171 snprintf(key
, sizeof(key
), "foo%u", x
);
1173 uint64_t query_id
= memcached_query_id(memc
);
1174 test_compare(return_value_based_on_buffering(memc
),
1175 memcached_set(memc
, key
, strlen(key
),
1176 &value
[0], value
.size(),
1177 time_t(0), uint32_t(0)));
1178 test_compare(query_id
+1, memcached_query_id(memc
));
1181 return TEST_SUCCESS
;
1184 test_return_t
mget_end(memcached_st
*memc
)
1186 const char *keys
[]= { "foo", "foo2" };
1187 size_t lengths
[]= { 3, 4 };
1188 const char *values
[]= { "fjord", "41" };
1191 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1193 test_compare(MEMCACHED_SUCCESS
,
1195 keys
[x
], lengths
[x
],
1196 values
[x
], strlen(values
[x
]),
1197 time_t(0), uint32_t(0)));
1201 size_t string_length
;
1204 // retrieve both via mget
1205 test_compare(MEMCACHED_SUCCESS
,
1206 memcached_mget(memc
,
1208 test_array_length(keys
)));
1210 char key
[MEMCACHED_MAX_KEY
];
1212 memcached_return_t rc
;
1214 // this should get both
1215 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1217 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1219 test_compare(MEMCACHED_SUCCESS
, rc
);
1221 if (key_length
== 4)
1226 test_compare(string_length
, strlen(values
[val
]));
1227 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1231 // this should indicate end
1232 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1233 test_compare(MEMCACHED_END
, rc
);
1237 test_compare(MEMCACHED_SUCCESS
,
1238 memcached_mget(memc
, keys
, lengths
, 1));
1240 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1241 test_compare(key_length
, lengths
[0]);
1242 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1243 test_compare(string_length
, strlen(values
[0]));
1244 test_true(strncmp(values
[0], string
, string_length
) == 0);
1245 test_compare(MEMCACHED_SUCCESS
, rc
);
1248 // this should indicate end
1249 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1250 test_compare(MEMCACHED_END
, rc
);
1253 return TEST_SUCCESS
;
1256 /* Do not copy the style of this code, I just access hosts to testthis function */
1257 test_return_t
stats_servername_test(memcached_st
*memc
)
1259 memcached_stat_st memc_stat
;
1260 memcached_server_instance_st instance
=
1261 memcached_server_instance_by_position(memc
, 0);
1263 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1265 return TEST_SKIPPED
;
1268 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1269 memcached_server_name(instance
),
1270 memcached_server_port(instance
)));
1272 return TEST_SUCCESS
;
1275 test_return_t
increment_test(memcached_st
*memc
)
1277 uint64_t new_number
;
1279 test_compare(MEMCACHED_SUCCESS
,
1281 test_literal_param("number"),
1282 test_literal_param("0"),
1283 (time_t)0, (uint32_t)0));
1285 test_compare(MEMCACHED_SUCCESS
,
1286 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1287 test_compare(uint64_t(1), new_number
);
1289 test_compare(MEMCACHED_SUCCESS
,
1290 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1291 test_compare(uint64_t(2), new_number
);
1293 return TEST_SUCCESS
;
1296 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1298 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1300 uint64_t new_number
;
1301 uint64_t initial
= 0;
1303 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1305 test_compare(MEMCACHED_SUCCESS
,
1306 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1307 test_compare(new_number
, initial
);
1309 test_compare(MEMCACHED_SUCCESS
,
1310 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1311 test_compare(new_number
, (initial
+1));
1313 return TEST_SUCCESS
;
1316 test_return_t
decrement_test(memcached_st
*memc
)
1318 test_compare(return_value_based_on_buffering(memc
),
1320 test_literal_param(__func__
),
1321 test_literal_param("3"),
1322 time_t(0), uint32_t(0)));
1324 // Make sure we flush the value we just set
1325 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1327 uint64_t new_number
;
1328 test_compare(MEMCACHED_SUCCESS
,
1329 memcached_decrement(memc
,
1330 test_literal_param(__func__
),
1332 test_compare(uint64_t(2), new_number
);
1334 test_compare(MEMCACHED_SUCCESS
,
1335 memcached_decrement(memc
,
1336 test_literal_param(__func__
),
1338 test_compare(uint64_t(1), new_number
);
1340 return TEST_SUCCESS
;
1343 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1345 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1347 uint64_t initial
= 3;
1349 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1351 uint64_t new_number
;
1352 test_compare(MEMCACHED_SUCCESS
,
1353 memcached_decrement_with_initial(memc
,
1354 test_literal_param(__func__
),
1357 test_compare(new_number
, initial
);
1359 test_compare(MEMCACHED_SUCCESS
,
1360 memcached_decrement_with_initial(memc
,
1361 test_literal_param(__func__
),
1364 test_compare(new_number
, (initial
- 1));
1366 return TEST_SUCCESS
;
1369 test_return_t
increment_by_key_test(memcached_st
*memc
)
1371 const char *master_key
= "foo";
1372 const char *key
= "number";
1373 const char *value
= "0";
1375 test_compare(return_value_based_on_buffering(memc
),
1376 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1378 value
, strlen(value
),
1379 time_t(0), uint32_t(0)));
1381 // Make sure we flush the value we just set
1382 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1384 uint64_t new_number
;
1385 test_compare(MEMCACHED_SUCCESS
,
1386 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1387 key
, strlen(key
), 1, &new_number
));
1388 test_compare(uint64_t(1), new_number
);
1390 test_compare(MEMCACHED_SUCCESS
,
1391 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1392 key
, strlen(key
), 1, &new_number
));
1393 test_compare(uint64_t(2), new_number
);
1395 return TEST_SUCCESS
;
1398 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1400 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1402 uint64_t new_number
;
1403 const char *master_key
= "foo";
1404 const char *key
= "number";
1405 uint64_t initial
= 0;
1407 test_compare(MEMCACHED_SUCCESS
,
1408 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1410 1, initial
, 0, &new_number
));
1411 test_compare(new_number
, initial
);
1413 test_compare(MEMCACHED_SUCCESS
,
1414 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1416 1, initial
, 0, &new_number
));
1417 test_compare(new_number
, (initial
+1));
1419 return TEST_SUCCESS
;
1422 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1424 uint64_t new_number
;
1425 const char *value
= "3";
1427 test_compare(return_value_based_on_buffering(memc
),
1428 memcached_set_by_key(memc
,
1429 test_literal_param("foo"),
1430 test_literal_param("number"),
1431 value
, strlen(value
),
1432 (time_t)0, (uint32_t)0));
1434 test_compare(MEMCACHED_SUCCESS
,
1435 memcached_decrement_by_key(memc
,
1436 test_literal_param("foo"),
1437 test_literal_param("number"),
1439 test_compare(uint64_t(2), new_number
);
1441 test_compare(MEMCACHED_SUCCESS
,
1442 memcached_decrement_by_key(memc
,
1443 test_literal_param("foo"),
1444 test_literal_param("number"),
1446 test_compare(uint64_t(1), new_number
);
1448 return TEST_SUCCESS
;
1451 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1453 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1455 uint64_t new_number
;
1456 uint64_t initial
= 3;
1458 test_compare(MEMCACHED_SUCCESS
,
1459 memcached_decrement_with_initial_by_key(memc
,
1460 test_literal_param("foo"),
1461 test_literal_param("number"),
1462 1, initial
, 0, &new_number
));
1463 test_compare(new_number
, initial
);
1465 test_compare(MEMCACHED_SUCCESS
,
1466 memcached_decrement_with_initial_by_key(memc
,
1467 test_literal_param("foo"),
1468 test_literal_param("number"),
1469 1, initial
, 0, &new_number
));
1470 test_compare(new_number
, (initial
- 1));
1472 return TEST_SUCCESS
;
1474 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1476 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1478 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1480 test_compare(return_value_based_on_buffering(memc
),
1482 test_literal_param("number"),
1483 test_literal_param("0"),
1484 (time_t)0, (uint32_t)0));
1486 uint64_t new_number
;
1487 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1488 test_literal_param("number"),
1490 test_compare(uint64_t(1), new_number
);
1492 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1493 test_literal_param("number"),
1495 test_compare(uint64_t(2), new_number
);
1497 return TEST_SUCCESS
;
1500 test_return_t
quit_test(memcached_st
*memc
)
1502 const char *value
= "sanford and sun";
1504 test_compare(return_value_based_on_buffering(memc
),
1506 test_literal_param(__func__
),
1507 value
, strlen(value
),
1508 time_t(10), uint32_t(3)));
1509 memcached_quit(memc
);
1511 test_compare(return_value_based_on_buffering(memc
),
1513 test_literal_param(__func__
),
1514 value
, strlen(value
),
1515 time_t(50), uint32_t(9)));
1517 return TEST_SUCCESS
;
1520 test_return_t
mget_result_test(memcached_st
*memc
)
1522 const char *keys
[]= {"fudge", "son", "food"};
1523 size_t key_length
[]= {5, 3, 4};
1525 memcached_result_st results_obj
;
1526 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1528 test_true(&results_obj
== results
);
1530 /* We need to empty the server before continueing test */
1531 test_compare(MEMCACHED_SUCCESS
,
1532 memcached_flush(memc
, 0));
1534 test_compare(MEMCACHED_SUCCESS
,
1535 memcached_mget(memc
, keys
, key_length
, 3));
1537 memcached_return_t rc
;
1538 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1543 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1544 test_false(results
);
1545 test_compare(MEMCACHED_NOTFOUND
, rc
);
1547 for (uint32_t x
= 0; x
< 3; x
++)
1549 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1550 keys
[x
], key_length
[x
],
1551 (time_t)50, (uint32_t)9);
1552 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1555 test_compare(MEMCACHED_SUCCESS
,
1556 memcached_mget(memc
, keys
, key_length
, 3));
1558 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1561 test_true(&results_obj
== results
);
1562 test_compare(MEMCACHED_SUCCESS
, rc
);
1563 test_memcmp(memcached_result_key_value(results
),
1564 memcached_result_value(results
),
1565 memcached_result_length(results
));
1566 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1569 memcached_result_free(&results_obj
);
1571 return TEST_SUCCESS
;
1574 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1576 const char *keys
[]= {"fudge", "son", "food"};
1577 size_t key_length
[]= {5, 3, 4};
1579 memcached_result_st
*results
;
1581 /* We need to empty the server before continueing test */
1582 test_compare(MEMCACHED_SUCCESS
,
1583 memcached_flush(memc
, 0));
1585 test_compare(MEMCACHED_SUCCESS
,
1586 memcached_mget(memc
, keys
, key_length
, 3));
1588 memcached_return_t rc
;
1589 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1593 test_false(results
);
1594 test_compare(MEMCACHED_NOTFOUND
, rc
);
1596 for (uint32_t x
= 0; x
< 3; x
++)
1598 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1599 keys
[x
], key_length
[x
],
1600 (time_t)50, (uint32_t)9);
1601 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1604 test_compare(MEMCACHED_SUCCESS
,
1605 memcached_mget(memc
, keys
, key_length
, 3));
1608 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1611 test_compare(MEMCACHED_SUCCESS
, rc
);
1612 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1613 test_memcmp(memcached_result_key_value(results
),
1614 memcached_result_value(results
),
1615 memcached_result_length(results
));
1616 memcached_result_free(results
);
1620 return TEST_SUCCESS
;
1623 test_return_t
mget_result_function(memcached_st
*memc
)
1625 const char *keys
[]= {"fudge", "son", "food"};
1626 size_t key_length
[]= {5, 3, 4};
1628 memcached_execute_fn callbacks
[1];
1630 for (uint32_t x
= 0; x
< 3; x
++)
1632 test_compare(return_value_based_on_buffering(memc
),
1633 memcached_set(memc
, keys
[x
], key_length
[x
],
1634 keys
[x
], key_length
[x
],
1635 time_t(50), uint32_t(9)));
1637 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1638 memcached_quit(memc
);
1640 test_compare(MEMCACHED_SUCCESS
,
1641 memcached_mget(memc
, keys
, key_length
, 3));
1643 callbacks
[0]= &callback_counter
;
1646 test_compare(MEMCACHED_SUCCESS
,
1647 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1649 test_compare(size_t(3), counter
);
1651 return TEST_SUCCESS
;
1654 test_return_t
mget_test(memcached_st
*memc
)
1656 const char *keys
[]= {"fudge", "son", "food"};
1657 size_t key_length
[]= {5, 3, 4};
1659 char return_key
[MEMCACHED_MAX_KEY
];
1660 size_t return_key_length
;
1662 size_t return_value_length
;
1664 test_compare(MEMCACHED_SUCCESS
,
1665 memcached_mget(memc
, keys
, key_length
, 3));
1668 memcached_return_t rc
;
1669 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1670 &return_value_length
, &flags
, &rc
)))
1672 test_true(return_value
);
1674 test_false(return_value
);
1675 test_zero(return_value_length
);
1676 test_compare(MEMCACHED_NOTFOUND
, rc
);
1678 for (uint32_t x
= 0; x
< 3; x
++)
1680 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1681 keys
[x
], key_length
[x
],
1682 (time_t)50, (uint32_t)9);
1683 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1685 test_compare(MEMCACHED_SUCCESS
,
1686 memcached_mget(memc
, keys
, key_length
, 3));
1689 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1690 &return_value_length
, &flags
, &rc
)))
1692 test_true(return_value
);
1693 test_compare(MEMCACHED_SUCCESS
, rc
);
1694 if (not memc
->_namespace
)
1696 test_compare(return_key_length
, return_value_length
);
1697 test_memcmp(return_value
, return_key
, return_value_length
);
1703 return TEST_SUCCESS
;
1706 test_return_t
mget_execute(memcached_st
*original_memc
)
1708 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1710 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1713 keys_st
keys(20480);
1715 /* First add all of the items.. */
1716 char blob
[1024] = {0};
1718 for (size_t x
= 0; x
< keys
.size(); ++x
)
1720 uint64_t query_id
= memcached_query_id(memc
);
1721 memcached_return_t rc
= memcached_add(memc
,
1722 keys
.key_at(x
), keys
.length_at(x
),
1725 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1726 test_compare(query_id
+1, memcached_query_id(memc
));
1729 /* Try to get all of them with a large multiget */
1731 memcached_execute_fn callbacks
[]= { &callback_counter
};
1732 test_compare(MEMCACHED_SUCCESS
,
1733 memcached_mget_execute(memc
,
1734 keys
.keys_ptr(), keys
.lengths_ptr(),
1735 keys
.size(), callbacks
, &counter
, 1));
1738 uint64_t query_id
= memcached_query_id(memc
);
1739 test_compare(MEMCACHED_SUCCESS
,
1740 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1741 test_compare(query_id
, memcached_query_id(memc
));
1743 /* Verify that we got all of the items */
1744 test_compare(keys
.size(), counter
);
1747 memcached_free(memc
);
1749 return TEST_SUCCESS
;
1752 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1753 static pairs_st
*global_pairs
= NULL
;
1755 test_return_t
key_setup(memcached_st
*memc
)
1757 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1759 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1761 return TEST_SUCCESS
;
1764 test_return_t
key_teardown(memcached_st
*)
1766 pairs_free(global_pairs
);
1769 return TEST_SUCCESS
;
1772 test_return_t
block_add_regression(memcached_st
*memc
)
1774 /* First add all of the items.. */
1775 for (ptrdiff_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1777 libtest::vchar_t blob
;
1778 libtest::vchar::make(blob
, 1024);
1780 memcached_return_t rc
= memcached_add_by_key(memc
,
1781 test_literal_param("bob"),
1782 global_pairs
[x
].key
, global_pairs
[x
].key_length
,
1783 &blob
[0], blob
.size(),
1784 time_t(0), uint32_t(0));
1785 if (rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
)
1787 Error
<< memcached_last_error_message(memc
);
1788 return TEST_SKIPPED
;
1790 test_compare(*memc
, MEMCACHED_SUCCESS
);
1791 test_compare(rc
, MEMCACHED_SUCCESS
);
1794 return TEST_SUCCESS
;
1797 test_return_t
binary_add_regression(memcached_st
*memc
)
1799 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1800 return block_add_regression(memc
);
1803 test_return_t
get_stats_keys(memcached_st
*memc
)
1807 memcached_stat_st memc_stat
;
1808 memcached_return_t rc
;
1810 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1811 test_compare(MEMCACHED_SUCCESS
, rc
);
1812 for (ptr
= stat_list
; *ptr
; ptr
++)
1817 return TEST_SUCCESS
;
1820 test_return_t
version_string_test(memcached_st
*)
1822 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1824 return TEST_SUCCESS
;
1827 test_return_t
get_stats(memcached_st
*memc
)
1829 memcached_return_t rc
;
1831 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1832 test_compare(MEMCACHED_SUCCESS
, rc
);
1833 test_true(memc_stat
);
1835 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1837 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1838 test_compare(MEMCACHED_SUCCESS
, rc
);
1839 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1844 memcached_stat_free(NULL
, memc_stat
);
1846 return TEST_SUCCESS
;
1849 test_return_t
add_host_test(memcached_st
*memc
)
1851 char servername
[]= "0.example.com";
1853 memcached_return_t rc
;
1854 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1855 test_compare(1U, memcached_server_list_count(servers
));
1857 for (unsigned int x
= 2; x
< 20; x
++)
1859 char buffer
[SMALL_STRING_LEN
];
1861 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1862 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1864 test_compare(MEMCACHED_SUCCESS
, rc
);
1865 test_compare(x
, memcached_server_list_count(servers
));
1868 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1869 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1871 memcached_server_list_free(servers
);
1873 return TEST_SUCCESS
;
1876 test_return_t
regression_1048945_TEST(memcached_st
*)
1878 memcached_return status
;
1880 memcached_server_st
* list
= memcached_server_list_append_with_weight(NULL
, "a", 11211, 0, &status
);
1881 test_compare(status
, MEMCACHED_SUCCESS
);
1883 list
= memcached_server_list_append_with_weight(list
, "b", 11211, 0, &status
);
1884 test_compare(status
, MEMCACHED_SUCCESS
);
1886 list
= memcached_server_list_append_with_weight(list
, "c", 11211, 0, &status
);
1887 test_compare(status
, MEMCACHED_SUCCESS
);
1889 memcached_st
* memc
= memcached_create(NULL
);
1891 status
= memcached_server_push(memc
, list
);
1892 memcached_server_list_free(list
);
1893 test_compare(status
, MEMCACHED_SUCCESS
);
1895 memcached_server_instance_st server
= memcached_server_by_key(memc
, test_literal_param(__func__
), &status
);
1897 test_compare(status
, MEMCACHED_SUCCESS
);
1899 memcached_free(memc
);
1901 return TEST_SUCCESS
;
1904 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1906 memcached_return_t rc
;
1908 const char *key
= "not_found";
1909 size_t key_length
= test_literal_param_size("not_found");
1911 test_compare(MEMCACHED_SUCCESS
,
1912 memcached_mget(memc
, &key
, &key_length
, 1));
1914 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1916 test_compare(MEMCACHED_NOTFOUND
, rc
);
1918 memcached_result_free(result
);
1920 return TEST_SUCCESS
;
1923 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1925 return MEMCACHED_SUCCESS
;
1928 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1930 return MEMCACHED_SUCCESS
;
1933 test_return_t
callback_test(memcached_st
*memc
)
1935 /* Test User Data */
1939 memcached_return_t rc
;
1941 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1942 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1943 test_true(*test_ptr
== x
);
1946 /* Test Clone Callback */
1948 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1949 void *clone_cb_ptr
= *(void **)&clone_cb
;
1950 void *temp_function
= NULL
;
1952 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
1953 memcached_return_t rc
;
1954 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1955 test_true(temp_function
== clone_cb_ptr
);
1956 test_compare(MEMCACHED_SUCCESS
, rc
);
1959 /* Test Cleanup Callback */
1961 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
1962 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1963 void *temp_function
= NULL
;
1964 memcached_return_t rc
;
1966 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
1967 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1968 test_true(temp_function
== cleanup_cb_ptr
);
1971 return TEST_SUCCESS
;
1974 /* We don't test the behavior itself, we test the switches */
1975 test_return_t
behavior_test(memcached_st
*memc
)
1977 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
1978 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
1980 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
1981 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
1983 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
1984 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1986 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
1987 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
1989 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
1990 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
1992 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
1993 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1995 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
1996 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1998 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2000 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2002 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2003 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2004 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2006 return TEST_SUCCESS
;
2009 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2011 test_compare(MEMCACHED_DEPRECATED
,
2012 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2014 // Platform dependent
2016 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2020 return TEST_SUCCESS
;
2024 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2026 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2027 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2029 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2031 if (memcached_success(rc
))
2040 return TEST_SUCCESS
;
2044 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2046 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2047 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2049 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2051 if (memcached_success(rc
))
2060 return TEST_SUCCESS
;
2063 /* Make sure we behave properly if server list has no values */
2064 test_return_t
user_supplied_bug4(memcached_st
*memc
)
2066 const char *keys
[]= {"fudge", "son", "food"};
2067 size_t key_length
[]= {5, 3, 4};
2069 /* Here we free everything before running a bunch of mget tests */
2070 memcached_servers_reset(memc
);
2073 /* We need to empty the server before continueing test */
2074 test_compare(MEMCACHED_NO_SERVERS
,
2075 memcached_flush(memc
, 0));
2077 test_compare(MEMCACHED_NO_SERVERS
,
2078 memcached_mget(memc
, keys
, key_length
, 3));
2081 unsigned int keys_returned
;
2082 memcached_return_t rc
;
2083 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2084 test_compare(MEMCACHED_NOTFOUND
, rc
);
2085 test_zero(keys_returned
);
2088 for (uint32_t x
= 0; x
< 3; x
++)
2090 test_compare(MEMCACHED_NO_SERVERS
,
2091 memcached_set(memc
, keys
[x
], key_length
[x
],
2092 keys
[x
], key_length
[x
],
2093 (time_t)50, (uint32_t)9));
2096 test_compare(MEMCACHED_NO_SERVERS
,
2097 memcached_mget(memc
, keys
, key_length
, 3));
2101 char return_key
[MEMCACHED_MAX_KEY
];
2102 memcached_return_t rc
;
2103 size_t return_key_length
;
2104 size_t return_value_length
;
2107 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2108 &return_value_length
, &flags
, &rc
)))
2110 test_true(return_value
);
2111 test_compare(MEMCACHED_SUCCESS
, rc
);
2112 test_true(return_key_length
== return_value_length
);
2113 test_memcmp(return_value
, return_key
, return_value_length
);
2119 return TEST_SUCCESS
;
2122 #define VALUE_SIZE_BUG5 1048064
2123 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2125 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2126 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2128 size_t value_length
;
2130 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2132 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2134 insert_data
[x
]= (signed char)rand();
2137 test_compare(MEMCACHED_SUCCESS
,
2138 memcached_flush(memc
, 0));
2140 memcached_return_t rc
;
2141 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2142 test_compare(MEMCACHED_SUCCESS
,
2143 memcached_mget(memc
, keys
, key_length
, 4));
2146 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2147 test_compare(MEMCACHED_NOTFOUND
, rc
);
2150 for (uint32_t x
= 0; x
< 4; x
++)
2152 test_compare(MEMCACHED_SUCCESS
,
2153 memcached_set(memc
, keys
[x
], key_length
[x
],
2154 insert_data
, VALUE_SIZE_BUG5
,
2155 (time_t)0, (uint32_t)0));
2158 for (uint32_t x
= 0; x
< 10; x
++)
2160 value
= memcached_get(memc
, keys
[0], key_length
[0],
2161 &value_length
, &flags
, &rc
);
2162 test_compare(rc
, MEMCACHED_SUCCESS
);
2166 test_compare(MEMCACHED_SUCCESS
,
2167 memcached_mget(memc
, keys
, key_length
, 4));
2169 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2170 test_compare(4U, count
);
2172 delete [] insert_data
;
2174 return TEST_SUCCESS
;
2177 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2179 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2180 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2181 char return_key
[MEMCACHED_MAX_KEY
];
2182 size_t return_key_length
;
2184 size_t value_length
;
2186 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2188 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2190 insert_data
[x
]= (signed char)rand();
2193 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2195 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2197 // We will now confirm that memcached_mget() returns success, but we will
2198 // then check to make sure that no actual keys are returned.
2199 test_compare(MEMCACHED_SUCCESS
,
2200 memcached_mget(memc
, keys
, key_length
, 4));
2202 memcached_return_t rc
;
2204 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2205 &value_length
, &flags
, &rc
)))
2210 test_compare(MEMCACHED_NOTFOUND
, rc
);
2212 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2214 test_compare(MEMCACHED_SUCCESS
,
2215 memcached_set(memc
, keys
[x
], key_length
[x
],
2216 insert_data
, VALUE_SIZE_BUG5
,
2217 (time_t)0, (uint32_t)0));
2219 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2221 for (uint32_t x
= 0; x
< 2; x
++)
2223 value
= memcached_get(memc
, keys
[0], key_length
[0],
2224 &value_length
, &flags
, &rc
);
2228 test_compare(MEMCACHED_SUCCESS
,
2229 memcached_mget(memc
, keys
, key_length
, 4));
2230 /* We test for purge of partial complete fetches */
2231 for (count
= 3; count
; count
--)
2233 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2234 &value_length
, &flags
, &rc
);
2235 test_compare(MEMCACHED_SUCCESS
, rc
);
2236 test_memcmp(value
, insert_data
, value_length
);
2237 test_true(value_length
);
2241 delete [] insert_data
;
2243 return TEST_SUCCESS
;
2246 test_return_t
user_supplied_bug8(memcached_st
*)
2248 memcached_return_t rc
;
2250 memcached_st
*memc_clone
;
2252 memcached_server_st
*servers
;
2253 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";
2255 servers
= memcached_servers_parse(server_list
);
2258 mine
= memcached_create(NULL
);
2259 rc
= memcached_server_push(mine
, servers
);
2260 test_compare(MEMCACHED_SUCCESS
, rc
);
2261 memcached_server_list_free(servers
);
2264 memc_clone
= memcached_clone(NULL
, mine
);
2266 memcached_quit(mine
);
2267 memcached_quit(memc_clone
);
2270 memcached_free(mine
);
2271 memcached_free(memc_clone
);
2273 return TEST_SUCCESS
;
2276 /* Test flag store/retrieve */
2277 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2279 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2280 test_true(insert_data
);
2282 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2284 insert_data
[x
]= (signed char)rand();
2287 memcached_flush(memc
, 0);
2289 const char *keys
= "036790384900";
2290 size_t key_length
= strlen(keys
);
2291 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2292 insert_data
, VALUE_SIZE_BUG5
,
2295 memcached_return_t rc
;
2296 size_t value_length
;
2298 char *value
= memcached_get(memc
, keys
, key_length
,
2299 &value_length
, &flags
, &rc
);
2300 test_compare(245U, flags
);
2304 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2306 char return_key
[MEMCACHED_MAX_KEY
];
2307 size_t return_key_length
;
2309 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2310 &value_length
, &flags
, &rc
);
2311 test_compare(uint32_t(245), flags
);
2314 delete [] insert_data
;
2317 return TEST_SUCCESS
;
2320 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2322 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2323 size_t key_length
[3];
2327 char return_key
[MEMCACHED_MAX_KEY
];
2328 size_t return_key_length
;
2330 size_t return_value_length
;
2333 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2334 key_length
[1]= strlen("fudge&*@#");
2335 key_length
[2]= strlen("for^#@&$not");
2338 for (unsigned int x
= 0; x
< 3; x
++)
2340 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2341 keys
[x
], key_length
[x
],
2342 (time_t)50, (uint32_t)9);
2343 test_compare(MEMCACHED_SUCCESS
, rc
);
2346 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2347 test_compare(MEMCACHED_SUCCESS
, rc
);
2349 /* We need to empty the server before continueing test */
2350 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2351 &return_value_length
, &flags
, &rc
)) != NULL
)
2353 test_true(return_value
);
2357 test_compare(3U, count
);
2359 return TEST_SUCCESS
;
2362 /* We are testing with aggressive timeout to get failures */
2363 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2365 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
2367 size_t value_length
= 512;
2368 unsigned int set
= 1;
2369 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2371 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2372 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2373 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2375 libtest::vchar_t value
;
2376 value
.reserve(value_length
);
2377 for (uint32_t x
= 0; x
< value_length
; x
++)
2379 value
.push_back(char(x
% 127));
2382 for (unsigned int x
= 1; x
<= 100000; ++x
)
2384 memcached_return_t rc
= memcached_set(mclone
,
2385 test_literal_param("foo"),
2386 &value
[0], value
.size(),
2389 test_true((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2390 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
));
2392 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2398 memcached_free(mclone
);
2400 return TEST_SUCCESS
;
2404 We are looking failures in the async protocol
2406 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2408 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2410 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2411 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2412 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2414 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2417 libtest::vchar_t value
;
2419 for (unsigned int x
= 0; x
< 512; x
++)
2421 value
.push_back(char(x
% 127));
2424 for (unsigned int x
= 1; x
<= 100000; ++x
)
2426 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2430 memcached_free(mclone
);
2432 return TEST_SUCCESS
;
2436 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2438 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2440 memcached_return_t rc
;
2442 size_t value_length
;
2444 uint64_t number_value
;
2446 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2447 &value_length
, &flags
, &rc
);
2449 test_compare(MEMCACHED_NOTFOUND
, rc
);
2451 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2454 /* The binary protocol will set the key if it doesn't exist */
2455 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2457 test_compare(MEMCACHED_SUCCESS
, rc
);
2461 test_compare(MEMCACHED_NOTFOUND
, rc
);
2464 test_compare(MEMCACHED_SUCCESS
,
2465 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2467 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2471 test_compare(MEMCACHED_SUCCESS
,
2472 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2473 test_compare(2UL, number_value
);
2475 return TEST_SUCCESS
;
2479 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2480 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2482 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2484 char key
[] = "key34567890";
2486 char commandFirst
[]= "set key34567890 0 0 ";
2487 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2488 size_t commandLength
;
2490 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2492 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2494 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2496 char *overflow
= new (std::nothrow
) char[testSize
];
2497 test_true(overflow
);
2499 memset(overflow
, 'x', testSize
);
2500 test_compare(MEMCACHED_SUCCESS
,
2501 memcached_set(memc
, key
, strlen(key
),
2502 overflow
, testSize
, 0, 0));
2506 return TEST_SUCCESS
;
2511 Test values of many different sizes
2512 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2513 set key34567890 0 0 8169 \r\n
2514 is sent followed by buffer of size 8169, followed by 8169
2516 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2518 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2520 libtest::vchar_t value
;
2521 value
.reserve(18000);
2522 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2524 value
.push_back((char) (x
% 127));
2527 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2529 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2530 &value
[0], current_length
,
2531 (time_t)0, (uint32_t)0);
2532 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2534 size_t string_length
;
2536 char *string
= memcached_get(memc
, test_literal_param("foo"),
2537 &string_length
, &flags
, &rc
);
2539 test_compare(MEMCACHED_SUCCESS
, rc
);
2540 test_compare(string_length
, current_length
);
2542 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2543 test_memcmp(string
, &value
[0], string_length
);
2548 return TEST_SUCCESS
;
2552 Look for zero length value problems
2554 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2556 for (uint32_t x
= 0; x
< 2; x
++)
2558 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2560 (time_t)0, (uint32_t)0);
2562 test_compare(MEMCACHED_SUCCESS
, rc
);
2566 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2567 &length
, &flags
, &rc
);
2569 test_compare(MEMCACHED_SUCCESS
, rc
);
2574 value
= memcached_get(memc
, test_literal_param("mykey"),
2575 &length
, &flags
, &rc
);
2577 test_compare(MEMCACHED_SUCCESS
, rc
);
2583 return TEST_SUCCESS
;
2586 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2587 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2589 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2591 (time_t)0, UINT32_MAX
));
2596 memcached_return_t rc
;
2597 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2598 &length
, &flags
, &rc
);
2600 test_compare(MEMCACHED_SUCCESS
, rc
);
2603 test_compare(flags
, UINT32_MAX
);
2605 return TEST_SUCCESS
;
2608 #if !defined(__sun) && !defined(__OpenBSD__)
2609 /* Check the validity of chinese key*/
2610 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2612 const char *key
= "豆瓣";
2613 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2614 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2615 value
, strlen(value
),
2618 test_compare(MEMCACHED_SUCCESS
, rc
);
2622 char *value2
= memcached_get(memc
, key
, strlen(key
),
2623 &length
, &flags
, &rc
);
2625 test_compare(length
, strlen(value
));
2626 test_compare(MEMCACHED_SUCCESS
, rc
);
2627 test_memcmp(value
, value2
, length
);
2630 return TEST_SUCCESS
;
2638 test_return_t
user_supplied_bug19(memcached_st
*)
2640 memcached_return_t res
;
2642 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2644 memcached_server_instance_st server
= memcached_server_by_key(memc
, "a", 1, &res
);
2647 memcached_free(memc
);
2649 return TEST_SUCCESS
;
2652 /* CAS test from Andei */
2653 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2655 const char *key
= "abc";
2656 size_t key_len
= strlen("abc");
2658 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2660 test_compare(MEMCACHED_SUCCESS
,
2662 test_literal_param("abc"),
2663 test_literal_param("foobar"),
2664 (time_t)0, (uint32_t)0));
2666 test_compare(MEMCACHED_SUCCESS
,
2667 memcached_mget(memc
, &key
, &key_len
, 1));
2669 memcached_result_st result_obj
;
2670 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2673 memcached_result_create(memc
, &result_obj
);
2674 memcached_return_t status
;
2675 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2678 test_compare(MEMCACHED_SUCCESS
, status
);
2680 memcached_result_free(result
);
2682 return TEST_SUCCESS
;
2685 /* Large mget() of missing keys with binary proto
2687 * If many binary quiet commands (such as getq's in an mget) fill the output
2688 * buffer and the server chooses not to respond, memcached_flush hangs. See
2689 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2692 /* sighandler_t function that always asserts false */
2693 static __attribute__((noreturn
)) void fail(int)
2699 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2704 return TEST_SKIPPED
;
2706 void (*oldalarm
)(int);
2708 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2709 test_true(memc_clone
);
2711 /* only binproto uses getq for mget */
2712 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2714 /* empty the cache to ensure misses (hence non-responses) */
2715 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2717 keys_st
keys(key_count
);
2719 oldalarm
= signal(SIGALRM
, fail
);
2722 test_compare_got(MEMCACHED_SUCCESS
,
2723 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2724 memcached_last_error_message(memc_clone
));
2727 signal(SIGALRM
, oldalarm
);
2729 memcached_return_t rc
;
2731 char return_key
[MEMCACHED_MAX_KEY
];
2732 size_t return_key_length
;
2734 size_t return_value_length
;
2735 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2736 &return_value_length
, &flags
, &rc
)))
2738 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2740 test_compare(MEMCACHED_NOTFOUND
, rc
);
2741 test_zero(return_value_length
);
2742 test_zero(return_key_length
);
2743 test_false(return_key
[0]);
2744 test_false(return_value
);
2746 memcached_free(memc_clone
);
2748 return TEST_SUCCESS
;
2752 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2754 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2756 /* should work as of r580 */
2757 test_compare(TEST_SUCCESS
,
2758 _user_supplied_bug21(memc
, 10));
2760 /* should fail as of r580 */
2761 test_compare(TEST_SUCCESS
,
2762 _user_supplied_bug21(memc
, 1000));
2764 return TEST_SUCCESS
;
2767 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2769 memcached_st
*memc
= memcached_create(NULL
);
2773 test_compare(MEMCACHED_SUCCESS
,
2774 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2776 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2777 test_compare(value
, uint64_t(1));
2779 test_compare(MEMCACHED_SUCCESS
,
2780 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2782 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2783 test_true(value
== MEMCACHED_HASH_MD5
);
2786 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2788 memcached_server_st
*server_pool
;
2789 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");
2790 memcached_server_push(memc
, server_pool
);
2792 // @todo this needs to be refactored to actually test something.
2795 if ((fp
= fopen("ketama_keys.txt", "w")))
2799 printf("cannot write to file ketama_keys.txt");
2800 return TEST_FAILURE
;
2803 for (int x
= 0; x
< 10000; x
++)
2806 snprintf(key
, sizeof(key
), "%d", x
);
2808 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2809 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2810 in_port_t port
= memc
->hosts
[server_idx
].port
;
2811 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2812 memcached_server_instance_st instance
=
2813 memcached_server_instance_by_position(memc
, host_index
);
2817 memcached_server_list_free(server_pool
);
2818 memcached_free(memc
);
2820 return TEST_SUCCESS
;
2824 test_return_t
result_static(memcached_st
*memc
)
2826 memcached_result_st result
;
2827 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
2828 test_false(result
.options
.is_allocated
);
2829 test_true(memcached_is_initialized(&result
));
2830 test_true(result_ptr
);
2831 test_true(result_ptr
== &result
);
2833 memcached_result_free(&result
);
2835 test_false(result
.options
.is_allocated
);
2836 test_false(memcached_is_initialized(&result
));
2838 return TEST_SUCCESS
;
2841 test_return_t
result_alloc(memcached_st
*memc
)
2843 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
2844 test_true(result_ptr
);
2845 test_true(result_ptr
->options
.is_allocated
);
2846 test_true(memcached_is_initialized(result_ptr
));
2847 memcached_result_free(result_ptr
);
2849 return TEST_SUCCESS
;
2853 test_return_t
add_host_test1(memcached_st
*memc
)
2855 memcached_return_t rc
;
2856 char servername
[]= "0.example.com";
2858 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2860 test_compare(1U, memcached_server_list_count(servers
));
2862 for (uint32_t x
= 2; x
< 20; x
++)
2864 char buffer
[SMALL_STRING_LEN
];
2866 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
2867 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2869 test_compare(MEMCACHED_SUCCESS
, rc
);
2870 test_compare(x
, memcached_server_list_count(servers
));
2873 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2874 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2876 memcached_server_list_free(servers
);
2878 return TEST_SUCCESS
;
2882 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
2886 #ifdef HARD_MALLOC_TESTS
2887 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
2895 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
2899 #ifdef HARD_MALLOC_TESTS
2900 void *ret
= malloc(size
+ 8);
2903 ret
= (void*)((caddr_t
)ret
+ 8);
2906 void *ret
= malloc(size
);
2911 memset(ret
, 0xff, size
);
2918 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
2920 #ifdef HARD_MALLOC_TESTS
2921 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
2922 void *nmem
= realloc(real_ptr
, size
+ 8);
2927 ret
= (void*)((caddr_t
)nmem
+ 8);
2933 return realloc(mem
, size
);
2938 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
2940 #ifdef HARD_MALLOC_TESTS
2941 void *mem
= my_malloc(ptr
, nelem
* size
);
2944 memset(mem
, 0, nelem
* size
);
2950 return calloc(nelem
, size
);
2954 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
2956 memcached_return_t rc
;
2957 const char *key
= "mine";
2960 /* Make sure be default none exists */
2961 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2963 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2965 /* Test a clean set */
2966 test_compare(MEMCACHED_SUCCESS
,
2967 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2969 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2971 test_memcmp(value
, key
, 4);
2972 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2974 /* Test that we can turn it off */
2975 test_compare(MEMCACHED_SUCCESS
,
2976 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
2978 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2980 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2982 /* Now setup for main test */
2983 test_compare(MEMCACHED_SUCCESS
,
2984 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2986 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2988 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2989 test_memcmp(value
, key
, 4);
2991 /* Set to Zero, and then Set to something too large */
2994 memset(long_key
, 0, 255);
2996 test_compare(MEMCACHED_SUCCESS
,
2997 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
2999 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3001 test_compare(MEMCACHED_SUCCESS
, rc
);
3003 /* Test a long key for failure */
3004 /* TODO, extend test to determine based on setting, what result should be */
3005 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3006 test_compare(MEMCACHED_SUCCESS
,
3007 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3009 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3010 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3011 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3012 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3014 /* Test for a bad prefix, but with a short key */
3015 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3016 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3018 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3019 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3022 return TEST_SUCCESS
;
3025 test_return_t
set_namespace(memcached_st
*memc
)
3027 memcached_return_t rc
;
3028 const char *key
= "mine";
3031 // Make sure we default to a null namespace
3032 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3034 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3036 /* Test a clean set */
3037 test_compare(MEMCACHED_SUCCESS
,
3038 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3040 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3042 test_memcmp(value
, key
, 4);
3043 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3045 return TEST_SUCCESS
;
3048 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3050 test_return_if(pre_binary(memc
));
3051 test_return_if(set_namespace(memc
));
3053 return TEST_SUCCESS
;
3056 #ifdef MEMCACHED_ENABLE_DEPRECATED
3057 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3059 void *test_ptr
= NULL
;
3062 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
3063 cb_ptr
= *(void **)&malloc_cb
;
3064 memcached_return_t rc
;
3066 test_compare(MEMCACHED_SUCCESS
,
3067 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3068 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3069 test_compare(MEMCACHED_SUCCESS
, rc
);
3070 test_true(test_ptr
== cb_ptr
);
3074 memcached_realloc_fn realloc_cb
=
3075 (memcached_realloc_fn
)my_realloc
;
3076 cb_ptr
= *(void **)&realloc_cb
;
3077 memcached_return_t rc
;
3079 test_compare(MEMCACHED_SUCCESS
,
3080 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3081 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3082 test_compare(MEMCACHED_SUCCESS
, rc
);
3083 test_true(test_ptr
== cb_ptr
);
3087 memcached_free_fn free_cb
=
3088 (memcached_free_fn
)my_free
;
3089 cb_ptr
= *(void **)&free_cb
;
3090 memcached_return_t rc
;
3092 test_compare(MEMCACHED_SUCCESS
,
3093 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3094 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3095 test_compare(MEMCACHED_SUCCESS
, rc
);
3096 test_true(test_ptr
== cb_ptr
);
3099 return TEST_SUCCESS
;
3104 test_return_t
set_memory_alloc(memcached_st
*memc
)
3106 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3107 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3108 my_realloc
, my_calloc
, NULL
));
3110 test_compare(MEMCACHED_SUCCESS
,
3111 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3112 my_realloc
, my_calloc
, NULL
));
3114 memcached_malloc_fn mem_malloc
;
3115 memcached_free_fn mem_free
;
3116 memcached_realloc_fn mem_realloc
;
3117 memcached_calloc_fn mem_calloc
;
3118 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3119 &mem_realloc
, &mem_calloc
);
3121 test_true(mem_malloc
== my_malloc
);
3122 test_true(mem_realloc
== my_realloc
);
3123 test_true(mem_calloc
== my_calloc
);
3124 test_true(mem_free
== my_free
);
3126 return TEST_SUCCESS
;
3129 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3131 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
));
3132 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3135 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3140 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3142 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_CRC
)
3144 return TEST_SKIPPED
;
3147 return TEST_SUCCESS
;
3150 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3153 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT
);
3154 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3159 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT
));
3161 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
) != MEMCACHED_HASH_HSIEH
)
3163 return TEST_SKIPPED
;
3166 return TEST_SUCCESS
;
3169 test_return_t
enable_cas(memcached_st
*memc
)
3171 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3173 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true);
3175 return TEST_SUCCESS
;
3178 return TEST_SKIPPED
;
3181 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3183 memcached_version(memc
);
3185 memcached_server_instance_st instance
=
3186 memcached_server_instance_by_position(memc
, 0);
3188 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3189 or instance
->minor_version
> 2)
3191 return TEST_SUCCESS
;
3194 return TEST_SKIPPED
;
3197 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3199 const uint64_t timeout
= 100; // Not using, just checking that it sets
3201 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3203 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3205 return TEST_SUCCESS
;
3208 test_return_t
noreply_test(memcached_st
*memc
)
3210 test_compare(MEMCACHED_SUCCESS
,
3211 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3212 test_compare(MEMCACHED_SUCCESS
,
3213 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3214 test_compare(MEMCACHED_SUCCESS
,
3215 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3216 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3217 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3218 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3220 memcached_return_t ret
;
3221 for (int count
= 0; count
< 5; ++count
)
3223 for (size_t x
= 0; x
< 100; ++x
)
3225 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3226 int check_length
= snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3227 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3229 size_t len
= (size_t)check_length
;
3234 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3237 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3240 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3243 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3246 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3252 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3253 memcached_strerror(NULL
, ret
));
3257 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3258 ** API and is _ONLY_ done this way to verify that the library works the
3259 ** way it is supposed to do!!!!
3263 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3265 memcached_server_instance_st instance
=
3266 memcached_server_instance_by_position(memc
, x
);
3267 no_msg
+=(int)(instance
->cursor_active
);
3270 test_true(no_msg
== 0);
3272 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3275 ** Now validate that all items was set properly!
3277 for (size_t x
= 0; x
< 100; ++x
)
3281 int check_length
= snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3283 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3285 size_t len
= (size_t)check_length
;
3288 char* value
=memcached_get(memc
, key
, strlen(key
),
3289 &length
, &flags
, &ret
);
3290 // For the moment we will just go to the next key
3291 if (MEMCACHED_TIMEOUT
== ret
)
3295 test_true(ret
== MEMCACHED_SUCCESS
and value
!= NULL
);
3298 case 0: /* FALLTHROUGH */
3299 case 1: /* FALLTHROUGH */
3301 test_true(strncmp(value
, key
, len
) == 0);
3302 test_true(len
== length
);
3305 test_true(length
== len
* 2);
3308 test_true(length
== len
* 3);
3318 /* Try setting an illegal cas value (should not return an error to
3319 * the caller (because we don't expect a return message from the server)
3321 const char* keys
[]= {"0"};
3322 size_t lengths
[]= {1};
3325 memcached_result_st results_obj
;
3326 memcached_result_st
*results
;
3327 test_compare(MEMCACHED_SUCCESS
,
3328 memcached_mget(memc
, keys
, lengths
, 1));
3330 results
= memcached_result_create(memc
, &results_obj
);
3332 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3334 test_compare(MEMCACHED_SUCCESS
, ret
);
3335 uint64_t cas
= memcached_result_cas(results
);
3336 memcached_result_free(&results_obj
);
3338 test_compare(MEMCACHED_SUCCESS
,
3339 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3342 * The item will have a new cas value, so try to set it again with the old
3343 * value. This should fail!
3345 test_compare(MEMCACHED_SUCCESS
,
3346 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3347 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3348 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3349 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3352 return TEST_SUCCESS
;
3355 test_return_t
analyzer_test(memcached_st
*memc
)
3357 memcached_analysis_st
*report
;
3358 memcached_return_t rc
;
3360 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3361 test_compare(MEMCACHED_SUCCESS
, rc
);
3362 test_true(memc_stat
);
3364 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3365 test_compare(MEMCACHED_SUCCESS
, rc
);
3369 memcached_stat_free(NULL
, memc_stat
);
3371 return TEST_SUCCESS
;
3374 test_return_t
util_version_test(memcached_st
*memc
)
3376 test_compare(memcached_version(memc
), MEMCACHED_SUCCESS
);
3377 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3379 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3381 // We expect failure
3384 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3385 fprintf(stderr
, "\nDumping Server Information\n\n");
3386 memcached_server_fn callbacks
[1];
3388 callbacks
[0]= dump_server_information
;
3389 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3390 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3392 test_true(if_successful
== false);
3394 memcached_server_instance_st instance
=
3395 memcached_server_instance_by_position(memc
, 0);
3397 memcached_version(memc
);
3399 // We only use one binary when we test, so this should be just fine.
3400 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3401 test_true(if_successful
== true);
3403 if (instance
->micro_version
> 0)
3405 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3407 else if (instance
->minor_version
> 0)
3409 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3411 else if (instance
->major_version
> 0)
3413 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3416 test_true(if_successful
== true);
3418 if (instance
->micro_version
> 0)
3420 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3422 else if (instance
->minor_version
> 0)
3424 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3426 else if (instance
->major_version
> 0)
3428 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3431 test_true(if_successful
== false);
3433 return TEST_SUCCESS
;
3436 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3438 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3439 memcached_return_t rc
;
3440 memcached_server_instance_st instance
=
3441 memcached_server_instance_by_position(memc
, 0);
3443 // Test both the version that returns a code, and the one that does not.
3444 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3445 memcached_server_port(instance
) -1, NULL
) == -1);
3447 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3448 memcached_server_port(instance
) -1, &rc
) == -1);
3449 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3451 return TEST_SUCCESS
;
3455 test_return_t
getpid_test(memcached_st
*memc
)
3457 memcached_return_t rc
;
3458 memcached_server_instance_st instance
=
3459 memcached_server_instance_by_position(memc
, 0);
3461 // Test both the version that returns a code, and the one that does not.
3462 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3463 memcached_server_port(instance
), NULL
) > -1);
3465 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3466 memcached_server_port(instance
), &rc
) > -1);
3467 test_compare(MEMCACHED_SUCCESS
, rc
);
3469 return TEST_SUCCESS
;
3472 static memcached_return_t
ping_each_server(const memcached_st
*,
3473 memcached_server_instance_st instance
,
3476 // Test both the version that returns a code, and the one that does not.
3477 memcached_return_t rc
;
3478 if (libmemcached_util_ping(memcached_server_name(instance
),
3479 memcached_server_port(instance
), &rc
) == false)
3481 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d %s", memcached_server_name(instance
),
3482 memcached_server_port(instance
), memcached_strerror(NULL
, rc
));
3485 if (libmemcached_util_ping(memcached_server_name(instance
),
3486 memcached_server_port(instance
), NULL
) == false)
3488 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "%s:%d", memcached_server_name(instance
), memcached_server_port(instance
));
3491 return MEMCACHED_SUCCESS
;
3494 test_return_t
libmemcached_util_ping_TEST(memcached_st
*memc
)
3496 memcached_server_fn callbacks
[1]= { ping_each_server
};
3497 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
3499 return TEST_SUCCESS
;
3504 test_return_t
hash_sanity_test (memcached_st
*memc
)
3508 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3509 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3510 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3511 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3512 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3513 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3514 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3515 #ifdef HAVE_HSIEH_HASH
3516 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3518 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3519 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3520 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3522 return TEST_SUCCESS
;
3526 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3528 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3530 test_compare(MEMCACHED_SUCCESS
,
3531 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3532 (uint64_t)MEMCACHED_HASH_HSIEH
));
3534 return TEST_SUCCESS
;
3537 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3539 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3541 test_compare(MEMCACHED_SUCCESS
,
3542 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3544 return TEST_SUCCESS
;
3547 test_return_t
one_at_a_time_run (memcached_st
*)
3552 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3554 test_compare(one_at_a_time_values
[x
],
3555 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3558 return TEST_SUCCESS
;
3561 test_return_t
md5_run (memcached_st
*)
3566 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3568 test_compare(md5_values
[x
],
3569 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3572 return TEST_SUCCESS
;
3575 test_return_t
crc_run (memcached_st
*)
3580 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3582 test_compare(crc_values
[x
],
3583 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3586 return TEST_SUCCESS
;
3589 test_return_t
fnv1_64_run (memcached_st
*)
3591 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3596 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3598 test_compare(fnv1_64_values
[x
],
3599 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3602 return TEST_SUCCESS
;
3605 test_return_t
fnv1a_64_run (memcached_st
*)
3607 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3612 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3614 test_compare(fnv1a_64_values
[x
],
3615 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3618 return TEST_SUCCESS
;
3621 test_return_t
fnv1_32_run (memcached_st
*)
3626 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3628 test_compare(fnv1_32_values
[x
],
3629 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3632 return TEST_SUCCESS
;
3635 test_return_t
fnv1a_32_run (memcached_st
*)
3640 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3642 test_compare(fnv1a_32_values
[x
],
3643 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3646 return TEST_SUCCESS
;
3649 test_return_t
hsieh_run (memcached_st
*)
3651 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3656 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3658 test_compare(hsieh_values
[x
],
3659 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3662 return TEST_SUCCESS
;
3665 test_return_t
murmur_run (memcached_st
*)
3667 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3669 #ifdef WORDS_BIGENDIAN
3670 (void)murmur_values
;
3671 return TEST_SKIPPED
;
3676 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3678 test_compare(murmur_values
[x
],
3679 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3682 return TEST_SUCCESS
;
3686 test_return_t
murmur3_TEST(hashkit_st
*)
3688 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR3
));
3690 #ifdef WORDS_BIGENDIAN
3691 (void)murmur3_values
;
3692 return TEST_SKIPPED
;
3697 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3699 test_compare(murmur3_values
[x
],
3700 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR3
));
3703 return TEST_SUCCESS
;
3707 test_return_t
jenkins_run (memcached_st
*)
3712 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3714 test_compare(jenkins_values
[x
],
3715 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3718 return TEST_SUCCESS
;
3721 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3723 return libhashkit_md5(string
, string_length
);
3726 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3728 return libhashkit_crc32(string
, string_length
);
3731 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3737 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3739 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};
3740 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};
3742 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3744 hashkit_clone(&new_kit
, kit
);
3745 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3747 memcached_set_hashkit(memc
, &new_kit
);
3750 Verify Setting the hash.
3752 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3756 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3757 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3762 Now check memcached_st.
3764 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3768 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3769 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3772 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3774 memcached_set_hashkit(memc
, &new_kit
);
3777 Verify Setting the hash.
3779 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3783 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3784 test_true(crc_values
[x
] == hash_val
);
3787 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3791 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3792 test_compare(crc_hosts
[x
], hash_val
);
3795 memcached_free(memc
);
3797 return TEST_SUCCESS
;
3801 Test case adapted from John Gorman <johngorman2@gmail.com>
3803 We are testing the error condition when we connect to a server via memcached_get()
3804 but find that the server is not available.
3806 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3810 memcached_return rc
;
3813 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3815 // See if memcached is reachable.
3816 char *value
= memcached_get(tl_memc_h
,
3817 test_literal_param(__func__
),
3822 test_true(memcached_failed(rc
));
3824 memcached_free(tl_memc_h
);
3826 return TEST_SUCCESS
;
3830 We connect to a server which exists, but search for a key that does not exist.
3832 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3836 memcached_return rc
;
3838 // See if memcached is reachable.
3839 char *value
= memcached_get(memc
,
3840 test_literal_param(__func__
),
3845 test_compare(MEMCACHED_NOTFOUND
, rc
);
3847 return TEST_SUCCESS
;
3851 Test case adapted from John Gorman <johngorman2@gmail.com>
3853 We are testing the error condition when we connect to a server via memcached_get_by_key()
3854 but find that the server is not available.
3856 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
3860 memcached_return rc
;
3863 memcached_st
*tl_memc_h
= memcached_create(NULL
);
3864 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
3865 memcached_server_push(tl_memc_h
, servers
);
3866 memcached_server_list_free(servers
);
3868 // See if memcached is reachable.
3869 char *value
= memcached_get_by_key(tl_memc_h
,
3870 test_literal_param(__func__
), // Key
3871 test_literal_param(__func__
), // Value
3876 test_true(memcached_failed(rc
));
3878 memcached_free(tl_memc_h
);
3880 return TEST_SUCCESS
;
3884 We connect to a server which exists, but search for a key that does not exist.
3886 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3890 memcached_return rc
;
3892 // See if memcached is reachable.
3893 char *value
= memcached_get_by_key(memc
,
3894 test_literal_param(__func__
), // Key
3895 test_literal_param(__func__
), // Value
3900 test_compare(MEMCACHED_NOTFOUND
, rc
);
3902 return TEST_SUCCESS
;
3905 test_return_t
regression_bug_434484(memcached_st
*memc
)
3907 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3909 test_compare(MEMCACHED_NOTSTORED
,
3910 memcached_append(memc
,
3911 test_literal_param(__func__
), // Key
3912 test_literal_param(__func__
), // Value
3915 libtest::vchar_t data
;
3916 data
.resize(2048 * 1024);
3917 test_compare(MEMCACHED_E2BIG
,
3919 test_literal_param(__func__
), // Key
3920 &data
[0], data
.size(), 0, 0));
3922 return TEST_SUCCESS
;
3925 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
3927 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
3929 memcached_return_t rc
;
3931 memcached_execute_fn callbacks
[]= { &callback_counter
};
3934 * I only want to hit only _one_ server so I know the number of requests I'm
3935 * sending in the pipleine to the server. Let's try to do a multiget of
3936 * 1024 (that should satisfy most users don't you think?). Future versions
3937 * will include a mget_execute function call if you need a higher number.
3939 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
3944 * Run two times.. the first time we should have 100% cache miss,
3945 * and the second time we should have 100% cache hits
3947 for (ptrdiff_t y
= 0; y
< 2; y
++)
3949 test_compare(MEMCACHED_SUCCESS
,
3950 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
3952 // One the first run we should get a NOT_FOUND, but on the second some data
3953 // should be returned.
3954 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
3955 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3959 /* The first iteration should give me a 100% cache miss. verify that*/
3960 char blob
[1024]= { 0 };
3962 test_false(counter
);
3964 for (size_t x
= 0; x
< keys
.size(); ++x
)
3966 rc
= memcached_add(memc
,
3967 keys
.key_at(x
), keys
.length_at(x
),
3968 blob
, sizeof(blob
), 0, 0);
3969 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3974 /* Verify that we received all of the key/value pairs */
3975 test_compare(counter
, keys
.size());
3979 memcached_free(memc
);
3981 return TEST_SUCCESS
;
3984 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
3986 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3988 return regression_bug_434843(memc
);
3991 test_return_t
regression_bug_421108(memcached_st
*memc
)
3993 memcached_return_t rc
;
3994 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3995 test_compare(MEMCACHED_SUCCESS
, rc
);
3997 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
3998 test_compare(MEMCACHED_SUCCESS
, rc
);
3999 test_true(bytes_str
);
4000 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4002 test_compare(MEMCACHED_SUCCESS
, rc
);
4003 test_true(bytes_read_str
);
4005 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4006 "bytes_written", &rc
);
4007 test_compare(MEMCACHED_SUCCESS
, rc
);
4008 test_true(bytes_written_str
);
4010 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4011 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4012 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4014 test_true(bytes
!= bytes_read
);
4015 test_true(bytes
!= bytes_written
);
4017 /* Release allocated resources */
4019 free(bytes_read_str
);
4020 free(bytes_written_str
);
4021 memcached_stat_free(NULL
, memc_stat
);
4023 return TEST_SUCCESS
;
4027 * The test case isn't obvious so I should probably document why
4028 * it works the way it does. Bug 442914 was caused by a bug
4029 * in the logic in memcached_purge (it did not handle the case
4030 * where the number of bytes sent was equal to the watermark).
4031 * In this test case, create messages so that we hit that case
4032 * and then disable noreply mode and issue a new command to
4033 * verify that it isn't stuck. If we change the format for the
4034 * delete command or the watermarks, we need to update this
4037 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
4039 test_skip(original_memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
4041 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
4043 for (uint32_t x
= 0; x
< 250; ++x
)
4046 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
4047 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4048 char error_buffer
[2048]= { 0 };
4049 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
4050 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
4053 // Delete, and then delete again to look for not found
4056 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
4057 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
4058 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4060 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
4061 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
4064 memcached_free(memc
);
4066 return TEST_SUCCESS
;
4069 test_return_t
regression_bug_447342(memcached_st
*memc
)
4071 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4073 return TEST_SKIPPED
;
4076 test_compare(MEMCACHED_SUCCESS
,
4077 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4081 for (size_t x
= 0; x
< keys
.size(); ++x
)
4083 test_compare(MEMCACHED_SUCCESS
,
4085 keys
.key_at(x
), keys
.length_at(x
), // Keys
4086 keys
.key_at(x
), keys
.length_at(x
), // Values
4091 ** We are using the quiet commands to store the replicas, so we need
4092 ** to ensure that all of them are processed before we can continue.
4093 ** In the test we go directly from storing the object to trying to
4094 ** receive the object from all of the different servers, so we
4095 ** could end up in a race condition (the memcached server hasn't yet
4096 ** processed the quiet command from the replication set when it process
4097 ** the request from the other client (created by the clone)). As a
4098 ** workaround for that we call memcached_quit to send the quit command
4099 ** to the server and wait for the response ;-) If you use the test code
4100 ** as an example for your own code, please note that you shouldn't need
4103 memcached_quit(memc
);
4105 /* Verify that all messages are stored, and we didn't stuff too much
4108 test_compare(MEMCACHED_SUCCESS
,
4109 memcached_mget(memc
,
4110 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4112 unsigned int counter
= 0;
4113 memcached_execute_fn callbacks
[]= { &callback_counter
};
4114 test_compare(MEMCACHED_SUCCESS
,
4115 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4117 /* Verify that we received all of the key/value pairs */
4118 test_compare(counter
, keys
.size());
4120 memcached_quit(memc
);
4122 * Don't do the following in your code. I am abusing the internal details
4123 * within the library, and this is not a supported interface.
4124 * This is to verify correct behavior in the library. Fake that two servers
4127 memcached_server_instance_st instance_one
= memcached_server_instance_by_position(memc
, 0);
4128 memcached_server_instance_st instance_two
= memcached_server_instance_by_position(memc
, 2);
4129 in_port_t port0
= instance_one
->port();
4130 in_port_t port2
= instance_two
->port();
4132 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4133 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4135 test_compare(MEMCACHED_SUCCESS
,
4136 memcached_mget(memc
,
4137 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4140 test_compare(MEMCACHED_SUCCESS
,
4141 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4142 test_compare(counter
, keys
.size());
4144 /* restore the memc handle */
4145 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4146 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4148 memcached_quit(memc
);
4150 /* Remove half of the objects */
4151 for (size_t x
= 0; x
< keys
.size(); ++x
)
4155 test_compare(MEMCACHED_SUCCESS
,
4156 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4160 memcached_quit(memc
);
4161 ((memcached_server_write_instance_st
)instance_one
)->port(0);
4162 ((memcached_server_write_instance_st
)instance_two
)->port(0);
4164 /* now retry the command, this time we should have cache misses */
4165 test_compare(MEMCACHED_SUCCESS
,
4166 memcached_mget(memc
,
4167 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4170 test_compare(MEMCACHED_SUCCESS
,
4171 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4172 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4174 /* restore the memc handle */
4175 ((memcached_server_write_instance_st
)instance_one
)->port(port0
);
4176 ((memcached_server_write_instance_st
)instance_two
)->port(port2
);
4178 return TEST_SUCCESS
;
4181 test_return_t
regression_bug_463297(memcached_st
*memc
)
4183 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4185 // Since we blocked timed delete, this test is no longer valid.
4187 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4188 test_true(memc_clone
);
4189 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4191 memcached_server_instance_st instance
=
4192 memcached_server_instance_by_position(memc_clone
, 0);
4194 if (instance
->major_version
> 1 ||
4195 (instance
->major_version
== 1 &&
4196 instance
->minor_version
> 2))
4198 /* Binary protocol doesn't support deferred delete */
4199 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4200 test_true(bin_clone
);
4201 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4202 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4203 memcached_free(bin_clone
);
4205 memcached_quit(memc_clone
);
4207 /* If we know the server version, deferred delete should fail
4208 * with invalid arguments */
4209 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4211 /* If we don't know the server version, we should get a protocol error */
4212 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4214 /* but there is a bug in some of the memcached servers (1.4) that treats
4215 * the counter as noreply so it doesn't send the proper error message
4217 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4219 /* And buffered mode should be disabled and we should get protocol error */
4220 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4221 rc
= memcached_delete(memc
, "foo", 3, 1);
4222 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4224 /* Same goes for noreply... */
4225 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4226 rc
= memcached_delete(memc
, "foo", 3, 1);
4227 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4229 /* but a normal request should go through (and be buffered) */
4230 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4231 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4233 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4234 /* unbuffered noreply should be success */
4235 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4236 /* unbuffered with reply should be not found... */
4237 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4238 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4241 memcached_free(memc_clone
);
4244 return TEST_SUCCESS
;
4248 /* Test memcached_server_get_last_disconnect
4249 * For a working server set, shall be NULL
4250 * For a set of non existing server, shall not be NULL
4252 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4254 memcached_return_t rc
;
4255 memcached_server_instance_st disconnected_server
;
4257 /* With the working set of server */
4258 const char *key
= "marmotte";
4259 const char *value
= "milka";
4261 memcached_reset_last_disconnected_server(memc
);
4262 test_false(memc
->last_disconnected_server
);
4263 rc
= memcached_set(memc
, key
, strlen(key
),
4264 value
, strlen(value
),
4265 (time_t)0, (uint32_t)0);
4266 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4268 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4269 test_false(disconnected_server
);
4271 /* With a non existing server */
4273 memcached_server_st
*servers
;
4275 const char *server_list
= "localhost:9";
4277 servers
= memcached_servers_parse(server_list
);
4279 mine
= memcached_create(NULL
);
4280 rc
= memcached_server_push(mine
, servers
);
4281 test_compare(MEMCACHED_SUCCESS
, rc
);
4282 memcached_server_list_free(servers
);
4285 rc
= memcached_set(mine
, key
, strlen(key
),
4286 value
, strlen(value
),
4287 (time_t)0, (uint32_t)0);
4288 test_true(memcached_failed(rc
));
4290 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4291 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4292 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4293 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4295 memcached_quit(mine
);
4296 memcached_free(mine
);
4298 return TEST_SUCCESS
;
4301 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4303 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4304 char buffer
[BUFSIZ
];
4306 test_compare(MEMCACHED_SUCCESS
,
4307 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4309 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4312 // We will just use the error strings as our keys
4313 uint32_t counter
= 100;
4316 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4318 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4319 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4320 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4322 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
4323 test_true(disconnected_server
);
4324 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4325 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4329 memcached_reset_last_disconnected_server(memc
);
4334 memcached_free(memc
);
4336 return TEST_SUCCESS
;
4339 test_return_t
test_verbosity(memcached_st
*memc
)
4341 memcached_verbosity(memc
, 3);
4343 return TEST_SUCCESS
;
4347 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
4348 const char *key
, size_t key_length
,
4349 const char *value
, size_t value_length
,
4359 return MEMCACHED_SUCCESS
;
4362 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4364 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4365 test_compare(MEMCACHED_SUCCESS
, rc
);
4367 test_compare(MEMCACHED_SUCCESS
,
4368 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4370 test_compare(MEMCACHED_SUCCESS
,
4371 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4373 test_compare(MEMCACHED_SUCCESS
,
4374 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4376 return TEST_SUCCESS
;
4380 * This test ensures that the failure counter isn't incremented during
4381 * normal termination of the memcached instance.
4383 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4385 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4387 /* Ensure that we are connected to the server by setting a value */
4388 memcached_return_t rc
= memcached_set(memc
,
4389 test_literal_param(__func__
), // Key
4390 test_literal_param(__func__
), // Value
4391 time_t(0), uint32_t(0));
4392 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4395 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4397 /* The test is to see that the memcached_quit doesn't increase the
4398 * the server failure conter, so let's ensure that it is zero
4399 * before sending quit
4401 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4403 memcached_quit(memc
);
4405 /* Verify that it memcached_quit didn't increment the failure counter
4406 * Please note that this isn't bullet proof, because an error could
4409 test_zero(instance
->server_failure_counter
);
4411 memcached_free(memc
);
4413 return TEST_SUCCESS
;
4417 * This tests ensures expected disconnections (for some behavior changes
4418 * for instance) do not wrongly increase failure counter
4420 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4422 /* Set value to force connection to the server */
4423 const char *key
= "marmotte";
4424 const char *value
= "milka";
4426 test_compare_hint(MEMCACHED_SUCCESS
,
4427 memcached_set(memc
, key
, strlen(key
),
4428 value
, strlen(value
),
4429 (time_t)0, (uint32_t)0),
4430 memcached_last_error_message(memc
));
4433 /* put failure limit to 1 */
4434 test_compare(MEMCACHED_SUCCESS
,
4435 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4437 /* Put a retry timeout to effectively activate failure_limit effect */
4438 test_compare(MEMCACHED_SUCCESS
,
4439 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4441 /* change behavior that triggers memcached_quit()*/
4442 test_compare(MEMCACHED_SUCCESS
,
4443 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4446 /* Check if we still are connected */
4448 size_t string_length
;
4449 memcached_return rc
;
4450 char *string
= memcached_get(memc
, key
, strlen(key
),
4451 &string_length
, &flags
, &rc
);
4453 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4457 return TEST_SUCCESS
;
4460 test_return_t
regression_996813_TEST(memcached_st
*)
4462 memcached_st
* memc
= memcached_create(NULL
);
4464 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
4465 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
4466 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4467 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4468 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1));
4469 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 300));
4470 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 30));
4472 // We will never connect to these servers
4473 in_port_t base_port
= 11211;
4474 for (size_t x
= 0; x
< 17; x
++)
4476 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", base_port
+x
));
4478 test_compare(6U, memcached_generate_hash(memc
, test_literal_param("SZ6hu0SHweFmpwpc0w2R")));
4479 test_compare(1U, memcached_generate_hash(memc
, test_literal_param("SQCK9eiCf53YxHWnYA.o")));
4480 test_compare(9U, memcached_generate_hash(memc
, test_literal_param("SUSDkGXuuZC9t9VhMwa.")));
4481 test_compare(0U, memcached_generate_hash(memc
, test_literal_param("SnnqnJARfaCNT679iAF_")));
4483 memcached_free(memc
);
4485 return TEST_SUCCESS
;
4490 * Test that ensures mget_execute does not end into recursive calls that finally fails
4492 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4496 return TEST_SKIPPED
; // My MAC can't handle this test
4499 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4502 * I only want to hit _one_ server so I know the number of requests I'm
4503 * sending in the pipeline.
4505 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4508 keys_st
keys(20480);
4510 /* First add all of the items.. */
4511 char blob
[1024]= { 0 };
4512 for (size_t x
= 0; x
< keys
.size(); ++x
)
4514 memcached_return rc
= memcached_set(memc
,
4515 keys
.key_at(x
), keys
.length_at(x
),
4516 blob
, sizeof(blob
), 0, 0);
4517 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4522 /* Try to get all of them with a large multiget */
4524 memcached_execute_function callbacks
[]= { &callback_counter
};
4525 memcached_return_t rc
= memcached_mget_execute(memc
,
4526 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4527 callbacks
, &counter
, 1);
4528 test_compare(MEMCACHED_SUCCESS
, rc
);
4530 char* the_value
= NULL
;
4531 char the_key
[MEMCACHED_MAX_KEY
];
4532 size_t the_key_length
;
4533 size_t the_value_length
;
4537 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4539 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4545 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4548 test_compare(MEMCACHED_END
, rc
);
4550 /* Verify that we got all of the items */
4551 test_compare(counter
, keys
.size());
4554 memcached_free(memc
);
4556 return TEST_SUCCESS
;
4559 test_return_t
regression_1021819_TEST(memcached_st
*original
)
4561 memcached_st
*memc
= memcached_clone(NULL
, original
);
4564 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 2000000), MEMCACHED_SUCCESS
);
4565 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 3000000), MEMCACHED_SUCCESS
);
4567 memcached_return_t rc
;
4570 test_literal_param(__func__
),
4573 test_compare(rc
, MEMCACHED_NOTFOUND
);
4575 memcached_free(memc
);
4577 return TEST_SUCCESS
;
4580 test_return_t
regression_bug_583031(memcached_st
*)
4582 memcached_st
*memc
= memcached_create(NULL
);
4584 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
4586 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
4587 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4588 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4589 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4590 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4591 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4593 memcached_return_t rc
;
4597 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4601 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
4603 memcached_free(memc
);
4605 return TEST_SUCCESS
;
4608 test_return_t
regression_bug_581030(memcached_st
*)
4611 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4612 test_false(local_stat
);
4614 memcached_stat_free(NULL
, NULL
);
4617 return TEST_SUCCESS
;
4620 #define regression_bug_655423_COUNT 6000
4621 test_return_t
regression_bug_655423(memcached_st
*memc
)
4623 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4624 memc
= NULL
; // Just to make sure it is not used
4629 return TEST_SKIPPED
;
4632 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4633 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4634 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4635 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4637 memset(payload
, int('x'), sizeof(payload
));
4639 keys_st
keys(regression_bug_655423_COUNT
);
4641 for (size_t x
= 0; x
< keys
.size(); x
++)
4643 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4646 payload
, sizeof(payload
), 0, 0));
4649 for (size_t x
= 0; x
< keys
.size(); x
++)
4651 size_t value_length
;
4652 memcached_return_t rc
;
4653 char *value
= memcached_get(clone
,
4656 &value_length
, NULL
, &rc
);
4658 if (rc
== MEMCACHED_NOTFOUND
)
4661 test_zero(value_length
);
4665 test_compare(MEMCACHED_SUCCESS
, rc
);
4667 test_compare(100LLU, value_length
);
4671 test_compare(MEMCACHED_SUCCESS
,
4672 memcached_mget(clone
,
4673 keys
.keys_ptr(), keys
.lengths_ptr(),
4677 memcached_result_st
*result
= NULL
;
4678 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4680 test_compare(size_t(100), memcached_result_length(result
));
4684 test_true(count
> 100); // If we don't get back atleast this, something is up
4686 memcached_free(clone
);
4688 return TEST_SUCCESS
;
4692 * Test that ensures that buffered set to not trigger problems during io_flush
4694 #define regression_bug_490520_COUNT 200480
4695 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4697 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4699 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4700 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4701 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4702 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4703 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4705 /* First add all of the items.. */
4706 char blob
[3333] = {0};
4707 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4710 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4712 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4713 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4716 memcached_free(memc
);
4718 return TEST_SUCCESS
;
4721 test_return_t
regression_1009493_TEST(memcached_st
*)
4723 memcached_st
* memc
= memcached_create(NULL
);
4725 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, true));
4727 memcached_st
* clone
= memcached_clone(NULL
, memc
);
4730 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
),
4731 memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
4733 memcached_free(memc
);
4734 memcached_free(clone
);
4736 return TEST_SUCCESS
;
4739 test_return_t
regression_994772_TEST(memcached_st
* memc
)
4741 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4743 test_compare(MEMCACHED_SUCCESS
,
4745 test_literal_param(__func__
), // Key
4746 test_literal_param(__func__
), // Value
4747 time_t(0), uint32_t(0)));
4749 const char *keys
[] = { __func__
};
4750 size_t key_length
[]= { strlen(__func__
) };
4751 test_compare(MEMCACHED_SUCCESS
,
4752 memcached_mget(memc
, keys
, key_length
, 1));
4754 memcached_return_t rc
;
4755 memcached_result_st
*results
= memcached_fetch_result(memc
, NULL
, &rc
);
4757 test_compare(MEMCACHED_SUCCESS
, rc
);
4759 test_strcmp(__func__
, memcached_result_value(results
));
4760 uint64_t cas_value
= memcached_result_cas(results
);
4761 test_true(cas_value
);
4763 char* take_value
= memcached_result_take_value(results
);
4764 test_strcmp(__func__
, take_value
);
4767 memcached_result_free(results
);
4769 // Bad cas value, sanity check
4770 test_true(cas_value
!= 9999);
4771 test_compare(MEMCACHED_END
,
4773 test_literal_param(__func__
), // Key
4774 test_literal_param(__FILE__
), // Value
4775 time_t(0), uint32_t(0), 9999));
4777 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
4778 "different", strlen("different"), // Key
4779 test_literal_param(__FILE__
), // Value
4780 time_t(0), uint32_t(0)));
4782 return TEST_SUCCESS
;
4785 test_return_t
regression_bug_854604(memcached_st
*)
4789 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4791 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4793 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4794 test_compare(buffer
[0], 0);
4796 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4797 test_true(strlen(buffer
));
4799 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4800 test_true(strlen(buffer
));
4802 return TEST_SUCCESS
;
4805 static void die_message(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4807 fprintf(stderr
, "Iteration #%u: ", it
);
4809 if (error
== MEMCACHED_ERRNO
)
4811 fprintf(stderr
, "system error %d from %s: %s\n",
4812 errno
, what
, strerror(errno
));
4816 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4817 memcached_strerror(mc
, error
));
4821 #define TEST_CONSTANT_CREATION 200
4823 test_return_t
regression_bug_(memcached_st
*memc
)
4825 const char *remote_server
;
4828 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4830 return TEST_SKIPPED
;
4833 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4835 memcached_st
* mc
= memcached_create(NULL
);
4836 memcached_return rc
;
4838 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4839 if (rc
!= MEMCACHED_SUCCESS
)
4841 die_message(mc
, rc
, "memcached_behavior_set", x
);
4844 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4845 if (rc
!= MEMCACHED_SUCCESS
)
4847 die_message(mc
, rc
, "memcached_behavior_set", x
);
4850 rc
= memcached_server_add(mc
, remote_server
, 0);
4851 if (rc
!= MEMCACHED_SUCCESS
)
4853 die_message(mc
, rc
, "memcached_server_add", x
);
4856 const char *set_key
= "akey";
4857 const size_t set_key_len
= strlen(set_key
);
4858 const char *set_value
= "a value";
4859 const size_t set_value_len
= strlen(set_value
);
4861 if (rc
== MEMCACHED_SUCCESS
)
4865 size_t get_value_len
;
4867 uint32_t get_value_flags
;
4869 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
4870 &get_value_flags
, &rc
);
4871 if (rc
!= MEMCACHED_SUCCESS
)
4873 die_message(mc
, rc
, "memcached_get", x
);
4879 (get_value_len
!= set_value_len
4880 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
4882 fprintf(stderr
, "Values don't match?\n");
4883 rc
= MEMCACHED_FAILURE
;
4889 rc
= memcached_set(mc
,
4890 set_key
, set_key_len
,
4891 set_value
, set_value_len
,
4895 if (rc
!= MEMCACHED_SUCCESS
)
4897 die_message(mc
, rc
, "memcached_set", x
);
4904 if (rc
!= MEMCACHED_SUCCESS
)
4910 return TEST_SUCCESS
;
4913 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
4915 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
4918 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4921 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
4922 memcached_server_port(instance
), NULL
)) > -1);
4925 test_compare(MEMCACHED_SUCCESS
,
4927 test_literal_param(__func__
), // Keys
4928 test_literal_param(__func__
), // Values
4930 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
4932 test_compare(MEMCACHED_CONNECTION_FAILURE
,
4934 test_literal_param(__func__
), // Keys
4935 test_literal_param(__func__
), // Values
4938 memcached_free(memc
);
4940 return TEST_SUCCESS
;