1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 #include <libtest/test.hpp>
41 #if defined(HAVE_LIBUUID) && HAVE_LIBUUID
42 #include <uuid/uuid.h>
49 #include <libmemcached-1.0/memcached.h>
50 #include <libmemcached/is.h>
51 #include <libmemcached/server_instance.h>
53 #include <libhashkit-1.0/hashkit.h>
59 #include <semaphore.h>
63 #include <sys/types.h>
68 #include <libtest/server.h>
70 #include "clients/generator.h"
72 #define SMALL_STRING_LEN 1024
74 #include <libtest/test.hpp>
76 #include "tests/basic.h"
77 #include "tests/debug.h"
78 #include "tests/deprecated.h"
79 #include "tests/error_conditions.h"
80 #include "tests/exist.h"
81 #include "tests/ketama.h"
82 #include "tests/namespace.h"
83 #include "tests/parser.h"
84 #include "tests/libmemcached-1.0/callback_counter.h"
85 #include "tests/libmemcached-1.0/dump.h"
86 #include "tests/libmemcached-1.0/fetch_all_results.h"
87 #include "tests/libmemcached-1.0/generate.h"
88 #include "tests/libmemcached-1.0/haldenbrand.h"
89 #include "tests/libmemcached-1.0/stat.h"
90 #include "tests/touch.h"
91 #include "tests/callbacks.h"
92 #include "tests/pool.h"
93 #include "tests/print.h"
94 #include "tests/replication.h"
95 #include "tests/server_add.h"
96 #include "tests/virtual_buckets.h"
98 using namespace libtest
;
100 #include <libmemcached/util.h>
102 #include "tests/hash_results.h"
104 #include "tests/libmemcached-1.0/servers_to_create.h"
106 #define UUID_STRING_MAXLENGTH 36
112 init(arg
, UUID_STRING_MAXLENGTH
);
115 keys_st(size_t arg
, size_t padding
)
120 void init(size_t arg
, size_t padding
)
122 _lengths
.resize(arg
);
125 for (size_t x
= 0; x
< _keys
.size(); x
++)
127 libtest::vchar_t key_buffer
;
128 key_buffer
.resize(padding
+1);
129 memset(&key_buffer
[0], 'x', padding
);
136 uuid_unparse(out
, &key_buffer
[0]);
137 _keys
[x
]= strdup(&key_buffer
[0]);
138 (_keys
[x
])[UUID_STRING_MAXLENGTH
]= 'x';
140 else // We just use a number and pad the string if UUID is not available
142 char int_buffer
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
143 int key_length
= snprintf(int_buffer
, sizeof(int_buffer
), "%u", uint32_t(x
));
144 memcpy(&key_buffer
[0], int_buffer
, key_length
);
145 _keys
[x
]= strdup(&key_buffer
[0]);
147 _lengths
[x
]= padding
;
153 for (libtest::vchar_ptr_t::iterator iter
= _keys
.begin();
161 libtest::vchar_ptr_t::iterator
begin()
163 return _keys
.begin();
166 libtest::vchar_ptr_t::iterator
end()
176 std::vector
<size_t>& lengths()
181 libtest::vchar_ptr_t
& keys()
186 size_t* lengths_ptr()
196 char* key_at(size_t arg
)
201 size_t length_at(size_t arg
)
203 return _lengths
[arg
];
207 libtest::vchar_ptr_t _keys
;
208 std::vector
<size_t> _lengths
;
212 @note This should be testing to see if the server really supports the binary protocol.
214 static test_return_t
pre_binary(memcached_st
*memc
)
216 test_skip(true, libmemcached_util_version_check(memc
, 1, 4, 4));
217 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
222 static memcached_return_t
return_value_based_on_buffering(memcached_st
*memc
)
224 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
))
226 return MEMCACHED_BUFFERED
;
229 return MEMCACHED_SUCCESS
;
232 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
235 * I only want to hit _one_ server so I know the number of requests I'm
236 * sending in the pipeline.
238 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
240 char server_string
[1024];
241 int server_string_length
;
244 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
245 memcached_server_name(instance
), int(memcached_server_port(instance
)),
250 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
251 memcached_server_name(instance
), int(memcached_server_port(instance
)));
254 if (server_string_length
<= 0)
260 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, buffer
, sizeof(buffer
))))
262 Error
<< "Failed to parse " << server_string_length
;
266 return memcached(server_string
, server_string_length
);
270 static test_return_t
init_test(memcached_st
*not_used
)
275 (void)memcached_create(&memc
);
276 memcached_free(&memc
);
281 #define TEST_PORT_COUNT 7
282 in_port_t test_ports
[TEST_PORT_COUNT
];
284 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
285 const memcached_server_st
*server
,
289 size_t bigger
= *((size_t *)(context
));
291 assert(bigger
<= memcached_server_port(server
));
292 *((size_t *)(context
))= memcached_server_port(server
);
294 return MEMCACHED_SUCCESS
;
297 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
298 const memcached_server_st
*instance
,
302 FILE *stream
= (FILE *)context
;
305 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
306 memcached_server_name(instance
),
307 memcached_server_port(instance
),
308 instance
->major_version
,
309 instance
->minor_version
,
310 instance
->micro_version
);
312 return MEMCACHED_SUCCESS
;
315 static test_return_t
server_sort_test(memcached_st
*ptr
)
317 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
319 memcached_return_t rc
;
320 memcached_server_fn callbacks
[1];
321 memcached_st
*local_memc
;
324 local_memc
= memcached_create(NULL
);
325 test_true(local_memc
);
326 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
328 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
330 test_ports
[x
]= (in_port_t
)random() % 64000;
331 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
332 test_compare(memcached_server_count(local_memc
), x
+1);
334 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
336 test_compare(MEMCACHED_SUCCESS
, rc
);
339 callbacks
[0]= server_display_function
;
340 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
343 memcached_free(local_memc
);
348 static test_return_t
server_sort2_test(memcached_st
*ptr
)
350 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
351 memcached_server_fn callbacks
[1];
352 memcached_st
*local_memc
;
353 memcached_server_instance_st instance
;
356 local_memc
= memcached_create(NULL
);
357 test_true(local_memc
);
358 test_compare(MEMCACHED_SUCCESS
,
359 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
361 test_compare(MEMCACHED_SUCCESS
,
362 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
363 instance
= memcached_server_instance_by_position(local_memc
, 0);
364 test_compare(in_port_t(43043), memcached_server_port(instance
));
366 test_compare(MEMCACHED_SUCCESS
,
367 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
369 instance
= memcached_server_instance_by_position(local_memc
, 0);
370 test_compare(in_port_t(43042), memcached_server_port(instance
));
372 instance
= memcached_server_instance_by_position(local_memc
, 1);
373 test_compare(in_port_t(43043), memcached_server_port(instance
));
375 callbacks
[0]= server_display_function
;
376 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
379 memcached_free(local_memc
);
384 static test_return_t
memcached_server_remove_test(memcached_st
*)
386 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";
389 test_compare(MEMCACHED_SUCCESS
,
390 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
391 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
394 memcached_server_fn callbacks
[1];
395 callbacks
[0]= server_print_callback
;
396 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
398 memcached_free(memc
);
403 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
404 const memcached_server_st
*server
,
408 uint32_t x
= *((uint32_t *)(context
));
410 if (! (test_ports
[x
] == server
->port
))
412 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
413 return MEMCACHED_FAILURE
;
416 *((uint32_t *)(context
))= ++x
;
418 return MEMCACHED_SUCCESS
;
421 static test_return_t
server_unsort_test(memcached_st
*ptr
)
423 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
424 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
425 memcached_server_fn callbacks
[1];
426 memcached_st
*local_memc
;
429 local_memc
= memcached_create(NULL
);
430 test_true(local_memc
);
432 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
434 test_ports
[x
]= (in_port_t
)(random() % 64000);
435 test_compare(MEMCACHED_SUCCESS
,
436 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
437 test_compare(memcached_server_count(local_memc
), x
+1);
439 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
443 callbacks
[0]= server_display_unsort_function
;
444 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
446 /* Now we sort old data! */
447 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
448 callbacks
[0]= server_display_function
;
449 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
452 memcached_free(local_memc
);
457 static test_return_t
allocation_test(memcached_st
*not_used
)
461 memc
= memcached_create(NULL
);
463 memcached_free(memc
);
468 static test_return_t
clone_test(memcached_st
*memc
)
472 memcached_st
*memc_clone
;
473 memc_clone
= memcached_clone(NULL
, NULL
);
474 test_true(memc_clone
);
475 memcached_free(memc_clone
);
478 /* Can we init from null? */
480 memcached_st
*memc_clone
;
481 memc_clone
= memcached_clone(NULL
, memc
);
482 test_true(memc_clone
);
485 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
486 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
487 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
488 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
491 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
492 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
493 test_true(memc_clone
->distribution
== memc
->distribution
);
494 { // Test all of the flags
495 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
496 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
497 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
498 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
499 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
500 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
501 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
502 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
503 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
504 test_true(memc_clone
->flags
.reply
== memc
->flags
.reply
);
505 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
506 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
507 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
509 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
510 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
511 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
512 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
513 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
514 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
515 test_true(memc_clone
->on_clone
== memc
->on_clone
);
516 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
517 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
518 test_true(memc_clone
->recv_size
== memc
->recv_size
);
519 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
520 test_true(memc_clone
->send_size
== memc
->send_size
);
521 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
522 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
523 test_true(memc_clone
->user_data
== memc
->user_data
);
525 memcached_free(memc_clone
);
528 /* Can we init from struct? */
530 memcached_st declared_clone
;
531 memcached_st
*memc_clone
;
532 memset(&declared_clone
, 0 , sizeof(memcached_st
));
533 memc_clone
= memcached_clone(&declared_clone
, NULL
);
534 test_true(memc_clone
);
535 memcached_free(memc_clone
);
538 /* Can we init from struct? */
540 memcached_st declared_clone
;
541 memcached_st
*memc_clone
;
542 memset(&declared_clone
, 0 , sizeof(memcached_st
));
543 memc_clone
= memcached_clone(&declared_clone
, memc
);
544 test_true(memc_clone
);
545 memcached_free(memc_clone
);
551 static test_return_t
userdata_test(memcached_st
*memc
)
554 test_false(memcached_set_user_data(memc
, foo
));
555 test_true(memcached_get_user_data(memc
) == foo
);
556 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
561 static test_return_t
connection_test(memcached_st
*memc
)
563 test_compare(MEMCACHED_SUCCESS
,
564 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
569 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
571 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
573 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
575 test_compare(37, int(MEMCACHED_BEHAVIOR_MAX
));
580 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
582 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
584 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
586 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
591 static test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
593 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
594 982370485U, 1263635348U, 4242906218U, 3829656100U,
595 1891735253U, 334139633U, 2257084983U, 3351789013U,
596 13199785U, 2542027183U, 1097051614U, 199566778U,
597 2748246961U, 2465192557U, 1664094137U, 2405439045U,
598 1842224848U, 692413798U, 3479807801U, 919913813U,
599 4269430871U, 610793021U, 527273862U, 1437122909U,
600 2300930706U, 2943759320U, 674306647U, 2400528935U,
601 54481931U, 4186304426U, 1741088401U, 2979625118U,
602 4159057246U, 3425930182U, 2593724503U, 1868899624U,
603 1769812374U, 2302537950U, 1110330676U, 3365377466U,
604 1336171666U, 3021258493U, 2334992265U, 3861994737U,
605 3582734124U, 3365377466U };
607 // You have updated the memcache_error messages but not updated docs/tests.
608 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
611 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
612 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
613 MEMCACHED_HASH_JENKINS
);
614 if (values
[rc
] != hash_val
)
616 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
617 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
619 test_compare(values
[rc
], hash_val
);
621 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
626 static test_return_t
set_test(memcached_st
*memc
)
628 memcached_return_t rc
= memcached_set(memc
,
629 test_literal_param("foo"),
630 test_literal_param("when we sanitize"),
631 time_t(0), (uint32_t)0);
632 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
637 static test_return_t
append_test(memcached_st
*memc
)
639 memcached_return_t rc
;
640 const char *in_value
= "we";
644 test_compare(MEMCACHED_SUCCESS
,
645 memcached_flush(memc
, 0));
647 test_compare(MEMCACHED_SUCCESS
,
649 test_literal_param(__func__
),
650 in_value
, strlen(in_value
),
651 time_t(0), uint32_t(0)));
653 test_compare(MEMCACHED_SUCCESS
,
654 memcached_append(memc
,
655 test_literal_param(__func__
),
656 " the", strlen(" the"),
657 time_t(0), uint32_t(0)));
659 test_compare(MEMCACHED_SUCCESS
,
660 memcached_append(memc
,
661 test_literal_param(__func__
),
662 " people", strlen(" people"),
663 time_t(0), uint32_t(0)));
665 char *out_value
= memcached_get(memc
,
666 test_literal_param(__func__
),
667 &value_length
, &flags
, &rc
);
668 test_memcmp(out_value
, "we the people", strlen("we the people"));
669 test_compare(strlen("we the people"), value_length
);
670 test_compare(MEMCACHED_SUCCESS
, rc
);
676 static test_return_t
append_binary_test(memcached_st
*memc
)
678 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
680 test_compare(MEMCACHED_SUCCESS
,
681 memcached_flush(memc
, 0));
683 test_compare(MEMCACHED_SUCCESS
,
685 test_literal_param(__func__
),
687 time_t(0), uint32_t(0)));
690 for (uint32_t x
= 0; store_list
[x
] ; x
++)
692 test_compare(MEMCACHED_SUCCESS
,
693 memcached_append(memc
,
694 test_literal_param(__func__
),
695 (char *)&store_list
[x
], sizeof(uint32_t),
696 time_t(0), uint32_t(0)));
702 memcached_return_t rc
;
703 uint32_t *value
= (uint32_t *)memcached_get(memc
,
704 test_literal_param(__func__
),
705 &value_length
, &flags
, &rc
);
706 test_compare(value_length
, sizeof(uint32_t) * count
);
707 test_compare(MEMCACHED_SUCCESS
, rc
);
709 for (uint32_t counter
= count
, *ptr
= value
; counter
; counter
--)
711 test_compare(*ptr
, store_list
[count
- counter
]);
719 static test_return_t
memcached_mget_mixed_memcached_get_TEST(memcached_st
*memc
)
723 for (libtest::vchar_ptr_t::iterator iter
= keys
.begin();
727 test_compare(MEMCACHED_SUCCESS
,
731 time_t(0), uint32_t(0)));
734 for (size_t loop
= 0; loop
< 20; loop
++)
738 test_compare(MEMCACHED_SUCCESS
,
739 memcached_mget(memc
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()));
741 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
744 size_t result_count
= 0;
745 memcached_return_t rc
;
746 while (memcached_fetch_result(memc
, results
, &rc
))
750 test_compare(keys
.size(), result_count
);
754 int which_key
= random() %keys
.size();
757 memcached_return_t rc
;
758 char *out_value
= memcached_get(memc
, keys
.key_at(which_key
), keys
.length_at(which_key
),
759 &value_length
, &flags
, &rc
);
760 test_compare(MEMCACHED_SUCCESS
, rc
);
761 test_null(out_value
);
762 test_zero(value_length
);
770 static test_return_t
cas2_test(memcached_st
*memc
)
772 const char *keys
[]= {"fudge", "son", "food"};
773 size_t key_length
[]= {5, 3, 4};
774 const char *value
= "we the people";
775 size_t value_length
= strlen("we the people");
777 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
779 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
781 for (uint32_t x
= 0; x
< 3; x
++)
783 test_compare(MEMCACHED_SUCCESS
,
784 memcached_set(memc
, keys
[x
], key_length
[x
],
785 keys
[x
], key_length
[x
],
786 time_t(50), uint32_t(9)));
789 test_compare(MEMCACHED_SUCCESS
,
790 memcached_mget(memc
, keys
, key_length
, 3));
792 memcached_result_st
*results
= memcached_result_create(memc
, NULL
);
795 memcached_return_t rc
;
796 results
= memcached_fetch_result(memc
, results
, &rc
);
798 test_true(results
->item_cas
);
799 test_compare(MEMCACHED_SUCCESS
, rc
);
800 test_true(memcached_result_cas(results
));
802 test_memcmp(value
, "we the people", strlen("we the people"));
803 test_compare(strlen("we the people"), value_length
);
804 test_compare(MEMCACHED_SUCCESS
, rc
);
806 memcached_result_free(results
);
811 static test_return_t
cas_test(memcached_st
*memc
)
813 const char* keys
[2] = { __func__
, NULL
};
814 size_t keylengths
[2] = { strlen(__func__
), 0 };
816 memcached_result_st results_obj
;
818 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
820 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
822 test_compare(MEMCACHED_SUCCESS
,
824 test_literal_param(__func__
),
825 test_literal_param("we the people"),
826 (time_t)0, (uint32_t)0));
828 test_compare(MEMCACHED_SUCCESS
,
829 memcached_mget(memc
, keys
, keylengths
, 1));
831 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
834 memcached_return_t rc
;
835 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
837 test_compare(MEMCACHED_SUCCESS
, rc
);
838 test_true(memcached_result_cas(results
));
839 test_memcmp("we the people", memcached_result_value(results
), test_literal_param_size("we the people"));
840 test_compare(test_literal_param_size("we the people"),
841 strlen(memcached_result_value(results
)));
843 uint64_t cas
= memcached_result_cas(results
);
846 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
847 test_true(rc
== MEMCACHED_END
);
848 test_true(results
== NULL
);
851 test_compare(MEMCACHED_SUCCESS
,
853 test_literal_param(__func__
),
854 test_literal_param("change the value"),
858 * The item will have a new cas value, so try to set it again with the old
859 * value. This should fail!
861 test_compare(MEMCACHED_DATA_EXISTS
,
863 test_literal_param(__func__
),
864 test_literal_param("change the value"),
867 memcached_result_free(&results_obj
);
872 static test_return_t
prepend_test(memcached_st
*memc
)
874 const char *key
= "fig";
875 const char *value
= "people";
877 test_compare(MEMCACHED_SUCCESS
,
878 memcached_flush(memc
, 0));
880 test_compare(MEMCACHED_SUCCESS
,
881 memcached_set(memc
, key
, strlen(key
),
882 value
, strlen(value
),
883 time_t(0), uint32_t(0)));
885 test_compare(MEMCACHED_SUCCESS
,
886 memcached_prepend(memc
, key
, strlen(key
),
887 "the ", strlen("the "),
888 time_t(0), uint32_t(0)));
890 test_compare(MEMCACHED_SUCCESS
,
891 memcached_prepend(memc
, key
, strlen(key
),
892 "we ", strlen("we "),
893 time_t(0), uint32_t(0)));
897 memcached_return_t rc
;
898 char *out_value
= memcached_get(memc
, key
, strlen(key
),
899 &value_length
, &flags
, &rc
);
900 test_memcmp(out_value
, "we the people", strlen("we the people"));
901 test_compare(strlen("we the people"), value_length
);
902 test_compare(MEMCACHED_SUCCESS
, rc
);
909 Set the value, then quit to make sure it is flushed.
910 Come back in and test that add fails.
912 static test_return_t
add_test(memcached_st
*memc
)
914 test_compare_hint(return_value_based_on_buffering(memc
),
916 test_literal_param(__func__
),
917 test_literal_param("when we sanitize"),
918 time_t(0), uint32_t(0)),
919 memcached_last_error_message(memc
));
921 memcached_quit(memc
);
923 test_compare_hint(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_DATA_EXISTS
: MEMCACHED_NOTSTORED
,
925 test_literal_param(__func__
),
926 test_literal_param("try something else"),
927 time_t(0), uint32_t(0)),
928 memcached_last_error_message(memc
));
934 ** There was a problem of leaking filedescriptors in the initial release
935 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
936 ** systems it seems that the kernel is slow on reclaiming the resources
937 ** because the connects starts to time out (the test doesn't do much
938 ** anyway, so just loop 10 iterations)
940 static test_return_t
add_wrapper(memcached_st
*memc
)
942 unsigned int max
= 10000;
950 for (uint32_t x
= 0; x
< max
; x
++)
956 static test_return_t
replace_test(memcached_st
*memc
)
958 test_compare(return_value_based_on_buffering(memc
),
960 test_literal_param(__func__
),
961 test_literal_param("when we sanitize"),
962 time_t(0), uint32_t(0)));
964 test_compare(MEMCACHED_SUCCESS
,
965 memcached_replace(memc
,
966 test_literal_param(__func__
),
967 test_literal_param("first we insert some data"),
968 time_t(0), uint32_t(0)));
973 static test_return_t
delete_test(memcached_st
*memc
)
975 test_compare(return_value_based_on_buffering(memc
),
977 test_literal_param(__func__
),
978 test_literal_param("when we sanitize"),
979 time_t(0), uint32_t(0)));
981 test_compare_hint(return_value_based_on_buffering(memc
),
982 memcached_delete(memc
,
983 test_literal_param(__func__
),
985 memcached_last_error_message(memc
));
990 static test_return_t
flush_test(memcached_st
*memc
)
992 uint64_t query_id
= memcached_query_id(memc
);
993 test_compare(MEMCACHED_SUCCESS
,
994 memcached_flush(memc
, 0));
995 test_compare(query_id
+1, memcached_query_id(memc
));
1000 static memcached_return_t
server_function(const memcached_st
*,
1001 const memcached_server_st
*,
1005 return MEMCACHED_SUCCESS
;
1008 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
1011 strncpy(context
, "foo bad", sizeof(context
));
1012 memcached_server_fn callbacks
[1];
1014 callbacks
[0]= server_function
;
1015 memcached_server_cursor(memc
, callbacks
, context
, 1);
1016 return TEST_SUCCESS
;
1019 static test_return_t
bad_key_test(memcached_st
*memc
)
1021 memcached_return_t rc
;
1022 const char *key
= "foo bad";
1025 uint64_t query_id
= memcached_query_id(memc
);
1027 // Just skip if we are in binary mode.
1028 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1030 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
1032 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
1033 test_true(memc_clone
);
1035 query_id
= memcached_query_id(memc_clone
);
1036 test_compare(MEMCACHED_SUCCESS
,
1037 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1038 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
1040 /* All keys are valid in the binary protocol (except for length) */
1041 if (memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == false)
1043 uint64_t before_query_id
= memcached_query_id(memc_clone
);
1045 size_t string_length
;
1046 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1047 &string_length
, &flags
, &rc
);
1048 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1049 test_zero(string_length
);
1052 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
1054 query_id
= memcached_query_id(memc_clone
);
1055 test_compare(MEMCACHED_SUCCESS
,
1056 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
1057 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
1059 size_t string_length
;
1060 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
1061 &string_length
, &flags
, &rc
);
1062 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1063 test_zero(string_length
);
1067 /* Test multi key for bad keys */
1068 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
1069 size_t key_lengths
[] = { 7, 7, 7 };
1070 query_id
= memcached_query_id(memc_clone
);
1071 test_compare(MEMCACHED_SUCCESS
,
1072 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1073 test_compare(query_id
, memcached_query_id(memc_clone
));
1075 query_id
= memcached_query_id(memc_clone
);
1076 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
1077 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
1078 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1080 query_id
= memcached_query_id(memc_clone
);
1081 // Grouping keys are not required to follow normal key behaviors
1082 test_compare(MEMCACHED_SUCCESS
,
1083 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
1084 test_compare(query_id
+1, memcached_query_id(memc_clone
));
1086 /* The following test should be moved to the end of this function when the
1087 memcached server is updated to allow max size length of the keys in the
1090 test_compare(MEMCACHED_SUCCESS
,
1091 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
1093 libtest::vchar_t longkey
;
1095 libtest::vchar_t::iterator it
= longkey
.begin();
1096 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
1099 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
1101 size_t string_length
;
1103 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
1104 test_compare(MEMCACHED_NOTFOUND
, rc
);
1105 test_zero(string_length
);
1107 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
1108 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1109 test_zero(string_length
);
1113 /* Make sure zero length keys are marked as bad */
1115 test_compare(MEMCACHED_SUCCESS
,
1116 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
1117 size_t string_length
;
1118 char *string
= memcached_get(memc_clone
, key
, 0,
1119 &string_length
, &flags
, &rc
);
1120 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
1121 test_zero(string_length
);
1125 memcached_free(memc_clone
);
1127 return TEST_SUCCESS
;
1130 #define READ_THROUGH_VALUE "set for me"
1131 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
1134 memcached_result_st
*result
)
1136 (void)memc
;(void)key
;(void)key_length
;
1137 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
1140 #ifndef __INTEL_COMPILER
1141 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1144 static test_return_t
read_through(memcached_st
*memc
)
1146 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1148 size_t string_length
;
1150 memcached_return_t rc
;
1151 char *string
= memcached_get(memc
,
1152 test_literal_param(__func__
),
1153 &string_length
, &flags
, &rc
);
1155 test_compare(MEMCACHED_NOTFOUND
, rc
);
1156 test_false(string_length
);
1159 test_compare(MEMCACHED_SUCCESS
,
1160 memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
));
1162 string
= memcached_get(memc
,
1163 test_literal_param(__func__
),
1164 &string_length
, &flags
, &rc
);
1166 test_compare(MEMCACHED_SUCCESS
, rc
);
1167 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1168 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1169 test_strcmp(READ_THROUGH_VALUE
, string
);
1172 string
= memcached_get(memc
,
1173 test_literal_param(__func__
),
1174 &string_length
, &flags
, &rc
);
1176 test_compare(MEMCACHED_SUCCESS
, rc
);
1178 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1179 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1180 test_strcmp(READ_THROUGH_VALUE
, string
);
1183 return TEST_SUCCESS
;
1186 static test_return_t
get_test(memcached_st
*memc
)
1188 memcached_return_t rc
;
1190 size_t string_length
;
1193 uint64_t query_id
= memcached_query_id(memc
);
1194 rc
= memcached_delete(memc
,
1195 test_literal_param(__func__
),
1197 test_true_got(rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_NOTFOUND
, memcached_last_error_message(memc
));
1198 test_compare(query_id
+1, memcached_query_id(memc
));
1200 string
= memcached_get(memc
,
1201 test_literal_param(__func__
),
1202 &string_length
, &flags
, &rc
);
1204 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1205 test_false(string_length
);
1208 return TEST_SUCCESS
;
1211 static test_return_t
get_test2(memcached_st
*memc
)
1213 const char *value
= "when we sanitize";
1215 uint64_t query_id
= memcached_query_id(memc
);
1216 test_compare(return_value_based_on_buffering(memc
),
1218 test_literal_param(__func__
),
1219 value
, strlen(value
),
1220 time_t(0), uint32_t(0)));
1221 test_compare(query_id
+1, memcached_query_id(memc
));
1223 query_id
= memcached_query_id(memc
);
1224 test_true(query_id
);
1227 size_t string_length
;
1228 memcached_return_t rc
;
1229 char *string
= memcached_get(memc
,
1230 test_literal_param(__func__
),
1231 &string_length
, &flags
, &rc
);
1232 test_compare(query_id
+1, memcached_query_id(memc
));
1234 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1235 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1237 test_compare(strlen(value
), string_length
);
1238 test_memcmp(string
, value
, string_length
);
1242 return TEST_SUCCESS
;
1245 static test_return_t
set_test2(memcached_st
*memc
)
1247 for (uint32_t x
= 0; x
< 10; x
++)
1249 test_compare(return_value_based_on_buffering(memc
),
1251 test_literal_param("foo"),
1252 test_literal_param("train in the brain"),
1253 time_t(0), uint32_t(0)));
1256 return TEST_SUCCESS
;
1259 static test_return_t
set_test3(memcached_st
*memc
)
1261 size_t value_length
= 8191;
1263 libtest::vchar_t value
;
1264 value
.reserve(value_length
);
1265 for (uint32_t x
= 0; x
< value_length
; x
++)
1267 value
.push_back(char(x
% 127));
1270 /* The dump test relies on there being at least 32 items in memcached */
1271 for (uint32_t x
= 0; x
< 32; x
++)
1275 snprintf(key
, sizeof(key
), "foo%u", x
);
1277 uint64_t query_id
= memcached_query_id(memc
);
1278 test_compare_hint(return_value_based_on_buffering(memc
),
1279 memcached_set(memc
, key
, strlen(key
),
1280 &value
[0], value
.size(),
1281 time_t(0), uint32_t(0)),
1282 memcached_last_error_message(memc
));
1283 test_compare(query_id
+1, memcached_query_id(memc
));
1286 return TEST_SUCCESS
;
1289 static test_return_t
get_test3(memcached_st
*memc
)
1291 size_t value_length
= 8191;
1293 libtest::vchar_t value
;
1294 value
.reserve(value_length
);
1295 for (uint32_t x
= 0; x
< value_length
; x
++)
1297 value
.push_back(char(x
% 127));
1300 test_compare_hint(return_value_based_on_buffering(memc
),
1302 test_literal_param(__func__
),
1303 &value
[0], value
.size(),
1304 time_t(0), uint32_t(0)),
1305 memcached_last_error_message(memc
));
1307 size_t string_length
;
1309 memcached_return_t rc
;
1310 char *string
= memcached_get(memc
,
1311 test_literal_param(__func__
),
1312 &string_length
, &flags
, &rc
);
1314 test_compare(MEMCACHED_SUCCESS
, rc
);
1316 test_compare(value
.size(), string_length
);
1317 test_memcmp(string
, &value
[0], string_length
);
1321 return TEST_SUCCESS
;
1324 static test_return_t
get_test4(memcached_st
*memc
)
1326 size_t value_length
= 8191;
1328 libtest::vchar_t value
;
1329 value
.reserve(value_length
);
1330 for (uint32_t x
= 0; x
< value_length
; x
++)
1332 value
.push_back(char(x
% 127));
1335 test_compare_hint(return_value_based_on_buffering(memc
),
1337 test_literal_param(__func__
),
1338 &value
[0], value
.size(),
1339 time_t(0), uint32_t(0)),
1340 memcached_last_error_message(memc
));
1342 for (uint32_t x
= 0; x
< 10; x
++)
1345 size_t string_length
;
1346 memcached_return_t rc
;
1347 char *string
= memcached_get(memc
,
1348 test_literal_param(__func__
),
1349 &string_length
, &flags
, &rc
);
1351 test_compare(MEMCACHED_SUCCESS
, rc
);
1353 test_compare(value
.size(), string_length
);
1354 test_memcmp(string
, &value
[0], string_length
);
1358 return TEST_SUCCESS
;
1362 * This test verifies that memcached_read_one_response doesn't try to
1363 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1364 * responses before you execute a storage command.
1366 static test_return_t
get_test5(memcached_st
*memc
)
1369 ** Request the same key twice, to ensure that we hash to the same server
1370 ** (so that we have multiple response values queued up) ;-)
1372 const char *keys
[]= { "key", "key" };
1373 size_t lengths
[]= { 3, 3 };
1377 test_compare_hint(return_value_based_on_buffering(memc
),
1378 memcached_set(memc
, keys
[0], lengths
[0],
1379 keys
[0], lengths
[0],
1380 time_t(0), uint32_t(0)),
1381 memcached_last_error_message(memc
));
1382 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1384 memcached_result_st results_obj
;
1385 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1388 memcached_return_t rc
;
1389 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1392 memcached_result_free(&results_obj
);
1394 /* Don't read out the second result, but issue a set instead.. */
1395 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1397 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1398 &rlen
, &flags
, &rc
);
1400 test_compare(MEMCACHED_NOTFOUND
, rc
);
1401 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1403 test_compare(MEMCACHED_SUCCESS
, rc
);
1406 return TEST_SUCCESS
;
1409 static test_return_t
mget_end(memcached_st
*memc
)
1411 const char *keys
[]= { "foo", "foo2" };
1412 size_t lengths
[]= { 3, 4 };
1413 const char *values
[]= { "fjord", "41" };
1416 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1418 test_compare(MEMCACHED_SUCCESS
,
1420 keys
[x
], lengths
[x
],
1421 values
[x
], strlen(values
[x
]),
1422 time_t(0), uint32_t(0)));
1426 size_t string_length
;
1429 // retrieve both via mget
1430 test_compare(MEMCACHED_SUCCESS
,
1431 memcached_mget(memc
,
1433 test_array_length(keys
)));
1435 char key
[MEMCACHED_MAX_KEY
];
1437 memcached_return_t rc
;
1439 // this should get both
1440 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1442 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1444 test_compare(MEMCACHED_SUCCESS
, rc
);
1446 if (key_length
== 4)
1451 test_compare(string_length
, strlen(values
[val
]));
1452 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1456 // this should indicate end
1457 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1458 test_compare(MEMCACHED_END
, rc
);
1462 test_compare(MEMCACHED_SUCCESS
,
1463 memcached_mget(memc
, keys
, lengths
, 1));
1465 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1466 test_compare(key_length
, lengths
[0]);
1467 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1468 test_compare(string_length
, strlen(values
[0]));
1469 test_true(strncmp(values
[0], string
, string_length
) == 0);
1470 test_compare(MEMCACHED_SUCCESS
, rc
);
1473 // this should indicate end
1474 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1475 test_compare(MEMCACHED_END
, rc
);
1478 return TEST_SUCCESS
;
1481 /* Do not copy the style of this code, I just access hosts to testthis function */
1482 static test_return_t
stats_servername_test(memcached_st
*memc
)
1484 memcached_stat_st memc_stat
;
1485 memcached_server_instance_st instance
=
1486 memcached_server_instance_by_position(memc
, 0);
1488 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1490 return TEST_SKIPPED
;
1493 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1494 memcached_server_name(instance
),
1495 memcached_server_port(instance
)));
1497 return TEST_SUCCESS
;
1500 static test_return_t
increment_test(memcached_st
*memc
)
1502 uint64_t new_number
;
1504 test_compare(MEMCACHED_SUCCESS
,
1506 test_literal_param("number"),
1507 test_literal_param("0"),
1508 (time_t)0, (uint32_t)0));
1510 test_compare(MEMCACHED_SUCCESS
,
1511 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1512 test_compare(uint64_t(1), new_number
);
1514 test_compare(MEMCACHED_SUCCESS
,
1515 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1516 test_compare(uint64_t(2), new_number
);
1518 return TEST_SUCCESS
;
1521 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1523 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1525 uint64_t new_number
;
1526 uint64_t initial
= 0;
1528 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1530 test_compare(MEMCACHED_SUCCESS
,
1531 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1532 test_compare(new_number
, initial
);
1534 test_compare(MEMCACHED_SUCCESS
,
1535 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1536 test_compare(new_number
, (initial
+1));
1538 return TEST_SUCCESS
;
1541 static test_return_t
decrement_test(memcached_st
*memc
)
1543 test_compare(return_value_based_on_buffering(memc
),
1545 test_literal_param(__func__
),
1546 test_literal_param("3"),
1547 time_t(0), uint32_t(0)));
1548 // Make sure we flush the value we just set
1549 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1551 uint64_t new_number
;
1552 test_compare(MEMCACHED_SUCCESS
,
1553 memcached_decrement(memc
,
1554 test_literal_param(__func__
),
1556 test_compare(uint64_t(2), new_number
);
1558 test_compare(MEMCACHED_SUCCESS
,
1559 memcached_decrement(memc
,
1560 test_literal_param(__func__
),
1562 test_compare(uint64_t(1), new_number
);
1564 return TEST_SUCCESS
;
1567 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1569 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1571 uint64_t initial
= 3;
1573 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1575 uint64_t new_number
;
1576 test_compare(MEMCACHED_SUCCESS
,
1577 memcached_decrement_with_initial(memc
,
1578 test_literal_param(__func__
),
1581 test_compare(new_number
, initial
);
1583 test_compare(MEMCACHED_SUCCESS
,
1584 memcached_decrement_with_initial(memc
,
1585 test_literal_param(__func__
),
1588 test_compare(new_number
, (initial
- 1));
1590 return TEST_SUCCESS
;
1593 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1595 const char *master_key
= "foo";
1596 const char *key
= "number";
1597 const char *value
= "0";
1599 test_compare(return_value_based_on_buffering(memc
),
1600 memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1602 value
, strlen(value
),
1603 time_t(0), uint32_t(0)));
1605 // Make sure we flush the value we just set
1606 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1608 uint64_t new_number
;
1609 test_compare(MEMCACHED_SUCCESS
,
1610 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1611 key
, strlen(key
), 1, &new_number
));
1612 test_compare(uint64_t(1), new_number
);
1614 test_compare(MEMCACHED_SUCCESS
,
1615 memcached_increment_by_key(memc
, master_key
, strlen(master_key
),
1616 key
, strlen(key
), 1, &new_number
));
1617 test_compare(uint64_t(2), new_number
);
1619 return TEST_SUCCESS
;
1622 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1624 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1626 uint64_t new_number
;
1627 const char *master_key
= "foo";
1628 const char *key
= "number";
1629 uint64_t initial
= 0;
1631 test_compare(MEMCACHED_SUCCESS
,
1632 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1634 1, initial
, 0, &new_number
));
1635 test_compare(new_number
, initial
);
1637 test_compare(MEMCACHED_SUCCESS
,
1638 memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1640 1, initial
, 0, &new_number
));
1641 test_compare(new_number
, (initial
+1));
1643 return TEST_SUCCESS
;
1646 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1648 uint64_t new_number
;
1649 const char *value
= "3";
1651 test_compare(return_value_based_on_buffering(memc
),
1652 memcached_set_by_key(memc
,
1653 test_literal_param("foo"),
1654 test_literal_param("number"),
1655 value
, strlen(value
),
1656 (time_t)0, (uint32_t)0));
1658 test_compare(MEMCACHED_SUCCESS
,
1659 memcached_decrement_by_key(memc
,
1660 test_literal_param("foo"),
1661 test_literal_param("number"),
1663 test_compare(uint64_t(2), new_number
);
1665 test_compare(MEMCACHED_SUCCESS
,
1666 memcached_decrement_by_key(memc
,
1667 test_literal_param("foo"),
1668 test_literal_param("number"),
1670 test_compare(uint64_t(1), new_number
);
1672 return TEST_SUCCESS
;
1675 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1677 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1679 uint64_t new_number
;
1680 uint64_t initial
= 3;
1682 test_compare(MEMCACHED_SUCCESS
,
1683 memcached_decrement_with_initial_by_key(memc
,
1684 test_literal_param("foo"),
1685 test_literal_param("number"),
1686 1, initial
, 0, &new_number
));
1687 test_compare(new_number
, initial
);
1689 test_compare(MEMCACHED_SUCCESS
,
1690 memcached_decrement_with_initial_by_key(memc
,
1691 test_literal_param("foo"),
1692 test_literal_param("number"),
1693 1, initial
, 0, &new_number
));
1694 test_compare(new_number
, (initial
- 1));
1696 return TEST_SUCCESS
;
1698 static test_return_t
binary_increment_with_prefix_test(memcached_st
*memc
)
1700 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1702 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1704 test_compare(return_value_based_on_buffering(memc
),
1706 test_literal_param("number"),
1707 test_literal_param("0"),
1708 (time_t)0, (uint32_t)0));
1710 uint64_t new_number
;
1711 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1712 test_literal_param("number"),
1714 test_compare(uint64_t(1), new_number
);
1716 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1717 test_literal_param("number"),
1719 test_compare(uint64_t(2), new_number
);
1721 return TEST_SUCCESS
;
1724 static test_return_t
quit_test(memcached_st
*memc
)
1726 const char *value
= "sanford and sun";
1728 test_compare(return_value_based_on_buffering(memc
),
1730 test_literal_param(__func__
),
1731 value
, strlen(value
),
1732 (time_t)10, (uint32_t)3));
1733 memcached_quit(memc
);
1735 test_compare(return_value_based_on_buffering(memc
),
1737 test_literal_param(__func__
),
1738 value
, strlen(value
),
1739 (time_t)50, (uint32_t)9));
1741 return TEST_SUCCESS
;
1744 static test_return_t
mget_result_test(memcached_st
*memc
)
1746 const char *keys
[]= {"fudge", "son", "food"};
1747 size_t key_length
[]= {5, 3, 4};
1749 memcached_result_st results_obj
;
1750 memcached_result_st
*results
;
1752 results
= memcached_result_create(memc
, &results_obj
);
1754 test_true(&results_obj
== results
);
1756 /* We need to empty the server before continueing test */
1757 test_compare(MEMCACHED_SUCCESS
,
1758 memcached_flush(memc
, 0));
1760 test_compare(MEMCACHED_SUCCESS
,
1761 memcached_mget(memc
, keys
, key_length
, 3));
1763 memcached_return_t rc
;
1764 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1769 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1770 test_false(results
);
1771 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1773 for (uint32_t x
= 0; x
< 3; x
++)
1775 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1776 keys
[x
], key_length
[x
],
1777 (time_t)50, (uint32_t)9);
1778 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1781 test_compare(MEMCACHED_SUCCESS
,
1782 memcached_mget(memc
, keys
, key_length
, 3));
1784 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1787 test_true(&results_obj
== results
);
1788 test_compare(MEMCACHED_SUCCESS
, rc
);
1789 test_memcmp(memcached_result_key_value(results
),
1790 memcached_result_value(results
),
1791 memcached_result_length(results
));
1792 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1795 memcached_result_free(&results_obj
);
1797 return TEST_SUCCESS
;
1800 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1802 const char *keys
[]= {"fudge", "son", "food"};
1803 size_t key_length
[]= {5, 3, 4};
1805 memcached_result_st
*results
;
1807 /* We need to empty the server before continueing test */
1808 test_compare(MEMCACHED_SUCCESS
,
1809 memcached_flush(memc
, 0));
1811 test_compare(MEMCACHED_SUCCESS
,
1812 memcached_mget(memc
, keys
, key_length
, 3));
1814 memcached_return_t rc
;
1815 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1819 test_false(results
);
1820 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1822 for (uint32_t x
= 0; x
< 3; x
++)
1824 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1825 keys
[x
], key_length
[x
],
1826 (time_t)50, (uint32_t)9);
1827 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1830 test_compare(MEMCACHED_SUCCESS
,
1831 memcached_mget(memc
, keys
, key_length
, 3));
1834 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1837 test_compare(MEMCACHED_SUCCESS
, rc
);
1838 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1839 test_memcmp(memcached_result_key_value(results
),
1840 memcached_result_value(results
),
1841 memcached_result_length(results
));
1842 memcached_result_free(results
);
1846 return TEST_SUCCESS
;
1849 static test_return_t
mget_result_function(memcached_st
*memc
)
1851 const char *keys
[]= {"fudge", "son", "food"};
1852 size_t key_length
[]= {5, 3, 4};
1854 memcached_execute_fn callbacks
[1];
1856 for (uint32_t x
= 0; x
< 3; x
++)
1858 test_compare(return_value_based_on_buffering(memc
),
1859 memcached_set(memc
, keys
[x
], key_length
[x
],
1860 keys
[x
], key_length
[x
],
1861 time_t(50), uint32_t(9)));
1863 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1864 memcached_quit(memc
);
1866 test_compare(MEMCACHED_SUCCESS
,
1867 memcached_mget(memc
, keys
, key_length
, 3));
1869 callbacks
[0]= &callback_counter
;
1872 test_compare(MEMCACHED_SUCCESS
,
1873 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1875 test_compare(size_t(3), counter
);
1877 return TEST_SUCCESS
;
1880 static test_return_t
mget_test(memcached_st
*memc
)
1882 const char *keys
[]= {"fudge", "son", "food"};
1883 size_t key_length
[]= {5, 3, 4};
1885 char return_key
[MEMCACHED_MAX_KEY
];
1886 size_t return_key_length
;
1888 size_t return_value_length
;
1890 test_compare(MEMCACHED_SUCCESS
,
1891 memcached_mget(memc
, keys
, key_length
, 3));
1894 memcached_return_t rc
;
1895 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1896 &return_value_length
, &flags
, &rc
)))
1898 test_true(return_value
);
1900 test_false(return_value
);
1901 test_zero(return_value_length
);
1902 test_compare(MEMCACHED_NOTFOUND
, rc
);
1904 for (uint32_t x
= 0; x
< 3; x
++)
1906 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1907 keys
[x
], key_length
[x
],
1908 (time_t)50, (uint32_t)9);
1909 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1911 test_compare(MEMCACHED_SUCCESS
,
1912 memcached_mget(memc
, keys
, key_length
, 3));
1915 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1916 &return_value_length
, &flags
, &rc
)))
1918 test_true(return_value
);
1919 test_compare(MEMCACHED_SUCCESS
, rc
);
1920 if (not memc
->_namespace
)
1922 test_compare(return_key_length
, return_value_length
);
1923 test_memcmp(return_value
, return_key
, return_value_length
);
1929 return TEST_SUCCESS
;
1932 static test_return_t
mget_execute(memcached_st
*original_memc
)
1934 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1936 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1939 keys_st
keys(20480);
1941 /* First add all of the items.. */
1942 char blob
[1024] = {0};
1944 for (size_t x
= 0; x
< keys
.size(); ++x
)
1946 uint64_t query_id
= memcached_query_id(memc
);
1947 memcached_return_t rc
= memcached_add(memc
,
1948 keys
.key_at(x
), keys
.length_at(x
),
1951 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
,
1952 memcached_strerror(NULL
, rc
));
1953 test_compare(query_id
+1, memcached_query_id(memc
));
1956 /* Try to get all of them with a large multiget */
1958 memcached_execute_fn callbacks
[]= { &callback_counter
};
1959 test_compare(MEMCACHED_SUCCESS
,
1960 memcached_mget_execute(memc
,
1961 keys
.keys_ptr(), keys
.lengths_ptr(),
1962 keys
.size(), callbacks
, &counter
, 1));
1965 uint64_t query_id
= memcached_query_id(memc
);
1966 test_compare(MEMCACHED_SUCCESS
,
1967 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1968 test_compare(query_id
, memcached_query_id(memc
));
1970 /* Verify that we got all of the items */
1971 test_compare(keys
.size(), counter
);
1974 memcached_free(memc
);
1976 return TEST_SUCCESS
;
1979 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1980 static pairs_st
*global_pairs
;
1982 static test_return_t
key_setup(memcached_st
*memc
)
1984 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1986 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1988 return TEST_SUCCESS
;
1991 static test_return_t
key_teardown(memcached_st
*)
1993 pairs_free(global_pairs
);
1995 return TEST_SUCCESS
;
1998 static test_return_t
block_add_regression(memcached_st
*memc
)
2000 /* First add all of the items.. */
2001 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
2003 char blob
[1024] = {0};
2005 memcached_return_t rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
2006 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
, memcached_strerror(NULL
, rc
));
2009 return TEST_SUCCESS
;
2012 static test_return_t
binary_add_regression(memcached_st
*memc
)
2014 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2015 test_return_t rc
= block_add_regression(memc
);
2020 static test_return_t
get_stats_keys(memcached_st
*memc
)
2024 memcached_stat_st memc_stat
;
2025 memcached_return_t rc
;
2027 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
2028 test_compare(MEMCACHED_SUCCESS
, rc
);
2029 for (ptr
= stat_list
; *ptr
; ptr
++)
2034 return TEST_SUCCESS
;
2037 static test_return_t
version_string_test(memcached_st
*)
2039 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
2041 return TEST_SUCCESS
;
2044 static test_return_t
get_stats(memcached_st
*memc
)
2046 memcached_return_t rc
;
2048 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
2049 test_compare(MEMCACHED_SUCCESS
, rc
);
2050 test_true(memc_stat
);
2052 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
2054 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
2055 test_compare(MEMCACHED_SUCCESS
, rc
);
2056 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
2061 memcached_stat_free(NULL
, memc_stat
);
2063 return TEST_SUCCESS
;
2066 static test_return_t
add_host_test(memcached_st
*memc
)
2068 char servername
[]= "0.example.com";
2070 memcached_return_t rc
;
2071 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
2072 test_compare(1U, memcached_server_list_count(servers
));
2074 for (unsigned int x
= 2; x
< 20; x
++)
2076 char buffer
[SMALL_STRING_LEN
];
2078 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
2079 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
2081 test_compare(MEMCACHED_SUCCESS
, rc
);
2082 test_compare(x
, memcached_server_list_count(servers
));
2085 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2086 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
2088 memcached_server_list_free(servers
);
2090 return TEST_SUCCESS
;
2093 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
2095 memcached_return_t rc
;
2097 const char *key
= "not_found";
2098 size_t key_length
= test_literal_param_size("not_found");
2100 test_compare(MEMCACHED_SUCCESS
,
2101 memcached_mget(memc
, &key
, &key_length
, 1));
2103 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
2105 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2107 memcached_result_free(result
);
2109 return TEST_SUCCESS
;
2112 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
2114 return MEMCACHED_SUCCESS
;
2117 static memcached_return_t
cleanup_test_callback(memcached_st
*)
2119 return MEMCACHED_SUCCESS
;
2122 static test_return_t
callback_test(memcached_st
*memc
)
2124 /* Test User Data */
2128 memcached_return_t rc
;
2130 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
2131 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
2132 test_true(*test_ptr
== x
);
2135 /* Test Clone Callback */
2137 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2138 void *clone_cb_ptr
= *(void **)&clone_cb
;
2139 void *temp_function
= NULL
;
2141 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
2142 memcached_return_t rc
;
2143 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2144 test_true(temp_function
== clone_cb_ptr
);
2145 test_compare(MEMCACHED_SUCCESS
, rc
);
2148 /* Test Cleanup Callback */
2150 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2151 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2152 void *temp_function
= NULL
;
2153 memcached_return_t rc
;
2155 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2156 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2157 test_true(temp_function
== cleanup_cb_ptr
);
2160 return TEST_SUCCESS
;
2163 /* We don't test the behavior itself, we test the switches */
2164 static test_return_t
behavior_test(memcached_st
*memc
)
2166 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2167 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2169 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2170 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2172 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2173 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2175 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2176 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2178 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2179 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2181 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2182 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2184 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2185 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2187 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2189 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2191 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2192 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2193 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2195 return TEST_SUCCESS
;
2198 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2200 test_compare(MEMCACHED_DEPRECATED
,
2201 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2203 // Platform dependent
2205 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2209 return TEST_SUCCESS
;
2213 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2215 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2216 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2218 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2220 if (memcached_success(rc
))
2229 return TEST_SUCCESS
;
2233 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2235 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2236 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2238 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2240 if (memcached_success(rc
))
2249 return TEST_SUCCESS
;
2252 /* Make sure we behave properly if server list has no values */
2253 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2255 const char *keys
[]= {"fudge", "son", "food"};
2256 size_t key_length
[]= {5, 3, 4};
2258 /* Here we free everything before running a bunch of mget tests */
2259 memcached_servers_reset(memc
);
2262 /* We need to empty the server before continueing test */
2263 test_compare(MEMCACHED_NO_SERVERS
,
2264 memcached_flush(memc
, 0));
2266 test_compare(MEMCACHED_NO_SERVERS
,
2267 memcached_mget(memc
, keys
, key_length
, 3));
2270 unsigned int keys_returned
;
2271 memcached_return_t rc
;
2272 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
2273 test_compare(MEMCACHED_NOTFOUND
, rc
);
2274 test_zero(keys_returned
);
2277 for (uint32_t x
= 0; x
< 3; x
++)
2279 test_compare(MEMCACHED_NO_SERVERS
,
2280 memcached_set(memc
, keys
[x
], key_length
[x
],
2281 keys
[x
], key_length
[x
],
2282 (time_t)50, (uint32_t)9));
2285 test_compare(MEMCACHED_NO_SERVERS
,
2286 memcached_mget(memc
, keys
, key_length
, 3));
2290 char return_key
[MEMCACHED_MAX_KEY
];
2291 memcached_return_t rc
;
2292 size_t return_key_length
;
2293 size_t return_value_length
;
2296 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2297 &return_value_length
, &flags
, &rc
)))
2299 test_true(return_value
);
2300 test_compare(MEMCACHED_SUCCESS
, rc
);
2301 test_true(return_key_length
== return_value_length
);
2302 test_memcmp(return_value
, return_key
, return_value_length
);
2308 return TEST_SUCCESS
;
2311 #define VALUE_SIZE_BUG5 1048064
2312 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2314 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2315 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2317 size_t value_length
;
2319 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2321 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2323 insert_data
[x
]= (signed char)rand();
2326 test_compare(MEMCACHED_SUCCESS
,
2327 memcached_flush(memc
, 0));
2329 memcached_return_t rc
;
2330 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2331 test_compare(MEMCACHED_SUCCESS
,
2332 memcached_mget(memc
, keys
, key_length
, 4));
2335 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
2336 test_compare(MEMCACHED_NOTFOUND
, rc
);
2339 for (uint32_t x
= 0; x
< 4; x
++)
2341 test_compare(MEMCACHED_SUCCESS
,
2342 memcached_set(memc
, keys
[x
], key_length
[x
],
2343 insert_data
, VALUE_SIZE_BUG5
,
2344 (time_t)0, (uint32_t)0));
2347 for (uint32_t x
= 0; x
< 10; x
++)
2349 value
= memcached_get(memc
, keys
[0], key_length
[0],
2350 &value_length
, &flags
, &rc
);
2351 test_compare(rc
, MEMCACHED_SUCCESS
);
2355 test_compare(MEMCACHED_SUCCESS
,
2356 memcached_mget(memc
, keys
, key_length
, 4));
2358 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
2359 test_compare(4U, count
);
2361 delete [] insert_data
;
2363 return TEST_SUCCESS
;
2366 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2368 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2369 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2370 char return_key
[MEMCACHED_MAX_KEY
];
2371 size_t return_key_length
;
2373 size_t value_length
;
2375 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2377 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2379 insert_data
[x
]= (signed char)rand();
2382 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2384 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2386 // We will now confirm that memcached_mget() returns success, but we will
2387 // then check to make sure that no actual keys are returned.
2388 test_compare(MEMCACHED_SUCCESS
,
2389 memcached_mget(memc
, keys
, key_length
, 4));
2391 memcached_return_t rc
;
2393 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2394 &value_length
, &flags
, &rc
)))
2399 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2401 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2403 test_compare(MEMCACHED_SUCCESS
,
2404 memcached_set(memc
, keys
[x
], key_length
[x
],
2405 insert_data
, VALUE_SIZE_BUG5
,
2406 (time_t)0, (uint32_t)0));
2408 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2410 for (uint32_t x
= 0; x
< 2; x
++)
2412 value
= memcached_get(memc
, keys
[0], key_length
[0],
2413 &value_length
, &flags
, &rc
);
2417 test_compare(MEMCACHED_SUCCESS
,
2418 memcached_mget(memc
, keys
, key_length
, 4));
2419 /* We test for purge of partial complete fetches */
2420 for (count
= 3; count
; count
--)
2422 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2423 &value_length
, &flags
, &rc
);
2424 test_compare(MEMCACHED_SUCCESS
, rc
);
2425 test_memcmp(value
, insert_data
, value_length
);
2426 test_true(value_length
);
2430 delete [] insert_data
;
2432 return TEST_SUCCESS
;
2435 static test_return_t
user_supplied_bug8(memcached_st
*)
2437 memcached_return_t rc
;
2439 memcached_st
*memc_clone
;
2441 memcached_server_st
*servers
;
2442 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";
2444 servers
= memcached_servers_parse(server_list
);
2447 mine
= memcached_create(NULL
);
2448 rc
= memcached_server_push(mine
, servers
);
2449 test_compare(MEMCACHED_SUCCESS
, rc
);
2450 memcached_server_list_free(servers
);
2453 memc_clone
= memcached_clone(NULL
, mine
);
2455 memcached_quit(mine
);
2456 memcached_quit(memc_clone
);
2459 memcached_free(mine
);
2460 memcached_free(memc_clone
);
2462 return TEST_SUCCESS
;
2465 /* Test flag store/retrieve */
2466 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2468 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2469 test_true(insert_data
);
2471 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2473 insert_data
[x
]= (signed char)rand();
2476 memcached_flush(memc
, 0);
2478 const char *keys
= "036790384900";
2479 size_t key_length
= strlen(keys
);
2480 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2481 insert_data
, VALUE_SIZE_BUG5
,
2483 memcached_last_error_message(memc
));
2485 memcached_return_t rc
;
2486 size_t value_length
;
2488 char *value
= memcached_get(memc
, keys
, key_length
,
2489 &value_length
, &flags
, &rc
);
2490 test_compare(245U, flags
);
2494 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2496 char return_key
[MEMCACHED_MAX_KEY
];
2497 size_t return_key_length
;
2499 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2500 &value_length
, &flags
, &rc
);
2501 test_compare(uint32_t(245), flags
);
2504 delete [] insert_data
;
2507 return TEST_SUCCESS
;
2510 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2512 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2513 size_t key_length
[3];
2517 char return_key
[MEMCACHED_MAX_KEY
];
2518 size_t return_key_length
;
2520 size_t return_value_length
;
2523 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2524 key_length
[1]= strlen("fudge&*@#");
2525 key_length
[2]= strlen("for^#@&$not");
2528 for (unsigned int x
= 0; x
< 3; x
++)
2530 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2531 keys
[x
], key_length
[x
],
2532 (time_t)50, (uint32_t)9);
2533 test_compare(MEMCACHED_SUCCESS
, rc
);
2536 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2537 test_compare(MEMCACHED_SUCCESS
, rc
);
2539 /* We need to empty the server before continueing test */
2540 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2541 &return_value_length
, &flags
, &rc
)) != NULL
)
2543 test_true(return_value
);
2547 test_compare(3U, count
);
2549 return TEST_SUCCESS
;
2552 /* We are testing with aggressive timeout to get failures */
2553 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2555 size_t value_length
= 512;
2556 unsigned int set
= 1;
2557 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2559 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2560 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2561 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2563 libtest::vchar_t value
;
2564 value
.reserve(value_length
);
2565 for (uint32_t x
= 0; x
< value_length
; x
++)
2567 value
.push_back(char(x
% 127));
2570 for (unsigned int x
= 1; x
<= 100000; ++x
)
2572 memcached_return_t rc
= memcached_set(mclone
,
2573 test_literal_param("foo"),
2574 &value
[0], value
.size(),
2577 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2578 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2579 memcached_strerror(NULL
, rc
));
2581 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2587 memcached_free(mclone
);
2589 return TEST_SUCCESS
;
2593 We are looking failures in the async protocol
2595 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2597 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2599 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2600 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2601 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2603 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2606 libtest::vchar_t value
;
2608 for (unsigned int x
= 0; x
< 512; x
++)
2610 value
.push_back(char(x
% 127));
2613 for (unsigned int x
= 1; x
<= 100000; ++x
)
2615 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2619 memcached_free(mclone
);
2621 return TEST_SUCCESS
;
2625 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2627 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2629 memcached_return_t rc
;
2631 size_t value_length
;
2633 uint64_t number_value
;
2635 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2636 &value_length
, &flags
, &rc
);
2638 test_compare(MEMCACHED_NOTFOUND
, rc
);
2640 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2643 /* The binary protocol will set the key if it doesn't exist */
2644 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2646 test_compare(MEMCACHED_SUCCESS
, rc
);
2650 test_compare(MEMCACHED_NOTFOUND
, rc
);
2653 test_compare(MEMCACHED_SUCCESS
,
2654 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2656 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2660 test_compare(MEMCACHED_SUCCESS
,
2661 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2662 test_compare(2UL, number_value
);
2664 return TEST_SUCCESS
;
2668 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2669 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2671 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2673 char key
[] = "key34567890";
2675 char commandFirst
[]= "set key34567890 0 0 ";
2676 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2677 size_t commandLength
;
2679 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2681 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2683 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2685 char *overflow
= new (std::nothrow
) char[testSize
];
2686 test_true(overflow
);
2688 memset(overflow
, 'x', testSize
);
2689 test_compare(MEMCACHED_SUCCESS
,
2690 memcached_set(memc
, key
, strlen(key
),
2691 overflow
, testSize
, 0, 0));
2695 return TEST_SUCCESS
;
2700 Test values of many different sizes
2701 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2702 set key34567890 0 0 8169 \r\n
2703 is sent followed by buffer of size 8169, followed by 8169
2705 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2707 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2709 libtest::vchar_t value
;
2710 value
.reserve(18000);
2711 for (size_t x
= 0; x
< 18000; x
++)
2713 value
.push_back((char) (x
% 127));
2716 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2718 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2719 &value
[0], current_length
,
2720 (time_t)0, (uint32_t)0);
2721 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2723 size_t string_length
;
2725 char *string
= memcached_get(memc
, test_literal_param("foo"),
2726 &string_length
, &flags
, &rc
);
2728 test_compare(MEMCACHED_SUCCESS
, rc
);
2729 test_compare(string_length
, current_length
);
2730 test_memcmp(string
, &value
[0], string_length
);
2735 return TEST_SUCCESS
;
2739 Look for zero length value problems
2741 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2743 for (uint32_t x
= 0; x
< 2; x
++)
2745 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2747 (time_t)0, (uint32_t)0);
2749 test_compare(MEMCACHED_SUCCESS
, rc
);
2753 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2754 &length
, &flags
, &rc
);
2756 test_compare(MEMCACHED_SUCCESS
, rc
);
2761 value
= memcached_get(memc
, test_literal_param("mykey"),
2762 &length
, &flags
, &rc
);
2764 test_compare(MEMCACHED_SUCCESS
, rc
);
2770 return TEST_SUCCESS
;
2773 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2774 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2776 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2778 (time_t)0, UINT32_MAX
),
2779 memcached_last_error_message(memc
));
2784 memcached_return_t rc
;
2785 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2786 &length
, &flags
, &rc
);
2788 test_compare(MEMCACHED_SUCCESS
, rc
);
2791 test_compare(flags
, UINT32_MAX
);
2793 return TEST_SUCCESS
;
2796 #if !defined(__sun) && !defined(__OpenBSD__)
2797 /* Check the validity of chinese key*/
2798 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2800 const char *key
= "豆瓣";
2801 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2802 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2803 value
, strlen(value
),
2806 test_compare(MEMCACHED_SUCCESS
, rc
);
2810 char *value2
= memcached_get(memc
, key
, strlen(key
),
2811 &length
, &flags
, &rc
);
2813 test_true(length
==strlen(value
));
2814 test_compare(MEMCACHED_SUCCESS
, rc
);
2815 test_memcmp(value
, value2
, length
);
2818 return TEST_SUCCESS
;
2826 static test_return_t
user_supplied_bug19(memcached_st
*)
2828 memcached_return_t res
;
2830 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2832 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2835 memcached_free(memc
);
2837 return TEST_SUCCESS
;
2840 /* CAS test from Andei */
2841 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2843 const char *key
= "abc";
2844 size_t key_len
= strlen("abc");
2846 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2848 test_compare(MEMCACHED_SUCCESS
,
2850 test_literal_param("abc"),
2851 test_literal_param("foobar"),
2852 (time_t)0, (uint32_t)0));
2854 test_compare(MEMCACHED_SUCCESS
,
2855 memcached_mget(memc
, &key
, &key_len
, 1));
2857 memcached_result_st result_obj
;
2858 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2861 memcached_result_create(memc
, &result_obj
);
2862 memcached_return_t status
;
2863 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2866 test_compare(MEMCACHED_SUCCESS
, status
);
2868 memcached_result_free(result
);
2870 return TEST_SUCCESS
;
2873 /* Large mget() of missing keys with binary proto
2875 * If many binary quiet commands (such as getq's in an mget) fill the output
2876 * buffer and the server chooses not to respond, memcached_flush hangs. See
2877 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2880 /* sighandler_t function that always asserts false */
2881 static void fail(int)
2887 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2892 return TEST_SKIPPED
;
2894 void (*oldalarm
)(int);
2896 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2897 test_true(memc_clone
);
2899 /* only binproto uses getq for mget */
2900 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2902 /* empty the cache to ensure misses (hence non-responses) */
2903 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2905 keys_st
keys(key_count
);
2907 oldalarm
= signal(SIGALRM
, fail
);
2910 test_compare_got(MEMCACHED_SUCCESS
,
2911 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
2912 memcached_last_error_message(memc_clone
));
2915 signal(SIGALRM
, oldalarm
);
2917 memcached_return_t rc
;
2919 char return_key
[MEMCACHED_MAX_KEY
];
2920 size_t return_key_length
;
2922 size_t return_value_length
;
2923 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2924 &return_value_length
, &flags
, &rc
)))
2926 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2928 test_compare(MEMCACHED_NOTFOUND
, rc
);
2929 test_zero(return_value_length
);
2930 test_zero(return_key_length
);
2931 test_false(return_key
[0]);
2932 test_false(return_value
);
2934 memcached_free(memc_clone
);
2936 return TEST_SUCCESS
;
2940 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
2942 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2944 /* should work as of r580 */
2945 test_compare(TEST_SUCCESS
,
2946 _user_supplied_bug21(memc
, 10));
2948 /* should fail as of r580 */
2949 test_compare(TEST_SUCCESS
,
2950 _user_supplied_bug21(memc
, 1000));
2952 return TEST_SUCCESS
;
2955 static test_return_t
output_ketama_weighted_keys(memcached_st
*)
2957 memcached_st
*memc
= memcached_create(NULL
);
2961 test_compare(MEMCACHED_SUCCESS
,
2962 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
2964 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2965 test_compare(value
, uint64_t(1));
2967 test_compare(MEMCACHED_SUCCESS
,
2968 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
2970 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2971 test_true(value
== MEMCACHED_HASH_MD5
);
2974 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
2976 memcached_server_st
*server_pool
;
2977 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");
2978 memcached_server_push(memc
, server_pool
);
2980 // @todo this needs to be refactored to actually test something.
2983 if ((fp
= fopen("ketama_keys.txt", "w")))
2987 printf("cannot write to file ketama_keys.txt");
2988 return TEST_FAILURE
;
2991 for (int x
= 0; x
< 10000; x
++)
2994 snprintf(key
, sizeof(key
), "%d", x
);
2996 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
2997 char *hostname
= memc
->hosts
[server_idx
].hostname
;
2998 in_port_t port
= memc
->hosts
[server_idx
].port
;
2999 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3000 memcached_server_instance_st instance
=
3001 memcached_server_instance_by_position(memc
, host_index
);
3005 memcached_server_list_free(server_pool
);
3006 memcached_free(memc
);
3008 return TEST_SUCCESS
;
3012 static test_return_t
result_static(memcached_st
*memc
)
3014 memcached_result_st result
;
3015 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3016 test_false(result
.options
.is_allocated
);
3017 test_true(memcached_is_initialized(&result
));
3018 test_true(result_ptr
);
3019 test_true(result_ptr
== &result
);
3021 memcached_result_free(&result
);
3023 test_false(result
.options
.is_allocated
);
3024 test_false(memcached_is_initialized(&result
));
3026 return TEST_SUCCESS
;
3029 static test_return_t
result_alloc(memcached_st
*memc
)
3031 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3032 test_true(result_ptr
);
3033 test_true(result_ptr
->options
.is_allocated
);
3034 test_true(memcached_is_initialized(result_ptr
));
3035 memcached_result_free(result_ptr
);
3037 return TEST_SUCCESS
;
3041 static test_return_t
add_host_test1(memcached_st
*memc
)
3043 memcached_return_t rc
;
3044 char servername
[]= "0.example.com";
3046 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3048 test_compare(1U, memcached_server_list_count(servers
));
3050 for (uint32_t x
= 2; x
< 20; x
++)
3052 char buffer
[SMALL_STRING_LEN
];
3054 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3055 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3057 test_compare(MEMCACHED_SUCCESS
, rc
);
3058 test_compare(x
, memcached_server_list_count(servers
));
3061 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3062 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3064 memcached_server_list_free(servers
);
3066 return TEST_SUCCESS
;
3069 static test_return_t
pre_nonblock(memcached_st
*memc
)
3071 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3073 return TEST_SUCCESS
;
3076 static test_return_t
pre_cork(memcached_st
*memc
)
3079 return TEST_SKIPPED
;
3082 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3083 return TEST_SUCCESS
;
3085 return TEST_SKIPPED
;
3088 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3091 return TEST_SKIPPED
;
3093 test_return_t test_rc
;
3094 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3097 return pre_nonblock(memc
);
3100 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3102 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3103 test_true(memc_clone
);
3105 // The memcached_version needs to be done on a clone, because the server
3106 // will not toggle protocol on an connection.
3107 memcached_version(memc_clone
);
3109 memcached_return_t rc
= MEMCACHED_FAILURE
;
3110 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3112 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3113 test_compare(MEMCACHED_SUCCESS
,
3114 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3115 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3119 memcached_free(memc_clone
);
3120 return TEST_SKIPPED
;
3123 memcached_free(memc_clone
);
3125 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3128 static test_return_t
pre_murmur(memcached_st
*memc
)
3130 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3131 return TEST_SUCCESS
;
3134 static test_return_t
pre_jenkins(memcached_st
*memc
)
3136 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3138 return TEST_SKIPPED
;
3142 static test_return_t
pre_md5(memcached_st
*memc
)
3144 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3146 return TEST_SUCCESS
;
3149 static test_return_t
pre_crc(memcached_st
*memc
)
3151 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3153 return TEST_SUCCESS
;
3156 static test_return_t
pre_hsieh(memcached_st
*memc
)
3158 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
));
3159 return TEST_SUCCESS
;
3162 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3164 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3166 return TEST_SUCCESS
;
3169 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3171 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
));
3173 return TEST_SUCCESS
;
3176 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3178 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3180 return TEST_SUCCESS
;
3183 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3185 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3187 return TEST_SUCCESS
;
3190 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3192 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3193 test_compare(MEMCACHED_SUCCESS
, rc
);
3195 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3196 test_compare(value
, uint64_t(1));
3198 return TEST_SUCCESS
;
3201 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3203 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3204 test_compare(MEMCACHED_SUCCESS
, rc
);
3206 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3207 test_compare(value
, uint64_t(1));
3209 test_compare(MEMCACHED_SUCCESS
,
3210 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3212 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3213 test_compare(MEMCACHED_HASH_MD5
, memcached_hash_t(value
));
3215 return TEST_SUCCESS
;
3218 static test_return_t
pre_replication(memcached_st
*memc
)
3220 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3223 * Make sure that we store the item on all servers
3224 * (master + replicas == number of servers)
3226 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3227 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3229 return TEST_SUCCESS
;
3233 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3235 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3237 return pre_nonblock(memc
);
3241 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3245 #ifdef HARD_MALLOC_TESTS
3246 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3254 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3258 #ifdef HARD_MALLOC_TESTS
3259 void *ret
= malloc(size
+ 8);
3262 ret
= (void*)((caddr_t
)ret
+ 8);
3265 void *ret
= malloc(size
);
3270 memset(ret
, 0xff, size
);
3277 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3279 #ifdef HARD_MALLOC_TESTS
3280 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3281 void *nmem
= realloc(real_ptr
, size
+ 8);
3286 ret
= (void*)((caddr_t
)nmem
+ 8);
3292 return realloc(mem
, size
);
3297 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3299 #ifdef HARD_MALLOC_TESTS
3300 void *mem
= my_malloc(ptr
, nelem
* size
);
3303 memset(mem
, 0, nelem
* size
);
3309 return calloc(nelem
, size
);
3313 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3315 memcached_return_t rc
;
3316 const char *key
= "mine";
3319 /* Make sure be default none exists */
3320 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3322 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3324 /* Test a clean set */
3325 test_compare(MEMCACHED_SUCCESS
,
3326 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3328 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3330 test_memcmp(value
, key
, 4);
3331 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3333 /* Test that we can turn it off */
3334 test_compare(MEMCACHED_SUCCESS
,
3335 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3337 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3339 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3341 /* Now setup for main test */
3342 test_compare(MEMCACHED_SUCCESS
,
3343 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3345 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3347 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3348 test_memcmp(value
, key
, 4);
3350 /* Set to Zero, and then Set to something too large */
3353 memset(long_key
, 0, 255);
3355 test_compare(MEMCACHED_SUCCESS
,
3356 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3358 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3360 test_compare(MEMCACHED_SUCCESS
, rc
);
3362 /* Test a long key for failure */
3363 /* TODO, extend test to determine based on setting, what result should be */
3364 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3365 test_compare(MEMCACHED_SUCCESS
,
3366 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3368 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3369 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3370 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3371 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3373 /* Test for a bad prefix, but with a short key */
3374 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3375 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3377 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3378 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3381 return TEST_SUCCESS
;
3384 static test_return_t
set_namespace(memcached_st
*memc
)
3386 memcached_return_t rc
;
3387 const char *key
= "mine";
3390 // Make sure we default to a null namespace
3391 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3393 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3395 /* Test a clean set */
3396 test_compare(MEMCACHED_SUCCESS
,
3397 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3399 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3401 test_memcmp(value
, key
, 4);
3402 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3404 return TEST_SUCCESS
;
3407 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3409 test_return_if(pre_binary(memc
));
3410 test_return_if(set_namespace(memc
));
3412 return TEST_SUCCESS
;
3415 #ifdef MEMCACHED_ENABLE_DEPRECATED
3416 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3418 void *test_ptr
= NULL
;
3421 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
3422 cb_ptr
= *(void **)&malloc_cb
;
3423 memcached_return_t rc
;
3425 test_compare(MEMCACHED_SUCCESS
,
3426 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3427 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3428 test_compare(MEMCACHED_SUCCESS
, rc
);
3429 test_true(test_ptr
== cb_ptr
);
3433 memcached_realloc_fn realloc_cb
=
3434 (memcached_realloc_fn
)my_realloc
;
3435 cb_ptr
= *(void **)&realloc_cb
;
3436 memcached_return_t rc
;
3438 test_compare(MEMCACHED_SUCCESS
,
3439 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3440 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3441 test_compare(MEMCACHED_SUCCESS
, rc
);
3442 test_true(test_ptr
== cb_ptr
);
3446 memcached_free_fn free_cb
=
3447 (memcached_free_fn
)my_free
;
3448 cb_ptr
= *(void **)&free_cb
;
3449 memcached_return_t rc
;
3451 test_compare(MEMCACHED_SUCCESS
,
3452 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3453 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3454 test_compare(MEMCACHED_SUCCESS
, rc
);
3455 test_true(test_ptr
== cb_ptr
);
3458 return TEST_SUCCESS
;
3463 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3465 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3466 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3467 my_realloc
, my_calloc
, NULL
));
3469 test_compare(MEMCACHED_SUCCESS
,
3470 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3471 my_realloc
, my_calloc
, NULL
));
3473 memcached_malloc_fn mem_malloc
;
3474 memcached_free_fn mem_free
;
3475 memcached_realloc_fn mem_realloc
;
3476 memcached_calloc_fn mem_calloc
;
3477 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3478 &mem_realloc
, &mem_calloc
);
3480 test_true(mem_malloc
== my_malloc
);
3481 test_true(mem_realloc
== my_realloc
);
3482 test_true(mem_calloc
== my_calloc
);
3483 test_true(mem_free
== my_free
);
3485 return TEST_SUCCESS
;
3488 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3491 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3492 memcached_hash_t hash
;
3493 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3494 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3497 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3498 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3500 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3502 if (hash
!= MEMCACHED_HASH_CRC
)
3503 return TEST_SKIPPED
;
3505 return TEST_SUCCESS
;
3508 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3511 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3512 memcached_hash_t hash
;
3513 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3514 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3519 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3520 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3522 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3524 if (hash
!= MEMCACHED_HASH_HSIEH
)
3525 return TEST_SKIPPED
;
3528 return TEST_SUCCESS
;
3531 static test_return_t
enable_cas(memcached_st
*memc
)
3533 unsigned int set
= 1;
3535 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3537 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3539 return TEST_SUCCESS
;
3542 return TEST_SKIPPED
;
3545 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3547 memcached_version(memc
);
3549 memcached_server_instance_st instance
=
3550 memcached_server_instance_by_position(memc
, 0);
3552 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3553 or instance
->minor_version
> 2)
3555 return TEST_SUCCESS
;
3558 return TEST_SKIPPED
;
3561 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3565 memcached_servers_reset(memc
);
3566 const char *socket_file
= default_socket();
3568 test_skip(0, stat(socket_file
, &buf
));
3570 test_compare(MEMCACHED_SUCCESS
,
3571 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
3573 return TEST_SUCCESS
;
3576 static test_return_t
pre_nodelay(memcached_st
*memc
)
3578 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3579 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3581 return TEST_SUCCESS
;
3584 static test_return_t
pre_settimer(memcached_st
*memc
)
3586 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3587 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3589 return TEST_SUCCESS
;
3592 static test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3594 const uint64_t timeout
= 100; // Not using, just checking that it sets
3596 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3598 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3600 return TEST_SUCCESS
;
3603 static test_return_t
noreply_test(memcached_st
*memc
)
3605 test_compare(MEMCACHED_SUCCESS
,
3606 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3607 test_compare(MEMCACHED_SUCCESS
,
3608 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3609 test_compare(MEMCACHED_SUCCESS
,
3610 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3611 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3612 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3613 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3615 memcached_return_t ret
;
3616 for (int count
= 0; count
< 5; ++count
)
3618 for (size_t x
= 0; x
< 100; ++x
)
3620 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
3621 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3622 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3624 size_t len
= (size_t)check_length
;
3629 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3632 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3635 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3638 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3641 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3647 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
,
3648 memcached_strerror(NULL
, ret
));
3652 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3653 ** API and is _ONLY_ done this way to verify that the library works the
3654 ** way it is supposed to do!!!!
3658 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3660 memcached_server_instance_st instance
=
3661 memcached_server_instance_by_position(memc
, x
);
3662 no_msg
+=(int)(instance
->cursor_active
);
3665 test_true(no_msg
== 0);
3667 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3670 ** Now validate that all items was set properly!
3672 for (size_t x
= 0; x
< 100; ++x
)
3676 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3678 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3680 size_t len
= (size_t)check_length
;
3683 char* value
=memcached_get(memc
, key
, strlen(key
),
3684 &length
, &flags
, &ret
);
3685 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
3688 case 0: /* FALLTHROUGH */
3689 case 1: /* FALLTHROUGH */
3691 test_true(strncmp(value
, key
, len
) == 0);
3692 test_true(len
== length
);
3695 test_true(length
== len
* 2);
3698 test_true(length
== len
* 3);
3708 /* Try setting an illegal cas value (should not return an error to
3709 * the caller (because we don't expect a return message from the server)
3711 const char* keys
[]= {"0"};
3712 size_t lengths
[]= {1};
3715 memcached_result_st results_obj
;
3716 memcached_result_st
*results
;
3717 test_compare(MEMCACHED_SUCCESS
,
3718 memcached_mget(memc
, keys
, lengths
, 1));
3720 results
= memcached_result_create(memc
, &results_obj
);
3722 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
3724 test_compare(MEMCACHED_SUCCESS
, ret
);
3725 uint64_t cas
= memcached_result_cas(results
);
3726 memcached_result_free(&results_obj
);
3728 test_compare(MEMCACHED_SUCCESS
,
3729 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3732 * The item will have a new cas value, so try to set it again with the old
3733 * value. This should fail!
3735 test_compare(MEMCACHED_SUCCESS
,
3736 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
3737 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
3738 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
3739 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
3742 return TEST_SUCCESS
;
3745 static test_return_t
analyzer_test(memcached_st
*memc
)
3747 memcached_analysis_st
*report
;
3748 memcached_return_t rc
;
3750 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
3751 test_compare(MEMCACHED_SUCCESS
, rc
);
3752 test_true(memc_stat
);
3754 report
= memcached_analyze(memc
, memc_stat
, &rc
);
3755 test_compare(MEMCACHED_SUCCESS
, rc
);
3759 memcached_stat_free(NULL
, memc_stat
);
3761 return TEST_SUCCESS
;
3764 static test_return_t
util_version_test(memcached_st
*memc
)
3766 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
3767 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
3769 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
3771 // We expect failure
3774 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3775 fprintf(stderr
, "\nDumping Server Information\n\n");
3776 memcached_server_fn callbacks
[1];
3778 callbacks
[0]= dump_server_information
;
3779 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
3780 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
3782 test_true(if_successful
== false);
3784 memcached_server_instance_st instance
=
3785 memcached_server_instance_by_position(memc
, 0);
3787 memcached_version(memc
);
3789 // We only use one binary when we test, so this should be just fine.
3790 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
3791 test_true(if_successful
== true);
3793 if (instance
->micro_version
> 0)
3795 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
3797 else if (instance
->minor_version
> 0)
3799 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
3801 else if (instance
->major_version
> 0)
3803 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
3806 test_true(if_successful
== true);
3808 if (instance
->micro_version
> 0)
3810 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
3812 else if (instance
->minor_version
> 0)
3814 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
3816 else if (instance
->major_version
> 0)
3818 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
3821 test_true(if_successful
== false);
3823 return TEST_SUCCESS
;
3826 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
3828 memcached_return_t rc
;
3829 memcached_server_instance_st instance
=
3830 memcached_server_instance_by_position(memc
, 0);
3832 // Test both the version that returns a code, and the one that does not.
3833 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3834 memcached_server_port(instance
) -1, NULL
) == -1);
3836 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3837 memcached_server_port(instance
) -1, &rc
) == -1);
3838 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
3840 return TEST_SUCCESS
;
3844 static test_return_t
getpid_test(memcached_st
*memc
)
3846 memcached_return_t rc
;
3847 memcached_server_instance_st instance
=
3848 memcached_server_instance_by_position(memc
, 0);
3850 // Test both the version that returns a code, and the one that does not.
3851 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3852 memcached_server_port(instance
), NULL
) > -1);
3854 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
3855 memcached_server_port(instance
), &rc
) > -1);
3856 test_compare(MEMCACHED_SUCCESS
, rc
);
3858 return TEST_SUCCESS
;
3861 static test_return_t
ping_test(memcached_st
*memc
)
3863 memcached_return_t rc
;
3864 memcached_server_instance_st instance
=
3865 memcached_server_instance_by_position(memc
, 0);
3867 // Test both the version that returns a code, and the one that does not.
3868 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3869 memcached_server_port(instance
), NULL
));
3871 test_true(libmemcached_util_ping(memcached_server_name(instance
),
3872 memcached_server_port(instance
), &rc
));
3874 test_compare(MEMCACHED_SUCCESS
, rc
);
3876 return TEST_SUCCESS
;
3881 static test_return_t
hash_sanity_test (memcached_st
*memc
)
3885 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
3886 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
3887 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
3888 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
3889 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
3890 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
3891 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
3892 #ifdef HAVE_HSIEH_HASH
3893 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
3895 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
3896 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
3897 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
3899 return TEST_SUCCESS
;
3903 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
3905 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
3907 test_compare(MEMCACHED_SUCCESS
,
3908 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
3909 (uint64_t)MEMCACHED_HASH_HSIEH
));
3911 return TEST_SUCCESS
;
3914 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
3916 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
3918 test_compare(MEMCACHED_SUCCESS
,
3919 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3921 return TEST_SUCCESS
;
3924 static test_return_t
one_at_a_time_run (memcached_st
*)
3929 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3931 test_compare(one_at_a_time_values
[x
],
3932 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
3935 return TEST_SUCCESS
;
3938 static test_return_t
md5_run (memcached_st
*)
3943 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3945 test_compare(md5_values
[x
],
3946 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
3949 return TEST_SUCCESS
;
3952 static test_return_t
crc_run (memcached_st
*)
3957 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3959 test_compare(crc_values
[x
],
3960 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
3963 return TEST_SUCCESS
;
3966 static test_return_t
fnv1_64_run (memcached_st
*)
3968 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
3973 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3975 test_compare(fnv1_64_values
[x
],
3976 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
3979 return TEST_SUCCESS
;
3982 static test_return_t
fnv1a_64_run (memcached_st
*)
3984 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
3989 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
3991 test_compare(fnv1a_64_values
[x
],
3992 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
3995 return TEST_SUCCESS
;
3998 static test_return_t
fnv1_32_run (memcached_st
*)
4003 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4005 test_compare(fnv1_32_values
[x
],
4006 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
4009 return TEST_SUCCESS
;
4012 static test_return_t
fnv1a_32_run (memcached_st
*)
4017 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4019 test_compare(fnv1a_32_values
[x
],
4020 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
4023 return TEST_SUCCESS
;
4026 static test_return_t
hsieh_run (memcached_st
*)
4028 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4033 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4035 test_compare(hsieh_values
[x
],
4036 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
4039 return TEST_SUCCESS
;
4042 static test_return_t
murmur_run (memcached_st
*)
4044 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4046 #ifdef WORDS_BIGENDIAN
4047 (void)murmur_values
;
4048 return TEST_SKIPPED
;
4053 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4055 test_compare(murmur_values
[x
],
4056 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
4059 return TEST_SUCCESS
;
4063 static test_return_t
jenkins_run (memcached_st
*)
4068 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4070 test_compare(jenkins_values
[x
],
4071 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
4074 return TEST_SUCCESS
;
4077 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
4079 return libhashkit_md5(string
, string_length
);
4082 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
4084 return libhashkit_crc32(string
, string_length
);
4087 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4093 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
4095 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};
4096 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};
4098 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4100 hashkit_clone(&new_kit
, kit
);
4101 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4103 memcached_set_hashkit(memc
, &new_kit
);
4106 Verify Setting the hash.
4108 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4112 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4113 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4118 Now check memcached_st.
4120 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4124 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4125 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4128 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4130 memcached_set_hashkit(memc
, &new_kit
);
4133 Verify Setting the hash.
4135 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4139 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4140 test_true(crc_values
[x
] == hash_val
);
4143 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4147 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4148 test_compare(crc_hosts
[x
], hash_val
);
4151 memcached_free(memc
);
4153 return TEST_SUCCESS
;
4157 Test case adapted from John Gorman <johngorman2@gmail.com>
4159 We are testing the error condition when we connect to a server via memcached_get()
4160 but find that the server is not available.
4162 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4164 const char *key
= "MemcachedLives";
4167 memcached_return rc
;
4170 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4172 // See if memcached is reachable.
4173 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4177 test_true(memcached_failed(rc
));
4179 memcached_free(tl_memc_h
);
4181 return TEST_SUCCESS
;
4185 We connect to a server which exists, but search for a key that does not exist.
4187 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4189 const char *key
= "MemcachedKeyNotEXIST";
4192 memcached_return rc
;
4194 // See if memcached is reachable.
4195 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4199 test_compare(MEMCACHED_NOTFOUND
, rc
);
4201 return TEST_SUCCESS
;
4205 Test case adapted from John Gorman <johngorman2@gmail.com>
4207 We are testing the error condition when we connect to a server via memcached_get_by_key()
4208 but find that the server is not available.
4210 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4213 memcached_st
*tl_memc_h
;
4214 memcached_server_st
*servers
;
4216 const char *key
= "MemcachedLives";
4219 memcached_return rc
;
4223 tl_memc_h
= memcached_create(NULL
);
4224 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4225 memcached_server_push(tl_memc_h
, servers
);
4226 memcached_server_list_free(servers
);
4228 // See if memcached is reachable.
4229 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4233 test_true(memcached_failed(rc
));
4235 memcached_free(tl_memc_h
);
4237 return TEST_SUCCESS
;
4241 We connect to a server which exists, but search for a key that does not exist.
4243 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4245 const char *key
= "MemcachedKeyNotEXIST";
4248 memcached_return rc
;
4251 // See if memcached is reachable.
4252 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4256 test_compare(MEMCACHED_NOTFOUND
, rc
);
4258 return TEST_SUCCESS
;
4261 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4263 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4265 const char *key
= "regression_bug_434484";
4266 size_t keylen
= strlen(key
);
4268 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4269 test_compare(MEMCACHED_NOTSTORED
, ret
);
4271 size_t size
= 2048 * 1024;
4272 char *data
= (char*)calloc(1, size
);
4274 test_compare(MEMCACHED_E2BIG
,
4275 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4278 return TEST_SUCCESS
;
4281 static test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4283 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4285 memcached_return_t rc
;
4287 memcached_execute_fn callbacks
[]= { &callback_counter
};
4290 * I only want to hit only _one_ server so I know the number of requests I'm
4291 * sending in the pipleine to the server. Let's try to do a multiget of
4292 * 1024 (that should satisfy most users don't you think?). Future versions
4293 * will include a mget_execute function call if you need a higher number.
4295 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4297 const size_t max_keys
= 1024;
4298 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4299 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4301 for (size_t x
= 0; x
< max_keys
; ++x
)
4305 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4311 * Run two times.. the first time we should have 100% cache miss,
4312 * and the second time we should have 100% cache hits
4314 for (size_t y
= 0; y
< 2; y
++)
4316 test_compare(MEMCACHED_SUCCESS
,
4317 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4319 // One the first run we should get a NOT_FOUND, but on the second some data
4320 // should be returned.
4321 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4322 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4326 /* The first iteration should give me a 100% cache miss. verify that*/
4327 char blob
[1024]= { 0 };
4329 test_false(counter
);
4331 for (size_t x
= 0; x
< max_keys
; ++x
)
4333 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4334 blob
, sizeof(blob
), 0, 0);
4335 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4340 /* Verify that we received all of the key/value pairs */
4341 test_compare(counter
, max_keys
);
4345 /* Release allocated resources */
4346 for (size_t x
= 0; x
< max_keys
; ++x
)
4353 memcached_free(memc
);
4355 return TEST_SUCCESS
;
4358 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4360 memcached_return_t rc
;
4361 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4362 test_compare(MEMCACHED_SUCCESS
, rc
);
4364 return regression_bug_434843(memc
);
4367 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4369 memcached_return_t rc
;
4370 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4371 test_compare(MEMCACHED_SUCCESS
, rc
);
4373 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4374 test_compare(MEMCACHED_SUCCESS
, rc
);
4375 test_true(bytes_str
);
4376 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4378 test_compare(MEMCACHED_SUCCESS
, rc
);
4379 test_true(bytes_read_str
);
4381 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4382 "bytes_written", &rc
);
4383 test_compare(MEMCACHED_SUCCESS
, rc
);
4384 test_true(bytes_written_str
);
4386 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4387 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4388 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4390 test_true(bytes
!= bytes_read
);
4391 test_true(bytes
!= bytes_written
);
4393 /* Release allocated resources */
4395 free(bytes_read_str
);
4396 free(bytes_written_str
);
4397 memcached_stat_free(NULL
, memc_stat
);
4399 return TEST_SUCCESS
;
4403 * The test case isn't obvious so I should probably document why
4404 * it works the way it does. Bug 442914 was caused by a bug
4405 * in the logic in memcached_purge (it did not handle the case
4406 * where the number of bytes sent was equal to the watermark).
4407 * In this test case, create messages so that we hit that case
4408 * and then disable noreply mode and issue a new command to
4409 * verify that it isn't stuck. If we change the format for the
4410 * delete command or the watermarks, we need to update this
4413 static test_return_t
regression_bug_442914(memcached_st
*memc
)
4415 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4416 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4418 uint32_t number_of_hosts
= memcached_server_count(memc
);
4419 memc
->number_of_hosts
= 1;
4424 for (uint32_t x
= 0; x
< 250; ++x
)
4426 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4427 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4428 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4431 len
= snprintf(k
, sizeof(k
), "%037u", 251U);
4433 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4434 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4436 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4437 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
4439 memc
->number_of_hosts
= number_of_hosts
;
4441 return TEST_SUCCESS
;
4444 static test_return_t
regression_bug_447342(memcached_st
*memc
)
4446 memcached_server_instance_st instance_one
;
4447 memcached_server_instance_st instance_two
;
4449 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4450 return TEST_SKIPPED
;
4452 test_compare(MEMCACHED_SUCCESS
,
4453 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4455 const unsigned int max_keys
= 100;
4456 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4457 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4459 for (unsigned int x
= 0; x
< max_keys
; ++x
)
4463 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4466 test_compare(MEMCACHED_SUCCESS
,
4467 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
4471 ** We are using the quiet commands to store the replicas, so we need
4472 ** to ensure that all of them are processed before we can continue.
4473 ** In the test we go directly from storing the object to trying to
4474 ** receive the object from all of the different servers, so we
4475 ** could end up in a race condition (the memcached server hasn't yet
4476 ** processed the quiet command from the replication set when it process
4477 ** the request from the other client (created by the clone)). As a
4478 ** workaround for that we call memcached_quit to send the quit command
4479 ** to the server and wait for the response ;-) If you use the test code
4480 ** as an example for your own code, please note that you shouldn't need
4483 memcached_quit(memc
);
4485 /* Verify that all messages are stored, and we didn't stuff too much
4488 test_compare(MEMCACHED_SUCCESS
,
4489 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4491 unsigned int counter
= 0;
4492 memcached_execute_fn callbacks
[]= { &callback_counter
};
4493 test_compare(MEMCACHED_SUCCESS
,
4494 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4496 /* Verify that we received all of the key/value pairs */
4497 test_compare(counter
, max_keys
);
4499 memcached_quit(memc
);
4501 * Don't do the following in your code. I am abusing the internal details
4502 * within the library, and this is not a supported interface.
4503 * This is to verify correct behavior in the library. Fake that two servers
4506 instance_one
= memcached_server_instance_by_position(memc
, 0);
4507 instance_two
= memcached_server_instance_by_position(memc
, 2);
4508 in_port_t port0
= instance_one
->port
;
4509 in_port_t port2
= instance_two
->port
;
4511 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4512 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4514 test_compare(MEMCACHED_SUCCESS
,
4515 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4518 test_compare(MEMCACHED_SUCCESS
,
4519 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4520 test_compare(counter
, (unsigned int)max_keys
);
4522 /* restore the memc handle */
4523 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4524 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4526 memcached_quit(memc
);
4528 /* Remove half of the objects */
4529 for (size_t x
= 0; x
< max_keys
; ++x
)
4533 test_compare(MEMCACHED_SUCCESS
,
4534 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
4538 memcached_quit(memc
);
4539 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4540 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4542 /* now retry the command, this time we should have cache misses */
4543 test_compare(MEMCACHED_SUCCESS
,
4544 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4547 test_compare(MEMCACHED_SUCCESS
,
4548 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4549 test_compare(counter
, (unsigned int)(max_keys
>> 1));
4551 /* Release allocated resources */
4552 for (size_t x
= 0; x
< max_keys
; ++x
)
4559 /* restore the memc handle */
4560 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4561 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4563 return TEST_SUCCESS
;
4566 static test_return_t
regression_bug_463297(memcached_st
*memc
)
4568 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc
, "foo", 3, 1));
4570 // Since we blocked timed delete, this test is no longer valid.
4572 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4573 test_true(memc_clone
);
4574 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4576 memcached_server_instance_st instance
=
4577 memcached_server_instance_by_position(memc_clone
, 0);
4579 if (instance
->major_version
> 1 ||
4580 (instance
->major_version
== 1 &&
4581 instance
->minor_version
> 2))
4583 /* Binary protocol doesn't support deferred delete */
4584 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4585 test_true(bin_clone
);
4586 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4587 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4588 memcached_free(bin_clone
);
4590 memcached_quit(memc_clone
);
4592 /* If we know the server version, deferred delete should fail
4593 * with invalid arguments */
4594 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4596 /* If we don't know the server version, we should get a protocol error */
4597 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4599 /* but there is a bug in some of the memcached servers (1.4) that treats
4600 * the counter as noreply so it doesn't send the proper error message
4602 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4604 /* And buffered mode should be disabled and we should get protocol error */
4605 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4606 rc
= memcached_delete(memc
, "foo", 3, 1);
4607 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4609 /* Same goes for noreply... */
4610 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4611 rc
= memcached_delete(memc
, "foo", 3, 1);
4612 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4614 /* but a normal request should go through (and be buffered) */
4615 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4616 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4618 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4619 /* unbuffered noreply should be success */
4620 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4621 /* unbuffered with reply should be not found... */
4622 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4623 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4626 memcached_free(memc_clone
);
4629 return TEST_SUCCESS
;
4633 /* Test memcached_server_get_last_disconnect
4634 * For a working server set, shall be NULL
4635 * For a set of non existing server, shall not be NULL
4637 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4639 memcached_return_t rc
;
4640 memcached_server_instance_st disconnected_server
;
4642 /* With the working set of server */
4643 const char *key
= "marmotte";
4644 const char *value
= "milka";
4646 memcached_reset_last_disconnected_server(memc
);
4647 test_false(memc
->last_disconnected_server
);
4648 rc
= memcached_set(memc
, key
, strlen(key
),
4649 value
, strlen(value
),
4650 (time_t)0, (uint32_t)0);
4651 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4653 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4654 test_false(disconnected_server
);
4656 /* With a non existing server */
4658 memcached_server_st
*servers
;
4660 const char *server_list
= "localhost:9";
4662 servers
= memcached_servers_parse(server_list
);
4664 mine
= memcached_create(NULL
);
4665 rc
= memcached_server_push(mine
, servers
);
4666 test_compare(MEMCACHED_SUCCESS
, rc
);
4667 memcached_server_list_free(servers
);
4670 rc
= memcached_set(mine
, key
, strlen(key
),
4671 value
, strlen(value
),
4672 (time_t)0, (uint32_t)0);
4673 test_true(memcached_failed(rc
));
4675 disconnected_server
= memcached_server_get_last_disconnect(mine
);
4676 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
4677 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
4678 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
4680 memcached_quit(mine
);
4681 memcached_free(mine
);
4683 return TEST_SUCCESS
;
4686 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
4688 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4689 char buffer
[BUFSIZ
];
4691 test_compare(MEMCACHED_SUCCESS
,
4692 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
4694 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
4697 // We will just use the error strings as our keys
4698 uint32_t counter
= 100;
4701 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
4703 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
4704 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
4705 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
4707 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
4708 test_true(disconnected_server
);
4709 test_strcmp("localhost", memcached_server_name(disconnected_server
));
4710 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
4714 memcached_reset_last_disconnected_server(memc
);
4719 memcached_free(memc
);
4721 return TEST_SUCCESS
;
4724 static test_return_t
test_verbosity(memcached_st
*memc
)
4726 memcached_verbosity(memc
, 3);
4728 return TEST_SUCCESS
;
4732 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
4733 const char *key
, size_t key_length
,
4734 const char *value
, size_t value_length
,
4744 return MEMCACHED_SUCCESS
;
4747 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
4749 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
4750 test_compare(MEMCACHED_SUCCESS
, rc
);
4752 test_compare(MEMCACHED_SUCCESS
,
4753 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
4755 test_compare(MEMCACHED_SUCCESS
,
4756 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
4758 test_compare(MEMCACHED_SUCCESS
,
4759 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
4761 return TEST_SUCCESS
;
4765 * This test ensures that the failure counter isn't incremented during
4766 * normal termination of the memcached instance.
4768 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
4770 memcached_return_t rc
;
4771 memcached_server_instance_st instance
;
4773 /* Set value to force connection to the server */
4774 const char *key
= "marmotte";
4775 const char *value
= "milka";
4778 * Please note that I'm abusing the internal structures in libmemcached
4779 * in a non-portable way and you shouldn't be doing this. I'm only
4780 * doing this in order to verify that the library works the way it should
4782 uint32_t number_of_hosts
= memcached_server_count(memc
);
4783 memc
->number_of_hosts
= 1;
4785 /* Ensure that we are connected to the server by setting a value */
4786 rc
= memcached_set(memc
, key
, strlen(key
),
4787 value
, strlen(value
),
4788 (time_t)0, (uint32_t)0);
4789 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
4792 instance
= memcached_server_instance_by_position(memc
, 0);
4793 /* The test is to see that the memcached_quit doesn't increase the
4794 * the server failure conter, so let's ensure that it is zero
4795 * before sending quit
4797 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
4799 memcached_quit(memc
);
4801 /* Verify that it memcached_quit didn't increment the failure counter
4802 * Please note that this isn't bullet proof, because an error could
4805 test_zero(instance
->server_failure_counter
);
4807 /* restore the instance */
4808 memc
->number_of_hosts
= number_of_hosts
;
4810 return TEST_SUCCESS
;
4814 * This tests ensures expected disconnections (for some behavior changes
4815 * for instance) do not wrongly increase failure counter
4817 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
4819 /* Set value to force connection to the server */
4820 const char *key
= "marmotte";
4821 const char *value
= "milka";
4823 test_compare_hint(MEMCACHED_SUCCESS
,
4824 memcached_set(memc
, key
, strlen(key
),
4825 value
, strlen(value
),
4826 (time_t)0, (uint32_t)0),
4827 memcached_last_error_message(memc
));
4830 /* put failure limit to 1 */
4831 test_compare(MEMCACHED_SUCCESS
,
4832 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
4834 /* Put a retry timeout to effectively activate failure_limit effect */
4835 test_compare(MEMCACHED_SUCCESS
,
4836 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
4838 /* change behavior that triggers memcached_quit()*/
4839 test_compare(MEMCACHED_SUCCESS
,
4840 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
4843 /* Check if we still are connected */
4845 size_t string_length
;
4846 memcached_return rc
;
4847 char *string
= memcached_get(memc
, key
, strlen(key
),
4848 &string_length
, &flags
, &rc
);
4850 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4854 return TEST_SUCCESS
;
4859 * Test that ensures mget_execute does not end into recursive calls that finally fails
4861 static test_return_t
regression_bug_490486(memcached_st
*original_memc
)
4865 return TEST_SKIPPED
; // My MAC can't handle this test
4868 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4871 * I only want to hit _one_ server so I know the number of requests I'm
4872 * sending in the pipeline.
4874 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4877 size_t max_keys
= 20480;
4879 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
4880 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4882 /* First add all of the items.. */
4883 char blob
[1024]= { 0 };
4884 for (size_t x
= 0; x
< max_keys
; ++x
)
4887 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4890 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
4891 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4896 /* Try to get all of them with a large multiget */
4898 memcached_execute_function callbacks
[]= { &callback_counter
};
4899 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
4900 (size_t)max_keys
, callbacks
, &counter
, 1);
4901 test_compare(MEMCACHED_SUCCESS
, rc
);
4903 char* the_value
= NULL
;
4904 char the_key
[MEMCACHED_MAX_KEY
];
4905 size_t the_key_length
;
4906 size_t the_value_length
;
4910 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
4912 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
4918 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
4921 test_compare(MEMCACHED_END
, rc
);
4923 /* Verify that we got all of the items */
4924 test_compare(counter
, max_keys
);
4927 /* Release all allocated resources */
4928 for (size_t x
= 0; x
< max_keys
; ++x
)
4935 memcached_free(memc
);
4937 return TEST_SUCCESS
;
4940 static test_return_t
regression_bug_583031(memcached_st
*)
4942 memcached_st
*memc
= memcached_create(NULL
);
4944 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
4946 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
4947 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
4948 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4949 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4950 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
4951 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
4953 memcached_return_t rc
;
4957 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
4961 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
4963 memcached_free(memc
);
4965 return TEST_SUCCESS
;
4968 static test_return_t
regression_bug_581030(memcached_st
*)
4971 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
4972 test_false(local_stat
);
4974 memcached_stat_free(NULL
, NULL
);
4977 return TEST_SUCCESS
;
4980 #define regression_bug_655423_COUNT 6000
4981 static test_return_t
regression_bug_655423(memcached_st
*memc
)
4983 memcached_st
*clone
= memcached_clone(NULL
, memc
);
4984 memc
= NULL
; // Just to make sure it is not used
4989 return TEST_SKIPPED
;
4992 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4993 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4994 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
4995 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
4997 memset(payload
, int('x'), sizeof(payload
));
4999 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5001 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5002 snprintf(key
, sizeof(key
), "%u", x
);
5004 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5007 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5009 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5010 snprintf(key
, sizeof(key
), "%u", x
);
5012 size_t value_length
;
5013 memcached_return_t rc
;
5014 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5016 if (rc
== MEMCACHED_NOTFOUND
)
5019 test_zero(value_length
);
5023 test_compare(MEMCACHED_SUCCESS
, rc
);
5025 test_compare(100LLU, value_length
);
5029 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5030 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5031 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5033 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5034 snprintf(key
, sizeof(key
), "%u", x
);
5036 keys
[x
]= strdup(key
);
5038 key_length
[x
]= strlen(key
);
5039 test_true(key_length
[x
]);
5042 test_compare(MEMCACHED_SUCCESS
,
5043 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5046 memcached_result_st
*result
= NULL
;
5047 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5049 test_compare(size_t(100), memcached_result_length(result
));
5053 test_true(count
> 100); // If we don't get back atleast this, something is up
5055 /* Release all allocated resources */
5056 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5064 memcached_free(clone
);
5066 return TEST_SUCCESS
;
5070 * Test that ensures that buffered set to not trigger problems during io_flush
5072 #define regression_bug_490520_COUNT 200480
5073 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5075 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5076 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5077 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5078 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5079 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5081 memc
->number_of_hosts
= 1;
5083 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5084 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5086 /* First add all of the items.. */
5087 char blob
[3333] = {0};
5088 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5091 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5095 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5096 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
5099 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5106 return TEST_SUCCESS
;
5110 static test_return_t
regression_bug_854604(memcached_st
*)
5114 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
5116 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
5118 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
5119 test_compare(buffer
[0], 0);
5121 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
5122 test_true(strlen(buffer
));
5124 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
5125 test_true(strlen(buffer
));
5127 return TEST_SUCCESS
;
5130 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5132 fprintf(stderr
, "Iteration #%u: ", it
);
5134 if (error
== MEMCACHED_ERRNO
)
5136 fprintf(stderr
, "system error %d from %s: %s\n",
5137 errno
, what
, strerror(errno
));
5141 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5142 memcached_strerror(mc
, error
));
5146 #define TEST_CONSTANT_CREATION 200
5148 static test_return_t
regression_bug_(memcached_st
*memc
)
5150 const char *remote_server
;
5153 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5155 return TEST_SKIPPED
;
5158 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5160 memcached_st
* mc
= memcached_create(NULL
);
5161 memcached_return rc
;
5163 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5164 if (rc
!= MEMCACHED_SUCCESS
)
5166 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5169 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5170 if (rc
!= MEMCACHED_SUCCESS
)
5172 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5175 rc
= memcached_server_add(mc
, remote_server
, 0);
5176 if (rc
!= MEMCACHED_SUCCESS
)
5178 memcached_die(mc
, rc
, "memcached_server_add", x
);
5181 const char *set_key
= "akey";
5182 const size_t set_key_len
= strlen(set_key
);
5183 const char *set_value
= "a value";
5184 const size_t set_value_len
= strlen(set_value
);
5186 if (rc
== MEMCACHED_SUCCESS
)
5190 size_t get_value_len
;
5192 uint32_t get_value_flags
;
5194 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5195 &get_value_flags
, &rc
);
5196 if (rc
!= MEMCACHED_SUCCESS
)
5198 memcached_die(mc
, rc
, "memcached_get", x
);
5204 (get_value_len
!= set_value_len
5205 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5207 fprintf(stderr
, "Values don't match?\n");
5208 rc
= MEMCACHED_FAILURE
;
5214 rc
= memcached_set(mc
,
5215 set_key
, set_key_len
,
5216 set_value
, set_value_len
,
5220 if (rc
!= MEMCACHED_SUCCESS
)
5222 memcached_die(mc
, rc
, "memcached_set", x
);
5229 if (rc
!= MEMCACHED_SUCCESS
)
5235 return TEST_SUCCESS
;
5238 /* Clean the server before beginning testing */
5240 {"util_version", true, (test_callback_fn
*)util_version_test
},
5241 {"flush", false, (test_callback_fn
*)flush_test
},
5242 {"init", false, (test_callback_fn
*)init_test
},
5243 {"allocation", false, (test_callback_fn
*)allocation_test
},
5244 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5245 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5246 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5247 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5248 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5249 {"clone_test", false, (test_callback_fn
*)clone_test
},
5250 {"connection_test", false, (test_callback_fn
*)connection_test
},
5251 {"callback_test", false, (test_callback_fn
*)callback_test
},
5252 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5253 {"memcached_set()", false, (test_callback_fn
*)set_test
},
5254 {"memcached_set() 2", false, (test_callback_fn
*)set_test2
},
5255 {"memcached_set() 3", false, (test_callback_fn
*)set_test3
},
5256 {"add", true, (test_callback_fn
*)add_test
},
5257 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5258 {"replace", true, (test_callback_fn
*)replace_test
},
5259 {"delete", true, (test_callback_fn
*)delete_test
},
5260 {"get", true, (test_callback_fn
*)get_test
},
5261 {"get2", false, (test_callback_fn
*)get_test2
},
5262 {"get3", false, (test_callback_fn
*)get_test3
},
5263 {"get4", false, (test_callback_fn
*)get_test4
},
5264 {"partial mget", false, (test_callback_fn
*)get_test5
},
5265 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5266 {"increment", false, (test_callback_fn
*)increment_test
},
5267 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5268 {"decrement", false, (test_callback_fn
*)decrement_test
},
5269 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5270 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5271 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5272 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5273 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5274 {"binary_increment_with_prefix", true, (test_callback_fn
*)binary_increment_with_prefix_test
},
5275 {"quit", false, (test_callback_fn
*)quit_test
},
5276 {"mget", true, (test_callback_fn
*)mget_test
},
5277 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5278 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5279 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5280 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5281 {"mget_end", false, (test_callback_fn
*)mget_end
},
5282 {"get_stats", false, (test_callback_fn
*)get_stats
},
5283 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5284 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5285 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5286 {"version_string_test", true, (test_callback_fn
*)version_string_test
},
5287 {"memcached_mget() mixed memcached_get()", true, (test_callback_fn
*)memcached_mget_mixed_memcached_get_TEST
},
5288 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5289 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5290 {"read_through", true, (test_callback_fn
*)read_through
},
5291 {"delete_through", true, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER
},
5292 {"noreply", true, (test_callback_fn
*)noreply_test
},
5293 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5294 {"memcached_pool_st", true, (test_callback_fn
*)connection_pool_test
},
5295 {"memcached_pool_st #2", true, (test_callback_fn
*)connection_pool2_test
},
5297 {"memcached_pool_st #3", true, (test_callback_fn
*)connection_pool3_test
},
5299 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
5300 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
5301 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
5302 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
5303 {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_NOTFOUND
},
5304 {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_SUCCESS
},
5305 {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_by_key_NOTFOUND
},
5306 {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_by_key_SUCCESS
},
5307 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5308 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5310 {"memcached_dump() no data", true, (test_callback_fn
*)memcached_dump_TEST
},
5312 {"memcached_dump() with data", true, (test_callback_fn
*)memcached_dump_TEST2
},
5316 test_st touch_tests
[] ={
5317 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5318 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5322 test_st memcached_stat_tests
[] ={
5323 {"memcached_stat() INVALID ARG", 0, (test_callback_fn
*)memcached_stat_TEST
},
5324 {"memcached_stat()", 0, (test_callback_fn
*)memcached_stat_TEST2
},
5328 test_st behavior_tests
[] ={
5329 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5330 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5331 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5332 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5333 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5334 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5335 {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test
},
5336 {"MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY", false, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY
},
5340 test_st libmemcachedutil_tests
[] ={
5341 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5342 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5343 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5347 test_st basic_tests
[] ={
5348 {"init", true, (test_callback_fn
*)basic_init_test
},
5349 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5350 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5351 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5352 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5353 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5354 {"memcached_return_t", false, (test_callback_fn
*)memcached_return_t_TEST
},
5358 test_st regression_binary_vs_block
[] ={
5359 {"block add", true, (test_callback_fn
*)block_add_regression
},
5360 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
5364 test_st async_tests
[] ={
5365 {"add", true, (test_callback_fn
*)add_wrapper
},
5369 test_st memcached_server_get_last_disconnect_tests
[] ={
5370 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
5371 {0, 0, (test_callback_fn
*)0}
5375 test_st result_tests
[] ={
5376 {"result static", false, (test_callback_fn
*)result_static
},
5377 {"result alloc", false, (test_callback_fn
*)result_alloc
},
5378 {0, 0, (test_callback_fn
*)0}
5381 test_st version_1_2_3
[] ={
5382 {"append", false, (test_callback_fn
*)append_test
},
5383 {"prepend", false, (test_callback_fn
*)prepend_test
},
5384 {"cas", false, (test_callback_fn
*)cas_test
},
5385 {"cas2", false, (test_callback_fn
*)cas2_test
},
5386 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
5387 {0, 0, (test_callback_fn
*)0}
5390 test_st haldenbrand_TESTS
[] ={
5391 {"memcached_set", false, (test_callback_fn
*)haldenbrand_TEST1
},
5392 {"memcached_get()", false, (test_callback_fn
*)haldenbrand_TEST2
},
5393 {"memcached_mget()", false, (test_callback_fn
*)haldenbrand_TEST3
},
5394 {0, 0, (test_callback_fn
*)0}
5397 test_st user_tests
[] ={
5398 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
5399 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
5400 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
5401 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
5402 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
5403 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
5404 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
5405 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
5406 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
5407 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
5408 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
5409 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
5410 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
5411 #if !defined(__sun) && !defined(__OpenBSD__)
5413 ** It seems to be something weird with the character sets..
5414 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5415 ** guess I need to find out how this is supposed to work.. Perhaps I need
5416 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5417 ** so just disable the code for now...).
5419 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
5421 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
5422 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
5423 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
5424 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
5425 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
5426 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
5427 {0, 0, (test_callback_fn
*)0}
5430 test_st replication_tests
[]= {
5431 {"set", true, (test_callback_fn
*)replication_set_test
},
5432 {"get", false, (test_callback_fn
*)replication_get_test
},
5433 {"mget", false, (test_callback_fn
*)replication_mget_test
},
5434 {"delete", true, (test_callback_fn
*)replication_delete_test
},
5435 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
5436 {"miss", false, (test_callback_fn
*)replication_miss_test
},
5437 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
5438 {0, 0, (test_callback_fn
*)0}
5442 * The following test suite is used to verify that we don't introduce
5443 * regression bugs. If you want more information about the bug / test,
5444 * you should look in the bug report at
5445 * http://bugs.launchpad.net/libmemcached
5447 test_st regression_tests
[]= {
5448 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
5449 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
5450 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
5451 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
5452 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
5453 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
5454 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
5455 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
5456 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
5457 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
5458 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
5459 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
5460 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
5461 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
5462 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
5463 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
5464 {"lp:854604", true, (test_callback_fn
*)regression_bug_854604
},
5465 {0, false, (test_callback_fn
*)0}
5468 test_st ketama_compatibility
[]= {
5469 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
5470 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
5471 {0, 0, (test_callback_fn
*)0}
5474 test_st generate_tests
[] ={
5475 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5476 {"generate_data", true, (test_callback_fn
*)generate_data
},
5477 {"get_read", false, (test_callback_fn
*)get_read
},
5478 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
5479 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5480 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
5481 {"generate_data", true, (test_callback_fn
*)generate_data
},
5482 {"mget_read", false, (test_callback_fn
*)mget_read
},
5483 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
5484 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
5485 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
5486 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
5487 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5488 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
5489 {"generate_data", true, (test_callback_fn
*)generate_data
},
5490 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5491 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5492 {0, 0, (test_callback_fn
*)0}
5495 test_st consistent_tests
[] ={
5496 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5497 {"generate_data", true, (test_callback_fn
*)generate_data
},
5498 {"get_read", 0, (test_callback_fn
*)get_read_count
},
5499 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5500 {0, 0, (test_callback_fn
*)0}
5503 test_st consistent_weighted_tests
[] ={
5504 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5505 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
5506 {"get_read", false, (test_callback_fn
*)get_read_count
},
5507 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5508 {0, 0, (test_callback_fn
*)0}
5511 test_st hsieh_availability
[] ={
5512 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
5513 {0, 0, (test_callback_fn
*)0}
5516 test_st murmur_availability
[] ={
5517 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
5518 {0, 0, (test_callback_fn
*)0}
5522 test_st hash_sanity
[] ={
5523 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
5524 {0, 0, (test_callback_fn
*)0}
5528 test_st ketama_auto_eject_hosts
[] ={
5529 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
5530 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
5531 {0, 0, (test_callback_fn
*)0}
5534 test_st hash_tests
[] ={
5535 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
5536 {"md5", false, (test_callback_fn
*)md5_run
},
5537 {"crc", false, (test_callback_fn
*)crc_run
},
5538 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
5539 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
5540 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
5541 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
5542 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
5543 {"murmur", false, (test_callback_fn
*)murmur_run
},
5544 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
5545 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
5546 {0, 0, (test_callback_fn
*)0}
5549 test_st error_conditions
[] ={
5550 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
5551 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
5552 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
5553 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5554 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5555 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
5556 {0, 0, (test_callback_fn
*)0}
5559 test_st parser_tests
[] ={
5560 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
5561 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
5562 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
5563 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
5564 {"hash", false, (test_callback_fn
*)parser_hash_test
},
5565 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
5566 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
5567 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
5568 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
5569 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
5570 {"server", false, (test_callback_fn
*)server_test
},
5571 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
5572 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
5573 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
5574 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
5575 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
5576 {0, 0, (test_callback_fn
*)0}
5579 test_st virtual_bucket_tests
[] ={
5580 {"basic", false, (test_callback_fn
*)virtual_back_map
},
5581 {0, 0, (test_callback_fn
*)0}
5584 test_st memcached_server_add_tests
[] ={
5585 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
5586 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
5587 {0, 0, (test_callback_fn
*)0}
5590 test_st namespace_tests
[] ={
5591 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
5592 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
5593 {0, 0, (test_callback_fn
*)0}
5596 collection_st collection
[] ={
5598 {"hash_sanity", 0, 0, hash_sanity
},
5600 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
5601 {"basic", 0, 0, basic_tests
},
5602 {"hsieh_availability", 0, 0, hsieh_availability
},
5603 {"murmur_availability", 0, 0, murmur_availability
},
5604 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
5605 {"block", 0, 0, tests
},
5606 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
5607 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
5608 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5609 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
5610 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
5611 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
5612 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
5613 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
5614 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
5615 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
5616 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
5617 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
5618 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
5619 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
5620 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
5621 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5622 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
5623 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
5624 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
5625 #ifdef MEMCACHED_ENABLE_DEPRECATED
5626 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
5628 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
5629 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
5630 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
5631 {"specific namespace", 0, 0, namespace_tests
},
5632 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
5633 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
5634 {"result", 0, 0, result_tests
},
5635 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
5636 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
5637 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_TESTS
},
5638 {"user written tests", 0, 0, user_tests
},
5639 {"generate", 0, 0, generate_tests
},
5640 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
5641 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
5642 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
5643 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
5644 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
5645 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
5646 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
5648 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
5649 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
5650 {"consistent_not", 0, 0, consistent_tests
},
5651 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
5652 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
5653 {"ketama_compat", 0, 0, ketama_compatibility
},
5654 {"test_hashes", 0, 0, hash_tests
},
5655 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
5656 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
5657 {"regression", 0, 0, regression_tests
},
5658 {"behaviors", 0, 0, behavior_tests
},
5659 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
5660 {"error_conditions", 0, 0, error_conditions
},
5661 {"parser", 0, 0, parser_tests
},
5662 {"virtual buckets", 0, 0, virtual_bucket_tests
},
5663 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
5664 {"touch", 0, 0, touch_tests
},
5665 {"touch", (test_callback_fn
*)pre_binary
, 0, touch_tests
},
5666 {"memcached_stat()", 0, 0, memcached_stat_tests
},
5670 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
5672 #include "tests/libmemcached_world.h"
5674 void get_world(Framework
*world
)
5676 world
->collections
= collection
;
5678 world
->_create
= (test_callback_create_fn
*)world_create
;
5679 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
5681 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
5682 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
5683 world
->item
.set_flush((test_callback_fn
*)world_flush
);
5684 world
->item
.set_post((test_callback_fn
*)world_post_run
);
5685 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
5687 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
5688 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
5690 world
->set_runner(&defualt_libmemcached_runner
);
5692 world
->set_socket();