1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 #include <libtest/test.hpp>
41 #if defined(HAVE_LIBUUID) && HAVE_LIBUUID
42 #include <uuid/uuid.h>
49 #include <libmemcached-1.0/memcached.h>
50 #include <libmemcached/is.h>
51 #include <libmemcached/server_instance.h>
53 #include <libhashkit-1.0/hashkit.h>
58 #include <semaphore.h>
62 #include <sys/types.h>
67 #include <libtest/server.h>
69 #include "clients/generator.h"
71 #define SMALL_STRING_LEN 1024
73 #include <libtest/test.hpp>
75 using namespace libtest
;
77 #include <libmemcached/util.h>
79 #include "tests/hash_results.h"
81 #include "tests/libmemcached-1.0/callback_counter.h"
82 #include "tests/libmemcached-1.0/fetch_all_results.h"
83 #include "tests/libmemcached-1.0/mem_functions.h"
84 #include "tests/libmemcached-1.0/setup_and_teardowns.h"
85 #include "tests/print.h"
86 #include "tests/debug.h"
88 #define UUID_STRING_MAXLENGTH 36
90 #include "tests/keys.hpp"
92 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
95 If no options are given, copy over at least the binary flag.
97 char options_buffer
[1024]= { 0 };
100 if (memcached_is_binary(original_memc
))
102 snprintf(options_buffer
, sizeof(options_buffer
), "--BINARY");
107 * I only want to hit _one_ server so I know the number of requests I'm
108 * sending in the pipeline.
110 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
112 char server_string
[1024];
113 int server_string_length
;
114 if (instance
->type
== MEMCACHED_CONNECTION_UNIX_SOCKET
)
118 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\" %s",
119 memcached_server_name(instance
), options
);
123 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--SOCKET=\"%s\"",
124 memcached_server_name(instance
));
131 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
132 memcached_server_name(instance
), int(memcached_server_port(instance
)),
137 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
138 memcached_server_name(instance
), int(memcached_server_port(instance
)));
142 if (server_string_length
<= 0)
147 char errror_buffer
[1024];
148 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, errror_buffer
, sizeof(errror_buffer
))))
150 Error
<< "Failed to parse (" << server_string
<< ") " << errror_buffer
;
154 return memcached(server_string
, server_string_length
);
158 test_return_t
init_test(memcached_st
*not_used
)
163 (void)memcached_create(&memc
);
164 memcached_free(&memc
);
169 #define TEST_PORT_COUNT 7
170 in_port_t test_ports
[TEST_PORT_COUNT
];
172 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
173 const memcached_server_st
*server
,
177 size_t bigger
= *((size_t *)(context
));
179 fatal_assert(bigger
<= memcached_server_port(server
));
180 *((size_t *)(context
))= memcached_server_port(server
);
182 return MEMCACHED_SUCCESS
;
185 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
186 const memcached_server_st
*instance
,
190 FILE *stream
= (FILE *)context
;
193 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
194 memcached_server_name(instance
),
195 memcached_server_port(instance
),
196 instance
->major_version
,
197 instance
->minor_version
,
198 instance
->micro_version
);
200 return MEMCACHED_SUCCESS
;
203 test_return_t
server_sort_test(memcached_st
*ptr
)
205 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
207 memcached_return_t rc
;
208 memcached_server_fn callbacks
[1];
209 memcached_st
*local_memc
;
212 local_memc
= memcached_create(NULL
);
213 test_true(local_memc
);
214 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
216 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
218 test_ports
[x
]= (in_port_t
)random() % 64000;
219 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
220 test_compare(memcached_server_count(local_memc
), x
+1);
222 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
224 test_compare(MEMCACHED_SUCCESS
, rc
);
227 callbacks
[0]= server_display_function
;
228 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
231 memcached_free(local_memc
);
236 test_return_t
server_sort2_test(memcached_st
*ptr
)
238 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
239 memcached_server_fn callbacks
[1];
240 memcached_st
*local_memc
;
241 memcached_server_instance_st instance
;
244 local_memc
= memcached_create(NULL
);
245 test_true(local_memc
);
246 test_compare(MEMCACHED_SUCCESS
,
247 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
249 test_compare(MEMCACHED_SUCCESS
,
250 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
251 instance
= memcached_server_instance_by_position(local_memc
, 0);
252 test_compare(in_port_t(43043), memcached_server_port(instance
));
254 test_compare(MEMCACHED_SUCCESS
,
255 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
257 instance
= memcached_server_instance_by_position(local_memc
, 0);
258 test_compare(in_port_t(43042), memcached_server_port(instance
));
260 instance
= memcached_server_instance_by_position(local_memc
, 1);
261 test_compare(in_port_t(43043), memcached_server_port(instance
));
263 callbacks
[0]= server_display_function
;
264 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
267 memcached_free(local_memc
);
272 test_return_t
memcached_server_remove_test(memcached_st
*)
274 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";
277 test_compare(MEMCACHED_SUCCESS
,
278 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
279 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
282 memcached_server_fn callbacks
[1];
283 callbacks
[0]= server_print_callback
;
284 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
286 memcached_free(memc
);
291 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
292 const memcached_server_st
*server
,
296 uint32_t x
= *((uint32_t *)(context
));
298 if (! (test_ports
[x
] == server
->port
))
300 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
301 return MEMCACHED_FAILURE
;
304 *((uint32_t *)(context
))= ++x
;
306 return MEMCACHED_SUCCESS
;
309 test_return_t
server_unsort_test(memcached_st
*ptr
)
311 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
312 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
313 memcached_server_fn callbacks
[1];
314 memcached_st
*local_memc
;
317 local_memc
= memcached_create(NULL
);
318 test_true(local_memc
);
320 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
322 test_ports
[x
]= (in_port_t
)(random() % 64000);
323 test_compare(MEMCACHED_SUCCESS
,
324 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
325 test_compare(memcached_server_count(local_memc
), x
+1);
327 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
331 callbacks
[0]= server_display_unsort_function
;
332 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
334 /* Now we sort old data! */
335 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
336 callbacks
[0]= server_display_function
;
337 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
340 memcached_free(local_memc
);
345 test_return_t
allocation_test(memcached_st
*not_used
)
349 memc
= memcached_create(NULL
);
351 memcached_free(memc
);
356 test_return_t
clone_test(memcached_st
*memc
)
360 memcached_st
*memc_clone
;
361 memc_clone
= memcached_clone(NULL
, NULL
);
362 test_true(memc_clone
);
363 memcached_free(memc_clone
);
366 /* Can we init from null? */
368 memcached_st
*memc_clone
;
369 memc_clone
= memcached_clone(NULL
, memc
);
370 test_true(memc_clone
);
373 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
374 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
375 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
376 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
379 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
380 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
381 test_true(memc_clone
->distribution
== memc
->distribution
);
382 { // Test all of the flags
383 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
384 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
385 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
386 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
387 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
388 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
389 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
390 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
391 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
392 test_true(memc_clone
->flags
.reply
== memc
->flags
.reply
);
393 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
394 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
395 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
397 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
398 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
399 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
400 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
401 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
402 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
403 test_true(memc_clone
->on_clone
== memc
->on_clone
);
404 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
405 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
406 test_true(memc_clone
->recv_size
== memc
->recv_size
);
407 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
408 test_true(memc_clone
->send_size
== memc
->send_size
);
409 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
410 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
411 test_true(memc_clone
->user_data
== memc
->user_data
);
413 memcached_free(memc_clone
);
416 /* Can we init from struct? */
418 memcached_st declared_clone
;
419 memcached_st
*memc_clone
;
420 memset(&declared_clone
, 0 , sizeof(memcached_st
));
421 memc_clone
= memcached_clone(&declared_clone
, NULL
);
422 test_true(memc_clone
);
423 memcached_free(memc_clone
);
426 /* Can we init from struct? */
428 memcached_st declared_clone
;
429 memcached_st
*memc_clone
;
430 memset(&declared_clone
, 0 , sizeof(memcached_st
));
431 memc_clone
= memcached_clone(&declared_clone
, memc
);
432 test_true(memc_clone
);
433 memcached_free(memc_clone
);
439 test_return_t
userdata_test(memcached_st
*memc
)
442 test_false(memcached_set_user_data(memc
, foo
));
443 test_true(memcached_get_user_data(memc
) == foo
);
444 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
449 test_return_t
connection_test(memcached_st
*memc
)
451 test_compare(MEMCACHED_SUCCESS
,
452 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
457 test_return_t
libmemcached_string_behavior_test(memcached_st
*)
459 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
461 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
463 test_compare(37, int(MEMCACHED_BEHAVIOR_MAX
));
468 test_return_t
libmemcached_string_distribution_test(memcached_st
*)
470 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
472 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
474 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
479 test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
481 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
482 982370485U, 1263635348U, 4242906218U, 3829656100U,
483 1891735253U, 334139633U, 2257084983U, 3351789013U,
484 13199785U, 2542027183U, 1097051614U, 199566778U,
485 2748246961U, 2465192557U, 1664094137U, 2405439045U,
486 1842224848U, 692413798U, 3479807801U, 919913813U,
487 4269430871U, 610793021U, 527273862U, 1437122909U,
488 2300930706U, 2943759320U, 674306647U, 2400528935U,
489 54481931U, 4186304426U, 1741088401U, 2979625118U,
490 4159057246U, 3425930182U, 2593724503U, 1868899624U,
491 1769812374U, 2302537950U, 1110330676U, 3365377466U,
492 1336171666U, 3021258493U, 2334992265U, 3861994737U,
493 3582734124U, 3365377466U };
495 // You have updated the memcache_error messages but not updated docs/tests.
496 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
499 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
500 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
501 MEMCACHED_HASH_JENKINS
);
502 if (values
[rc
] != hash_val
)
504 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
505 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
507 test_compare(values
[rc
], hash_val
);
509 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
514 test_return_t
set_test(memcached_st
*memc
)
516 memcached_return_t rc
= memcached_set(memc
,
517 test_literal_param("foo"),
518 test_literal_param("when we sanitize"),
519 time_t(0), (uint32_t)0);
520 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
525 test_return_t
append_test(memcached_st
*memc
)
527 memcached_return_t rc
;
528 const char *in_value
= "we";
532 test_compare(MEMCACHED_SUCCESS
,
533 memcached_flush(memc
, 0));
535 test_compare(MEMCACHED_SUCCESS
,
537 test_literal_param(__func__
),
538 in_value
, strlen(in_value
),
539 time_t(0), uint32_t(0)));
541 test_compare(MEMCACHED_SUCCESS
,
542 memcached_append(memc
,
543 test_literal_param(__func__
),
544 " the", strlen(" the"),
545 time_t(0), uint32_t(0)));
547 test_compare(MEMCACHED_SUCCESS
,
548 memcached_append(memc
,
549 test_literal_param(__func__
),
550 " people", strlen(" people"),
551 time_t(0), uint32_t(0)));
553 char *out_value
= memcached_get(memc
,
554 test_literal_param(__func__
),
555 &value_length
, &flags
, &rc
);
556 test_memcmp(out_value
, "we the people", strlen("we the people"));
557 test_compare(strlen("we the people"), value_length
);
558 test_compare(MEMCACHED_SUCCESS
, rc
);
564 test_return_t
append_binary_test(memcached_st
*memc
)
566 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
568 test_compare(MEMCACHED_SUCCESS
,
569 memcached_flush(memc
, 0));
571 test_compare(MEMCACHED_SUCCESS
,
573 test_literal_param(__func__
),
575 time_t(0), uint32_t(0)));
578 for (uint32_t x
= 0; store_list
[x
] ; x
++)
580 test_compare(MEMCACHED_SUCCESS
,
581 memcached_append(memc
,
582 test_literal_param(__func__
),
583 (char *)&store_list
[x
], sizeof(uint32_t),
584 time_t(0), uint32_t(0)));
590 memcached_return_t rc
;
591 uint32_t *value
= (uint32_t *)memcached_get(memc
,
592 test_literal_param(__func__
),
593 &value_length
, &flags
, &rc
);
594 test_compare(value_length
, sizeof(uint32_t) * count
);
595 test_compare(MEMCACHED_SUCCESS
, rc
);
597 for (uint32_t counter
= count
, *ptr
= value
; counter
; counter
--)
599 test_compare(*ptr
, store_list
[count
- counter
]);
607 test_return_t
memcached_mget_mixed_memcached_get_TEST(memcached_st
*memc
)
611 for (libtest::vchar_ptr_t::iterator iter
= keys
.begin();
615 test_compare_hint(MEMCACHED_SUCCESS
,
619 time_t(0), uint32_t(0)),
620 memcached_last_error_message(memc
));
623 for (ptrdiff_t loop
= 0; loop
< 20; loop
++)
627 test_compare(MEMCACHED_SUCCESS
,
628 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
630 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
633 size_t result_count
= 0;
634 memcached_return_t rc
;
635 while (memcached_fetch_result(memc
, results
, &rc
))
639 test_true(keys
.size() >= result_count
);
643 int which_key
= random() %keys
.size();
646 memcached_return_t rc
;
647 char *out_value
= memcached_get(memc
, keys
.key_at(which_key
), keys
.length_at(which_key
),
648 &value_length
, &flags
, &rc
);
649 if (rc
== MEMCACHED_NOTFOUND
)
650 { } // It is possible that the value has been purged.
653 test_compare_hint(MEMCACHED_SUCCESS
, rc
, memcached_last_error_message(memc
));
655 test_null(out_value
);
656 test_zero(value_length
);
664 test_return_t
cas2_test(memcached_st
*memc
)
666 const char *keys
[]= {"fudge", "son", "food"};
667 size_t key_length
[]= {5, 3, 4};
668 const char *value
= "we the people";
669 size_t value_length
= strlen("we the people");
671 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
673 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
675 for (uint32_t x
= 0; x
< 3; x
++)
677 test_compare(MEMCACHED_SUCCESS
,
678 memcached_set(memc
, keys
[x
], key_length
[x
],
679 keys
[x
], key_length
[x
],
680 time_t(50), uint32_t(9)));
683 test_compare(MEMCACHED_SUCCESS
,
684 memcached_mget(memc
, keys
, key_length
, 3));
686 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
689 memcached_return_t rc
;
690 results
= memcached_fetch_result(memc
, results
, &rc
);
692 test_true(results
->item_cas
);
693 test_compare(MEMCACHED_SUCCESS
, rc
);
694 test_true(memcached_result_cas(results
));
696 test_memcmp(value
, "we the people", strlen("we the people"));
697 test_compare(strlen("we the people"), value_length
);
698 test_compare(MEMCACHED_SUCCESS
, rc
);
700 memcached_result_free(results
);
705 test_return_t
cas_test(memcached_st
*memc
)
707 const char* keys
[2] = { __func__
, NULL
};
708 size_t keylengths
[2] = { strlen(__func__
), 0 };
710 memcached_result_st results_obj
;
712 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
714 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
716 test_compare(MEMCACHED_SUCCESS
,
718 test_literal_param(__func__
),
719 test_literal_param("we the people"),
720 (time_t)0, (uint32_t)0));
722 test_compare(MEMCACHED_SUCCESS
,
723 memcached_mget(memc
, keys
, keylengths
, 1));
725 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
728 memcached_return_t rc
;
729 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
731 test_compare(MEMCACHED_SUCCESS
, rc
);
732 test_true(memcached_result_cas(results
));
733 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
734 test_compare(test_literal_param_size("we the people"),
735 strlen(memcached_result_value(results
)));
737 uint64_t cas
= memcached_result_cas(results
);
740 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
741 test_true(rc
== MEMCACHED_END
);
742 test_true(results
== NULL
);
745 test_compare(MEMCACHED_SUCCESS
,
747 test_literal_param(__func__
),
748 test_literal_param("change the value"),
752 * The item will have a new cas value, so try to set it again with the old
753 * value. This should fail!
755 test_compare(MEMCACHED_DATA_EXISTS
,
757 test_literal_param(__func__
),
758 test_literal_param("change the value"),
761 memcached_result_free(&results_obj
);
767 test_return_t
prepend_test(memcached_st
*memc
)
769 const char *key
= "fig";
770 const char *value
= "people";
772 test_compare(MEMCACHED_SUCCESS
,
773 memcached_flush(memc
, 0));
775 test_compare(MEMCACHED_SUCCESS
,
776 memcached_set(memc
, key
, strlen(key
),
777 value
, strlen(value
),
778 time_t(0), uint32_t(0)));
780 test_compare(MEMCACHED_SUCCESS
,
781 memcached_prepend(memc
, key
, strlen(key
),
782 "the ", strlen("the "),
783 time_t(0), uint32_t(0)));
785 test_compare(MEMCACHED_SUCCESS
,
786 memcached_prepend(memc
, key
, strlen(key
),
787 "we ", strlen("we "),
788 time_t(0), uint32_t(0)));
792 memcached_return_t rc
;
793 char *out_value
= memcached_get(memc
, key
, strlen(key
),
794 &value_length
, &flags
, &rc
);
795 test_memcmp(out_value
, "we the people", strlen("we the people"));
796 test_compare(strlen("we the people"), value_length
);
797 test_compare(MEMCACHED_SUCCESS
, rc
);
804 Set the value, then quit to make sure it is flushed.
805 Come back in and test that add fails.
807 test_return_t
add_test(memcached_st
*memc
)
809 test_compare_hint(return_value_based_on_buffering(memc
),
811 test_literal_param(__func__
),
812 test_literal_param("when we sanitize"),
813 time_t(0), uint32_t(0)),
814 memcached_last_error_message(memc
));
816 memcached_quit(memc
);
818 test_compare_hint(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
820 test_literal_param(__func__
),
821 test_literal_param("try something else"),
822 time_t(0), uint32_t(0)),
823 memcached_last_error_message(memc
));
829 ** There was a problem of leaking filedescriptors in the initial release
830 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
831 ** systems it seems that the kernel is slow on reclaiming the resources
832 ** because the connects starts to time out (the test doesn't do much
833 ** anyway, so just loop 10 iterations)
835 test_return_t
add_wrapper(memcached_st
*memc
)
837 unsigned int max
= 10000;
845 for (uint32_t x
= 0; x
< max
; x
++)
851 test_return_t
replace_test(memcached_st
*memc
)
853 test_compare_hint(return_value_based_on_buffering(memc
),
855 test_literal_param(__func__
),
856 test_literal_param("when we sanitize"),
857 time_t(0), uint32_t(0)),
858 memcached_last_error_message(memc
));
860 test_compare_hint(MEMCACHED_SUCCESS
,
861 memcached_replace(memc
,
862 test_literal_param(__func__
),
863 test_literal_param("first we insert some data"),
864 time_t(0), uint32_t(0)),
865 memcached_last_error_message(memc
));
870 test_return_t
delete_test(memcached_st
*memc
)
872 test_compare_hint(return_value_based_on_buffering(memc
),
874 test_literal_param(__func__
),
875 test_literal_param("when we sanitize"),
876 time_t(0), uint32_t(0)),
877 memcached_last_error_message(memc
));
879 test_compare_hint(return_value_based_on_buffering(memc
),
880 memcached_delete(memc
,
881 test_literal_param(__func__
),
883 memcached_last_error_message(memc
));
888 test_return_t
flush_test(memcached_st
*memc
)
890 uint64_t query_id
= memcached_query_id(memc
);
891 test_compare(MEMCACHED_SUCCESS
,
892 memcached_flush(memc
, 0));
893 test_compare(query_id
+1, memcached_query_id(memc
));
898 static memcached_return_t
server_function(const memcached_st
*,
899 const memcached_server_st
*,
903 return MEMCACHED_SUCCESS
;
906 test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
909 strncpy(context
, "foo bad", sizeof(context
));
910 memcached_server_fn callbacks
[1];
912 callbacks
[0]= server_function
;
913 memcached_server_cursor(memc
, callbacks
, context
, 1);
917 test_return_t
bad_key_test(memcached_st
*memc
)
919 memcached_return_t rc
;
920 const char *key
= "foo bad";
923 uint64_t query_id
= memcached_query_id(memc
);
925 // Just skip if we are in binary mode.
926 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
928 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
930 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
931 test_true(memc_clone
);
933 query_id
= memcached_query_id(memc_clone
);
934 test_compare(MEMCACHED_SUCCESS
,
935 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
936 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
938 /* All keys are valid in the binary protocol (except for length) */
939 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == false)
941 uint64_t before_query_id
= memcached_query_id(memc_clone
);
943 size_t string_length
;
944 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
945 &string_length
, &flags
, &rc
);
946 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
947 test_zero(string_length
);
950 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
952 query_id
= memcached_query_id(memc_clone
);
953 test_compare(MEMCACHED_SUCCESS
,
954 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
955 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
957 size_t string_length
;
958 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
959 &string_length
, &flags
, &rc
);
960 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
961 test_zero(string_length
);
965 /* Test multi key for bad keys */
966 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
967 size_t key_lengths
[] = { 7, 7, 7 };
968 query_id
= memcached_query_id(memc_clone
);
969 test_compare(MEMCACHED_SUCCESS
,
970 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
971 test_compare(query_id
, memcached_query_id(memc_clone
));
973 query_id
= memcached_query_id(memc_clone
);
974 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
975 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
976 test_compare(query_id
+1, memcached_query_id(memc_clone
));
978 query_id
= memcached_query_id(memc_clone
);
979 // Grouping keys are not required to follow normal key behaviors
980 test_compare(MEMCACHED_SUCCESS
,
981 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
982 test_compare(query_id
+1, memcached_query_id(memc_clone
));
984 /* The following test should be moved to the end of this function when the
985 memcached server is updated to allow max size length of the keys in the
988 test_compare(MEMCACHED_SUCCESS
,
989 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
991 libtest::vchar_t longkey
;
993 libtest::vchar_t::iterator it
= longkey
.begin();
994 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
997 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
999 size_t string_length
;
1001 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
1002 test_compare(MEMCACHED_NOTFOUND
, rc
);
1003 test_zero(string_length
);
1005 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
1006 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1007 test_zero(string_length
);
1011 /* Make sure zero length keys are marked as bad */
1013 test_compare(MEMCACHED_SUCCESS
,
1014 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1015 size_t string_length
;
1016 char *string
= memcached_get(memc_clone
, key
, 0,
1017 &string_length
, &flags
, &rc
);
1018 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1019 test_zero(string_length
);
1023 memcached_free(memc_clone
);
1025 return TEST_SUCCESS
;
1028 #define READ_THROUGH_VALUE "set for me"
1029 static memcached_return_t
read_through_trigger(memcached_st
*, // memc
1031 size_t, // key_length,
1032 memcached_result_st
*result
)
1034 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
1037 #ifndef __INTEL_COMPILER
1038 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1041 test_return_t
read_through(memcached_st
*memc
)
1043 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1045 size_t string_length
;
1047 memcached_return_t rc
;
1048 char *string
= memcached_get(memc
,
1049 test_literal_param(__func__
),
1050 &string_length
, &flags
, &rc
);
1052 test_compare(MEMCACHED_NOTFOUND
, rc
);
1053 test_false(string_length
);
1056 test_compare(MEMCACHED_SUCCESS
,
1057 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1059 string
= memcached_get(memc
,
1060 test_literal_param(__func__
),
1061 &string_length
, &flags
, &rc
);
1063 test_compare(MEMCACHED_SUCCESS
, rc
);
1064 test_compare(sizeof(READ_THROUGH_VALUE
) -1, string_length
);
1065 test_compare(0, string
[sizeof(READ_THROUGH_VALUE
) -1]);
1066 test_strcmp(READ_THROUGH_VALUE
, string
);
1069 string
= memcached_get(memc
,
1070 test_literal_param(__func__
),
1071 &string_length
, &flags
, &rc
);
1073 test_compare(MEMCACHED_SUCCESS
, rc
);
1075 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1076 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1077 test_strcmp(READ_THROUGH_VALUE
, string
);
1080 return TEST_SUCCESS
;
1083 test_return_t
set_test2(memcached_st
*memc
)
1085 for (uint32_t x
= 0; x
< 10; x
++)
1087 test_compare_hint(return_value_based_on_buffering(memc
),
1089 test_literal_param("foo"),
1090 test_literal_param("train in the brain"),
1091 time_t(0), uint32_t(0)),
1092 memcached_last_error_message(memc
));
1095 return TEST_SUCCESS
;
1098 test_return_t
set_test3(memcached_st
*memc
)
1100 size_t value_length
= 8191;
1102 libtest::vchar_t value
;
1103 value
.reserve(value_length
);
1104 for (uint32_t x
= 0; x
< value_length
; x
++)
1106 value
.push_back(char(x
% 127));
1109 /* The dump test relies on there being at least 32 items in memcached */
1110 for (uint32_t x
= 0; x
< 32; x
++)
1114 snprintf(key
, sizeof(key
), "foo%u", x
);
1116 uint64_t query_id
= memcached_query_id(memc
);
1117 test_compare_hint(return_value_based_on_buffering(memc
),
1118 memcached_set(memc
, key
, strlen(key
),
1119 &value
[0], value
.size(),
1120 time_t(0), uint32_t(0)),
1121 memcached_last_error_message(memc
));
1122 test_compare(query_id
+1, memcached_query_id(memc
));
1125 return TEST_SUCCESS
;
1128 test_return_t
mget_end(memcached_st
*memc
)
1130 const char *keys
[]= { "foo", "foo2" };
1131 size_t lengths
[]= { 3, 4 };
1132 const char *values
[]= { "fjord", "41" };
1135 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1137 test_compare(MEMCACHED_SUCCESS
,
1139 keys
[x
], lengths
[x
],
1140 values
[x
], strlen(values
[x
]),
1141 time_t(0), uint32_t(0)));
1145 size_t string_length
;
1148 // retrieve both via mget
1149 test_compare(MEMCACHED_SUCCESS
,
1150 memcached_mget(memc
,
1152 test_array_length(keys
)));
1154 char key
[MEMCACHED_MAX_KEY
];
1156 memcached_return_t rc
;
1158 // this should get both
1159 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1161 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1163 test_compare(MEMCACHED_SUCCESS
, rc
);
1165 if (key_length
== 4)
1170 test_compare(string_length
, strlen(values
[val
]));
1171 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1175 // this should indicate end
1176 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1177 test_compare(MEMCACHED_END
, rc
);
1181 test_compare(MEMCACHED_SUCCESS
,
1182 memcached_mget(memc
, keys
, lengths
, 1));
1184 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1185 test_compare(key_length
, lengths
[0]);
1186 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1187 test_compare(string_length
, strlen(values
[0]));
1188 test_true(strncmp(values
[0], string
, string_length
) == 0);
1189 test_compare(MEMCACHED_SUCCESS
, rc
);
1192 // this should indicate end
1193 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1194 test_compare(MEMCACHED_END
, rc
);
1197 return TEST_SUCCESS
;
1200 /* Do not copy the style of this code, I just access hosts to testthis function */
1201 test_return_t
stats_servername_test(memcached_st
*memc
)
1203 memcached_stat_st memc_stat
;
1204 memcached_server_instance_st instance
=
1205 memcached_server_instance_by_position(memc
, 0);
1207 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1209 return TEST_SKIPPED
;
1212 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1213 memcached_server_name(instance
),
1214 memcached_server_port(instance
)));
1216 return TEST_SUCCESS
;
1219 test_return_t
increment_test(memcached_st
*memc
)
1221 uint64_t new_number
;
1223 test_compare(MEMCACHED_SUCCESS
,
1225 test_literal_param("number"),
1226 test_literal_param("0"),
1227 (time_t)0, (uint32_t)0));
1229 test_compare(MEMCACHED_SUCCESS
,
1230 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1231 test_compare(uint64_t(1), new_number
);
1233 test_compare(MEMCACHED_SUCCESS
,
1234 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1235 test_compare(uint64_t(2), new_number
);
1237 return TEST_SUCCESS
;
1240 test_return_t
increment_with_initial_test(memcached_st
*memc
)
1242 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1244 uint64_t new_number
;
1245 uint64_t initial
= 0;
1247 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1249 test_compare(MEMCACHED_SUCCESS
,
1250 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1251 test_compare(new_number
, initial
);
1253 test_compare(MEMCACHED_SUCCESS
,
1254 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1255 test_compare(new_number
, (initial
+1));
1257 return TEST_SUCCESS
;
1260 test_return_t
decrement_test(memcached_st
*memc
)
1262 test_compare(return_value_based_on_buffering(memc
),
1264 test_literal_param(__func__
),
1265 test_literal_param("3"),
1266 time_t(0), uint32_t(0)));
1267 // Make sure we flush the value we just set
1268 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1270 uint64_t new_number
;
1271 test_compare(MEMCACHED_SUCCESS
,
1272 memcached_decrement(memc
,
1273 test_literal_param(__func__
),
1275 test_compare(uint64_t(2), new_number
);
1277 test_compare(MEMCACHED_SUCCESS
,
1278 memcached_decrement(memc
,
1279 test_literal_param(__func__
),
1281 test_compare(uint64_t(1), new_number
);
1283 return TEST_SUCCESS
;
1286 test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1288 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1290 uint64_t initial
= 3;
1292 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1294 uint64_t new_number
;
1295 test_compare(MEMCACHED_SUCCESS
,
1296 memcached_decrement_with_initial(memc
,
1297 test_literal_param(__func__
),
1300 test_compare(new_number
, initial
);
1302 test_compare(MEMCACHED_SUCCESS
,
1303 memcached_decrement_with_initial(memc
,
1304 test_literal_param(__func__
),
1307 test_compare(new_number
, (initial
- 1));
1309 return TEST_SUCCESS
;
1312 test_return_t
increment_by_key_test(memcached_st
*memc
)
1314 const char *master_key
= "foo";
1315 const char *key
= "number";
1316 const char *value
= "0";
1318 test_compare(return_value_based_on_buffering(memc
),
1319 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1321 value
, strlen(value
),
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_increment_by_key(memc
, master_key
, strlen(master_key
),
1330 key
, strlen(key
), 1, &new_number
));
1331 test_compare(uint64_t(1), new_number
);
1333 test_compare(MEMCACHED_SUCCESS
,
1334 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1335 key
, strlen(key
), 1, &new_number
));
1336 test_compare(uint64_t(2), new_number
);
1338 return TEST_SUCCESS
;
1341 test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1343 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1345 uint64_t new_number
;
1346 const char *master_key
= "foo";
1347 const char *key
= "number";
1348 uint64_t initial
= 0;
1350 test_compare(MEMCACHED_SUCCESS
,
1351 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1353 1, initial
, 0, &new_number
));
1354 test_compare(new_number
, initial
);
1356 test_compare(MEMCACHED_SUCCESS
,
1357 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1359 1, initial
, 0, &new_number
));
1360 test_compare(new_number
, (initial
+1));
1362 return TEST_SUCCESS
;
1365 test_return_t
decrement_by_key_test(memcached_st
*memc
)
1367 uint64_t new_number
;
1368 const char *value
= "3";
1370 test_compare(return_value_based_on_buffering(memc
),
1371 memcached_set_by_key(memc
,
1372 test_literal_param("foo"),
1373 test_literal_param("number"),
1374 value
, strlen(value
),
1375 (time_t)0, (uint32_t)0));
1377 test_compare(MEMCACHED_SUCCESS
,
1378 memcached_decrement_by_key(memc
,
1379 test_literal_param("foo"),
1380 test_literal_param("number"),
1382 test_compare(uint64_t(2), new_number
);
1384 test_compare(MEMCACHED_SUCCESS
,
1385 memcached_decrement_by_key(memc
,
1386 test_literal_param("foo"),
1387 test_literal_param("number"),
1389 test_compare(uint64_t(1), new_number
);
1391 return TEST_SUCCESS
;
1394 test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1396 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1398 uint64_t new_number
;
1399 uint64_t initial
= 3;
1401 test_compare(MEMCACHED_SUCCESS
,
1402 memcached_decrement_with_initial_by_key(memc
,
1403 test_literal_param("foo"),
1404 test_literal_param("number"),
1405 1, initial
, 0, &new_number
));
1406 test_compare(new_number
, initial
);
1408 test_compare(MEMCACHED_SUCCESS
,
1409 memcached_decrement_with_initial_by_key(memc
,
1410 test_literal_param("foo"),
1411 test_literal_param("number"),
1412 1, initial
, 0, &new_number
));
1413 test_compare(new_number
, (initial
- 1));
1415 return TEST_SUCCESS
;
1417 test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1419 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1421 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1423 test_compare(return_value_based_on_buffering(memc
),
1425 test_literal_param("number"),
1426 test_literal_param("0"),
1427 (time_t)0, (uint32_t)0));
1429 uint64_t new_number
;
1430 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1431 test_literal_param("number"),
1433 test_compare(uint64_t(1), new_number
);
1435 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1436 test_literal_param("number"),
1438 test_compare(uint64_t(2), new_number
);
1440 return TEST_SUCCESS
;
1443 test_return_t
quit_test(memcached_st
*memc
)
1445 const char *value
= "sanford and sun";
1447 test_compare_hint(return_value_based_on_buffering(memc
),
1449 test_literal_param(__func__
),
1450 value
, strlen(value
),
1451 (time_t)10, (uint32_t)3),
1452 memcached_last_error_message(memc
));
1453 memcached_quit(memc
);
1455 test_compare_hint(return_value_based_on_buffering(memc
),
1457 test_literal_param(__func__
),
1458 value
, strlen(value
),
1459 (time_t)50, (uint32_t)9),
1460 memcached_last_error_message(memc
));
1462 return TEST_SUCCESS
;
1465 test_return_t
mget_result_test(memcached_st
*memc
)
1467 const char *keys
[]= {"fudge", "son", "food"};
1468 size_t key_length
[]= {5, 3, 4};
1470 memcached_result_st results_obj
;
1471 memcached_result_st
*results
;
1473 results
= memcached_result_create(memc
, &results_obj
);
1475 test_true(&results_obj
== results
);
1477 /* We need to empty the server before continueing test */
1478 test_compare(MEMCACHED_SUCCESS
,
1479 memcached_flush(memc
, 0));
1481 test_compare(MEMCACHED_SUCCESS
,
1482 memcached_mget(memc
, keys
, key_length
, 3));
1484 memcached_return_t rc
;
1485 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1490 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1491 test_false(results
);
1492 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1494 for (uint32_t x
= 0; x
< 3; x
++)
1496 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1497 keys
[x
], key_length
[x
],
1498 (time_t)50, (uint32_t)9);
1499 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1502 test_compare(MEMCACHED_SUCCESS
,
1503 memcached_mget(memc
, keys
, key_length
, 3));
1505 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1508 test_true(&results_obj
== results
);
1509 test_compare(MEMCACHED_SUCCESS
, rc
);
1510 test_memcmp(memcached_result_key_value(results
),
1511 memcached_result_value(results
),
1512 memcached_result_length(results
));
1513 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1516 memcached_result_free(&results_obj
);
1518 return TEST_SUCCESS
;
1521 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1523 const char *keys
[]= {"fudge", "son", "food"};
1524 size_t key_length
[]= {5, 3, 4};
1526 memcached_result_st
*results
;
1528 /* We need to empty the server before continueing test */
1529 test_compare(MEMCACHED_SUCCESS
,
1530 memcached_flush(memc
, 0));
1532 test_compare(MEMCACHED_SUCCESS
,
1533 memcached_mget(memc
, keys
, key_length
, 3));
1535 memcached_return_t rc
;
1536 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1540 test_false(results
);
1541 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1543 for (uint32_t x
= 0; x
< 3; x
++)
1545 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1546 keys
[x
], key_length
[x
],
1547 (time_t)50, (uint32_t)9);
1548 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1551 test_compare(MEMCACHED_SUCCESS
,
1552 memcached_mget(memc
, keys
, key_length
, 3));
1555 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1558 test_compare(MEMCACHED_SUCCESS
, rc
);
1559 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1560 test_memcmp(memcached_result_key_value(results
),
1561 memcached_result_value(results
),
1562 memcached_result_length(results
));
1563 memcached_result_free(results
);
1567 return TEST_SUCCESS
;
1570 test_return_t
mget_result_function(memcached_st
*memc
)
1572 const char *keys
[]= {"fudge", "son", "food"};
1573 size_t key_length
[]= {5, 3, 4};
1575 memcached_execute_fn callbacks
[1];
1577 for (uint32_t x
= 0; x
< 3; x
++)
1579 test_compare(return_value_based_on_buffering(memc
),
1580 memcached_set(memc
, keys
[x
], key_length
[x
],
1581 keys
[x
], key_length
[x
],
1582 time_t(50), uint32_t(9)));
1584 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1585 memcached_quit(memc
);
1587 test_compare(MEMCACHED_SUCCESS
,
1588 memcached_mget(memc
, keys
, key_length
, 3));
1590 callbacks
[0]= &callback_counter
;
1593 test_compare(MEMCACHED_SUCCESS
,
1594 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1596 test_compare(size_t(3), counter
);
1598 return TEST_SUCCESS
;
1601 test_return_t
mget_test(memcached_st
*memc
)
1603 const char *keys
[]= {"fudge", "son", "food"};
1604 size_t key_length
[]= {5, 3, 4};
1606 char return_key
[MEMCACHED_MAX_KEY
];
1607 size_t return_key_length
;
1609 size_t return_value_length
;
1611 test_compare(MEMCACHED_SUCCESS
,
1612 memcached_mget(memc
, keys
, key_length
, 3));
1615 memcached_return_t rc
;
1616 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1617 &return_value_length
, &flags
, &rc
)))
1619 test_true(return_value
);
1621 test_false(return_value
);
1622 test_zero(return_value_length
);
1623 test_compare(MEMCACHED_NOTFOUND
, rc
);
1625 for (uint32_t x
= 0; x
< 3; x
++)
1627 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1628 keys
[x
], key_length
[x
],
1629 (time_t)50, (uint32_t)9);
1630 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1632 test_compare(MEMCACHED_SUCCESS
,
1633 memcached_mget(memc
, keys
, key_length
, 3));
1636 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1637 &return_value_length
, &flags
, &rc
)))
1639 test_true(return_value
);
1640 test_compare(MEMCACHED_SUCCESS
, rc
);
1641 if (not memc
->_namespace
)
1643 test_compare(return_key_length
, return_value_length
);
1644 test_memcmp(return_value
, return_key
, return_value_length
);
1650 return TEST_SUCCESS
;
1653 test_return_t
mget_execute(memcached_st
*original_memc
)
1655 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1657 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1660 keys_st
keys(20480);
1662 /* First add all of the items.. */
1663 char blob
[1024] = {0};
1665 for (size_t x
= 0; x
< keys
.size(); ++x
)
1667 uint64_t query_id
= memcached_query_id(memc
);
1668 memcached_return_t rc
= memcached_add(memc
,
1669 keys
.key_at(x
), keys
.length_at(x
),
1672 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
,
1673 memcached_last_error_message(memc
));
1674 test_compare(query_id
+1, memcached_query_id(memc
));
1677 /* Try to get all of them with a large multiget */
1679 memcached_execute_fn callbacks
[]= { &callback_counter
};
1680 test_compare(MEMCACHED_SUCCESS
,
1681 memcached_mget_execute(memc
,
1682 keys
.keys_ptr(), keys
.lengths_ptr(),
1683 keys
.size(), callbacks
, &counter
, 1));
1686 uint64_t query_id
= memcached_query_id(memc
);
1687 test_compare(MEMCACHED_SUCCESS
,
1688 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1689 test_compare(query_id
, memcached_query_id(memc
));
1691 /* Verify that we got all of the items */
1692 test_compare(keys
.size(), counter
);
1695 memcached_free(memc
);
1697 return TEST_SUCCESS
;
1700 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1701 static pairs_st
*global_pairs
= NULL
;
1703 test_return_t
key_setup(memcached_st
*memc
)
1705 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1707 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1709 return TEST_SUCCESS
;
1712 test_return_t
key_teardown(memcached_st
*)
1714 pairs_free(global_pairs
);
1717 return TEST_SUCCESS
;
1720 test_return_t
block_add_regression(memcached_st
*memc
)
1722 /* First add all of the items.. */
1723 for (ptrdiff_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1725 libtest::vchar_t blob
;
1726 libtest::vchar::make(blob
, 1024);
1728 memcached_return_t rc
= memcached_add_by_key(memc
,
1729 test_literal_param("bob"),
1730 global_pairs
[x
].key
, global_pairs
[x
].key_length
,
1731 &blob
[0], blob
.size(),
1732 time_t(0), uint32_t(0));
1733 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
, memcached_strerror(NULL
, rc
));
1736 return TEST_SUCCESS
;
1739 test_return_t
binary_add_regression(memcached_st
*memc
)
1741 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1742 test_return_t rc
= block_add_regression(memc
);
1747 test_return_t
get_stats_keys(memcached_st
*memc
)
1751 memcached_stat_st memc_stat
;
1752 memcached_return_t rc
;
1754 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1755 test_compare(MEMCACHED_SUCCESS
, rc
);
1756 for (ptr
= stat_list
; *ptr
; ptr
++)
1761 return TEST_SUCCESS
;
1764 test_return_t
version_string_test(memcached_st
*)
1766 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1768 return TEST_SUCCESS
;
1771 test_return_t
get_stats(memcached_st
*memc
)
1773 memcached_return_t rc
;
1775 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1776 test_compare(MEMCACHED_SUCCESS
, rc
);
1777 test_true(memc_stat
);
1779 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1781 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1782 test_compare(MEMCACHED_SUCCESS
, rc
);
1783 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1788 memcached_stat_free(NULL
, memc_stat
);
1790 return TEST_SUCCESS
;
1793 test_return_t
add_host_test(memcached_st
*memc
)
1795 char servername
[]= "0.example.com";
1797 memcached_return_t rc
;
1798 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1799 test_compare(1U, memcached_server_list_count(servers
));
1801 for (unsigned int x
= 2; x
< 20; x
++)
1803 char buffer
[SMALL_STRING_LEN
];
1805 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1806 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1808 test_compare(MEMCACHED_SUCCESS
, rc
);
1809 test_compare(x
, memcached_server_list_count(servers
));
1812 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1813 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1815 memcached_server_list_free(servers
);
1817 return TEST_SUCCESS
;
1820 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1822 memcached_return_t rc
;
1824 const char *key
= "not_found";
1825 size_t key_length
= test_literal_param_size("not_found");
1827 test_compare(MEMCACHED_SUCCESS
,
1828 memcached_mget(memc
, &key
, &key_length
, 1));
1830 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1832 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1834 memcached_result_free(result
);
1836 return TEST_SUCCESS
;
1839 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1841 return MEMCACHED_SUCCESS
;
1844 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1846 return MEMCACHED_SUCCESS
;
1849 test_return_t
callback_test(memcached_st
*memc
)
1851 /* Test User Data */
1855 memcached_return_t rc
;
1857 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1858 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1859 test_true(*test_ptr
== x
);
1862 /* Test Clone Callback */
1864 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1865 void *clone_cb_ptr
= *(void **)&clone_cb
;
1866 void *temp_function
= NULL
;
1868 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
1869 memcached_return_t rc
;
1870 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1871 test_true(temp_function
== clone_cb_ptr
);
1872 test_compare(MEMCACHED_SUCCESS
, rc
);
1875 /* Test Cleanup Callback */
1877 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
1878 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1879 void *temp_function
= NULL
;
1880 memcached_return_t rc
;
1882 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
1883 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1884 test_true(temp_function
== cleanup_cb_ptr
);
1887 return TEST_SUCCESS
;
1890 /* We don't test the behavior itself, we test the switches */
1891 test_return_t
behavior_test(memcached_st
*memc
)
1893 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
1894 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
1896 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
1897 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
1899 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
1900 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1902 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
1903 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
1905 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
1906 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
1908 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
1909 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1911 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
1912 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
1914 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
1916 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
1918 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
1919 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
1920 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
1922 return TEST_SUCCESS
;
1925 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
1927 test_compare(MEMCACHED_DEPRECATED
,
1928 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
1930 // Platform dependent
1932 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
1936 return TEST_SUCCESS
;
1940 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
1942 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
1943 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
1945 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
1947 if (memcached_success(rc
))
1956 return TEST_SUCCESS
;
1960 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
1962 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
1963 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
1965 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
1967 if (memcached_success(rc
))
1976 return TEST_SUCCESS
;
1979 /* Make sure we behave properly if server list has no values */
1980 test_return_t
user_supplied_bug4(memcached_st
*memc
)
1982 const char *keys
[]= {"fudge", "son", "food"};
1983 size_t key_length
[]= {5, 3, 4};
1985 /* Here we free everything before running a bunch of mget tests */
1986 memcached_servers_reset(memc
);
1989 /* We need to empty the server before continueing test */
1990 test_compare(MEMCACHED_NO_SERVERS
,
1991 memcached_flush(memc
, 0));
1993 test_compare(MEMCACHED_NO_SERVERS
,
1994 memcached_mget(memc
, keys
, key_length
, 3));
1997 unsigned int keys_returned
;
1998 memcached_return_t rc
;
1999 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2000 test_compare(MEMCACHED_NOTFOUND
, rc
);
2001 test_zero(keys_returned
);
2004 for (uint32_t x
= 0; x
< 3; x
++)
2006 test_compare(MEMCACHED_NO_SERVERS
,
2007 memcached_set(memc
, keys
[x
], key_length
[x
],
2008 keys
[x
], key_length
[x
],
2009 (time_t)50, (uint32_t)9));
2012 test_compare(MEMCACHED_NO_SERVERS
,
2013 memcached_mget(memc
, keys
, key_length
, 3));
2017 char return_key
[MEMCACHED_MAX_KEY
];
2018 memcached_return_t rc
;
2019 size_t return_key_length
;
2020 size_t return_value_length
;
2023 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2024 &return_value_length
, &flags
, &rc
)))
2026 test_true(return_value
);
2027 test_compare(MEMCACHED_SUCCESS
, rc
);
2028 test_true(return_key_length
== return_value_length
);
2029 test_memcmp(return_value
, return_key
, return_value_length
);
2035 return TEST_SUCCESS
;
2038 #define VALUE_SIZE_BUG5 1048064
2039 test_return_t
user_supplied_bug5(memcached_st
*memc
)
2041 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2042 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2044 size_t value_length
;
2046 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2048 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2050 insert_data
[x
]= (signed char)rand();
2053 test_compare(MEMCACHED_SUCCESS
,
2054 memcached_flush(memc
, 0));
2056 memcached_return_t rc
;
2057 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2058 test_compare(MEMCACHED_SUCCESS
,
2059 memcached_mget(memc
, keys
, key_length
, 4));
2062 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2063 test_compare(MEMCACHED_NOTFOUND
, rc
);
2066 for (uint32_t x
= 0; x
< 4; x
++)
2068 test_compare(MEMCACHED_SUCCESS
,
2069 memcached_set(memc
, keys
[x
], key_length
[x
],
2070 insert_data
, VALUE_SIZE_BUG5
,
2071 (time_t)0, (uint32_t)0));
2074 for (uint32_t x
= 0; x
< 10; x
++)
2076 value
= memcached_get(memc
, keys
[0], key_length
[0],
2077 &value_length
, &flags
, &rc
);
2078 test_compare(rc
, MEMCACHED_SUCCESS
);
2082 test_compare(MEMCACHED_SUCCESS
,
2083 memcached_mget(memc
, keys
, key_length
, 4));
2085 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2086 test_compare(4U, count
);
2088 delete [] insert_data
;
2090 return TEST_SUCCESS
;
2093 test_return_t
user_supplied_bug6(memcached_st
*memc
)
2095 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2096 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2097 char return_key
[MEMCACHED_MAX_KEY
];
2098 size_t return_key_length
;
2100 size_t value_length
;
2102 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2104 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2106 insert_data
[x
]= (signed char)rand();
2109 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2111 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2113 // We will now confirm that memcached_mget() returns success, but we will
2114 // then check to make sure that no actual keys are returned.
2115 test_compare(MEMCACHED_SUCCESS
,
2116 memcached_mget(memc
, keys
, key_length
, 4));
2118 memcached_return_t rc
;
2120 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2121 &value_length
, &flags
, &rc
)))
2126 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2128 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2130 test_compare(MEMCACHED_SUCCESS
,
2131 memcached_set(memc
, keys
[x
], key_length
[x
],
2132 insert_data
, VALUE_SIZE_BUG5
,
2133 (time_t)0, (uint32_t)0));
2135 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2137 for (uint32_t x
= 0; x
< 2; x
++)
2139 value
= memcached_get(memc
, keys
[0], key_length
[0],
2140 &value_length
, &flags
, &rc
);
2144 test_compare(MEMCACHED_SUCCESS
,
2145 memcached_mget(memc
, keys
, key_length
, 4));
2146 /* We test for purge of partial complete fetches */
2147 for (count
= 3; count
; count
--)
2149 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2150 &value_length
, &flags
, &rc
);
2151 test_compare(MEMCACHED_SUCCESS
, rc
);
2152 test_memcmp(value
, insert_data
, value_length
);
2153 test_true(value_length
);
2157 delete [] insert_data
;
2159 return TEST_SUCCESS
;
2162 test_return_t
user_supplied_bug8(memcached_st
*)
2164 memcached_return_t rc
;
2166 memcached_st
*memc_clone
;
2168 memcached_server_st
*servers
;
2169 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";
2171 servers
= memcached_servers_parse(server_list
);
2174 mine
= memcached_create(NULL
);
2175 rc
= memcached_server_push(mine
, servers
);
2176 test_compare(MEMCACHED_SUCCESS
, rc
);
2177 memcached_server_list_free(servers
);
2180 memc_clone
= memcached_clone(NULL
, mine
);
2182 memcached_quit(mine
);
2183 memcached_quit(memc_clone
);
2186 memcached_free(mine
);
2187 memcached_free(memc_clone
);
2189 return TEST_SUCCESS
;
2192 /* Test flag store/retrieve */
2193 test_return_t
user_supplied_bug7(memcached_st
*memc
)
2195 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2196 test_true(insert_data
);
2198 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2200 insert_data
[x
]= (signed char)rand();
2203 memcached_flush(memc
, 0);
2205 const char *keys
= "036790384900";
2206 size_t key_length
= strlen(keys
);
2207 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2208 insert_data
, VALUE_SIZE_BUG5
,
2210 memcached_last_error_message(memc
));
2212 memcached_return_t rc
;
2213 size_t value_length
;
2215 char *value
= memcached_get(memc
, keys
, key_length
,
2216 &value_length
, &flags
, &rc
);
2217 test_compare(245U, flags
);
2221 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2223 char return_key
[MEMCACHED_MAX_KEY
];
2224 size_t return_key_length
;
2226 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2227 &value_length
, &flags
, &rc
);
2228 test_compare(uint32_t(245), flags
);
2231 delete [] insert_data
;
2234 return TEST_SUCCESS
;
2237 test_return_t
user_supplied_bug9(memcached_st
*memc
)
2239 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2240 size_t key_length
[3];
2244 char return_key
[MEMCACHED_MAX_KEY
];
2245 size_t return_key_length
;
2247 size_t return_value_length
;
2250 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2251 key_length
[1]= strlen("fudge&*@#");
2252 key_length
[2]= strlen("for^#@&$not");
2255 for (unsigned int x
= 0; x
< 3; x
++)
2257 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2258 keys
[x
], key_length
[x
],
2259 (time_t)50, (uint32_t)9);
2260 test_compare(MEMCACHED_SUCCESS
, rc
);
2263 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2264 test_compare(MEMCACHED_SUCCESS
, rc
);
2266 /* We need to empty the server before continueing test */
2267 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2268 &return_value_length
, &flags
, &rc
)) != NULL
)
2270 test_true(return_value
);
2274 test_compare(3U, count
);
2276 return TEST_SUCCESS
;
2279 /* We are testing with aggressive timeout to get failures */
2280 test_return_t
user_supplied_bug10(memcached_st
*memc
)
2282 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
2284 size_t value_length
= 512;
2285 unsigned int set
= 1;
2286 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2288 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2289 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2290 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2292 libtest::vchar_t value
;
2293 value
.reserve(value_length
);
2294 for (uint32_t x
= 0; x
< value_length
; x
++)
2296 value
.push_back(char(x
% 127));
2299 for (unsigned int x
= 1; x
<= 100000; ++x
)
2301 memcached_return_t rc
= memcached_set(mclone
,
2302 test_literal_param("foo"),
2303 &value
[0], value
.size(),
2306 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2307 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2308 memcached_strerror(NULL
, rc
));
2310 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2316 memcached_free(mclone
);
2318 return TEST_SUCCESS
;
2322 We are looking failures in the async protocol
2324 test_return_t
user_supplied_bug11(memcached_st
*memc
)
2326 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2328 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2329 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2330 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2332 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2335 libtest::vchar_t value
;
2337 for (unsigned int x
= 0; x
< 512; x
++)
2339 value
.push_back(char(x
% 127));
2342 for (unsigned int x
= 1; x
<= 100000; ++x
)
2344 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2348 memcached_free(mclone
);
2350 return TEST_SUCCESS
;
2354 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2356 test_return_t
user_supplied_bug12(memcached_st
*memc
)
2358 memcached_return_t rc
;
2360 size_t value_length
;
2362 uint64_t number_value
;
2364 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2365 &value_length
, &flags
, &rc
);
2367 test_compare(MEMCACHED_NOTFOUND
, rc
);
2369 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2372 /* The binary protocol will set the key if it doesn't exist */
2373 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2375 test_compare(MEMCACHED_SUCCESS
, rc
);
2379 test_compare(MEMCACHED_NOTFOUND
, rc
);
2382 test_compare(MEMCACHED_SUCCESS
,
2383 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2385 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2389 test_compare(MEMCACHED_SUCCESS
,
2390 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2391 test_compare(2UL, number_value
);
2393 return TEST_SUCCESS
;
2397 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2398 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2400 test_return_t
user_supplied_bug13(memcached_st
*memc
)
2402 char key
[] = "key34567890";
2404 char commandFirst
[]= "set key34567890 0 0 ";
2405 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2406 size_t commandLength
;
2408 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2410 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2412 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2414 char *overflow
= new (std::nothrow
) char[testSize
];
2415 test_true(overflow
);
2417 memset(overflow
, 'x', testSize
);
2418 test_compare(MEMCACHED_SUCCESS
,
2419 memcached_set(memc
, key
, strlen(key
),
2420 overflow
, testSize
, 0, 0));
2424 return TEST_SUCCESS
;
2429 Test values of many different sizes
2430 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2431 set key34567890 0 0 8169 \r\n
2432 is sent followed by buffer of size 8169, followed by 8169
2434 test_return_t
user_supplied_bug14(memcached_st
*memc
)
2436 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2438 libtest::vchar_t value
;
2439 value
.reserve(18000);
2440 for (ptrdiff_t x
= 0; x
< 18000; x
++)
2442 value
.push_back((char) (x
% 127));
2445 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
2447 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2448 &value
[0], current_length
,
2449 (time_t)0, (uint32_t)0);
2450 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2452 size_t string_length
;
2454 char *string
= memcached_get(memc
, test_literal_param("foo"),
2455 &string_length
, &flags
, &rc
);
2457 test_compare(MEMCACHED_SUCCESS
, rc
);
2458 test_compare(string_length
, current_length
);
2460 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
2461 test_memcmp_hint(string
, &value
[0], string_length
, buffer
);
2466 return TEST_SUCCESS
;
2470 Look for zero length value problems
2472 test_return_t
user_supplied_bug15(memcached_st
*memc
)
2474 for (uint32_t x
= 0; x
< 2; x
++)
2476 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2478 (time_t)0, (uint32_t)0);
2480 test_compare(MEMCACHED_SUCCESS
, rc
);
2484 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2485 &length
, &flags
, &rc
);
2487 test_compare(MEMCACHED_SUCCESS
, rc
);
2492 value
= memcached_get(memc
, test_literal_param("mykey"),
2493 &length
, &flags
, &rc
);
2495 test_compare(MEMCACHED_SUCCESS
, rc
);
2501 return TEST_SUCCESS
;
2504 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2505 test_return_t
user_supplied_bug16(memcached_st
*memc
)
2507 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2509 (time_t)0, UINT32_MAX
),
2510 memcached_last_error_message(memc
));
2515 memcached_return_t rc
;
2516 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2517 &length
, &flags
, &rc
);
2519 test_compare(MEMCACHED_SUCCESS
, rc
);
2522 test_compare(flags
, UINT32_MAX
);
2524 return TEST_SUCCESS
;
2527 #if !defined(__sun) && !defined(__OpenBSD__)
2528 /* Check the validity of chinese key*/
2529 test_return_t
user_supplied_bug17(memcached_st
*memc
)
2531 const char *key
= "豆瓣";
2532 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2533 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2534 value
, strlen(value
),
2537 test_compare(MEMCACHED_SUCCESS
, rc
);
2541 char *value2
= memcached_get(memc
, key
, strlen(key
),
2542 &length
, &flags
, &rc
);
2544 test_true(length
==strlen(value
));
2545 test_compare(MEMCACHED_SUCCESS
, rc
);
2546 test_memcmp(value
, value2
, length
);
2549 return TEST_SUCCESS
;
2557 test_return_t
user_supplied_bug19(memcached_st
*)
2559 memcached_return_t res
;
2561 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2563 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2566 memcached_free(memc
);
2568 return TEST_SUCCESS
;
2571 /* CAS test from Andei */
2572 test_return_t
user_supplied_bug20(memcached_st
*memc
)
2574 const char *key
= "abc";
2575 size_t key_len
= strlen("abc");
2577 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2579 test_compare(MEMCACHED_SUCCESS
,
2581 test_literal_param("abc"),
2582 test_literal_param("foobar"),
2583 (time_t)0, (uint32_t)0));
2585 test_compare(MEMCACHED_SUCCESS
,
2586 memcached_mget(memc
, &key
, &key_len
, 1));
2588 memcached_result_st result_obj
;
2589 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2592 memcached_result_create(memc
, &result_obj
);
2593 memcached_return_t status
;
2594 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2597 test_compare(MEMCACHED_SUCCESS
, status
);
2599 memcached_result_free(result
);
2601 return TEST_SUCCESS
;
2604 /* Large mget() of missing keys with binary proto
2606 * If many binary quiet commands (such as getq's in an mget) fill the output
2607 * buffer and the server chooses not to respond, memcached_flush hangs. See
2608 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2611 /* sighandler_t function that always asserts false */
2612 static void fail(int)
2618 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2623 return TEST_SKIPPED
;
2625 void (*oldalarm
)(int);
2627 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2628 test_true(memc_clone
);
2630 /* only binproto uses getq for mget */
2631 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2633 /* empty the cache to ensure misses (hence non-responses) */
2634 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2636 keys_st
keys(key_count
);
2638 oldalarm
= signal(SIGALRM
, fail
);
2641 test_compare_got(MEMCACHED_SUCCESS
,
2642 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2643 memcached_last_error_message(memc_clone
));
2646 signal(SIGALRM
, oldalarm
);
2648 memcached_return_t rc
;
2650 char return_key
[MEMCACHED_MAX_KEY
];
2651 size_t return_key_length
;
2653 size_t return_value_length
;
2654 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2655 &return_value_length
, &flags
, &rc
)))
2657 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2659 test_compare(MEMCACHED_NOTFOUND
, rc
);
2660 test_zero(return_value_length
);
2661 test_zero(return_key_length
);
2662 test_false(return_key
[0]);
2663 test_false(return_value
);
2665 memcached_free(memc_clone
);
2667 return TEST_SUCCESS
;
2671 test_return_t
user_supplied_bug21(memcached_st
*memc
)
2673 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2675 /* should work as of r580 */
2676 test_compare(TEST_SUCCESS
,
2677 _user_supplied_bug21(memc
, 10));
2679 /* should fail as of r580 */
2680 test_compare(TEST_SUCCESS
,
2681 _user_supplied_bug21(memc
, 1000));
2683 return TEST_SUCCESS
;
2686 test_return_t
output_ketama_weighted_keys(memcached_st
*)
2688 memcached_st
*memc
= memcached_create(NULL
);
2692 test_compare(MEMCACHED_SUCCESS
,
2693 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2695 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2696 test_compare(value
, uint64_t(1));
2698 test_compare(MEMCACHED_SUCCESS
,
2699 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2701 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2702 test_true(value
== MEMCACHED_HASH_MD5
);
2705 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2707 memcached_server_st
*server_pool
;
2708 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");
2709 memcached_server_push(memc
, server_pool
);
2711 // @todo this needs to be refactored to actually test something.
2714 if ((fp
= fopen("ketama_keys.txt", "w")))
2718 printf("cannot write to file ketama_keys.txt");
2719 return TEST_FAILURE
;
2722 for (int x
= 0; x
< 10000; x
++)
2725 snprintf(key
, sizeof(key
), "%d", x
);
2727 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2728 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2729 in_port_t port
= memc
->hosts
[server_idx
].port
;
2730 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
2731 memcached_server_instance_st instance
=
2732 memcached_server_instance_by_position(memc
, host_index
);
2736 memcached_server_list_free(server_pool
);
2737 memcached_free(memc
);
2739 return TEST_SUCCESS
;
2743 test_return_t
result_static(memcached_st
*memc
)
2745 memcached_result_st result
;
2746 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
2747 test_false(result
.options
.is_allocated
);
2748 test_true(memcached_is_initialized(&result
));
2749 test_true(result_ptr
);
2750 test_true(result_ptr
== &result
);
2752 memcached_result_free(&result
);
2754 test_false(result
.options
.is_allocated
);
2755 test_false(memcached_is_initialized(&result
));
2757 return TEST_SUCCESS
;
2760 test_return_t
result_alloc(memcached_st
*memc
)
2762 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
2763 test_true(result_ptr
);
2764 test_true(result_ptr
->options
.is_allocated
);
2765 test_true(memcached_is_initialized(result_ptr
));
2766 memcached_result_free(result_ptr
);
2768 return TEST_SUCCESS
;
2772 test_return_t
add_host_test1(memcached_st
*memc
)
2774 memcached_return_t rc
;
2775 char servername
[]= "0.example.com";
2777 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2779 test_compare(1U, memcached_server_list_count(servers
));
2781 for (uint32_t x
= 2; x
< 20; x
++)
2783 char buffer
[SMALL_STRING_LEN
];
2785 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
2786 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2788 test_compare(MEMCACHED_SUCCESS
, rc
);
2789 test_compare(x
, memcached_server_list_count(servers
));
2792 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2793 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2795 memcached_server_list_free(servers
);
2797 return TEST_SUCCESS
;
2801 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
2805 #ifdef HARD_MALLOC_TESTS
2806 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
2814 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
2818 #ifdef HARD_MALLOC_TESTS
2819 void *ret
= malloc(size
+ 8);
2822 ret
= (void*)((caddr_t
)ret
+ 8);
2825 void *ret
= malloc(size
);
2830 memset(ret
, 0xff, size
);
2837 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
2839 #ifdef HARD_MALLOC_TESTS
2840 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
2841 void *nmem
= realloc(real_ptr
, size
+ 8);
2846 ret
= (void*)((caddr_t
)nmem
+ 8);
2852 return realloc(mem
, size
);
2857 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
2859 #ifdef HARD_MALLOC_TESTS
2860 void *mem
= my_malloc(ptr
, nelem
* size
);
2863 memset(mem
, 0, nelem
* size
);
2869 return calloc(nelem
, size
);
2873 test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
2875 memcached_return_t rc
;
2876 const char *key
= "mine";
2879 /* Make sure be default none exists */
2880 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2882 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2884 /* Test a clean set */
2885 test_compare(MEMCACHED_SUCCESS
,
2886 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2888 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2890 test_memcmp(value
, key
, 4);
2891 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2893 /* Test that we can turn it off */
2894 test_compare(MEMCACHED_SUCCESS
,
2895 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
2897 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2899 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2901 /* Now setup for main test */
2902 test_compare(MEMCACHED_SUCCESS
,
2903 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2905 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2907 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2908 test_memcmp(value
, key
, 4);
2910 /* Set to Zero, and then Set to something too large */
2913 memset(long_key
, 0, 255);
2915 test_compare(MEMCACHED_SUCCESS
,
2916 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
2918 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2920 test_compare(MEMCACHED_SUCCESS
, rc
);
2922 /* Test a long key for failure */
2923 /* TODO, extend test to determine based on setting, what result should be */
2924 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
2925 test_compare(MEMCACHED_SUCCESS
,
2926 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
2928 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
2929 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
2930 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
2931 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
2933 /* Test for a bad prefix, but with a short key */
2934 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
2935 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
2937 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
2938 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
2941 return TEST_SUCCESS
;
2944 test_return_t
set_namespace(memcached_st
*memc
)
2946 memcached_return_t rc
;
2947 const char *key
= "mine";
2950 // Make sure we default to a null namespace
2951 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2953 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2955 /* Test a clean set */
2956 test_compare(MEMCACHED_SUCCESS
,
2957 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
2959 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
2961 test_memcmp(value
, key
, 4);
2962 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2964 return TEST_SUCCESS
;
2967 test_return_t
set_namespace_and_binary(memcached_st
*memc
)
2969 test_return_if(pre_binary(memc
));
2970 test_return_if(set_namespace(memc
));
2972 return TEST_SUCCESS
;
2975 #ifdef MEMCACHED_ENABLE_DEPRECATED
2976 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
2978 void *test_ptr
= NULL
;
2981 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
2982 cb_ptr
= *(void **)&malloc_cb
;
2983 memcached_return_t rc
;
2985 test_compare(MEMCACHED_SUCCESS
,
2986 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
2987 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
2988 test_compare(MEMCACHED_SUCCESS
, rc
);
2989 test_true(test_ptr
== cb_ptr
);
2993 memcached_realloc_fn realloc_cb
=
2994 (memcached_realloc_fn
)my_realloc
;
2995 cb_ptr
= *(void **)&realloc_cb
;
2996 memcached_return_t rc
;
2998 test_compare(MEMCACHED_SUCCESS
,
2999 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3000 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3001 test_compare(MEMCACHED_SUCCESS
, rc
);
3002 test_true(test_ptr
== cb_ptr
);
3006 memcached_free_fn free_cb
=
3007 (memcached_free_fn
)my_free
;
3008 cb_ptr
= *(void **)&free_cb
;
3009 memcached_return_t rc
;
3011 test_compare(MEMCACHED_SUCCESS
,
3012 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3013 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3014 test_compare(MEMCACHED_SUCCESS
, rc
);
3015 test_true(test_ptr
== cb_ptr
);
3018 return TEST_SUCCESS
;
3023 test_return_t
set_memory_alloc(memcached_st
*memc
)
3025 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3026 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3027 my_realloc
, my_calloc
, NULL
));
3029 test_compare(MEMCACHED_SUCCESS
,
3030 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3031 my_realloc
, my_calloc
, NULL
));
3033 memcached_malloc_fn mem_malloc
;
3034 memcached_free_fn mem_free
;
3035 memcached_realloc_fn mem_realloc
;
3036 memcached_calloc_fn mem_calloc
;
3037 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3038 &mem_realloc
, &mem_calloc
);
3040 test_true(mem_malloc
== my_malloc
);
3041 test_true(mem_realloc
== my_realloc
);
3042 test_true(mem_calloc
== my_calloc
);
3043 test_true(mem_free
== my_free
);
3045 return TEST_SUCCESS
;
3048 test_return_t
enable_consistent_crc(memcached_st
*memc
)
3051 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3052 memcached_hash_t hash
;
3053 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3054 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3057 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3058 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3060 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3062 if (hash
!= MEMCACHED_HASH_CRC
)
3063 return TEST_SKIPPED
;
3065 return TEST_SUCCESS
;
3068 test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3071 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3072 memcached_hash_t hash
;
3073 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3074 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3079 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3080 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3082 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3084 if (hash
!= MEMCACHED_HASH_HSIEH
)
3085 return TEST_SKIPPED
;
3088 return TEST_SUCCESS
;
3091 test_return_t
enable_cas(memcached_st
*memc
)
3093 unsigned int set
= 1;
3095 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3097 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3099 return TEST_SUCCESS
;
3102 return TEST_SKIPPED
;
3105 test_return_t
check_for_1_2_3(memcached_st
*memc
)
3107 memcached_version(memc
);
3109 memcached_server_instance_st instance
=
3110 memcached_server_instance_by_position(memc
, 0);
3112 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3113 or instance
->minor_version
> 2)
3115 return TEST_SUCCESS
;
3118 return TEST_SKIPPED
;
3121 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3123 const uint64_t timeout
= 100; // Not using, just checking that it sets
3125 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3127 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3129 return TEST_SUCCESS
;
3132 test_return_t
noreply_test(memcached_st
*memc
)
3134 test_compare(MEMCACHED_SUCCESS
,
3135 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3136 test_compare(MEMCACHED_SUCCESS
,
3137 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3138 test_compare(MEMCACHED_SUCCESS
,
3139 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3140 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3141 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3142 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3144 memcached_return_t ret
;
3145 for (int count
= 0; count
< 5; ++count
)
3147 for (size_t x
= 0; x
< 100; ++x
)
3149 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3150 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3151 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3153 size_t len
= (size_t)check_length
;
3158 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3161 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3164 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3167 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3170 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3176 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3177 memcached_strerror(NULL
, ret
));
3181 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3182 ** API and is _ONLY_ done this way to verify that the library works the
3183 ** way it is supposed to do!!!!
3187 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3189 memcached_server_instance_st instance
=
3190 memcached_server_instance_by_position(memc
, x
);
3191 no_msg
+=(int)(instance
->cursor_active
);
3194 test_true(no_msg
== 0);
3196 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3199 ** Now validate that all items was set properly!
3201 for (size_t x
= 0; x
< 100; ++x
)
3205 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3207 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3209 size_t len
= (size_t)check_length
;
3212 char* value
=memcached_get(memc
, key
, strlen(key
),
3213 &length
, &flags
, &ret
);
3214 // For the moment we will just go to the next key
3215 if (MEMCACHED_TIMEOUT
== ret
)
3219 test_true_hint(ret
== MEMCACHED_SUCCESS
and value
!= NULL
, memcached_last_error_message(memc
));
3222 case 0: /* FALLTHROUGH */
3223 case 1: /* FALLTHROUGH */
3225 test_true(strncmp(value
, key
, len
) == 0);
3226 test_true(len
== length
);
3229 test_true(length
== len
* 2);
3232 test_true(length
== len
* 3);
3242 /* Try setting an illegal cas value (should not return an error to
3243 * the caller (because we don't expect a return message from the server)
3245 const char* keys
[]= {"0"};
3246 size_t lengths
[]= {1};
3249 memcached_result_st results_obj
;
3250 memcached_result_st
*results
;
3251 test_compare(MEMCACHED_SUCCESS
,
3252 memcached_mget(memc
, keys
, lengths
, 1));
3254 results
= memcached_result_create(memc
, &results_obj
);
3256 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3258 test_compare(MEMCACHED_SUCCESS
, ret
);
3259 uint64_t cas
= memcached_result_cas(results
);
3260 memcached_result_free(&results_obj
);
3262 test_compare(MEMCACHED_SUCCESS
,
3263 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3266 * The item will have a new cas value, so try to set it again with the old
3267 * value. This should fail!
3269 test_compare(MEMCACHED_SUCCESS
,
3270 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3271 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3272 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3273 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3276 return TEST_SUCCESS
;
3279 test_return_t
analyzer_test(memcached_st
*memc
)
3281 memcached_analysis_st
*report
;
3282 memcached_return_t rc
;
3284 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3285 test_compare(MEMCACHED_SUCCESS
, rc
);
3286 test_true(memc_stat
);
3288 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3289 test_compare(MEMCACHED_SUCCESS
, rc
);
3293 memcached_stat_free(NULL
, memc_stat
);
3295 return TEST_SUCCESS
;
3298 test_return_t
util_version_test(memcached_st
*memc
)
3300 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
3301 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3303 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3305 // We expect failure
3308 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3309 fprintf(stderr
, "\nDumping Server Information\n\n");
3310 memcached_server_fn callbacks
[1];
3312 callbacks
[0]= dump_server_information
;
3313 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3314 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3316 test_true(if_successful
== false);
3318 memcached_server_instance_st instance
=
3319 memcached_server_instance_by_position(memc
, 0);
3321 memcached_version(memc
);
3323 // We only use one binary when we test, so this should be just fine.
3324 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3325 test_true(if_successful
== true);
3327 if (instance
->micro_version
> 0)
3329 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3331 else if (instance
->minor_version
> 0)
3333 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3335 else if (instance
->major_version
> 0)
3337 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3340 test_true(if_successful
== true);
3342 if (instance
->micro_version
> 0)
3344 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3346 else if (instance
->minor_version
> 0)
3348 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3350 else if (instance
->major_version
> 0)
3352 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3355 test_true(if_successful
== false);
3357 return TEST_SUCCESS
;
3360 test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3362 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3363 memcached_return_t rc
;
3364 memcached_server_instance_st instance
=
3365 memcached_server_instance_by_position(memc
, 0);
3367 // Test both the version that returns a code, and the one that does not.
3368 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3369 memcached_server_port(instance
) -1, NULL
) == -1);
3371 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3372 memcached_server_port(instance
) -1, &rc
) == -1);
3373 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3375 return TEST_SUCCESS
;
3379 test_return_t
getpid_test(memcached_st
*memc
)
3381 memcached_return_t rc
;
3382 memcached_server_instance_st instance
=
3383 memcached_server_instance_by_position(memc
, 0);
3385 // Test both the version that returns a code, and the one that does not.
3386 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3387 memcached_server_port(instance
), NULL
) > -1);
3389 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3390 memcached_server_port(instance
), &rc
) > -1);
3391 test_compare(MEMCACHED_SUCCESS
, rc
);
3393 return TEST_SUCCESS
;
3396 test_return_t
ping_test(memcached_st
*memc
)
3398 memcached_return_t rc
;
3399 memcached_server_instance_st instance
=
3400 memcached_server_instance_by_position(memc
, 0);
3402 // Test both the version that returns a code, and the one that does not.
3403 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3404 memcached_server_port(instance
), NULL
));
3406 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3407 memcached_server_port(instance
), &rc
));
3409 test_compare(MEMCACHED_SUCCESS
, rc
);
3411 return TEST_SUCCESS
;
3416 test_return_t
hash_sanity_test (memcached_st
*memc
)
3420 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3421 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3422 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3423 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3424 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3425 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3426 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3427 #ifdef HAVE_HSIEH_HASH
3428 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3430 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3431 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3432 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3434 return TEST_SUCCESS
;
3438 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3440 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3442 test_compare(MEMCACHED_SUCCESS
,
3443 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3444 (uint64_t)MEMCACHED_HASH_HSIEH
));
3446 return TEST_SUCCESS
;
3449 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3451 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3453 test_compare(MEMCACHED_SUCCESS
,
3454 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3456 return TEST_SUCCESS
;
3459 test_return_t
one_at_a_time_run (memcached_st
*)
3464 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3466 test_compare(one_at_a_time_values
[x
],
3467 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3470 return TEST_SUCCESS
;
3473 test_return_t
md5_run (memcached_st
*)
3478 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3480 test_compare(md5_values
[x
],
3481 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3484 return TEST_SUCCESS
;
3487 test_return_t
crc_run (memcached_st
*)
3492 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3494 test_compare(crc_values
[x
],
3495 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3498 return TEST_SUCCESS
;
3501 test_return_t
fnv1_64_run (memcached_st
*)
3503 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3508 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3510 test_compare(fnv1_64_values
[x
],
3511 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3514 return TEST_SUCCESS
;
3517 test_return_t
fnv1a_64_run (memcached_st
*)
3519 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3524 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3526 test_compare(fnv1a_64_values
[x
],
3527 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3530 return TEST_SUCCESS
;
3533 test_return_t
fnv1_32_run (memcached_st
*)
3538 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3540 test_compare(fnv1_32_values
[x
],
3541 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
3544 return TEST_SUCCESS
;
3547 test_return_t
fnv1a_32_run (memcached_st
*)
3552 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3554 test_compare(fnv1a_32_values
[x
],
3555 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
3558 return TEST_SUCCESS
;
3561 test_return_t
hsieh_run (memcached_st
*)
3563 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3568 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3570 test_compare(hsieh_values
[x
],
3571 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
3574 return TEST_SUCCESS
;
3577 test_return_t
murmur_run (memcached_st
*)
3579 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3581 #ifdef WORDS_BIGENDIAN
3582 (void)murmur_values
;
3583 return TEST_SKIPPED
;
3588 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3590 test_compare(murmur_values
[x
],
3591 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
3594 return TEST_SUCCESS
;
3598 test_return_t
jenkins_run (memcached_st
*)
3603 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3605 test_compare(jenkins_values
[x
],
3606 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
3609 return TEST_SUCCESS
;
3612 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
3614 return libhashkit_md5(string
, string_length
);
3617 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
3619 return libhashkit_crc32(string
, string_length
);
3622 test_return_t
memcached_get_hashkit_test (memcached_st
*)
3628 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3630 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};
3631 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};
3633 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
3635 hashkit_clone(&new_kit
, kit
);
3636 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
3638 memcached_set_hashkit(memc
, &new_kit
);
3641 Verify Setting the hash.
3643 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3647 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3648 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
3653 Now check memcached_st.
3655 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3659 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3660 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
3663 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
3665 memcached_set_hashkit(memc
, &new_kit
);
3668 Verify Setting the hash.
3670 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3674 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
3675 test_true(crc_values
[x
] == hash_val
);
3678 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3682 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
3683 test_compare(crc_hosts
[x
], hash_val
);
3686 memcached_free(memc
);
3688 return TEST_SUCCESS
;
3692 Test case adapted from John Gorman <johngorman2@gmail.com>
3694 We are testing the error condition when we connect to a server via memcached_get()
3695 but find that the server is not available.
3697 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
3701 memcached_return rc
;
3704 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3706 // See if memcached is reachable.
3707 char *value
= memcached_get(tl_memc_h
,
3708 test_literal_param(__func__
),
3713 test_true(memcached_failed(rc
));
3715 memcached_free(tl_memc_h
);
3717 return TEST_SUCCESS
;
3721 We connect to a server which exists, but search for a key that does not exist.
3723 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3727 memcached_return rc
;
3729 // See if memcached is reachable.
3730 char *value
= memcached_get(memc
,
3731 test_literal_param(__func__
),
3736 test_compare(MEMCACHED_NOTFOUND
, rc
);
3738 return TEST_SUCCESS
;
3742 Test case adapted from John Gorman <johngorman2@gmail.com>
3744 We are testing the error condition when we connect to a server via memcached_get_by_key()
3745 but find that the server is not available.
3747 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
3751 memcached_return rc
;
3754 memcached_st
*tl_memc_h
= memcached_create(NULL
);
3755 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
3756 memcached_server_push(tl_memc_h
, servers
);
3757 memcached_server_list_free(servers
);
3759 // See if memcached is reachable.
3760 char *value
= memcached_get_by_key(tl_memc_h
,
3761 test_literal_param(__func__
), // Key
3762 test_literal_param(__func__
), // Value
3767 test_true(memcached_failed(rc
));
3769 memcached_free(tl_memc_h
);
3771 return TEST_SUCCESS
;
3775 We connect to a server which exists, but search for a key that does not exist.
3777 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
3781 memcached_return rc
;
3783 // See if memcached is reachable.
3784 char *value
= memcached_get_by_key(memc
,
3785 test_literal_param(__func__
), // Key
3786 test_literal_param(__func__
), // Value
3791 test_compare(MEMCACHED_NOTFOUND
, rc
);
3793 return TEST_SUCCESS
;
3796 test_return_t
regression_bug_434484(memcached_st
*memc
)
3798 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3800 test_compare(MEMCACHED_NOTSTORED
,
3801 memcached_append(memc
,
3802 test_literal_param(__func__
), // Key
3803 test_literal_param(__func__
), // Value
3806 libtest::vchar_t data
;
3807 data
.resize(2048 * 1024);
3808 test_compare(MEMCACHED_E2BIG
,
3810 test_literal_param(__func__
), // Key
3811 &data
[0], data
.size(), 0, 0));
3813 return TEST_SUCCESS
;
3816 test_return_t
regression_bug_434843(memcached_st
*original_memc
)
3818 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
3820 memcached_return_t rc
;
3822 memcached_execute_fn callbacks
[]= { &callback_counter
};
3825 * I only want to hit only _one_ server so I know the number of requests I'm
3826 * sending in the pipleine to the server. Let's try to do a multiget of
3827 * 1024 (that should satisfy most users don't you think?). Future versions
3828 * will include a mget_execute function call if you need a higher number.
3830 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
3835 * Run two times.. the first time we should have 100% cache miss,
3836 * and the second time we should have 100% cache hits
3838 for (ptrdiff_t y
= 0; y
< 2; y
++)
3840 test_compare(MEMCACHED_SUCCESS
,
3841 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
3843 // One the first run we should get a NOT_FOUND, but on the second some data
3844 // should be returned.
3845 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
3846 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3850 /* The first iteration should give me a 100% cache miss. verify that*/
3851 char blob
[1024]= { 0 };
3853 test_false(counter
);
3855 for (size_t x
= 0; x
< keys
.size(); ++x
)
3857 rc
= memcached_add(memc
,
3858 keys
.key_at(x
), keys
.length_at(x
),
3859 blob
, sizeof(blob
), 0, 0);
3860 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
3865 /* Verify that we received all of the key/value pairs */
3866 test_compare(counter
, keys
.size());
3870 memcached_free(memc
);
3872 return TEST_SUCCESS
;
3875 test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
3877 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3879 return regression_bug_434843(memc
);
3882 test_return_t
regression_bug_421108(memcached_st
*memc
)
3884 memcached_return_t rc
;
3885 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3886 test_compare(MEMCACHED_SUCCESS
, rc
);
3888 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
3889 test_compare(MEMCACHED_SUCCESS
, rc
);
3890 test_true(bytes_str
);
3891 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
3893 test_compare(MEMCACHED_SUCCESS
, rc
);
3894 test_true(bytes_read_str
);
3896 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
3897 "bytes_written", &rc
);
3898 test_compare(MEMCACHED_SUCCESS
, rc
);
3899 test_true(bytes_written_str
);
3901 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
3902 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
3903 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
3905 test_true(bytes
!= bytes_read
);
3906 test_true(bytes
!= bytes_written
);
3908 /* Release allocated resources */
3910 free(bytes_read_str
);
3911 free(bytes_written_str
);
3912 memcached_stat_free(NULL
, memc_stat
);
3914 return TEST_SUCCESS
;
3918 * The test case isn't obvious so I should probably document why
3919 * it works the way it does. Bug 442914 was caused by a bug
3920 * in the logic in memcached_purge (it did not handle the case
3921 * where the number of bytes sent was equal to the watermark).
3922 * In this test case, create messages so that we hit that case
3923 * and then disable noreply mode and issue a new command to
3924 * verify that it isn't stuck. If we change the format for the
3925 * delete command or the watermarks, we need to update this
3928 test_return_t
regression_bug_442914(memcached_st
*original_memc
)
3930 test_skip(original_memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
3932 memcached_st
* memc
= create_single_instance_memcached(original_memc
, "--NOREPLY --TCP-NODELAY");
3934 for (uint32_t x
= 0; x
< 250; ++x
)
3937 size_t len
= (size_t)snprintf(key
, sizeof(key
), "%0250u", x
);
3938 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
3939 char error_buffer
[2048]= { 0 };
3940 snprintf(error_buffer
, sizeof(error_buffer
), "%s key: %s", memcached_last_error_message(memc
), key
);
3941 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, error_buffer
);
3944 // Delete, and then delete again to look for not found
3947 size_t len
= snprintf(key
, sizeof(key
), "%037u", 251U);
3948 memcached_return_t rc
= memcached_delete(memc
, key
, len
, 0);
3949 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
3951 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, false));
3952 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, key
, len
, 0));
3955 memcached_free(memc
);
3957 return TEST_SUCCESS
;
3960 test_return_t
regression_bug_447342(memcached_st
*memc
)
3962 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
3964 return TEST_SKIPPED
;
3967 test_compare(MEMCACHED_SUCCESS
,
3968 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
3972 for (size_t x
= 0; x
< keys
.size(); ++x
)
3974 test_compare(MEMCACHED_SUCCESS
,
3976 keys
.key_at(x
), keys
.length_at(x
), // Keys
3977 keys
.key_at(x
), keys
.length_at(x
), // Values
3982 ** We are using the quiet commands to store the replicas, so we need
3983 ** to ensure that all of them are processed before we can continue.
3984 ** In the test we go directly from storing the object to trying to
3985 ** receive the object from all of the different servers, so we
3986 ** could end up in a race condition (the memcached server hasn't yet
3987 ** processed the quiet command from the replication set when it process
3988 ** the request from the other client (created by the clone)). As a
3989 ** workaround for that we call memcached_quit to send the quit command
3990 ** to the server and wait for the response ;-) If you use the test code
3991 ** as an example for your own code, please note that you shouldn't need
3994 memcached_quit(memc
);
3996 /* Verify that all messages are stored, and we didn't stuff too much
3999 test_compare(MEMCACHED_SUCCESS
,
4000 memcached_mget(memc
,
4001 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4003 unsigned int counter
= 0;
4004 memcached_execute_fn callbacks
[]= { &callback_counter
};
4005 test_compare(MEMCACHED_SUCCESS
,
4006 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4008 /* Verify that we received all of the key/value pairs */
4009 test_compare(counter
, keys
.size());
4011 memcached_quit(memc
);
4013 * Don't do the following in your code. I am abusing the internal details
4014 * within the library, and this is not a supported interface.
4015 * This is to verify correct behavior in the library. Fake that two servers
4018 memcached_server_instance_st instance_one
= memcached_server_instance_by_position(memc
, 0);
4019 memcached_server_instance_st instance_two
= memcached_server_instance_by_position(memc
, 2);
4020 in_port_t port0
= instance_one
->port
;
4021 in_port_t port2
= instance_two
->port
;
4023 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4024 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4026 test_compare(MEMCACHED_SUCCESS
,
4027 memcached_mget(memc
,
4028 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4031 test_compare(MEMCACHED_SUCCESS
,
4032 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4033 test_compare(counter
, keys
.size());
4035 /* restore the memc handle */
4036 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4037 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4039 memcached_quit(memc
);
4041 /* Remove half of the objects */
4042 for (size_t x
= 0; x
< keys
.size(); ++x
)
4046 test_compare(MEMCACHED_SUCCESS
,
4047 memcached_delete(memc
, keys
.key_at(x
), keys
.length_at(x
), 0));
4051 memcached_quit(memc
);
4052 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4053 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4055 /* now retry the command, this time we should have cache misses */
4056 test_compare(MEMCACHED_SUCCESS
,
4057 memcached_mget(memc
,
4058 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
4061 test_compare(MEMCACHED_SUCCESS
,
4062 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4063 test_compare(counter
, (unsigned int)(keys
.size() >> 1));
4065 /* restore the memc handle */
4066 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4067 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4069 return TEST_SUCCESS
;
4072 test_return_t
regression_bug_463297(memcached_st
*memc
)
4074 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4076 // Since we blocked timed delete, this test is no longer valid.
4078 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4079 test_true(memc_clone
);
4080 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4082 memcached_server_instance_st instance
=
4083 memcached_server_instance_by_position(memc_clone
, 0);
4085 if (instance
->major_version
> 1 ||
4086 (instance
->major_version
== 1 &&
4087 instance
->minor_version
> 2))
4089 /* Binary protocol doesn't support deferred delete */
4090 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4091 test_true(bin_clone
);
4092 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4093 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4094 memcached_free(bin_clone
);
4096 memcached_quit(memc_clone
);
4098 /* If we know the server version, deferred delete should fail
4099 * with invalid arguments */
4100 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4102 /* If we don't know the server version, we should get a protocol error */
4103 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4105 /* but there is a bug in some of the memcached servers (1.4) that treats
4106 * the counter as noreply so it doesn't send the proper error message
4108 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4110 /* And buffered mode should be disabled and we should get protocol error */
4111 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4112 rc
= memcached_delete(memc
, "foo", 3, 1);
4113 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4115 /* Same goes for noreply... */
4116 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4117 rc
= memcached_delete(memc
, "foo", 3, 1);
4118 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4120 /* but a normal request should go through (and be buffered) */
4121 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4122 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4124 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4125 /* unbuffered noreply should be success */
4126 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4127 /* unbuffered with reply should be not found... */
4128 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4129 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4132 memcached_free(memc_clone
);
4135 return TEST_SUCCESS
;
4139 /* Test memcached_server_get_last_disconnect
4140 * For a working server set, shall be NULL
4141 * For a set of non existing server, shall not be NULL
4143 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4145 memcached_return_t rc
;
4146 memcached_server_instance_st disconnected_server
;
4148 /* With the working set of server */
4149 const char *key
= "marmotte";
4150 const char *value
= "milka";
4152 memcached_reset_last_disconnected_server(memc
);
4153 test_false(memc
->last_disconnected_server
);
4154 rc
= memcached_set(memc
, key
, strlen(key
),
4155 value
, strlen(value
),
4156 (time_t)0, (uint32_t)0);
4157 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4159 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4160 test_false(disconnected_server
);
4162 /* With a non existing server */
4164 memcached_server_st
*servers
;
4166 const char *server_list
= "localhost:9";
4168 servers
= memcached_servers_parse(server_list
);
4170 mine
= memcached_create(NULL
);
4171 rc
= memcached_server_push(mine
, servers
);
4172 test_compare(MEMCACHED_SUCCESS
, rc
);
4173 memcached_server_list_free(servers
);
4176 rc
= memcached_set(mine
, key
, strlen(key
),
4177 value
, strlen(value
),
4178 (time_t)0, (uint32_t)0);
4179 test_true(memcached_failed(rc
));
4181 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4182 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4183 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4184 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4186 memcached_quit(mine
);
4187 memcached_free(mine
);
4189 return TEST_SUCCESS
;
4192 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4194 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4195 char buffer
[BUFSIZ
];
4197 test_compare(MEMCACHED_SUCCESS
,
4198 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4200 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4203 // We will just use the error strings as our keys
4204 uint32_t counter
= 100;
4207 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4209 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4210 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4211 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4213 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
4214 test_true(disconnected_server
);
4215 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4216 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4220 memcached_reset_last_disconnected_server(memc
);
4225 memcached_free(memc
);
4227 return TEST_SUCCESS
;
4230 test_return_t
test_verbosity(memcached_st
*memc
)
4232 memcached_verbosity(memc
, 3);
4234 return TEST_SUCCESS
;
4238 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
4239 const char *key
, size_t key_length
,
4240 const char *value
, size_t value_length
,
4250 return MEMCACHED_SUCCESS
;
4253 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4255 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4256 test_compare(MEMCACHED_SUCCESS
, rc
);
4258 test_compare(MEMCACHED_SUCCESS
,
4259 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4261 test_compare(MEMCACHED_SUCCESS
,
4262 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4264 test_compare(MEMCACHED_SUCCESS
,
4265 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4267 return TEST_SUCCESS
;
4271 * This test ensures that the failure counter isn't incremented during
4272 * normal termination of the memcached instance.
4274 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
4276 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4278 /* Ensure that we are connected to the server by setting a value */
4279 memcached_return_t rc
= memcached_set(memc
,
4280 test_literal_param(__func__
), // Key
4281 test_literal_param(__func__
), // Value
4282 time_t(0), uint32_t(0));
4283 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4286 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4288 /* The test is to see that the memcached_quit doesn't increase the
4289 * the server failure conter, so let's ensure that it is zero
4290 * before sending quit
4292 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4294 memcached_quit(memc
);
4296 /* Verify that it memcached_quit didn't increment the failure counter
4297 * Please note that this isn't bullet proof, because an error could
4300 test_zero(instance
->server_failure_counter
);
4302 memcached_free(memc
);
4304 return TEST_SUCCESS
;
4308 * This tests ensures expected disconnections (for some behavior changes
4309 * for instance) do not wrongly increase failure counter
4311 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4313 /* Set value to force connection to the server */
4314 const char *key
= "marmotte";
4315 const char *value
= "milka";
4317 test_compare_hint(MEMCACHED_SUCCESS
,
4318 memcached_set(memc
, key
, strlen(key
),
4319 value
, strlen(value
),
4320 (time_t)0, (uint32_t)0),
4321 memcached_last_error_message(memc
));
4324 /* put failure limit to 1 */
4325 test_compare(MEMCACHED_SUCCESS
,
4326 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4328 /* Put a retry timeout to effectively activate failure_limit effect */
4329 test_compare(MEMCACHED_SUCCESS
,
4330 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4332 /* change behavior that triggers memcached_quit()*/
4333 test_compare(MEMCACHED_SUCCESS
,
4334 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4337 /* Check if we still are connected */
4339 size_t string_length
;
4340 memcached_return rc
;
4341 char *string
= memcached_get(memc
, key
, strlen(key
),
4342 &string_length
, &flags
, &rc
);
4344 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4348 return TEST_SUCCESS
;
4351 test_return_t
regression_996813_TEST(memcached_st
*)
4353 memcached_st
* memc
= memcached_create(NULL
);
4355 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
4356 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
4357 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4358 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4359 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1));
4360 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 300));
4361 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 30));
4363 // We will never connect to these servers
4364 in_port_t base_port
= 11211;
4365 for (size_t x
= 0; x
< 17; x
++)
4367 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", base_port
+x
));
4369 test_compare(16U, memcached_generate_hash(memc
, test_literal_param("SZ6hu0SHweFmpwpc0w2R")));
4370 test_compare(1U, memcached_generate_hash(memc
, test_literal_param("SQCK9eiCf53YxHWnYA.o")));
4371 test_compare(10U, memcached_generate_hash(memc
, test_literal_param("SUSDkGXuuZC9t9VhMwa.")));
4372 test_compare(8U, memcached_generate_hash(memc
, test_literal_param("SnnqnJARfaCNT679iAF_")));
4374 memcached_free(memc
);
4376 return TEST_SUCCESS
;
4381 * Test that ensures mget_execute does not end into recursive calls that finally fails
4383 test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4387 return TEST_SKIPPED
; // My MAC can't handle this test
4390 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4393 * I only want to hit _one_ server so I know the number of requests I'm
4394 * sending in the pipeline.
4396 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4399 keys_st
keys(20480);
4401 /* First add all of the items.. */
4402 char blob
[1024]= { 0 };
4403 for (size_t x
= 0; x
< keys
.size(); ++x
)
4405 memcached_return rc
= memcached_set(memc
,
4406 keys
.key_at(x
), keys
.length_at(x
),
4407 blob
, sizeof(blob
), 0, 0);
4408 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4413 /* Try to get all of them with a large multiget */
4415 memcached_execute_function callbacks
[]= { &callback_counter
};
4416 memcached_return_t rc
= memcached_mget_execute(memc
,
4417 keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size(),
4418 callbacks
, &counter
, 1);
4419 test_compare(MEMCACHED_SUCCESS
, rc
);
4421 char* the_value
= NULL
;
4422 char the_key
[MEMCACHED_MAX_KEY
];
4423 size_t the_key_length
;
4424 size_t the_value_length
;
4428 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4430 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4436 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4439 test_compare(MEMCACHED_END
, rc
);
4441 /* Verify that we got all of the items */
4442 test_compare(counter
, keys
.size());
4445 memcached_free(memc
);
4447 return TEST_SUCCESS
;
4450 test_return_t
regression_bug_583031(memcached_st
*)
4452 memcached_st
*memc
= memcached_create(NULL
);
4454 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
4456 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
4457 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4458 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4459 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4460 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4461 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4463 memcached_return_t rc
;
4467 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4471 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
4473 memcached_free(memc
);
4475 return TEST_SUCCESS
;
4478 test_return_t
regression_bug_581030(memcached_st
*)
4481 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4482 test_false(local_stat
);
4484 memcached_stat_free(NULL
, NULL
);
4487 return TEST_SUCCESS
;
4490 #define regression_bug_655423_COUNT 6000
4491 test_return_t
regression_bug_655423(memcached_st
*memc
)
4493 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4494 memc
= NULL
; // Just to make sure it is not used
4499 return TEST_SKIPPED
;
4502 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4503 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4504 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4505 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4507 memset(payload
, int('x'), sizeof(payload
));
4509 keys_st
keys(regression_bug_655423_COUNT
);
4511 for (size_t x
= 0; x
< keys
.size(); x
++)
4513 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
4516 payload
, sizeof(payload
), 0, 0));
4519 for (size_t x
= 0; x
< keys
.size(); x
++)
4521 size_t value_length
;
4522 memcached_return_t rc
;
4523 char *value
= memcached_get(clone
,
4526 &value_length
, NULL
, &rc
);
4528 if (rc
== MEMCACHED_NOTFOUND
)
4531 test_zero(value_length
);
4535 test_compare(MEMCACHED_SUCCESS
, rc
);
4537 test_compare(100LLU, value_length
);
4541 test_compare(MEMCACHED_SUCCESS
,
4542 memcached_mget(clone
,
4543 keys
.keys_ptr(), keys
.lengths_ptr(),
4547 memcached_result_st
*result
= NULL
;
4548 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
4550 test_compare(size_t(100), memcached_result_length(result
));
4554 test_true(count
> 100); // If we don't get back atleast this, something is up
4556 memcached_free(clone
);
4558 return TEST_SUCCESS
;
4562 * Test that ensures that buffered set to not trigger problems during io_flush
4564 #define regression_bug_490520_COUNT 200480
4565 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
4567 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
4569 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
4570 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
4571 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4572 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
4573 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
4575 /* First add all of the items.. */
4576 char blob
[3333] = {0};
4577 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
4580 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
4582 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
4583 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
4586 memcached_free(memc
);
4588 return TEST_SUCCESS
;
4592 test_return_t
regression_994772_TEST(memcached_st
* memc
)
4594 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4596 test_compare(MEMCACHED_SUCCESS
,
4598 test_literal_param(__func__
), // Key
4599 test_literal_param(__func__
), // Value
4600 time_t(0), uint32_t(0)));
4602 const char *keys
[] = { __func__
};
4603 size_t key_length
[]= { strlen(__func__
) };
4604 test_compare(MEMCACHED_SUCCESS
,
4605 memcached_mget(memc
, keys
, key_length
, 1));
4607 memcached_return_t rc
;
4608 memcached_result_st
*results
= memcached_fetch_result(memc
, NULL
, &rc
);
4610 test_compare(MEMCACHED_SUCCESS
, rc
);
4612 test_strcmp(__func__
, memcached_result_value(results
));
4613 uint64_t cas_value
= memcached_result_cas(results
);
4614 test_true(cas_value
);
4616 memcached_result_free(results
);
4618 // Bad cas value, sanity check
4619 test_true(cas_value
!= 9999);
4620 test_compare(MEMCACHED_END
,
4622 test_literal_param(__func__
), // Key
4623 test_literal_param(__FILE__
), // Value
4624 time_t(0), uint32_t(0), 9999));
4626 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
4627 "different", strlen("different"), // Key
4628 test_literal_param(__FILE__
), // Value
4629 time_t(0), uint32_t(0)));
4631 return TEST_SUCCESS
;
4634 test_return_t
regression_bug_854604(memcached_st
*)
4638 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
4640 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
4642 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
4643 test_compare(buffer
[0], 0);
4645 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
4646 test_true(strlen(buffer
));
4648 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
4649 test_true(strlen(buffer
));
4651 return TEST_SUCCESS
;
4654 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
4656 fprintf(stderr
, "Iteration #%u: ", it
);
4658 if (error
== MEMCACHED_ERRNO
)
4660 fprintf(stderr
, "system error %d from %s: %s\n",
4661 errno
, what
, strerror(errno
));
4665 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
4666 memcached_strerror(mc
, error
));
4670 #define TEST_CONSTANT_CREATION 200
4672 test_return_t
regression_bug_(memcached_st
*memc
)
4674 const char *remote_server
;
4677 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4679 return TEST_SKIPPED
;
4682 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
4684 memcached_st
* mc
= memcached_create(NULL
);
4685 memcached_return rc
;
4687 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
4688 if (rc
!= MEMCACHED_SUCCESS
)
4690 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
4693 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
4694 if (rc
!= MEMCACHED_SUCCESS
)
4696 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
4699 rc
= memcached_server_add(mc
, remote_server
, 0);
4700 if (rc
!= MEMCACHED_SUCCESS
)
4702 memcached_die(mc
, rc
, "memcached_server_add", x
);
4705 const char *set_key
= "akey";
4706 const size_t set_key_len
= strlen(set_key
);
4707 const char *set_value
= "a value";
4708 const size_t set_value_len
= strlen(set_value
);
4710 if (rc
== MEMCACHED_SUCCESS
)
4714 size_t get_value_len
;
4716 uint32_t get_value_flags
;
4718 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
4719 &get_value_flags
, &rc
);
4720 if (rc
!= MEMCACHED_SUCCESS
)
4722 memcached_die(mc
, rc
, "memcached_get", x
);
4728 (get_value_len
!= set_value_len
4729 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
4731 fprintf(stderr
, "Values don't match?\n");
4732 rc
= MEMCACHED_FAILURE
;
4738 rc
= memcached_set(mc
,
4739 set_key
, set_key_len
,
4740 set_value
, set_value_len
,
4744 if (rc
!= MEMCACHED_SUCCESS
)
4746 memcached_die(mc
, rc
, "memcached_set", x
);
4753 if (rc
!= MEMCACHED_SUCCESS
)
4759 return TEST_SUCCESS
;
4762 test_return_t
kill_HUP_TEST(memcached_st
*original_memc
)
4764 memcached_st
*memc
= create_single_instance_memcached(original_memc
, 0);
4767 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
4770 test_true((pid
= libmemcached_util_getpid(memcached_server_name(instance
),
4771 memcached_server_port(instance
), NULL
)) > -1);
4774 test_compare(MEMCACHED_SUCCESS
,
4776 test_literal_param(__func__
), // Keys
4777 test_literal_param(__func__
), // Values
4779 test_true_got(kill(pid
, SIGHUP
) == 0, strerror(errno
));
4781 test_compare(MEMCACHED_CONNECTION_FAILURE
,
4783 test_literal_param(__func__
), // Keys
4784 test_literal_param(__func__
), // Values
4787 memcached_free(memc
);
4789 return TEST_SUCCESS
;