1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 #include <libtest/common.h>
44 #define BUILDING_LIBMEMCACHED
45 // !NEVER use common.h, always use memcached.h in your own apps
46 #include <libmemcached/common.h>
53 #include <sys/types.h>
58 #include <libtest/server.h>
60 #include "clients/generator.h"
61 #include "clients/execute.h"
63 #define SMALL_STRING_LEN 1024
65 #include <libtest/test.hpp>
66 #include "tests/deprecated.h"
67 #include "tests/parser.h"
68 #include "tests/pool.h"
69 #include "tests/string.h"
70 #include "tests/replication.h"
71 #include "tests/basic.h"
72 #include "tests/error_conditions.h"
73 #include "tests/print.h"
74 #include "tests/virtual_buckets.h"
77 #ifdef HAVE_LIBMEMCACHEDUTIL
79 #include "libmemcached/memcached_util.h"
82 #include "hash_results.h"
84 #define GLOBAL_COUNT 10000
85 #define GLOBAL2_COUNT 100
86 #define SERVERS_TO_CREATE 5
87 static uint32_t global_count
;
89 static pairs_st
*global_pairs
;
90 static const char *global_keys
[GLOBAL_COUNT
];
91 static size_t global_keys_length
[GLOBAL_COUNT
];
94 static test_return_t
pre_binary(memcached_st
*memc
);
97 static test_return_t
init_test(memcached_st
*not_used
)
102 (void)memcached_create(&memc
);
103 memcached_free(&memc
);
108 #define TEST_PORT_COUNT 7
109 in_port_t test_ports
[TEST_PORT_COUNT
];
111 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
112 const memcached_server_st
*server
,
116 size_t bigger
= *((size_t *)(context
));
118 assert(bigger
<= memcached_server_port(server
));
119 *((size_t *)(context
))= memcached_server_port(server
);
121 return MEMCACHED_SUCCESS
;
124 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
125 const memcached_server_st
*instance
,
129 FILE *stream
= (FILE *)context
;
132 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
133 memcached_server_name(instance
),
134 memcached_server_port(instance
),
135 instance
->major_version
,
136 instance
->minor_version
,
137 instance
->micro_version
);
139 return MEMCACHED_SUCCESS
;
142 static test_return_t
server_sort_test(memcached_st
*ptr
)
144 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
146 memcached_return_t rc
;
147 memcached_server_fn callbacks
[1];
148 memcached_st
*local_memc
;
151 local_memc
= memcached_create(NULL
);
152 test_true(local_memc
);
153 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
155 for (size_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
157 test_ports
[x
]= (in_port_t
)random() % 64000;
158 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
159 test_compare(memcached_server_count(local_memc
), x
+1);
161 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
163 test_compare(MEMCACHED_SUCCESS
, rc
);
166 callbacks
[0]= server_display_function
;
167 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
170 memcached_free(local_memc
);
175 static test_return_t
server_sort2_test(memcached_st
*ptr
)
177 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
178 memcached_server_fn callbacks
[1];
179 memcached_st
*local_memc
;
180 memcached_server_instance_st instance
;
183 local_memc
= memcached_create(NULL
);
184 test_true(local_memc
);
185 test_compare(MEMCACHED_SUCCESS
,
186 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
188 test_compare(MEMCACHED_SUCCESS
,
189 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
190 instance
= memcached_server_instance_by_position(local_memc
, 0);
191 test_compare(43043, memcached_server_port(instance
));
193 test_compare(MEMCACHED_SUCCESS
,
194 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
196 instance
= memcached_server_instance_by_position(local_memc
, 0);
197 test_compare(43042, memcached_server_port(instance
));
199 instance
= memcached_server_instance_by_position(local_memc
, 1);
200 test_compare(43043, memcached_server_port(instance
));
202 callbacks
[0]= server_display_function
;
203 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
206 memcached_free(local_memc
);
211 static test_return_t
memcached_server_remove_test(memcached_st
*)
213 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";
216 memcached_return_t rc
;
217 test_compare_got(MEMCACHED_SUCCESS
,
218 rc
= libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)),
219 memcached_strerror(NULL
, rc
));
220 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
223 memcached_server_fn callbacks
[1];
224 callbacks
[0]= server_print_callback
;
225 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
227 memcached_free(memc
);
232 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
233 const memcached_server_st
*server
,
237 uint32_t x
= *((uint32_t *)(context
));
239 if (! (test_ports
[x
] == server
->port
))
241 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
242 return MEMCACHED_FAILURE
;
245 *((uint32_t *)(context
))= ++x
;
247 return MEMCACHED_SUCCESS
;
250 static test_return_t
server_unsort_test(memcached_st
*ptr
)
252 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
253 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
254 memcached_server_fn callbacks
[1];
255 memcached_st
*local_memc
;
258 local_memc
= memcached_create(NULL
);
259 test_true(local_memc
);
261 for (size_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
263 test_ports
[x
]= (in_port_t
)(random() % 64000);
264 test_compare(MEMCACHED_SUCCESS
,
265 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
266 test_compare(memcached_server_count(local_memc
), x
+1);
268 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
272 callbacks
[0]= server_display_unsort_function
;
273 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
275 /* Now we sort old data! */
276 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
277 callbacks
[0]= server_display_function
;
278 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
281 memcached_free(local_memc
);
286 static test_return_t
allocation_test(memcached_st
*not_used
)
290 memc
= memcached_create(NULL
);
292 memcached_free(memc
);
297 static test_return_t
clone_test(memcached_st
*memc
)
301 memcached_st
*memc_clone
;
302 memc_clone
= memcached_clone(NULL
, NULL
);
303 test_true(memc_clone
);
304 memcached_free(memc_clone
);
307 /* Can we init from null? */
309 memcached_st
*memc_clone
;
310 memc_clone
= memcached_clone(NULL
, memc
);
311 test_true(memc_clone
);
314 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
315 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
316 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
317 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
320 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
321 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
322 test_true(memc_clone
->distribution
== memc
->distribution
);
323 { // Test all of the flags
324 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
325 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
326 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
327 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
328 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
329 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
330 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
331 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
332 test_true(memc_clone
->flags
.hash_with_prefix_key
== memc
->flags
.hash_with_prefix_key
);
333 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
334 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
335 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
336 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
338 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
339 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
340 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
341 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
342 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
343 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
344 test_true(memc_clone
->on_clone
== memc
->on_clone
);
345 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
346 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
347 test_true(memc_clone
->recv_size
== memc
->recv_size
);
348 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
349 test_true(memc_clone
->send_size
== memc
->send_size
);
350 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
351 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
352 test_true(memc_clone
->user_data
== memc
->user_data
);
354 memcached_free(memc_clone
);
357 /* Can we init from struct? */
359 memcached_st declared_clone
;
360 memcached_st
*memc_clone
;
361 memset(&declared_clone
, 0 , sizeof(memcached_st
));
362 memc_clone
= memcached_clone(&declared_clone
, NULL
);
363 test_true(memc_clone
);
364 memcached_free(memc_clone
);
367 /* Can we init from struct? */
369 memcached_st declared_clone
;
370 memcached_st
*memc_clone
;
371 memset(&declared_clone
, 0 , sizeof(memcached_st
));
372 memc_clone
= memcached_clone(&declared_clone
, memc
);
373 test_true(memc_clone
);
374 memcached_free(memc_clone
);
380 static test_return_t
userdata_test(memcached_st
*memc
)
383 test_false(memcached_set_user_data(memc
, foo
));
384 test_true(memcached_get_user_data(memc
) == foo
);
385 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
390 static test_return_t
connection_test(memcached_st
*memc
)
392 test_compare(MEMCACHED_SUCCESS
,
393 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
398 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
400 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
402 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
404 test_compare(36, MEMCACHED_BEHAVIOR_MAX
);
409 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
411 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
413 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
415 test_compare(7, MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
);
420 static test_return_t
error_test(memcached_st
*memc
)
422 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
423 982370485U, 1263635348U, 4242906218U, 3829656100U,
424 1891735253U, 334139633U, 2257084983U, 3088286104U,
425 13199785U, 2542027183U, 1097051614U, 199566778U,
426 2748246961U, 2465192557U, 1664094137U, 2405439045U,
427 1842224848U, 692413798U, 3479807801U, 919913813U,
428 4269430871U, 610793021U, 527273862U, 1437122909U,
429 2300930706U, 2943759320U, 674306647U, 2400528935U,
430 54481931U, 4186304426U, 1741088401U, 2979625118U,
431 4159057246U, 3425930182U, 2593724503U, 1868899624U,
432 1769812374U, 2302537950U, 1110330676U, 3365377466U,
433 1336171666U, 3021258493U, 2334992265U, 3365377466U };
435 // You have updated the memcache_error messages but not updated docs/tests.
436 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
439 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
440 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
441 MEMCACHED_HASH_JENKINS
);
442 if (values
[rc
] != hash_val
)
444 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the error_test\n");
445 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
447 test_compare(values
[rc
], hash_val
);
449 test_compare(MEMCACHED_MAXIMUM_RETURN
, 47);
454 static test_return_t
set_test(memcached_st
*memc
)
456 memcached_return_t rc
= memcached_set(memc
,
457 memcached_literal_param("foo"),
458 memcached_literal_param("when we sanitize"),
459 time_t(0), (uint32_t)0);
460 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
465 static test_return_t
append_test(memcached_st
*memc
)
467 memcached_return_t rc
;
468 const char *key
= "fig";
469 const char *in_value
= "we";
470 char *out_value
= NULL
;
474 rc
= memcached_flush(memc
, 0);
475 test_compare(MEMCACHED_SUCCESS
, rc
);
477 rc
= memcached_set(memc
, key
, strlen(key
),
478 in_value
, strlen(in_value
),
479 (time_t)0, (uint32_t)0);
480 test_compare(MEMCACHED_SUCCESS
, rc
);
482 rc
= memcached_append(memc
, key
, strlen(key
),
483 " the", strlen(" the"),
484 (time_t)0, (uint32_t)0);
485 test_compare(MEMCACHED_SUCCESS
, rc
);
487 rc
= memcached_append(memc
, key
, strlen(key
),
488 " people", strlen(" people"),
489 (time_t)0, (uint32_t)0);
490 test_compare(MEMCACHED_SUCCESS
, rc
);
492 out_value
= memcached_get(memc
, key
, strlen(key
),
493 &value_length
, &flags
, &rc
);
494 test_memcmp(out_value
, "we the people", strlen("we the people"));
495 test_compare(strlen("we the people"), value_length
);
496 test_compare(MEMCACHED_SUCCESS
, rc
);
502 static test_return_t
append_binary_test(memcached_st
*memc
)
504 memcached_return_t rc
;
505 const char *key
= "numbers";
506 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
512 rc
= memcached_flush(memc
, 0);
513 test_compare(MEMCACHED_SUCCESS
, rc
);
515 rc
= memcached_set(memc
,
518 (time_t)0, (uint32_t)0);
519 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
521 for (x
= 0; store_list
[x
] ; x
++)
523 rc
= memcached_append(memc
,
525 (char *)&store_list
[x
], sizeof(uint32_t),
526 (time_t)0, (uint32_t)0);
527 test_compare(MEMCACHED_SUCCESS
, rc
);
530 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
531 &value_length
, &flags
, &rc
);
532 test_compare(value_length
, sizeof(uint32_t) * x
);
533 test_compare(MEMCACHED_SUCCESS
, rc
);
535 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
537 test_compare(*ptr
, store_list
[x
- counter
]);
545 static test_return_t
cas2_test(memcached_st
*memc
)
547 memcached_return_t rc
;
548 const char *keys
[]= {"fudge", "son", "food"};
549 size_t key_length
[]= {5, 3, 4};
550 const char *value
= "we the people";
551 size_t value_length
= strlen("we the people");
552 memcached_result_st results_obj
;
553 memcached_result_st
*results
;
556 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
558 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
560 for (uint32_t x
= 0; x
< 3; x
++)
562 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
563 keys
[x
], key_length
[x
],
564 (time_t)50, (uint32_t)9);
565 test_compare(MEMCACHED_SUCCESS
, rc
);
568 rc
= memcached_mget(memc
, keys
, key_length
, 3);
570 results
= memcached_result_create(memc
, &results_obj
);
572 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
574 test_true(results
->item_cas
);
575 test_compare(MEMCACHED_SUCCESS
, rc
);
576 test_true(memcached_result_cas(results
));
578 test_memcmp(value
, "we the people", strlen("we the people"));
579 test_compare(strlen("we the people"), value_length
);
580 test_compare(MEMCACHED_SUCCESS
, rc
);
582 memcached_result_free(&results_obj
);
587 static test_return_t
cas_test(memcached_st
*memc
)
589 memcached_return_t rc
;
590 const char *key
= "fun";
591 size_t key_length
= strlen(key
);
592 const char *value
= "we the people";
593 const char* keys
[2] = { key
, NULL
};
594 size_t keylengths
[2] = { strlen(key
), 0 };
595 size_t value_length
= strlen(value
);
596 const char *value2
= "change the value";
597 size_t value2_length
= strlen(value2
);
599 memcached_result_st results_obj
;
600 memcached_result_st
*results
;
603 rc
= memcached_flush(memc
, 0);
604 test_compare(MEMCACHED_SUCCESS
, rc
);
606 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
608 rc
= memcached_set(memc
, key
, strlen(key
),
609 value
, strlen(value
),
610 (time_t)0, (uint32_t)0);
611 test_compare(MEMCACHED_SUCCESS
, rc
);
613 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
615 results
= memcached_result_create(memc
, &results_obj
);
617 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
619 test_compare(MEMCACHED_SUCCESS
, rc
);
620 test_true(memcached_result_cas(results
));
621 test_memcmp(value
, memcached_result_value(results
), value_length
);
622 test_compare(strlen(memcached_result_value(results
)), value_length
);
623 test_compare(MEMCACHED_SUCCESS
, rc
);
624 uint64_t cas
= memcached_result_cas(results
);
627 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
628 test_true(rc
== MEMCACHED_END
);
629 test_true(results
== NULL
);
632 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
633 test_compare(MEMCACHED_SUCCESS
, rc
);
636 * The item will have a new cas value, so try to set it again with the old
637 * value. This should fail!
639 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
640 test_compare(MEMCACHED_DATA_EXISTS
, rc
);
642 memcached_result_free(&results_obj
);
647 static test_return_t
prepend_test(memcached_st
*memc
)
649 memcached_return_t rc
;
650 const char *key
= "fig";
651 const char *value
= "people";
652 char *out_value
= NULL
;
656 rc
= memcached_flush(memc
, 0);
657 test_compare(MEMCACHED_SUCCESS
, rc
);
659 rc
= memcached_set(memc
, key
, strlen(key
),
660 value
, strlen(value
),
661 (time_t)0, (uint32_t)0);
662 test_compare(MEMCACHED_SUCCESS
, rc
);
664 rc
= memcached_prepend(memc
, key
, strlen(key
),
665 "the ", strlen("the "),
666 (time_t)0, (uint32_t)0);
667 test_compare(MEMCACHED_SUCCESS
, rc
);
669 rc
= memcached_prepend(memc
, key
, strlen(key
),
670 "we ", strlen("we "),
671 (time_t)0, (uint32_t)0);
672 test_compare(MEMCACHED_SUCCESS
, rc
);
674 out_value
= memcached_get(memc
, key
, strlen(key
),
675 &value_length
, &flags
, &rc
);
676 test_memcmp(out_value
, "we the people", strlen("we the people"));
677 test_compare(strlen("we the people"), value_length
);
678 test_compare(MEMCACHED_SUCCESS
, rc
);
685 Set the value, then quit to make sure it is flushed.
686 Come back in and test that add fails.
688 static test_return_t
add_test(memcached_st
*memc
)
690 memcached_return_t rc
;
691 const char *key
= "foo";
692 const char *value
= "when we sanitize";
693 unsigned long long setting_value
;
695 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
697 rc
= memcached_set(memc
, key
, strlen(key
),
698 value
, strlen(value
),
699 (time_t)0, (uint32_t)0);
700 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
701 memcached_quit(memc
);
702 rc
= memcached_add(memc
, key
, strlen(key
),
703 value
, strlen(value
),
704 (time_t)0, (uint32_t)0);
706 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
709 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
713 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
720 ** There was a problem of leaking filedescriptors in the initial release
721 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
722 ** systems it seems that the kernel is slow on reclaiming the resources
723 ** because the connects starts to time out (the test doesn't do much
724 ** anyway, so just loop 10 iterations)
726 static test_return_t
add_wrapper(memcached_st
*memc
)
728 unsigned int max
= 10000;
736 for (uint32_t x
= 0; x
< max
; x
++)
742 static test_return_t
replace_test(memcached_st
*memc
)
744 memcached_return_t rc
;
745 const char *key
= "foo";
746 const char *value
= "when we sanitize";
747 const char *original
= "first we insert some data";
749 rc
= memcached_set(memc
, key
, strlen(key
),
750 original
, strlen(original
),
751 (time_t)0, (uint32_t)0);
752 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
754 test_compare(MEMCACHED_SUCCESS
,
755 memcached_replace(memc
, key
, strlen(key
),
756 value
, strlen(value
),
757 (time_t)0, (uint32_t)0));
762 static test_return_t
delete_test(memcached_st
*memc
)
764 memcached_return_t rc
;
765 const char *key
= "foo";
766 const char *value
= "when we sanitize";
768 rc
= memcached_set(memc
, key
, strlen(key
),
769 value
, strlen(value
),
770 (time_t)0, (uint32_t)0);
771 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
773 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
774 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
779 static test_return_t
flush_test(memcached_st
*memc
)
781 uint64_t query_id
= memcached_query_id(memc
);
782 test_compare(MEMCACHED_SUCCESS
,
783 memcached_flush(memc
, 0));
784 test_compare(query_id
+1, memcached_query_id(memc
));
789 static memcached_return_t
server_function(const memcached_st
*ptr
,
790 const memcached_server_st
*server
,
793 (void)ptr
; (void)server
; (void)context
;
796 return MEMCACHED_SUCCESS
;
799 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
802 strncpy(context
, "foo bad", sizeof(context
));
803 memcached_server_fn callbacks
[1];
805 callbacks
[0]= server_function
;
806 memcached_server_cursor(memc
, callbacks
, context
, 1);
810 static test_return_t
bad_key_test(memcached_st
*memc
)
812 memcached_return_t rc
;
813 const char *key
= "foo bad";
815 size_t string_length
;
817 memcached_st
*memc_clone
;
819 size_t max_keylen
= 0xffff;
821 // Just skip if we are in binary mode.
822 uint64_t query_id
= memcached_query_id(memc
);
823 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
825 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
827 memc_clone
= memcached_clone(NULL
, memc
);
828 test_true(memc_clone
);
830 query_id
= memcached_query_id(memc_clone
);
831 test_compare(MEMCACHED_SUCCESS
,
832 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
833 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
835 /* All keys are valid in the binary protocol (except for length) */
836 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
838 query_id
= memcached_query_id(memc_clone
);
839 string
= memcached_get(memc_clone
, key
, strlen(key
),
840 &string_length
, &flags
, &rc
);
841 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
842 test_compare(0, string_length
);
846 query_id
= memcached_query_id(memc_clone
);
847 test_compare(MEMCACHED_SUCCESS
,
848 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
849 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
850 string
= memcached_get(memc_clone
, key
, strlen(key
),
851 &string_length
, &flags
, &rc
);
852 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
853 test_compare(0, string_length
);
856 /* Test multi key for bad keys */
857 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
858 size_t key_lengths
[] = { 7, 7, 7 };
860 query_id
= memcached_query_id(memc_clone
);
861 test_compare(MEMCACHED_SUCCESS
,
862 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
863 test_compare(query_id
, memcached_query_id(memc_clone
));
865 query_id
= memcached_query_id(memc_clone
);
866 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
867 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
868 test_compare(query_id
+1, memcached_query_id(memc_clone
));
870 query_id
= memcached_query_id(memc_clone
);
871 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
872 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
873 test_compare(query_id
+1, memcached_query_id(memc_clone
));
877 /* The following test should be moved to the end of this function when the
878 memcached server is updated to allow max size length of the keys in the
881 test_compare(MEMCACHED_SUCCESS
,
882 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
884 char *longkey
= (char *)malloc(max_keylen
+ 1);
887 memset(longkey
, 'a', max_keylen
+ 1);
888 string
= memcached_get(memc_clone
, longkey
, max_keylen
,
889 &string_length
, &flags
, &rc
);
890 test_compare(MEMCACHED_NOTFOUND
, rc
);
891 test_compare(0, string_length
);
894 string
= memcached_get(memc_clone
, longkey
, max_keylen
+ 1,
895 &string_length
, &flags
, &rc
);
896 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
897 test_compare(0, string_length
);
904 /* Make sure zero length keys are marked as bad */
906 test_compare(MEMCACHED_SUCCESS
,
907 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
908 string
= memcached_get(memc_clone
, key
, 0,
909 &string_length
, &flags
, &rc
);
910 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
911 test_compare(0, string_length
);
914 memcached_free(memc_clone
);
919 #define READ_THROUGH_VALUE "set for me"
920 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
923 memcached_result_st
*result
)
925 (void)memc
;(void)key
;(void)key_length
;
926 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
929 #ifndef __INTEL_COMPILER
930 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
933 static test_return_t
read_through(memcached_st
*memc
)
935 memcached_return_t rc
;
936 const char *key
= "foo";
938 size_t string_length
;
940 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
942 string
= memcached_get(memc
, key
, strlen(key
),
943 &string_length
, &flags
, &rc
);
945 test_compare(MEMCACHED_NOTFOUND
, rc
);
946 test_false(string_length
);
949 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
);
950 test_compare(MEMCACHED_SUCCESS
, rc
);
952 string
= memcached_get(memc
, key
, strlen(key
),
953 &string_length
, &flags
, &rc
);
955 test_compare(MEMCACHED_SUCCESS
, rc
);
956 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
957 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
958 test_strcmp(READ_THROUGH_VALUE
, string
);
961 string
= memcached_get(memc
, key
, strlen(key
),
962 &string_length
, &flags
, &rc
);
964 test_compare(MEMCACHED_SUCCESS
, rc
);
966 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
967 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
968 test_strcmp(READ_THROUGH_VALUE
, string
);
974 static memcached_return_t
delete_trigger(memcached_st
*,
981 return MEMCACHED_SUCCESS
;
984 static test_return_t
delete_through(memcached_st
*memc
)
986 memcached_trigger_delete_key_fn callback
;
987 memcached_return_t rc
;
989 callback
= (memcached_trigger_delete_key_fn
)delete_trigger
;
991 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
992 test_compare(MEMCACHED_SUCCESS
, rc
);
997 static test_return_t
get_test(memcached_st
*memc
)
999 memcached_return_t rc
;
1000 const char *key
= "foo";
1002 size_t string_length
;
1005 uint64_t query_id
= memcached_query_id(memc
);
1006 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
1007 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
1008 test_compare(query_id
+1, memcached_query_id(memc
));
1010 string
= memcached_get(memc
, key
, strlen(key
),
1011 &string_length
, &flags
, &rc
);
1013 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1014 test_false(string_length
);
1017 return TEST_SUCCESS
;
1020 static test_return_t
get_test2(memcached_st
*memc
)
1022 const char *key
= "foo";
1023 const char *value
= "when we sanitize";
1025 uint64_t query_id
= memcached_query_id(memc
);
1026 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1027 value
, strlen(value
),
1028 (time_t)0, (uint32_t)0);
1029 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1030 test_compare(query_id
+1, memcached_query_id(memc
));
1032 query_id
= memcached_query_id(memc
);
1033 test_true(query_id
);
1036 size_t string_length
;
1037 char *string
= memcached_get(memc
, key
, strlen(key
),
1038 &string_length
, &flags
, &rc
);
1039 test_compare(query_id
+1, memcached_query_id(memc
));
1041 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1042 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1044 test_compare(strlen(value
), string_length
);
1045 test_memcmp(string
, value
, string_length
);
1049 return TEST_SUCCESS
;
1052 static test_return_t
set_test2(memcached_st
*memc
)
1054 const char *key
= "foo";
1055 const char *value
= "train in the brain";
1056 size_t value_length
= strlen(value
);
1058 for (uint32_t x
= 0; x
< 10; x
++)
1060 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1061 value
, value_length
,
1062 (time_t)0, (uint32_t)0);
1063 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1066 return TEST_SUCCESS
;
1069 static test_return_t
set_test3(memcached_st
*memc
)
1071 size_t value_length
= 8191;
1073 char *value
= (char*)malloc(value_length
);
1076 for (uint32_t x
= 0; x
< value_length
; x
++)
1078 value
[x
] = (char) (x
% 127);
1081 /* The dump test relies on there being at least 32 items in memcached */
1082 for (uint32_t x
= 0; x
< 32; x
++)
1086 snprintf(key
, sizeof(key
), "foo%u", x
);
1088 uint64_t query_id
= memcached_query_id(memc
);
1089 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1090 value
, value_length
,
1091 (time_t)0, (uint32_t)0);
1092 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1093 test_compare(query_id
+1, memcached_query_id(memc
));
1098 return TEST_SUCCESS
;
1101 static test_return_t
get_test3(memcached_st
*memc
)
1103 const char *key
= "foo";
1104 size_t value_length
= 8191;
1106 char *value
= (char*)malloc(value_length
);
1109 for (uint32_t x
= 0; x
< value_length
; x
++)
1111 value
[x
] = (char) (x
% 127);
1114 memcached_return_t rc
;
1115 rc
= memcached_set(memc
, key
, strlen(key
),
1116 value
, value_length
,
1117 (time_t)0, (uint32_t)0);
1118 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1120 size_t string_length
;
1122 char *string
= memcached_get(memc
, key
, strlen(key
),
1123 &string_length
, &flags
, &rc
);
1125 test_compare(MEMCACHED_SUCCESS
, rc
);
1127 test_compare(string_length
, value_length
);
1128 test_memcmp(string
, value
, string_length
);
1133 return TEST_SUCCESS
;
1136 static test_return_t
get_test4(memcached_st
*memc
)
1138 memcached_return_t rc
;
1139 const char *key
= "foo";
1141 size_t value_length
= 8191;
1143 size_t string_length
;
1147 value
= (char*)malloc(value_length
);
1150 for (x
= 0; x
< value_length
; x
++)
1151 value
[x
] = (char) (x
% 127);
1153 rc
= memcached_set(memc
, key
, strlen(key
),
1154 value
, value_length
,
1155 (time_t)0, (uint32_t)0);
1156 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1158 for (x
= 0; x
< 10; x
++)
1160 string
= memcached_get(memc
, key
, strlen(key
),
1161 &string_length
, &flags
, &rc
);
1163 test_compare(MEMCACHED_SUCCESS
, rc
);
1165 test_compare(string_length
, value_length
);
1166 test_memcmp(string
, value
, string_length
);
1172 return TEST_SUCCESS
;
1176 * This test verifies that memcached_read_one_response doesn't try to
1177 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1178 * responses before you execute a storage command.
1180 static test_return_t
get_test5(memcached_st
*memc
)
1183 ** Request the same key twice, to ensure that we hash to the same server
1184 ** (so that we have multiple response values queued up) ;-)
1186 const char *keys
[]= { "key", "key" };
1187 size_t lengths
[]= { 3, 3 };
1191 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1192 keys
[0], lengths
[0], 0, 0);
1193 test_compare(MEMCACHED_SUCCESS
, rc
);
1194 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1196 memcached_result_st results_obj
;
1197 memcached_result_st
*results
;
1198 results
=memcached_result_create(memc
, &results_obj
);
1200 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
1202 memcached_result_free(&results_obj
);
1204 /* Don't read out the second result, but issue a set instead.. */
1205 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
1206 test_compare(MEMCACHED_SUCCESS
, rc
);
1208 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1209 &rlen
, &flags
, &rc
);
1211 test_compare(MEMCACHED_NOTFOUND
, rc
);
1212 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1214 test_compare(MEMCACHED_SUCCESS
, rc
);
1217 return TEST_SUCCESS
;
1220 static test_return_t
mget_end(memcached_st
*memc
)
1222 const char *keys
[]= { "foo", "foo2" };
1223 size_t lengths
[]= { 3, 4 };
1224 const char *values
[]= { "fjord", "41" };
1226 memcached_return_t rc
;
1229 for (int i
= 0; i
< 2; i
++)
1231 rc
= memcached_set(memc
, keys
[i
], lengths
[i
], values
[i
], strlen(values
[i
]),
1232 (time_t)0, (uint32_t)0);
1233 test_compare(MEMCACHED_SUCCESS
, rc
);
1237 size_t string_length
;
1240 // retrieve both via mget
1241 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1242 test_compare(MEMCACHED_SUCCESS
, rc
);
1244 char key
[MEMCACHED_MAX_KEY
];
1247 // this should get both
1248 for (int i
= 0; i
< 2; i
++)
1250 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1252 test_compare(MEMCACHED_SUCCESS
, rc
);
1254 if (key_length
== 4)
1259 test_compare(string_length
, strlen(values
[val
]));
1260 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1264 // this should indicate end
1265 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1266 test_compare(MEMCACHED_END
, rc
);
1269 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1270 test_compare(MEMCACHED_SUCCESS
, rc
);
1272 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1273 test_compare(key_length
, lengths
[0]);
1274 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1275 test_compare(string_length
, strlen(values
[0]));
1276 test_true(strncmp(values
[0], string
, string_length
) == 0);
1277 test_compare(MEMCACHED_SUCCESS
, rc
);
1280 // this should indicate end
1281 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1282 test_true(rc
== MEMCACHED_END
);
1284 return TEST_SUCCESS
;
1287 /* Do not copy the style of this code, I just access hosts to testthis function */
1288 static test_return_t
stats_servername_test(memcached_st
*memc
)
1290 memcached_return_t rc
;
1291 memcached_stat_st memc_stat
;
1292 memcached_server_instance_st instance
=
1293 memcached_server_instance_by_position(memc
, 0);
1295 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
1296 if (memcached_get_sasl_callbacks(memc
) != NULL
)
1297 return TEST_SKIPPED
;
1299 rc
= memcached_stat_servername(&memc_stat
, NULL
,
1300 memcached_server_name(instance
),
1301 memcached_server_port(instance
));
1303 return TEST_SUCCESS
;
1306 static test_return_t
increment_test(memcached_st
*memc
)
1308 uint64_t new_number
;
1310 test_compare(MEMCACHED_SUCCESS
,
1312 test_literal_param("number"),
1313 test_literal_param("0"),
1314 (time_t)0, (uint32_t)0));
1316 memcached_return_t rc
;
1317 test_compare_got(MEMCACHED_SUCCESS
,
1318 rc
= memcached_increment(memc
,
1319 test_literal_param("number"),
1321 memcached_strerror(NULL
, rc
));
1322 test_compare(1, new_number
);
1324 test_compare(MEMCACHED_SUCCESS
,
1325 memcached_increment(memc
,
1326 test_literal_param("number"),
1328 test_compare(2, new_number
);
1330 return TEST_SUCCESS
;
1333 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1335 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1337 uint64_t new_number
;
1338 uint64_t initial
= 0;
1340 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1342 memcached_return_t rc
;
1343 test_compare_got(MEMCACHED_SUCCESS
,
1344 rc
= memcached_increment_with_initial(memc
,
1345 test_literal_param("number"),
1346 1, initial
, 0, &new_number
),
1347 memcached_strerror(NULL
, rc
));
1348 test_compare(new_number
, initial
);
1350 test_compare(MEMCACHED_SUCCESS
,
1351 memcached_increment_with_initial(memc
,
1352 test_literal_param("number"),
1353 1, initial
, 0, &new_number
));
1354 test_compare(new_number
, (initial
+ 1));
1356 return TEST_SUCCESS
;
1359 static test_return_t
decrement_test(memcached_st
*memc
)
1361 uint64_t new_number
;
1362 memcached_return_t rc
;
1363 const char *value
= "3";
1365 rc
= memcached_set(memc
,
1366 test_literal_param("number"),
1367 value
, strlen(value
),
1368 (time_t)0, (uint32_t)0);
1369 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1371 test_compare(MEMCACHED_SUCCESS
,
1372 memcached_decrement(memc
,
1373 test_literal_param("number"),
1375 test_compare(new_number
, 2);
1377 test_compare(MEMCACHED_SUCCESS
,
1378 memcached_decrement(memc
,
1379 test_literal_param("number"),
1381 test_compare(new_number
, 1);
1383 return TEST_SUCCESS
;
1386 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1388 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1390 uint64_t new_number
;
1391 uint64_t initial
= 3;
1393 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1395 test_compare(MEMCACHED_SUCCESS
,
1396 memcached_decrement_with_initial(memc
,
1397 test_literal_param("number"),
1398 1, initial
, 0, &new_number
));
1399 test_compare(new_number
, initial
);
1401 test_compare(MEMCACHED_SUCCESS
,
1402 memcached_decrement_with_initial(memc
,
1403 test_literal_param("number"),
1404 1, initial
, 0, &new_number
));
1405 test_compare(new_number
, (initial
- 1));
1407 return TEST_SUCCESS
;
1410 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1412 uint64_t new_number
;
1413 memcached_return_t rc
;
1414 const char *master_key
= "foo";
1415 const char *key
= "number";
1416 const char *value
= "0";
1418 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1420 value
, strlen(value
),
1421 (time_t)0, (uint32_t)0);
1422 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1424 test_compare(MEMCACHED_SUCCESS
,
1425 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1427 test_compare(new_number
, 1);
1429 test_compare(MEMCACHED_SUCCESS
,
1430 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1432 test_compare(new_number
, 2);
1434 return TEST_SUCCESS
;
1437 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1439 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1441 uint64_t new_number
;
1442 memcached_return_t rc
;
1443 const char *master_key
= "foo";
1444 const char *key
= "number";
1445 uint64_t initial
= 0;
1447 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1449 1, initial
, 0, &new_number
);
1450 test_compare(MEMCACHED_SUCCESS
, rc
);
1451 test_true(new_number
== initial
);
1453 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1455 1, initial
, 0, &new_number
);
1456 test_compare(MEMCACHED_SUCCESS
, rc
);
1457 test_true(new_number
== (initial
+ 1));
1459 return TEST_SUCCESS
;
1462 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1464 uint64_t new_number
;
1465 memcached_return_t rc
;
1466 const char *value
= "3";
1468 rc
= memcached_set_by_key(memc
,
1469 test_literal_param("foo"),
1470 test_literal_param("number"),
1471 value
, strlen(value
),
1472 (time_t)0, (uint32_t)0);
1473 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1475 test_compare(MEMCACHED_SUCCESS
,
1476 memcached_decrement_by_key(memc
,
1477 test_literal_param("foo"),
1478 test_literal_param("number"),
1480 test_compare(new_number
, 2);
1482 test_compare(MEMCACHED_SUCCESS
,
1483 memcached_decrement_by_key(memc
,
1484 test_literal_param("foo"),
1485 test_literal_param("number"),
1487 test_compare(new_number
, 1);
1489 return TEST_SUCCESS
;
1492 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1494 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1496 uint64_t new_number
;
1497 uint64_t initial
= 3;
1499 test_compare(MEMCACHED_SUCCESS
,
1500 memcached_decrement_with_initial_by_key(memc
,
1501 test_literal_param("foo"),
1502 test_literal_param("number"),
1503 1, initial
, 0, &new_number
));
1504 test_compare(new_number
, initial
);
1506 test_compare(MEMCACHED_SUCCESS
,
1507 memcached_decrement_with_initial_by_key(memc
,
1508 test_literal_param("foo"),
1509 test_literal_param("number"),
1510 1, initial
, 0, &new_number
));
1511 test_compare(new_number
, (initial
- 1));
1513 return TEST_SUCCESS
;
1516 static test_return_t
quit_test(memcached_st
*memc
)
1518 memcached_return_t rc
;
1519 const char *key
= "fudge";
1520 const char *value
= "sanford and sun";
1522 rc
= memcached_set(memc
, key
, strlen(key
),
1523 value
, strlen(value
),
1524 (time_t)10, (uint32_t)3);
1525 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1526 memcached_quit(memc
);
1528 rc
= memcached_set(memc
, key
, strlen(key
),
1529 value
, strlen(value
),
1530 (time_t)50, (uint32_t)9);
1531 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1533 return TEST_SUCCESS
;
1536 static test_return_t
mget_result_test(memcached_st
*memc
)
1538 const char *keys
[]= {"fudge", "son", "food"};
1539 size_t key_length
[]= {5, 3, 4};
1541 memcached_result_st results_obj
;
1542 memcached_result_st
*results
;
1544 results
= memcached_result_create(memc
, &results_obj
);
1546 test_true(&results_obj
== results
);
1548 /* We need to empty the server before continueing test */
1549 test_compare(MEMCACHED_SUCCESS
,
1550 memcached_flush(memc
, 0));
1552 test_compare(MEMCACHED_SUCCESS
,
1553 memcached_mget(memc
, keys
, key_length
, 3));
1555 memcached_return_t rc
;
1556 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1561 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1562 test_false(results
);
1563 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1565 for (uint32_t x
= 0; x
< 3; x
++)
1567 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1568 keys
[x
], key_length
[x
],
1569 (time_t)50, (uint32_t)9);
1570 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1573 test_compare(MEMCACHED_SUCCESS
,
1574 memcached_mget(memc
, keys
, key_length
, 3));
1576 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1579 test_true(&results_obj
== results
);
1580 test_compare(MEMCACHED_SUCCESS
, rc
);
1581 test_memcmp(memcached_result_key_value(results
),
1582 memcached_result_value(results
),
1583 memcached_result_length(results
));
1584 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1587 memcached_result_free(&results_obj
);
1589 return TEST_SUCCESS
;
1592 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1594 const char *keys
[]= {"fudge", "son", "food"};
1595 size_t key_length
[]= {5, 3, 4};
1597 memcached_result_st
*results
;
1599 /* We need to empty the server before continueing test */
1600 test_compare(MEMCACHED_SUCCESS
,
1601 memcached_flush(memc
, 0));
1603 test_compare(MEMCACHED_SUCCESS
,
1604 memcached_mget(memc
, keys
, key_length
, 3));
1606 memcached_return_t rc
;
1607 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1611 test_false(results
);
1612 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1614 for (uint32_t x
= 0; x
< 3; x
++)
1616 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1617 keys
[x
], key_length
[x
],
1618 (time_t)50, (uint32_t)9);
1619 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1622 test_compare(MEMCACHED_SUCCESS
,
1623 memcached_mget(memc
, keys
, key_length
, 3));
1626 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1629 test_compare(MEMCACHED_SUCCESS
, rc
);
1630 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1631 test_memcmp(memcached_result_key_value(results
),
1632 memcached_result_value(results
),
1633 memcached_result_length(results
));
1634 memcached_result_free(results
);
1638 return TEST_SUCCESS
;
1641 /* Count the results */
1642 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1644 size_t *counter
= (size_t *)context
;
1646 *counter
= *counter
+ 1;
1648 return MEMCACHED_SUCCESS
;
1651 static test_return_t
mget_result_function(memcached_st
*memc
)
1653 const char *keys
[]= {"fudge", "son", "food"};
1654 size_t key_length
[]= {5, 3, 4};
1656 memcached_execute_fn callbacks
[1];
1658 /* We need to empty the server before continueing test */
1659 test_compare(MEMCACHED_SUCCESS
,
1660 memcached_flush(memc
, 0));
1661 for (uint32_t x
= 0; x
< 3; x
++)
1663 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1664 keys
[x
], key_length
[x
],
1665 (time_t)50, (uint32_t)9);
1666 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1669 test_compare(MEMCACHED_SUCCESS
,
1670 memcached_mget(memc
, keys
, key_length
, 3));
1672 callbacks
[0]= &callback_counter
;
1675 memcached_return_t rc
;
1676 test_compare_got(MEMCACHED_SUCCESS
,
1677 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1),
1678 memcached_strerror(NULL
, rc
));
1680 test_compare(counter
, 3);
1682 return TEST_SUCCESS
;
1685 static test_return_t
mget_test(memcached_st
*memc
)
1687 const char *keys
[]= {"fudge", "son", "food"};
1688 size_t key_length
[]= {5, 3, 4};
1690 char return_key
[MEMCACHED_MAX_KEY
];
1691 size_t return_key_length
;
1693 size_t return_value_length
;
1695 /* We need to empty the server before continueing test */
1696 test_compare(MEMCACHED_SUCCESS
,
1697 memcached_flush(memc
, 0));
1699 test_compare(MEMCACHED_SUCCESS
,
1700 memcached_mget(memc
, keys
, key_length
, 3));
1703 memcached_return_t rc
;
1704 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1705 &return_value_length
, &flags
, &rc
)))
1707 test_true(return_value
);
1709 test_false(return_value
);
1710 test_compare(0, return_value_length
);
1711 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1713 for (uint32_t x
= 0; x
< 3; x
++)
1715 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1716 keys
[x
], key_length
[x
],
1717 (time_t)50, (uint32_t)9);
1718 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1720 test_compare(MEMCACHED_SUCCESS
,
1721 memcached_mget(memc
, keys
, key_length
, 3));
1724 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1725 &return_value_length
, &flags
, &rc
)))
1727 test_true(return_value
);
1728 test_compare(MEMCACHED_SUCCESS
, rc
);
1729 if (not memc
->prefix_key
)
1731 test_compare(return_key_length
, return_value_length
);
1732 test_memcmp(return_value
, return_key
, return_value_length
);
1738 return TEST_SUCCESS
;
1741 static test_return_t
mget_execute(memcached_st
*memc
)
1745 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1749 * I only want to hit _one_ server so I know the number of requests I'm
1750 * sending in the pipeline.
1752 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1753 memc
->number_of_hosts
= 1;
1755 size_t max_keys
= 20480;
1758 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1759 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1761 /* First add all of the items.. */
1762 char blob
[1024] = {0};
1763 memcached_return_t rc
;
1765 for (size_t x
= 0; x
< max_keys
; ++x
)
1769 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1771 test_true(keys
[x
] != NULL
);
1772 uint64_t query_id
= memcached_query_id(memc
);
1773 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1774 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1775 test_compare(query_id
+1, memcached_query_id(memc
));
1778 /* Try to get all of them with a large multiget */
1780 memcached_execute_fn callbacks
[]= { &callback_counter
};
1781 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1782 max_keys
, callbacks
, &counter
, 1);
1784 if (memcached_success(rc
))
1787 uint64_t query_id
= memcached_query_id(memc
);
1788 test_compare(MEMCACHED_SUCCESS
,
1789 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1790 test_compare(query_id
, memcached_query_id(memc
));
1792 /* Verify that we got all of the items */
1793 test_true(counter
== max_keys
);
1795 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1797 test_true(counter
== 0);
1801 test_fail("note: this test functions differently when in binary mode");
1804 /* Release all allocated resources */
1805 for (size_t x
= 0; x
< max_keys
; ++x
)
1812 memc
->number_of_hosts
= number_of_hosts
;
1813 return TEST_SUCCESS
;
1816 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1818 static test_return_t
key_setup(memcached_st
*memc
)
1820 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1822 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1824 return TEST_SUCCESS
;
1827 static test_return_t
key_teardown(memcached_st
*memc
)
1830 pairs_free(global_pairs
);
1832 return TEST_SUCCESS
;
1835 static test_return_t
block_add_regression(memcached_st
*memc
)
1837 /* First add all of the items.. */
1838 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1840 memcached_return_t rc
;
1841 char blob
[1024] = {0};
1843 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1844 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1847 return TEST_SUCCESS
;
1850 static test_return_t
binary_add_regression(memcached_st
*memc
)
1852 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1853 test_return_t rc
= block_add_regression(memc
);
1854 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1858 static test_return_t
get_stats_keys(memcached_st
*memc
)
1862 memcached_stat_st memc_stat
;
1863 memcached_return_t rc
;
1865 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1866 test_compare(MEMCACHED_SUCCESS
, rc
);
1867 for (ptr
= stat_list
; *ptr
; ptr
++)
1872 return TEST_SUCCESS
;
1875 static test_return_t
version_string_test(memcached_st
*memc
)
1877 const char *version_string
;
1880 version_string
= memcached_lib_version();
1882 test_strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
);
1884 return TEST_SUCCESS
;
1887 static test_return_t
get_stats(memcached_st
*memc
)
1889 memcached_return_t rc
;
1891 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1892 test_compare(MEMCACHED_SUCCESS
, rc
);
1893 test_true(memc_stat
);
1895 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1897 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1898 test_compare(MEMCACHED_SUCCESS
, rc
);
1899 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1904 memcached_stat_free(NULL
, memc_stat
);
1906 return TEST_SUCCESS
;
1909 static test_return_t
add_host_test(memcached_st
*memc
)
1912 memcached_server_st
*servers
;
1913 memcached_return_t rc
;
1914 char servername
[]= "0.example.com";
1916 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1918 test_true(1 == memcached_server_list_count(servers
));
1920 for (x
= 2; x
< 20; x
++)
1922 char buffer
[SMALL_STRING_LEN
];
1924 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1925 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1927 test_compare(MEMCACHED_SUCCESS
, rc
);
1928 test_true(x
== memcached_server_list_count(servers
));
1931 rc
= memcached_server_push(memc
, servers
);
1932 test_compare(MEMCACHED_SUCCESS
, rc
);
1933 rc
= memcached_server_push(memc
, servers
);
1934 test_compare(MEMCACHED_SUCCESS
, rc
);
1936 memcached_server_list_free(servers
);
1938 return TEST_SUCCESS
;
1941 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1943 memcached_return_t rc
;
1944 const char *key
= "not_found";
1945 size_t key_len
= strlen(key
);
1947 test_compare(MEMCACHED_SUCCESS
,
1948 memcached_mget(memc
, &key
, &key_len
, 1));
1950 memcached_result_st
*result
= NULL
;
1951 result
= memcached_fetch_result(memc
, result
, &rc
);
1953 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1955 memcached_result_free(result
);
1957 return TEST_SUCCESS
;
1960 static memcached_return_t
clone_test_callback(memcached_st
*parent
, memcached_st
*memc_clone
)
1962 (void)parent
;(void)memc_clone
;
1963 return MEMCACHED_SUCCESS
;
1966 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
)
1969 return MEMCACHED_SUCCESS
;
1972 static test_return_t
callback_test(memcached_st
*memc
)
1974 /* Test User Data */
1978 memcached_return_t rc
;
1980 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1981 test_compare(MEMCACHED_SUCCESS
, rc
);
1982 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1983 test_true(*test_ptr
== x
);
1986 /* Test Clone Callback */
1988 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1989 void *clone_cb_ptr
= *(void **)&clone_cb
;
1990 void *temp_function
= NULL
;
1991 memcached_return_t rc
;
1993 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1995 test_compare(MEMCACHED_SUCCESS
, rc
);
1996 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1997 test_true(temp_function
== clone_cb_ptr
);
2000 /* Test Cleanup Callback */
2002 memcached_cleanup_fn cleanup_cb
=
2003 (memcached_cleanup_fn
)cleanup_test_callback
;
2004 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2005 void *temp_function
= NULL
;
2006 memcached_return_t rc
;
2008 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2010 test_compare(MEMCACHED_SUCCESS
, rc
);
2011 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2012 test_true(temp_function
== cleanup_cb_ptr
);
2015 return TEST_SUCCESS
;
2018 /* We don't test the behavior itself, we test the switches */
2019 static test_return_t
behavior_test(memcached_st
*memc
)
2024 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2025 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2026 test_true(value
== 1);
2028 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2029 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2030 test_true(value
== 1);
2032 set
= MEMCACHED_HASH_MD5
;
2033 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2034 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2035 test_true(value
== MEMCACHED_HASH_MD5
);
2039 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2040 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2041 test_true(value
== 0);
2043 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2044 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2045 test_true(value
== 0);
2047 set
= MEMCACHED_HASH_DEFAULT
;
2048 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2049 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2050 test_true(value
== MEMCACHED_HASH_DEFAULT
);
2052 set
= MEMCACHED_HASH_CRC
;
2053 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2054 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2055 test_true(value
== MEMCACHED_HASH_CRC
);
2057 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2058 test_true(value
> 0);
2060 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2061 test_true(value
> 0);
2063 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2064 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
2065 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2067 return TEST_SUCCESS
;
2070 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2072 memcached_return_t rc
;
2075 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
2076 test_true(rc
== MEMCACHED_DEPRECATED
);
2078 // Platform dependent
2080 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2084 return TEST_SUCCESS
;
2088 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2090 memcached_return_t rc
;
2094 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, set
);
2095 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2097 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2099 if (rc
== MEMCACHED_SUCCESS
)
2101 test_true((bool)value
== set
);
2105 test_false((bool)value
== set
);
2108 return TEST_SUCCESS
;
2112 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2114 memcached_return_t rc
;
2118 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, set
);
2119 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2121 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2123 if (rc
== MEMCACHED_SUCCESS
)
2125 test_true((bool)value
== set
);
2129 test_false((bool)value
== set
);
2132 return TEST_SUCCESS
;
2135 static test_return_t
fetch_all_results(memcached_st
*memc
, size_t &keys_returned
, const memcached_return_t expect
)
2137 memcached_return_t rc
;
2138 char return_key
[MEMCACHED_MAX_KEY
];
2139 size_t return_key_length
;
2141 size_t return_value_length
;
2145 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2146 &return_value_length
, &flags
, &rc
)))
2148 test_true(return_value
);
2149 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2154 if (memcached_success(expect
) and memcached_success(rc
))
2156 return TEST_SUCCESS
;
2158 else if (expect
== rc
)
2160 return TEST_SUCCESS
;
2162 fprintf(stderr
, "\n%s:%u %s(#%lu)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), (unsigned long)(keys_returned
));
2164 return TEST_FAILURE
;
2167 /* Test case provided by Cal Haldenbrand */
2168 #define HALDENBRAND_KEY_COUNT 3000 // * 1024576
2169 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2170 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2172 /* We just keep looking at the same values over and over */
2175 unsigned int setter
= 1;
2176 test_compare(MEMCACHED_SUCCESS
,
2177 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2178 test_compare(MEMCACHED_SUCCESS
,
2179 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2183 unsigned long long total
= 0;
2184 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2186 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2187 char randomstuff
[6 * 1024];
2188 memset(randomstuff
, 0, 6 * 1024);
2189 test_true(size
< 6 * 1024); /* Being safe here */
2191 for (uint32_t j
= 0 ; j
< size
;j
++)
2193 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2198 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2199 memcached_return_t rc
;
2200 test_compare_got(MEMCACHED_SUCCESS
,
2201 rc
= memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
),
2202 memcached_strerror(NULL
, rc
));
2204 test_true(total
> HALDENBRAND_KEY_COUNT
);
2206 return TEST_SUCCESS
;
2209 /* Test case provided by Cal Haldenbrand */
2210 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2212 unsigned int setter
= 1;
2214 test_compare(MEMCACHED_SUCCESS
,
2215 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2217 test_compare(MEMCACHED_SUCCESS
,
2218 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2221 setter
= 20 * 1024576;
2222 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2223 setter
= 20 * 1024576;
2224 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2225 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2226 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2228 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2231 size_t total_value_length
= 0;
2232 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2237 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2238 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2240 memcached_return_t rc
;
2241 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2242 if (memcached_failed(rc
))
2244 if (rc
== MEMCACHED_NOTFOUND
)
2255 test_compare(HALDENBRAND_FLAG_KEY
, flags
);
2257 total_value_length
+= val_len
;
2262 return TEST_SUCCESS
;
2265 /* Do a large mget() over all the keys we think exist */
2266 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2268 unsigned int setter
= 1;
2269 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2270 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2272 setter
= 20 * 1024576;
2273 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2274 setter
= 20 * 1024576;
2275 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2276 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2277 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2280 size_t key_lengths
[HALDENBRAND_KEY_COUNT
];
2281 char **keys
= static_cast<char **>(calloc(HALDENBRAND_KEY_COUNT
, sizeof(char *)));
2283 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2285 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2286 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2287 keys
[x
]= strdup(key
);
2289 key_lengths
[x
]= key_length
;
2290 test_compare(size_t(key_length
), strlen(keys
[x
]));
2293 test_compare(MEMCACHED_SUCCESS
,
2294 memcached_mget(memc
, (const char **)keys
, key_lengths
, HALDENBRAND_KEY_COUNT
));
2297 size_t keys_returned
;
2298 test_compare_got(TEST_SUCCESS
, foo
= fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
), test_strerror(foo
));
2299 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2301 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2307 return TEST_SUCCESS
;
2310 /* Make sure we behave properly if server list has no values */
2311 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2313 const char *keys
[]= {"fudge", "son", "food"};
2314 size_t key_length
[]= {5, 3, 4};
2316 /* Here we free everything before running a bunch of mget tests */
2317 memcached_servers_reset(memc
);
2320 /* We need to empty the server before continueing test */
2321 test_compare(MEMCACHED_NO_SERVERS
,
2322 memcached_flush(memc
, 0));
2324 test_compare(MEMCACHED_NO_SERVERS
,
2325 memcached_mget(memc
, keys
, key_length
, 3));
2327 size_t keys_returned
;
2328 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2329 test_compare(0, keys_returned
);
2331 for (uint32_t x
= 0; x
< 3; x
++)
2333 test_compare(MEMCACHED_NO_SERVERS
,
2334 memcached_set(memc
, keys
[x
], key_length
[x
],
2335 keys
[x
], key_length
[x
],
2336 (time_t)50, (uint32_t)9));
2339 test_compare(MEMCACHED_NO_SERVERS
,
2340 memcached_mget(memc
, keys
, key_length
, 3));
2344 char return_key
[MEMCACHED_MAX_KEY
];
2345 memcached_return_t rc
;
2346 size_t return_key_length
;
2347 size_t return_value_length
;
2350 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2351 &return_value_length
, &flags
, &rc
)))
2353 test_true(return_value
);
2354 test_compare(MEMCACHED_SUCCESS
, rc
);
2355 test_true(return_key_length
== return_value_length
);
2356 test_memcmp(return_value
, return_key
, return_value_length
);
2362 return TEST_SUCCESS
;
2365 #define VALUE_SIZE_BUG5 1048064
2366 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2368 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2369 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2371 size_t value_length
;
2373 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2375 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2377 insert_data
[x
]= (signed char)rand();
2380 test_compare(MEMCACHED_SUCCESS
,
2381 memcached_flush(memc
, 0));
2383 memcached_return_t rc
;
2384 value
= memcached_get(memc
, keys
[0], key_length
[0],
2385 &value_length
, &flags
, &rc
);
2387 test_compare(MEMCACHED_SUCCESS
,
2388 memcached_mget(memc
, keys
, key_length
, 4));
2391 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2392 test_compare(0, count
);
2394 for (uint32_t x
= 0; x
< 4; x
++)
2396 test_compare(MEMCACHED_SUCCESS
,
2397 memcached_set(memc
, keys
[x
], key_length
[x
],
2398 insert_data
, VALUE_SIZE_BUG5
,
2399 (time_t)0, (uint32_t)0));
2402 for (uint32_t x
= 0; x
< 10; x
++)
2404 value
= memcached_get(memc
, keys
[0], key_length
[0],
2405 &value_length
, &flags
, &rc
);
2406 test_compare(rc
, MEMCACHED_SUCCESS
);
2410 test_compare(MEMCACHED_SUCCESS
,
2411 memcached_mget(memc
, keys
, key_length
, 4));
2413 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2414 test_compare(4, count
);
2416 delete [] insert_data
;
2418 return TEST_SUCCESS
;
2421 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2423 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2424 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2425 char return_key
[MEMCACHED_MAX_KEY
];
2426 size_t return_key_length
;
2428 size_t value_length
;
2430 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2432 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2434 insert_data
[x
]= (signed char)rand();
2437 test_compare(MEMCACHED_SUCCESS
,
2438 memcached_flush(memc
, 0));
2440 memcached_return_t rc
;
2441 value
= memcached_get(memc
, keys
[0], key_length
[0],
2442 &value_length
, &flags
, &rc
);
2444 test_compare(MEMCACHED_NOTFOUND
, rc
);
2446 test_compare(MEMCACHED_SUCCESS
,
2447 memcached_mget(memc
, keys
, key_length
, 4));
2450 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2451 &value_length
, &flags
, &rc
)))
2455 test_compare(0, count
);
2456 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2458 for (uint32_t x
= 0; x
< 4; x
++)
2460 test_compare(MEMCACHED_SUCCESS
,
2461 memcached_set(memc
, keys
[x
], key_length
[x
],
2462 insert_data
, VALUE_SIZE_BUG5
,
2463 (time_t)0, (uint32_t)0));
2466 for (uint32_t x
= 0; x
< 2; x
++)
2468 value
= memcached_get(memc
, keys
[0], key_length
[0],
2469 &value_length
, &flags
, &rc
);
2473 test_compare(MEMCACHED_SUCCESS
,
2474 memcached_mget(memc
, keys
, key_length
, 4));
2476 /* We test for purge of partial complete fetches */
2477 for (count
= 3; count
; count
--)
2479 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2480 &value_length
, &flags
, &rc
);
2481 test_compare(MEMCACHED_SUCCESS
, rc
);
2482 test_memcmp(value
, insert_data
, value_length
);
2483 test_true(value_length
);
2487 delete [] insert_data
;
2489 return TEST_SUCCESS
;
2492 static test_return_t
user_supplied_bug8(memcached_st
*)
2494 memcached_return_t rc
;
2496 memcached_st
*memc_clone
;
2498 memcached_server_st
*servers
;
2499 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";
2501 servers
= memcached_servers_parse(server_list
);
2504 mine
= memcached_create(NULL
);
2505 rc
= memcached_server_push(mine
, servers
);
2506 test_compare(MEMCACHED_SUCCESS
, rc
);
2507 memcached_server_list_free(servers
);
2510 memc_clone
= memcached_clone(NULL
, mine
);
2512 memcached_quit(mine
);
2513 memcached_quit(memc_clone
);
2516 memcached_free(mine
);
2517 memcached_free(memc_clone
);
2519 return TEST_SUCCESS
;
2522 /* Test flag store/retrieve */
2523 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2525 const char *keys
= "036790384900";
2526 size_t key_length
= strlen(keys
);
2527 char return_key
[MEMCACHED_MAX_KEY
];
2528 size_t return_key_length
;
2530 size_t value_length
;
2532 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2534 for (unsigned int x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2535 insert_data
[x
]= (signed char)rand();
2537 memcached_flush(memc
, 0);
2540 memcached_return_t rc
= memcached_set(memc
, keys
, key_length
,
2541 insert_data
, VALUE_SIZE_BUG5
,
2543 test_compare(MEMCACHED_SUCCESS
, rc
);
2546 value
= memcached_get(memc
, keys
, key_length
,
2547 &value_length
, &flags
, &rc
);
2548 test_true(flags
== 245);
2552 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2555 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2556 &value_length
, &flags
, &rc
);
2557 test_compare(245, flags
);
2560 delete [] insert_data
;
2563 return TEST_SUCCESS
;
2566 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2568 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2569 size_t key_length
[3];
2573 char return_key
[MEMCACHED_MAX_KEY
];
2574 size_t return_key_length
;
2576 size_t return_value_length
;
2579 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2580 key_length
[1]= strlen("fudge&*@#");
2581 key_length
[2]= strlen("for^#@&$not");
2584 for (unsigned int x
= 0; x
< 3; x
++)
2586 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2587 keys
[x
], key_length
[x
],
2588 (time_t)50, (uint32_t)9);
2589 test_compare(MEMCACHED_SUCCESS
, rc
);
2592 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2593 test_compare(MEMCACHED_SUCCESS
, rc
);
2595 /* We need to empty the server before continueing test */
2596 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2597 &return_value_length
, &flags
, &rc
)) != NULL
)
2599 test_true(return_value
);
2603 test_compare(3, count
);
2605 return TEST_SUCCESS
;
2608 /* We are testing with aggressive timeout to get failures */
2609 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2611 const char *key
= "foo";
2612 size_t value_length
= 512;
2614 unsigned int set
= 1;
2615 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2617 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2618 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2620 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, (uint64_t)timeout
);
2622 char *value
= (char*)malloc(value_length
* sizeof(char));
2624 for (unsigned int x
= 0; x
< value_length
; x
++)
2626 value
[x
]= (char) (x
% 127);
2629 for (unsigned int x
= 1; x
<= 100000; ++x
)
2631 memcached_return_t rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2633 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
,
2634 memcached_strerror(NULL
, rc
));
2636 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2643 memcached_free(mclone
);
2645 return TEST_SUCCESS
;
2649 We are looking failures in the async protocol
2651 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2653 const char *key
= "foo";
2654 size_t value_length
= 512;
2656 unsigned int set
= 1;
2657 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2659 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2660 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2661 int32_t timeout
= -1;
2662 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, (size_t)timeout
);
2664 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2666 test_true(timeout
== -1);
2668 char *value
= (char*)malloc(value_length
* sizeof(char));
2670 for (unsigned int x
= 0; x
< value_length
; x
++)
2672 value
[x
]= (char) (x
% 127);
2675 for (unsigned int x
= 1; x
<= 100000; ++x
)
2677 memcached_return_t rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2682 memcached_free(mclone
);
2684 return TEST_SUCCESS
;
2688 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2690 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2692 memcached_return_t rc
;
2694 size_t value_length
;
2696 uint64_t number_value
;
2698 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2699 &value_length
, &flags
, &rc
);
2700 test_true(value
== NULL
);
2701 test_compare(MEMCACHED_NOTFOUND
, rc
);
2703 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2706 test_true(value
== NULL
);
2707 /* The binary protocol will set the key if it doesn't exist */
2708 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2710 test_compare(MEMCACHED_SUCCESS
, rc
);
2714 test_compare(MEMCACHED_NOTFOUND
, rc
);
2717 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2719 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2720 &value_length
, &flags
, &rc
);
2722 test_compare(MEMCACHED_SUCCESS
, rc
);
2725 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2727 test_true(number_value
== 2);
2728 test_compare(MEMCACHED_SUCCESS
, rc
);
2730 return TEST_SUCCESS
;
2734 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2735 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2737 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2739 char key
[] = "key34567890";
2740 memcached_return_t rc
;
2741 size_t overflowSize
;
2743 char commandFirst
[]= "set key34567890 0 0 ";
2744 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2745 size_t commandLength
;
2748 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2750 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2752 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2754 char *overflow
= new (std::nothrow
) char[testSize
];
2755 test_true(overflow
);
2757 memset(overflow
, 'x', testSize
);
2758 rc
= memcached_set(memc
, key
, strlen(key
),
2759 overflow
, testSize
, 0, 0);
2760 test_compare(MEMCACHED_SUCCESS
, rc
);
2764 return TEST_SUCCESS
;
2769 Test values of many different sizes
2770 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2771 set key34567890 0 0 8169 \r\n
2772 is sent followed by buffer of size 8169, followed by 8169
2774 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2777 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2778 memcached_return_t rc
;
2779 const char *key
= "foo";
2781 size_t value_length
= 18000;
2783 size_t string_length
;
2786 size_t current_length
;
2788 value
= (char*)malloc(value_length
);
2791 for (x
= 0; x
< value_length
; x
++)
2792 value
[x
] = (char) (x
% 127);
2794 for (current_length
= 0; current_length
< value_length
; current_length
++)
2796 rc
= memcached_set(memc
, key
, strlen(key
),
2797 value
, current_length
,
2798 (time_t)0, (uint32_t)0);
2799 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2801 string
= memcached_get(memc
, key
, strlen(key
),
2802 &string_length
, &flags
, &rc
);
2804 test_compare(MEMCACHED_SUCCESS
, rc
);
2805 test_true(string_length
== current_length
);
2806 test_memcmp(string
, value
, string_length
);
2813 return TEST_SUCCESS
;
2817 Look for zero length value problems
2819 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2822 memcached_return_t rc
;
2823 const char *key
= "mykey";
2827 for (x
= 0; x
< 2; x
++)
2829 rc
= memcached_set(memc
, key
, strlen(key
),
2831 (time_t)0, (uint32_t)0);
2833 test_compare(MEMCACHED_SUCCESS
, rc
);
2835 char *value
= memcached_get(memc
, key
, strlen(key
),
2836 &length
, &flags
, &rc
);
2838 test_compare(MEMCACHED_SUCCESS
, rc
);
2843 value
= memcached_get(memc
, key
, strlen(key
),
2844 &length
, &flags
, &rc
);
2846 test_compare(MEMCACHED_SUCCESS
, rc
);
2847 test_true(value
== NULL
);
2848 test_true(length
== 0);
2849 test_true(flags
== 0);
2852 return TEST_SUCCESS
;
2855 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2856 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2858 memcached_return_t rc
;
2859 const char *key
= "mykey";
2864 rc
= memcached_set(memc
, key
, strlen(key
),
2866 (time_t)0, UINT32_MAX
);
2868 test_compare(MEMCACHED_SUCCESS
, rc
);
2870 value
= memcached_get(memc
, key
, strlen(key
),
2871 &length
, &flags
, &rc
);
2873 test_compare(MEMCACHED_SUCCESS
, rc
);
2874 test_true(value
== NULL
);
2875 test_true(length
== 0);
2876 test_true(flags
== UINT32_MAX
);
2878 return TEST_SUCCESS
;
2881 #if !defined(__sun) && !defined(__OpenBSD__)
2882 /* Check the validity of chinese key*/
2883 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2885 memcached_return_t rc
;
2886 const char *key
= "豆瓣";
2887 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2892 rc
= memcached_set(memc
, key
, strlen(key
),
2893 value
, strlen(value
),
2896 test_compare(MEMCACHED_SUCCESS
, rc
);
2898 value2
= memcached_get(memc
, key
, strlen(key
),
2899 &length
, &flags
, &rc
);
2901 test_true(length
==strlen(value
));
2902 test_compare(MEMCACHED_SUCCESS
, rc
);
2903 test_memcmp(value
, value2
, length
);
2906 return TEST_SUCCESS
;
2914 static test_return_t
user_supplied_bug19(memcached_st
*not_used
)
2917 const memcached_server_st
*server
;
2918 memcached_return_t res
;
2922 memc
= memcached_create(NULL
);
2923 memcached_server_add_with_weight(memc
, "localhost", 11311, 100);
2924 memcached_server_add_with_weight(memc
, "localhost", 11312, 100);
2926 server
= memcached_server_by_key(memc
, "a", 1, &res
);
2928 memcached_free(memc
);
2930 return TEST_SUCCESS
;
2933 /* CAS test from Andei */
2934 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2936 memcached_return_t status
;
2937 memcached_result_st
*result
, result_obj
;
2938 const char *key
= "abc";
2939 size_t key_len
= strlen("abc");
2940 const char *value
= "foobar";
2941 size_t value_len
= strlen(value
);
2943 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2945 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2946 test_true(status
== MEMCACHED_SUCCESS
);
2948 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2949 test_true(status
== MEMCACHED_SUCCESS
);
2951 result
= memcached_result_create(memc
, &result_obj
);
2954 memcached_result_create(memc
, &result_obj
);
2955 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2958 test_true(status
== MEMCACHED_SUCCESS
);
2960 memcached_result_free(result
);
2962 return TEST_SUCCESS
;
2965 #include "ketama_test_cases.h"
2966 static test_return_t
user_supplied_bug18(memcached_st
*trash
)
2968 memcached_return_t rc
;
2975 memc
= memcached_create(NULL
);
2978 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2979 test_compare(MEMCACHED_SUCCESS
, rc
);
2981 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2982 test_true(value
== 1);
2984 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2985 test_compare(MEMCACHED_SUCCESS
, rc
);
2987 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2988 test_true(value
== MEMCACHED_HASH_MD5
);
2990 memcached_server_st
*server_pool
= memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
2991 memcached_server_push(memc
, server_pool
);
2993 /* verify that the server list was parsed okay. */
2994 test_true(memcached_server_count(memc
) == 8);
2995 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
2996 test_true(server_pool
[0].port
== 11211);
2997 test_true(server_pool
[0].weight
== 600);
2998 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
2999 test_true(server_pool
[2].port
== 11211);
3000 test_true(server_pool
[2].weight
== 200);
3001 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
3002 test_true(server_pool
[7].port
== 11211);
3003 test_true(server_pool
[7].weight
== 100);
3005 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
3006 * us test the boundary wraparound.
3008 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
3010 /* verify the standard ketama set. */
3011 for (x
= 0; x
< 99; x
++)
3013 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3015 memcached_server_instance_st instance
=
3016 memcached_server_instance_by_position(memc
, server_idx
);
3018 const char *hostname
= memcached_server_name(instance
);
3019 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
3022 memcached_server_list_free(server_pool
);
3023 memcached_free(memc
);
3025 return TEST_SUCCESS
;
3028 /* Large mget() of missing keys with binary proto
3030 * If many binary quiet commands (such as getq's in an mget) fill the output
3031 * buffer and the server chooses not to respond, memcached_flush hangs. See
3032 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
3035 /* sighandler_t function that always asserts false */
3036 static void fail(int)
3042 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
3047 return TEST_SKIPPED
;
3049 void (*oldalarm
)(int);
3051 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3052 test_true(memc_clone
);
3054 /* only binproto uses getq for mget */
3055 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3057 /* empty the cache to ensure misses (hence non-responses) */
3058 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
3060 size_t* key_lengths
= new (std::nothrow
) size_t[key_count
];
3061 test_true(key_lengths
);
3062 char **keys
= static_cast<char **>(calloc(key_count
, sizeof(char *)));
3064 for (unsigned int x
= 0; x
< key_count
; x
++)
3068 snprintf(buffer
, 30, "%u", x
);
3069 keys
[x
]= strdup(buffer
);
3071 key_lengths
[x
]= strlen(keys
[x
]);
3074 oldalarm
= signal(SIGALRM
, fail
);
3077 test_compare_got(MEMCACHED_SUCCESS
,
3078 memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
), memcached_last_error_message(memc_clone
));
3081 signal(SIGALRM
, oldalarm
);
3083 memcached_return_t rc
;
3085 char return_key
[MEMCACHED_MAX_KEY
];
3086 size_t return_key_length
;
3088 size_t return_value_length
;
3089 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
3090 &return_value_length
, &flags
, &rc
)))
3092 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
3094 test_compare(MEMCACHED_NOTFOUND
, rc
);
3095 test_compare(0, return_value_length
);
3096 test_compare(0, return_key_length
);
3097 test_false(return_key
[0]);
3098 test_false(return_value
);
3100 for (unsigned int x
= 0; x
< key_count
; x
++)
3105 delete [] key_lengths
;
3107 memcached_free(memc_clone
);
3109 return TEST_SUCCESS
;
3113 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3115 test_return_t test_rc
;
3116 test_rc
= pre_binary(memc
);
3118 if (test_rc
!= TEST_SUCCESS
)
3121 /* should work as of r580 */
3122 test_compare(TEST_SUCCESS
,
3123 _user_supplied_bug21(memc
, 10));
3125 /* should fail as of r580 */
3126 test_compare(TEST_SUCCESS
,
3127 _user_supplied_bug21(memc
, 1000));
3129 return TEST_SUCCESS
;
3132 static test_return_t
auto_eject_hosts(memcached_st
*trash
)
3135 memcached_server_instance_st instance
;
3137 memcached_return_t rc
;
3138 memcached_st
*memc
= memcached_create(NULL
);
3141 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3142 test_compare(MEMCACHED_SUCCESS
, rc
);
3144 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3145 test_true(value
== 1);
3147 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3148 test_compare(MEMCACHED_SUCCESS
, rc
);
3150 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3151 test_true(value
== MEMCACHED_HASH_MD5
);
3153 /* server should be removed when in delay */
3154 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
3155 test_compare(MEMCACHED_SUCCESS
, rc
);
3157 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
3158 test_true(value
== 1);
3160 memcached_server_st
*server_pool
;
3161 server_pool
= memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
3162 memcached_server_push(memc
, server_pool
);
3164 /* verify that the server list was parsed okay. */
3165 test_true(memcached_server_count(memc
) == 8);
3166 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
3167 test_true(server_pool
[0].port
== 11211);
3168 test_true(server_pool
[0].weight
== 600);
3169 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
3170 test_true(server_pool
[2].port
== 11211);
3171 test_true(server_pool
[2].weight
== 200);
3172 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
3173 test_true(server_pool
[7].port
== 11211);
3174 test_true(server_pool
[7].weight
== 100);
3176 instance
= memcached_server_instance_by_position(memc
, 2);
3177 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) + 15;
3178 memc
->ketama
.next_distribution_rebuild
= time(NULL
) - 1;
3181 This would not work if there were only two hosts.
3183 for (size_t x
= 0; x
< 99; x
++)
3185 memcached_autoeject(memc
);
3186 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3187 test_true(server_idx
!= 2);
3190 /* and re-added when it's back. */
3191 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) - 1;
3192 memc
->ketama
.next_distribution_rebuild
= time(NULL
) - 1;
3193 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
,
3194 memc
->distribution
);
3195 for (size_t x
= 0; x
< 99; x
++)
3197 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3198 // We re-use instance from above.
3200 memcached_server_instance_by_position(memc
, server_idx
);
3201 const char *hostname
= memcached_server_name(instance
);
3202 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
3205 memcached_server_list_free(server_pool
);
3206 memcached_free(memc
);
3208 return TEST_SUCCESS
;
3211 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
3215 memcached_return_t rc
;
3216 memcached_st
*memc
= memcached_create(NULL
);
3220 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3221 test_compare(MEMCACHED_SUCCESS
, rc
);
3223 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3224 test_true(value
== 1);
3226 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3227 test_compare(MEMCACHED_SUCCESS
, rc
);
3229 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3230 test_true(value
== MEMCACHED_HASH_MD5
);
3233 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3235 memcached_server_st
*server_pool
;
3236 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");
3237 memcached_server_push(memc
, server_pool
);
3239 // @todo this needs to be refactored to actually test something.
3242 if ((fp
= fopen("ketama_keys.txt", "w")))
3246 printf("cannot write to file ketama_keys.txt");
3247 return TEST_FAILURE
;
3250 for (int x
= 0; x
< 10000; x
++)
3253 snprintf(key
, sizeof(key
), "%d", x
);
3255 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3256 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3257 in_port_t port
= memc
->hosts
[server_idx
].port
;
3258 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3259 memcached_server_instance_st instance
=
3260 memcached_server_instance_by_position(memc
, host_index
);
3264 memcached_server_list_free(server_pool
);
3265 memcached_free(memc
);
3267 return TEST_SUCCESS
;
3271 static test_return_t
result_static(memcached_st
*memc
)
3273 memcached_result_st result
;
3274 memcached_result_st
*result_ptr
;
3276 result_ptr
= memcached_result_create(memc
, &result
);
3277 test_true(result
.options
.is_allocated
== false);
3278 test_true(memcached_is_initialized(&result
) == true);
3279 test_true(result_ptr
);
3280 test_true(result_ptr
== &result
);
3282 memcached_result_free(&result
);
3284 test_true(result
.options
.is_allocated
== false);
3285 test_true(memcached_is_initialized(&result
) == false);
3287 return TEST_SUCCESS
;
3290 static test_return_t
result_alloc(memcached_st
*memc
)
3292 memcached_result_st
*result_ptr
;
3294 result_ptr
= memcached_result_create(memc
, NULL
);
3295 test_true(result_ptr
);
3296 test_true(result_ptr
->options
.is_allocated
== true);
3297 test_true(memcached_is_initialized(result_ptr
) == true);
3298 memcached_result_free(result_ptr
);
3300 return TEST_SUCCESS
;
3303 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3306 pairs_free(global_pairs
);
3308 return TEST_SUCCESS
;
3311 static test_return_t
generate_pairs(memcached_st
*memc
)
3314 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3315 global_count
= GLOBAL_COUNT
;
3317 for (size_t x
= 0; x
< global_count
; x
++)
3319 global_keys
[x
]= global_pairs
[x
].key
;
3320 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3323 return TEST_SUCCESS
;
3326 static test_return_t
generate_large_pairs(memcached_st
*)
3328 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3329 global_count
= GLOBAL2_COUNT
;
3331 for (size_t x
= 0; x
< global_count
; x
++)
3333 global_keys
[x
]= global_pairs
[x
].key
;
3334 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3337 return TEST_SUCCESS
;
3340 static test_return_t
generate_data(memcached_st
*memc
)
3342 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3344 test_true(check_execute
== global_count
);
3346 return TEST_SUCCESS
;
3349 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3351 uint32_t host_index
= 0;
3352 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3354 test_true(check_execute
== global_count
);
3356 // @todo hosts used size stats
3357 memcached_return_t rc
;
3358 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3361 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3363 /* This test was changes so that "make test" would work properlly */
3365 memcached_server_instance_st instance
=
3366 memcached_server_instance_by_position(memc
, host_index
);
3368 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3370 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3373 memcached_stat_free(NULL
, stat_p
);
3375 return TEST_SUCCESS
;
3377 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3382 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3383 generate_data(memc
);
3385 return TEST_SUCCESS
;
3388 static test_return_t
get_read_count(memcached_st
*memc
)
3390 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3391 test_true(memc_clone
);
3393 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3397 size_t return_value_length
;
3401 for (size_t x
= count
= 0; x
< global_count
; x
++)
3403 memcached_return_t rc
;
3404 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3405 &return_value_length
, &flags
, &rc
);
3406 if (rc
== MEMCACHED_SUCCESS
)
3415 memcached_free(memc_clone
);
3417 return TEST_SUCCESS
;
3420 static test_return_t
get_read(memcached_st
*memc
)
3422 for (size_t x
= 0; x
< global_count
; x
++)
3424 size_t return_value_length
;
3426 memcached_return_t rc
;
3427 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3428 &return_value_length
, &flags
, &rc
);
3430 test_true(return_value);
3431 test_compare(MEMCACHED_SUCCESS, rc);
3433 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3437 return TEST_SUCCESS
;
3440 static test_return_t
mget_read(memcached_st
*memc
)
3443 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3445 memcached_return_t rc
;
3446 test_compare_got(MEMCACHED_SUCCESS
,
3447 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
),
3448 memcached_strerror(NULL
, rc
));
3450 // Go fetch the keys and test to see if all of them were returned
3452 size_t keys_returned
;
3453 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3454 test_true(keys_returned
> 0);
3456 snprintf(buffer
, sizeof(buffer
), "%lu", (unsigned long)keys_returned
);
3457 test_compare_got(global_count
, keys_returned
, buffer
);
3460 return TEST_SUCCESS
;
3463 static test_return_t
mget_read_result(memcached_st
*memc
)
3466 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3468 test_compare(MEMCACHED_SUCCESS
,
3469 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3471 /* Turn this into a help function */
3473 memcached_result_st results_obj
;
3474 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3476 memcached_return_t rc
;
3477 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3480 test_compare(MEMCACHED_SUCCESS
, rc
);
3482 test_compare(MEMCACHED_END
, rc
);
3484 memcached_result_free(&results_obj
);
3487 return TEST_SUCCESS
;
3490 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3493 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3495 test_compare(MEMCACHED_SUCCESS
,
3496 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3498 memcached_result_st
*results
= NULL
;
3499 memcached_return_t rc
;
3500 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3503 test_compare(MEMCACHED_SUCCESS
, rc
);
3505 test_compare(MEMCACHED_END
, rc
);
3507 memcached_result_free(results
);
3510 return TEST_SUCCESS
;
3513 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3516 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3518 test_compare(MEMCACHED_SUCCESS
,
3519 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3521 // We will scan for just one key
3523 memcached_result_st results_obj
;
3524 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3526 memcached_return_t rc
;
3527 results
= memcached_fetch_result(memc
, results
, &rc
);
3529 test_compare(MEMCACHED_SUCCESS
, rc
);
3531 memcached_result_free(&results_obj
);
3534 // We already have a read happening, lets start up another one.
3535 test_compare(MEMCACHED_SUCCESS
,
3536 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3538 memcached_result_st results_obj
;
3539 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3541 memcached_return_t rc
;
3542 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3545 test_compare(MEMCACHED_SUCCESS
, rc
);
3547 test_compare(MEMCACHED_END
, rc
);
3549 memcached_result_free(&results_obj
);
3552 return TEST_SUCCESS
;
3555 static test_return_t
mget_read_function(memcached_st
*memc
)
3557 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3559 test_compare(MEMCACHED_SUCCESS
,
3560 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3562 memcached_execute_fn callbacks
[]= { &callback_counter
};
3564 test_compare(MEMCACHED_SUCCESS
,
3565 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3567 return TEST_SUCCESS
;
3570 static test_return_t
delete_generate(memcached_st
*memc
)
3572 for (size_t x
= 0; x
< global_count
; x
++)
3574 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3577 return TEST_SUCCESS
;
3580 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3583 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3585 for (size_t x
= 0; x
< global_count
; x
++)
3587 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3590 return TEST_SUCCESS
;
3593 static test_return_t
add_host_test1(memcached_st
*memc
)
3595 memcached_return_t rc
;
3596 char servername
[]= "0.example.com";
3598 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3600 test_compare(1, memcached_server_list_count(servers
));
3602 for (size_t x
= 2; x
< 20; x
++)
3604 char buffer
[SMALL_STRING_LEN
];
3606 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3607 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3609 test_compare(MEMCACHED_SUCCESS
, rc
);
3610 test_compare(x
, memcached_server_list_count(servers
));
3613 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3614 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3616 memcached_server_list_free(servers
);
3618 return TEST_SUCCESS
;
3621 static test_return_t
pre_nonblock(memcached_st
*memc
)
3623 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3625 return TEST_SUCCESS
;
3628 static test_return_t
pre_cork(memcached_st
*memc
)
3631 return TEST_SKIPPED
;
3634 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3635 return TEST_SUCCESS
;
3637 return TEST_SKIPPED
;
3640 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3643 return TEST_SKIPPED
;
3645 test_return_t test_rc
;
3646 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3649 return pre_nonblock(memc
);
3652 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3654 memcached_return_t rc
= MEMCACHED_FAILURE
;
3655 memcached_st
*memc_clone
;
3657 memc_clone
= memcached_clone(NULL
, memc
);
3658 test_true(memc_clone
);
3659 // The memcached_version needs to be done on a clone, because the server
3660 // will not toggle protocol on an connection.
3661 memcached_version(memc_clone
);
3663 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3665 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3666 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3667 test_compare(MEMCACHED_SUCCESS
, rc
);
3668 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3672 return TEST_SKIPPED
;
3675 memcached_free(memc_clone
);
3677 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3680 static test_return_t
pre_murmur(memcached_st
*memc
)
3682 #ifdef HAVE_MURMUR_HASH
3683 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3684 return TEST_SUCCESS
;
3687 return TEST_SKIPPED
;
3691 static test_return_t
pre_jenkins(memcached_st
*memc
)
3693 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3695 return TEST_SUCCESS
;
3699 static test_return_t
pre_md5(memcached_st
*memc
)
3701 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3703 return TEST_SUCCESS
;
3706 static test_return_t
pre_crc(memcached_st
*memc
)
3708 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3710 return TEST_SUCCESS
;
3713 static test_return_t
pre_hsieh(memcached_st
*memc
)
3715 #ifdef HAVE_HSIEH_HASH
3716 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3717 return TEST_SUCCESS
;
3720 return TEST_SKIPPED
;
3724 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3726 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3728 return TEST_SUCCESS
;
3731 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3733 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3735 return TEST_SUCCESS
;
3738 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3740 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3742 return TEST_SUCCESS
;
3745 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3747 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3749 return TEST_SUCCESS
;
3752 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3754 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3755 test_compare(MEMCACHED_SUCCESS
, rc
);
3757 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3758 test_true(value
== 1);
3760 return TEST_SUCCESS
;
3763 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3765 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3766 test_compare(MEMCACHED_SUCCESS
, rc
);
3768 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3769 test_true(value
== 1);
3771 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3772 test_compare(MEMCACHED_SUCCESS
, rc
);
3774 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3775 test_true(value
== MEMCACHED_HASH_MD5
);
3777 return TEST_SUCCESS
;
3781 @note This should be testing to see if the server really supports the binary protocol.
3783 static test_return_t
pre_binary(memcached_st
*memc
)
3785 memcached_return_t rc
= MEMCACHED_FAILURE
;
3787 if (libmemcached_util_version_check(memc
, 1, 4, 4))
3789 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3790 test_compare(MEMCACHED_SUCCESS
, rc
);
3791 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3794 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3797 static test_return_t
pre_sasl(memcached_st
*memc
)
3799 memcached_return_t rc
= MEMCACHED_FAILURE
;
3801 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
3802 const char *server
= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
3803 const char *user
= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
3804 const char *pass
= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
3806 if (server
and user
and pass
)
3808 memcached_server_st
*servers
= memcached_servers_parse(server
);
3810 memcached_servers_reset(memc
);
3811 test_true(memcached_server_push(memc
, servers
) == MEMCACHED_SUCCESS
);
3812 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3813 rc
= memcached_set_sasl_auth_data(memc
, user
, pass
);
3814 test_compare(MEMCACHED_SUCCESS
, rc
);
3820 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3823 static test_return_t
pre_replication(memcached_st
*memc
)
3825 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3828 * Make sure that we store the item on all servers
3829 * (master + replicas == number of servers)
3831 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3832 memcached_server_count(memc
) - 1);
3833 test_compare(MEMCACHED_SUCCESS
, rc
);
3834 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memcached_server_count(memc
) - 1);
3836 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3840 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3842 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3844 return pre_nonblock(memc
);
3848 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3852 #ifdef HARD_MALLOC_TESTS
3853 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3861 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3865 #ifdef HARD_MALLOC_TESTS
3866 void *ret
= malloc(size
+ 8);
3869 ret
= (void*)((caddr_t
)ret
+ 8);
3872 void *ret
= malloc(size
);
3877 memset(ret
, 0xff, size
);
3884 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3886 #ifdef HARD_MALLOC_TESTS
3887 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3888 void *nmem
= realloc(real_ptr
, size
+ 8);
3893 ret
= (void*)((caddr_t
)nmem
+ 8);
3899 return realloc(mem
, size
);
3904 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3906 #ifdef HARD_MALLOC_TESTS
3907 void *mem
= my_malloc(ptr
, nelem
* size
);
3910 memset(mem
, 0, nelem
* size
);
3916 return calloc(nelem
, size
);
3920 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3922 memcached_return_t rc
;
3923 const char *key
= "mine";
3926 /* Make sure be default none exists */
3927 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3928 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3930 /* Test a clean set */
3931 test_compare(MEMCACHED_SUCCESS
,
3932 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3934 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3936 test_memcmp(value
, key
, 4);
3937 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3939 /* Test that we can turn it off */
3940 test_compare(MEMCACHED_SUCCESS
,
3941 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3943 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3945 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3947 /* Now setup for main test */
3948 test_compare(MEMCACHED_SUCCESS
,
3949 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3951 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3953 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3954 test_memcmp(value
, key
, 4);
3956 /* Set to Zero, and then Set to something too large */
3959 memset(long_key
, 0, 255);
3961 test_compare(MEMCACHED_SUCCESS
,
3962 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3964 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3966 test_true(rc
== MEMCACHED_FAILURE
);
3967 test_true(value
== NULL
);
3969 /* Test a long key for failure */
3970 /* TODO, extend test to determine based on setting, what result should be */
3971 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3972 test_compare(MEMCACHED_SUCCESS
,
3973 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3975 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3976 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3977 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3978 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3980 /* Test for a bad prefix, but with a short key */
3981 test_compare_got(MEMCACHED_SUCCESS
,
3982 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1),
3983 memcached_strerror(NULL
, rc
));
3985 if (not memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
3987 strncpy(long_key
, "dog cat", sizeof(long_key
));
3988 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
3989 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3993 return TEST_SUCCESS
;
3996 static test_return_t
set_namespace(memcached_st
*memc
)
3998 memcached_return_t rc
;
3999 const char *key
= "mine";
4002 /* Make sure be default none exists */
4003 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
4004 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
4006 /* Test a clean set */
4007 test_compare(MEMCACHED_SUCCESS
,
4008 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
4010 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
4012 test_memcmp(value
, key
, 4);
4013 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4015 return TEST_SUCCESS
;
4018 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
4020 test_return_if(pre_binary(memc
));
4021 test_return_if(set_namespace(memc
));
4023 return TEST_SUCCESS
;
4026 #ifdef MEMCACHED_ENABLE_DEPRECATED
4027 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
4029 void *test_ptr
= NULL
;
4032 memcached_malloc_fn malloc_cb
=
4033 (memcached_malloc_fn
)my_malloc
;
4034 cb_ptr
= *(void **)&malloc_cb
;
4035 memcached_return_t rc
;
4037 test_compare(MEMCACHED_SUCCESS
,
4038 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
4039 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
4040 test_compare(MEMCACHED_SUCCESS
, rc
);
4041 test_true(test_ptr
== cb_ptr
);
4045 memcached_realloc_fn realloc_cb
=
4046 (memcached_realloc_fn
)my_realloc
;
4047 cb_ptr
= *(void **)&realloc_cb
;
4048 memcached_return_t rc
;
4050 test_compare(MEMCACHED_SUCCESS
,
4051 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
4052 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
4053 test_compare(MEMCACHED_SUCCESS
, rc
);
4054 test_true(test_ptr
== cb_ptr
);
4058 memcached_free_fn free_cb
=
4059 (memcached_free_fn
)my_free
;
4060 cb_ptr
= *(void **)&free_cb
;
4061 memcached_return_t rc
;
4063 test_compare(MEMCACHED_SUCCESS
,
4064 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
4065 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
4066 test_compare(MEMCACHED_SUCCESS
, rc
);
4067 test_true(test_ptr
== cb_ptr
);
4070 return TEST_SUCCESS
;
4075 static test_return_t
set_memory_alloc(memcached_st
*memc
)
4077 test_compare(MEMCACHED_FAILURE
,
4078 memcached_set_memory_allocators(memc
, NULL
, my_free
,
4079 my_realloc
, my_calloc
, NULL
));
4081 test_compare(MEMCACHED_SUCCESS
,
4082 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
4083 my_realloc
, my_calloc
, NULL
));
4085 memcached_malloc_fn mem_malloc
;
4086 memcached_free_fn mem_free
;
4087 memcached_realloc_fn mem_realloc
;
4088 memcached_calloc_fn mem_calloc
;
4089 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
4090 &mem_realloc
, &mem_calloc
);
4092 test_true(mem_malloc
== my_malloc
);
4093 test_true(mem_realloc
== my_realloc
);
4094 test_true(mem_calloc
== my_calloc
);
4095 test_true(mem_free
== my_free
);
4097 return TEST_SUCCESS
;
4100 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
4103 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4104 memcached_hash_t hash
;
4105 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4106 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
4109 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4110 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4112 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4114 if (hash
!= MEMCACHED_HASH_CRC
)
4115 return TEST_SKIPPED
;
4117 return TEST_SUCCESS
;
4120 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
4123 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4124 memcached_hash_t hash
;
4125 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4126 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
4129 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4130 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4132 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4134 if (hash
!= MEMCACHED_HASH_HSIEH
)
4135 return TEST_SKIPPED
;
4138 return TEST_SUCCESS
;
4141 static test_return_t
enable_cas(memcached_st
*memc
)
4143 unsigned int set
= 1;
4145 if (libmemcached_util_version_check(memc
, 1, 2, 4))
4147 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
4149 return TEST_SUCCESS
;
4152 return TEST_SKIPPED
;
4155 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
4157 memcached_version(memc
);
4159 memcached_server_instance_st instance
=
4160 memcached_server_instance_by_position(memc
, 0);
4162 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
4163 || instance
->minor_version
> 2)
4165 return TEST_SUCCESS
;
4168 return TEST_SKIPPED
;
4171 static test_return_t
pre_unix_socket(memcached_st
*memc
)
4173 memcached_return_t rc
;
4176 memcached_servers_reset(memc
);
4178 if (stat("/tmp/memcached.socket", &buf
))
4179 return TEST_SKIPPED
;
4181 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
4183 return ( rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_FAILURE
);
4186 static test_return_t
pre_nodelay(memcached_st
*memc
)
4188 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
4189 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
4191 return TEST_SUCCESS
;
4194 static test_return_t
pre_settimer(memcached_st
*memc
)
4196 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4197 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4199 return TEST_SUCCESS
;
4202 static test_return_t
poll_timeout(memcached_st
*memc
)
4204 size_t timeout
= 100; // Not using, just checking that it sets
4206 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4208 timeout
= (size_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
4210 test_compare(100, timeout
);
4212 return TEST_SUCCESS
;
4215 static test_return_t
noreply_test(memcached_st
*memc
)
4217 memcached_return_t ret
;
4218 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
4219 test_true(ret
== MEMCACHED_SUCCESS
);
4220 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4221 test_true(ret
== MEMCACHED_SUCCESS
);
4222 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
4223 test_true(ret
== MEMCACHED_SUCCESS
);
4224 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
4225 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
4226 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
4228 for (int count
=0; count
< 5; ++count
)
4230 for (size_t x
= 0; x
< 100; ++x
)
4233 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4234 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4236 size_t len
= (size_t)check_length
;
4241 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4244 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4247 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4250 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4253 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4259 test_true(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
4263 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4264 ** API and is _ONLY_ done this way to verify that the library works the
4265 ** way it is supposed to do!!!!
4268 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4270 memcached_server_instance_st instance
=
4271 memcached_server_instance_by_position(memc
, x
);
4272 no_msg
+=(int)(instance
->cursor_active
);
4275 test_true(no_msg
== 0);
4276 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4279 ** Now validate that all items was set properly!
4281 for (size_t x
= 0; x
< 100; ++x
)
4285 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4287 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4289 size_t len
= (size_t)check_length
;
4292 char* value
=memcached_get(memc
, key
, strlen(key
),
4293 &length
, &flags
, &ret
);
4294 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4297 case 0: /* FALLTHROUGH */
4298 case 1: /* FALLTHROUGH */
4300 test_true(strncmp(value
, key
, len
) == 0);
4301 test_true(len
== length
);
4304 test_true(length
== len
* 2);
4307 test_true(length
== len
* 3);
4317 /* Try setting an illegal cas value (should not return an error to
4318 * the caller (because we don't expect a return message from the server)
4320 const char* keys
[]= {"0"};
4321 size_t lengths
[]= {1};
4324 memcached_result_st results_obj
;
4325 memcached_result_st
*results
;
4326 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4327 test_true(ret
== MEMCACHED_SUCCESS
);
4329 results
= memcached_result_create(memc
, &results_obj
);
4331 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4333 test_true(ret
== MEMCACHED_SUCCESS
);
4334 uint64_t cas
= memcached_result_cas(results
);
4335 memcached_result_free(&results_obj
);
4337 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4338 test_true(ret
== MEMCACHED_SUCCESS
);
4341 * The item will have a new cas value, so try to set it again with the old
4342 * value. This should fail!
4344 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4345 test_true(ret
== MEMCACHED_SUCCESS
);
4346 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4347 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4348 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4351 return TEST_SUCCESS
;
4354 static test_return_t
analyzer_test(memcached_st
*memc
)
4356 memcached_return_t rc
;
4357 memcached_stat_st
*memc_stat
;
4358 memcached_analysis_st
*report
;
4360 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4361 test_compare(MEMCACHED_SUCCESS
, rc
);
4362 test_true(memc_stat
);
4364 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4365 test_compare(MEMCACHED_SUCCESS
, rc
);
4369 memcached_stat_free(NULL
, memc_stat
);
4371 return TEST_SUCCESS
;
4374 /* Count the objects */
4375 static memcached_return_t
callback_dump_counter(const memcached_st
*ptr
,
4380 (void)ptr
; (void)key
; (void)key_length
;
4381 size_t *counter
= (size_t *)context
;
4383 *counter
= *counter
+ 1;
4385 return MEMCACHED_SUCCESS
;
4388 static test_return_t
dump_test(memcached_st
*memc
)
4391 memcached_dump_fn callbacks
[1];
4393 callbacks
[0]= &callback_dump_counter
;
4395 /* No support for Binary protocol yet */
4396 test_skip(false, memc
->flags
.binary_protocol
);
4398 test_compare(TEST_SUCCESS
, set_test3(memc
));
4400 test_compare(MEMCACHED_SUCCESS
,
4401 memcached_dump(memc
, callbacks
, (void *)&counter
, 1));
4403 /* We may have more then 32 if our previous flush has not completed */
4404 test_true(counter
>= 32);
4406 return TEST_SUCCESS
;
4409 #ifdef HAVE_LIBMEMCACHEDUTIL
4411 struct test_pool_context_st
{
4412 memcached_pool_st
* pool
;
4416 static void* connection_release(void *arg
)
4418 test_pool_context_st
*resource
= static_cast<test_pool_context_st
*>(arg
);
4421 // Release all of the memc we are holding
4422 assert(memcached_success(memcached_pool_push(resource
->pool
, resource
->mmc
)));
4426 #define POOL_SIZE 10
4427 static test_return_t
connection_pool_test(memcached_st
*memc
)
4429 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4430 test_true(pool
!= NULL
);
4431 memcached_st
*mmc
[POOL_SIZE
];
4432 memcached_return_t rc
;
4434 // Fill up our array that we will store the memc that are in the pool
4435 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4437 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4438 test_true(mmc
[x
] != NULL
);
4439 test_compare(MEMCACHED_SUCCESS
, rc
);
4442 // All memc should be gone
4443 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4444 test_compare(MEMCACHED_SUCCESS
, rc
);
4447 test_pool_context_st item
= { pool
, mmc
[9] };
4449 pthread_create(&tid
, NULL
, connection_release
, &item
);
4450 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4451 test_compare(MEMCACHED_SUCCESS
, rc
);
4452 pthread_join(tid
, NULL
);
4454 const char *key
= "key";
4455 size_t keylen
= strlen(key
);
4457 // verify that I can do ops with all connections
4458 test_compare(MEMCACHED_SUCCESS
,
4459 memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0));
4461 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4463 uint64_t number_value
;
4464 test_compare(MEMCACHED_SUCCESS
,
4465 memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
));
4466 test_compare(number_value
, (x
+1));
4470 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4472 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[x
]));
4476 /* verify that I can set behaviors on the pool when I don't have all
4477 * of the connections in the pool. It should however be enabled
4478 * when I push the item into the pool
4480 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4483 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4484 test_compare(MEMCACHED_SUCCESS
, rc
);
4486 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4489 test_compare(9999, memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4490 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[1]));
4491 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4493 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4494 test_compare(9999, memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4495 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4497 test_true(memcached_pool_destroy(pool
) == memc
);
4499 return TEST_SUCCESS
;
4502 static test_return_t
util_version_test(memcached_st
*memc
)
4504 bool if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4505 test_true(if_successful
);
4507 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4509 // We expect failure
4512 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4513 fprintf(stderr
, "\nDumping Server Information\n\n");
4514 memcached_server_fn callbacks
[1];
4516 callbacks
[0]= dump_server_information
;
4517 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4518 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4520 test_true(if_successful
== false);
4522 memcached_server_instance_st instance
=
4523 memcached_server_instance_by_position(memc
, 0);
4525 memcached_version(memc
);
4527 // We only use one binary when we test, so this should be just fine.
4528 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4529 test_true(if_successful
== true);
4531 if (instance
->micro_version
> 0)
4532 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4533 else if (instance
->minor_version
> 0)
4534 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4535 else if (instance
->major_version
> 0)
4536 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4538 test_true(if_successful
== true);
4540 if (instance
->micro_version
> 0)
4541 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4542 else if (instance
->minor_version
> 0)
4543 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4544 else if (instance
->major_version
> 0)
4545 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4547 test_true(if_successful
== false);
4549 return TEST_SUCCESS
;
4552 static test_return_t
ping_test(memcached_st
*memc
)
4554 memcached_return_t rc
;
4555 memcached_server_instance_st instance
=
4556 memcached_server_instance_by_position(memc
, 0);
4558 // Test both the version that returns a code, and the one that does not.
4559 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4560 memcached_server_port(instance
), NULL
));
4562 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4563 memcached_server_port(instance
), &rc
));
4565 test_compare(MEMCACHED_SUCCESS
, rc
);
4567 return TEST_SUCCESS
;
4573 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4577 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4578 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4579 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4580 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4581 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4582 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4583 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4584 #ifdef HAVE_HSIEH_HASH
4585 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4587 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4588 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4589 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4591 return TEST_SUCCESS
;
4595 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4597 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4598 #ifdef HAVE_HSIEH_HASH
4599 expected_rc
= MEMCACHED_SUCCESS
;
4601 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4602 (uint64_t)MEMCACHED_HASH_HSIEH
);
4603 test_true(rc
== expected_rc
);
4605 return TEST_SUCCESS
;
4608 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4610 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4611 #ifdef HAVE_MURMUR_HASH
4612 expected_rc
= MEMCACHED_SUCCESS
;
4614 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4615 (uint64_t)MEMCACHED_HASH_MURMUR
);
4616 test_true(rc
== expected_rc
);
4618 return TEST_SUCCESS
;
4621 static test_return_t
one_at_a_time_run (memcached_st
*memc
)
4627 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4631 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
);
4632 test_true(one_at_a_time_values
[x
] == hash_val
);
4635 return TEST_SUCCESS
;
4638 static test_return_t
md5_run (memcached_st
*memc
)
4644 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4648 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4649 test_true(md5_values
[x
] == hash_val
);
4652 return TEST_SUCCESS
;
4655 static test_return_t
crc_run (memcached_st
*memc
)
4661 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4665 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4666 test_true(crc_values
[x
] == hash_val
);
4669 return TEST_SUCCESS
;
4672 static test_return_t
fnv1_64_run (memcached_st
*memc
)
4678 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4682 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4683 test_true(fnv1_64_values
[x
] == hash_val
);
4686 return TEST_SUCCESS
;
4689 static test_return_t
fnv1a_64_run (memcached_st
*memc
)
4695 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4699 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4700 test_true(fnv1a_64_values
[x
] == hash_val
);
4703 return TEST_SUCCESS
;
4706 static test_return_t
fnv1_32_run (memcached_st
*memc
)
4712 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4716 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4717 test_true(fnv1_32_values
[x
] == hash_val
);
4720 return TEST_SUCCESS
;
4723 static test_return_t
fnv1a_32_run (memcached_st
*memc
)
4729 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4733 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4734 test_true(fnv1a_32_values
[x
] == hash_val
);
4737 return TEST_SUCCESS
;
4740 static test_return_t
hsieh_run (memcached_st
*memc
)
4746 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4750 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4751 test_true(hsieh_values
[x
] == hash_val
);
4754 return TEST_SUCCESS
;
4757 static test_return_t
murmur_run (memcached_st
*memc
)
4759 #ifdef WORDS_BIGENDIAN
4760 (void)murmur_values
;
4761 return TEST_SKIPPED
;
4767 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4771 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
4772 test_true(murmur_values
[x
] == hash_val
);
4775 return TEST_SUCCESS
;
4779 static test_return_t
jenkins_run (memcached_st
*memc
)
4785 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4789 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4790 test_true(jenkins_values
[x
] == hash_val
);
4793 return TEST_SUCCESS
;
4796 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *context
)
4799 return libhashkit_md5(string
, string_length
);
4802 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *context
)
4805 return libhashkit_crc32(string
, string_length
);
4808 static test_return_t
memcached_get_hashkit_test (memcached_st
*memc
)
4812 const hashkit_st
*kit
;
4814 hashkit_return_t hash_rc
;
4816 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};
4817 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};
4819 kit
= memcached_get_hashkit(memc
);
4821 hashkit_clone(&new_kit
, kit
);
4822 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
);
4823 test_true(hash_rc
== HASHKIT_SUCCESS
);
4825 memcached_set_hashkit(memc
, &new_kit
);
4828 Verify Setting the hash.
4830 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4834 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4835 test_true(md5_values
[x
] == hash_val
);
4840 Now check memcached_st.
4842 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4846 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4847 test_true(md5_hosts
[x
] == hash_val
);
4850 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
);
4851 test_true(hash_rc
== HASHKIT_SUCCESS
);
4853 memcached_set_hashkit(memc
, &new_kit
);
4856 Verify Setting the hash.
4858 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4862 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4863 test_true(crc_values
[x
] == hash_val
);
4866 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4870 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4871 test_true(crc_hosts
[x
] == hash_val
);
4874 return TEST_SUCCESS
;
4878 Test case adapted from John Gorman <johngorman2@gmail.com>
4880 We are testing the error condition when we connect to a server via memcached_get()
4881 but find that the server is not available.
4883 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*memc
)
4886 memcached_st
*tl_memc_h
;
4888 const char *key
= "MemcachedLives";
4891 memcached_return rc
;
4895 tl_memc_h
= memcached_create(NULL
);
4896 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4898 memcached_server_push(tl_memc_h
, servers
);
4899 memcached_server_list_free(servers
);
4901 // See if memcached is reachable.
4902 value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4905 test_compare(0, len
);
4906 test_true(memcached_failed(rc
));
4908 memcached_free(tl_memc_h
);
4910 return TEST_SUCCESS
;
4914 We connect to a server which exists, but search for a key that does not exist.
4916 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4918 const char *key
= "MemcachedKeyNotEXIST";
4921 memcached_return rc
;
4924 // See if memcached is reachable.
4925 value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4928 test_compare(0, len
);
4929 test_compare(MEMCACHED_NOTFOUND
, rc
);
4931 return TEST_SUCCESS
;
4935 Test case adapted from John Gorman <johngorman2@gmail.com>
4937 We are testing the error condition when we connect to a server via memcached_get_by_key()
4938 but find that the server is not available.
4940 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4943 memcached_st
*tl_memc_h
;
4944 memcached_server_st
*servers
;
4946 const char *key
= "MemcachedLives";
4949 memcached_return rc
;
4953 tl_memc_h
= memcached_create(NULL
);
4954 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4955 memcached_server_push(tl_memc_h
, servers
);
4956 memcached_server_list_free(servers
);
4958 // See if memcached is reachable.
4959 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4962 test_compare(0, len
);
4963 test_true(memcached_failed(rc
));
4965 memcached_free(tl_memc_h
);
4967 return TEST_SUCCESS
;
4971 We connect to a server which exists, but search for a key that does not exist.
4973 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4975 const char *key
= "MemcachedKeyNotEXIST";
4978 memcached_return rc
;
4981 // See if memcached is reachable.
4982 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4985 test_compare(0, len
);
4986 test_compare(MEMCACHED_NOTFOUND
, rc
);
4988 return TEST_SUCCESS
;
4992 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*)
4994 memcached_st
*memc
= memcached_create(NULL
);
4997 test_compare(MEMCACHED_SUCCESS
,
4998 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1));
5001 test_compare(1, value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
5003 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
5004 test_compare(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
, memcached_behavior_get_distribution(memc
));
5007 memcached_server_st
*server_pool
= memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
5008 memcached_server_push(memc
, server_pool
);
5010 /* verify that the server list was parsed okay. */
5011 test_compare(8, memcached_server_count(memc
));
5012 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5013 test_compare(11211, server_pool
[0].port
);
5014 test_compare(600, server_pool
[0].weight
);
5015 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5016 test_compare(11211, server_pool
[2].port
);
5017 test_compare(200, server_pool
[2].weight
);
5018 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5019 test_compare(11211, server_pool
[7].port
);
5020 test_compare(100, server_pool
[7].weight
);
5022 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5023 * us test the boundary wraparound.
5025 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
5027 /* verify the standard ketama set. */
5028 for (uint32_t x
= 0; x
< 99; x
++)
5030 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
5031 memcached_server_instance_st instance
=
5032 memcached_server_instance_by_position(memc
, server_idx
);
5033 const char *hostname
= memcached_server_name(instance
);
5035 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
5038 memcached_server_list_free(server_pool
);
5039 memcached_free(memc
);
5041 return TEST_SUCCESS
;
5044 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*)
5048 memcached_st
*memc
= memcached_create(NULL
);
5051 test_compare(MEMCACHED_SUCCESS
,
5052 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1));
5054 test_compare(1, value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
5056 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
));
5057 test_compare(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
, memcached_behavior_get_distribution(memc
));
5059 memcached_server_st
*server_pool
= memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
5060 test_true(server_pool
);
5061 memcached_server_push(memc
, server_pool
);
5063 /* verify that the server list was parsed okay. */
5064 test_compare(8, memcached_server_count(memc
));
5065 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5066 test_compare(11211, server_pool
[0].port
);
5067 test_compare(600, server_pool
[0].weight
);
5068 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5069 test_compare(11211, server_pool
[2].port
);
5070 test_compare(200, server_pool
[2].weight
);
5071 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5072 test_compare(11211, server_pool
[7].port
);
5073 test_compare(100, server_pool
[7].weight
);
5075 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5076 * us test the boundary wraparound.
5078 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
5080 /* verify the standard ketama set. */
5081 for (uint32_t x
= 0; x
< 99; x
++)
5083 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
5085 memcached_server_instance_st instance
=
5086 memcached_server_instance_by_position(memc
, server_idx
);
5088 const char *hostname
= memcached_server_name(instance
);
5090 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
5093 memcached_server_list_free(server_pool
);
5094 memcached_free(memc
);
5096 return TEST_SUCCESS
;
5099 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5101 test_return_t test_rc
;
5102 test_rc
= pre_binary(memc
);
5104 if (test_rc
!= TEST_SUCCESS
)
5107 const char *key
= "regression_bug_434484";
5108 size_t keylen
= strlen(key
);
5110 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5111 test_compare(MEMCACHED_NOTSTORED
, ret
);
5113 size_t size
= 2048 * 1024;
5114 char *data
= (char*)calloc(1, size
);
5116 test_compare(MEMCACHED_E2BIG
,
5117 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
5120 return TEST_SUCCESS
;
5123 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5125 test_return_t test_rc
;
5126 test_rc
= pre_binary(memc
);
5128 if (test_rc
!= TEST_SUCCESS
)
5131 memcached_return_t rc
;
5133 memcached_execute_fn callbacks
[]= { &callback_counter
};
5136 * I only want to hit only _one_ server so I know the number of requests I'm
5137 * sending in the pipleine to the server. Let's try to do a multiget of
5138 * 1024 (that should satisfy most users don't you think?). Future versions
5139 * will include a mget_execute function call if you need a higher number.
5141 uint32_t number_of_hosts
= memcached_server_count(memc
);
5142 memc
->number_of_hosts
= 1;
5143 const size_t max_keys
= 1024;
5144 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
5145 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5147 for (size_t x
= 0; x
< max_keys
; ++x
)
5151 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5157 * Run two times.. the first time we should have 100% cache miss,
5158 * and the second time we should have 100% cache hits
5160 for (size_t y
= 0; y
< 2; y
++)
5162 test_compare(MEMCACHED_SUCCESS
,
5163 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
5165 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
5166 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5170 /* The first iteration should give me a 100% cache miss. verify that*/
5171 char blob
[1024]= { 0 };
5173 test_false(counter
);
5175 for (size_t x
= 0; x
< max_keys
; ++x
)
5177 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5178 blob
, sizeof(blob
), 0, 0);
5179 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5184 /* Verify that we received all of the key/value pairs */
5185 test_compare(counter
, max_keys
);
5189 /* Release allocated resources */
5190 for (size_t x
= 0; x
< max_keys
; ++x
)
5197 memc
->number_of_hosts
= number_of_hosts
;
5199 return TEST_SUCCESS
;
5202 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5204 memcached_return_t rc
;
5205 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5206 test_compare(MEMCACHED_SUCCESS
, rc
);
5208 return regression_bug_434843(memc
);
5211 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5213 memcached_return_t rc
;
5214 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5215 test_compare(MEMCACHED_SUCCESS
, rc
);
5217 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5218 test_compare(MEMCACHED_SUCCESS
, rc
);
5219 test_true(bytes_str
);
5220 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
5222 test_compare(MEMCACHED_SUCCESS
, rc
);
5223 test_true(bytes_read_str
);
5225 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
5226 "bytes_written", &rc
);
5227 test_compare(MEMCACHED_SUCCESS
, rc
);
5228 test_true(bytes_written_str
);
5230 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
5231 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
5232 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
5234 test_true(bytes
!= bytes_read
);
5235 test_true(bytes
!= bytes_written
);
5237 /* Release allocated resources */
5239 free(bytes_read_str
);
5240 free(bytes_written_str
);
5241 memcached_stat_free(NULL
, memc_stat
);
5243 return TEST_SUCCESS
;
5247 * The test case isn't obvious so I should probably document why
5248 * it works the way it does. Bug 442914 was caused by a bug
5249 * in the logic in memcached_purge (it did not handle the case
5250 * where the number of bytes sent was equal to the watermark).
5251 * In this test case, create messages so that we hit that case
5252 * and then disable noreply mode and issue a new command to
5253 * verify that it isn't stuck. If we change the format for the
5254 * delete command or the watermarks, we need to update this
5257 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5259 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5260 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5262 uint32_t number_of_hosts
= memcached_server_count(memc
);
5263 memc
->number_of_hosts
= 1;
5268 for (uint32_t x
= 0; x
< 250; ++x
)
5270 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5271 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
5272 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5275 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5278 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
5279 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5281 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5282 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
5284 memc
->number_of_hosts
= number_of_hosts
;
5286 return TEST_SUCCESS
;
5289 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5291 memcached_server_instance_st instance_one
;
5292 memcached_server_instance_st instance_two
;
5294 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
5295 return TEST_SKIPPED
;
5297 test_compare(MEMCACHED_SUCCESS
,
5298 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
5300 const size_t max_keys
= 100;
5301 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
5302 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5304 for (size_t x
= 0; x
< max_keys
; ++x
)
5308 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5311 test_compare(MEMCACHED_SUCCESS
,
5312 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
5316 ** We are using the quiet commands to store the replicas, so we need
5317 ** to ensure that all of them are processed before we can continue.
5318 ** In the test we go directly from storing the object to trying to
5319 ** receive the object from all of the different servers, so we
5320 ** could end up in a race condition (the memcached server hasn't yet
5321 ** processed the quiet command from the replication set when it process
5322 ** the request from the other client (created by the clone)). As a
5323 ** workaround for that we call memcached_quit to send the quit command
5324 ** to the server and wait for the response ;-) If you use the test code
5325 ** as an example for your own code, please note that you shouldn't need
5328 memcached_quit(memc
);
5330 /* Verify that all messages are stored, and we didn't stuff too much
5333 test_compare(MEMCACHED_SUCCESS
,
5334 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5337 memcached_execute_fn callbacks
[]= { &callback_counter
};
5338 memcached_return_t rc
;
5339 test_compare_got(MEMCACHED_SUCCESS
,
5340 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1),
5341 memcached_strerror(NULL
, rc
));
5343 /* Verify that we received all of the key/value pairs */
5344 test_compare(counter
, max_keys
);
5346 memcached_quit(memc
);
5348 * Don't do the following in your code. I am abusing the internal details
5349 * within the library, and this is not a supported interface.
5350 * This is to verify correct behavior in the library. Fake that two servers
5353 instance_one
= memcached_server_instance_by_position(memc
, 0);
5354 instance_two
= memcached_server_instance_by_position(memc
, 2);
5355 in_port_t port0
= instance_one
->port
;
5356 in_port_t port2
= instance_two
->port
;
5358 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5359 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5361 test_compare(MEMCACHED_SUCCESS
,
5362 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5365 test_compare(MEMCACHED_SUCCESS
,
5366 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5367 test_compare(counter
, (unsigned int)max_keys
);
5369 /* restore the memc handle */
5370 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5371 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5373 memcached_quit(memc
);
5375 /* Remove half of the objects */
5376 for (size_t x
= 0; x
< max_keys
; ++x
)
5380 test_compare(MEMCACHED_SUCCESS
,
5381 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
5385 memcached_quit(memc
);
5386 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5387 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5389 /* now retry the command, this time we should have cache misses */
5390 test_compare(MEMCACHED_SUCCESS
,
5391 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5394 test_compare_got(MEMCACHED_SUCCESS
,
5395 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1),
5396 memcached_strerror(NULL
, rc
));
5397 test_compare(counter
, (unsigned int)(max_keys
>> 1));
5399 /* Release allocated resources */
5400 for (size_t x
= 0; x
< max_keys
; ++x
)
5407 /* restore the memc handle */
5408 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5409 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5411 return TEST_SUCCESS
;
5414 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5416 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5417 test_true(memc_clone
);
5418 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5420 memcached_server_instance_st instance
=
5421 memcached_server_instance_by_position(memc_clone
, 0);
5423 if (instance
->major_version
> 1 ||
5424 (instance
->major_version
== 1 &&
5425 instance
->minor_version
> 2))
5427 /* Binary protocol doesn't support deferred delete */
5428 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5429 test_true(bin_clone
);
5430 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5431 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
5432 memcached_free(bin_clone
);
5434 memcached_quit(memc_clone
);
5436 /* If we know the server version, deferred delete should fail
5437 * with invalid arguments */
5438 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
5440 /* If we don't know the server version, we should get a protocol error */
5441 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5443 /* but there is a bug in some of the memcached servers (1.4) that treats
5444 * the counter as noreply so it doesn't send the proper error message
5446 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5448 /* And buffered mode should be disabled and we should get protocol error */
5449 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5450 rc
= memcached_delete(memc
, "foo", 3, 1);
5451 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5453 /* Same goes for noreply... */
5454 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5455 rc
= memcached_delete(memc
, "foo", 3, 1);
5456 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5458 /* but a normal request should go through (and be buffered) */
5459 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
5460 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
5462 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
5463 /* unbuffered noreply should be success */
5464 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
5465 /* unbuffered with reply should be not found... */
5466 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5467 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
5470 memcached_free(memc_clone
);
5471 return TEST_SUCCESS
;
5475 /* Test memcached_server_get_last_disconnect
5476 * For a working server set, shall be NULL
5477 * For a set of non existing server, shall not be NULL
5479 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5481 memcached_return_t rc
;
5482 memcached_server_instance_st disconnected_server
;
5484 /* With the working set of server */
5485 const char *key
= "marmotte";
5486 const char *value
= "milka";
5488 memcached_reset_last_disconnected_server(memc
);
5489 test_false(memc
->last_disconnected_server
);
5490 rc
= memcached_set(memc
, key
, strlen(key
),
5491 value
, strlen(value
),
5492 (time_t)0, (uint32_t)0);
5493 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5495 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5496 test_false(disconnected_server
);
5498 /* With a non existing server */
5500 memcached_server_st
*servers
;
5502 const char *server_list
= "localhost:9";
5504 servers
= memcached_servers_parse(server_list
);
5506 mine
= memcached_create(NULL
);
5507 rc
= memcached_server_push(mine
, servers
);
5508 test_compare(MEMCACHED_SUCCESS
, rc
);
5509 memcached_server_list_free(servers
);
5512 rc
= memcached_set(mine
, key
, strlen(key
),
5513 value
, strlen(value
),
5514 (time_t)0, (uint32_t)0);
5515 test_true(memcached_failed(rc
));
5517 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5518 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5519 test_compare(9, memcached_server_port(disconnected_server
));
5520 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5522 memcached_quit(mine
);
5523 memcached_free(mine
);
5525 return TEST_SUCCESS
;
5528 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5530 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5531 char buffer
[BUFSIZ
];
5533 memcached_return_t rc
;
5534 test_compare_got(MEMCACHED_SUCCESS
,
5535 rc
= libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)),
5536 memcached_strerror(NULL
, rc
));
5538 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5541 // We will just use the error strings as our keys
5542 uint32_t counter
= 100;
5545 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5547 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5548 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5549 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, ret
, memcached_last_error_message(memc
));
5551 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5552 test_true(disconnected_server
);
5553 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5554 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5558 memcached_reset_last_disconnected_server(memc
);
5563 memcached_free(memc
);
5565 return TEST_SUCCESS
;
5568 static test_return_t
test_verbosity(memcached_st
*memc
)
5570 memcached_verbosity(memc
, 3);
5572 return TEST_SUCCESS
;
5575 static test_return_t
test_server_failure(memcached_st
*memc
)
5577 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
5579 memcached_st
*local_memc
= memcached_create(NULL
);
5581 memcached_server_add(local_memc
, memcached_server_name(instance
), memcached_server_port(instance
));
5582 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 2);
5584 uint32_t server_count
= memcached_server_count(local_memc
);
5585 test_compare(1, server_count
);
5587 // Disable the server
5588 instance
= memcached_server_instance_by_position(local_memc
, 0);
5589 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 2;
5591 memcached_return_t rc
;
5592 test_compare_got(MEMCACHED_SERVER_MARKED_DEAD
,
5593 rc
= memcached_set(local_memc
, "foo", strlen("foo"), NULL
, 0, (time_t)0, (uint32_t)0),
5594 memcached_last_error_message(local_memc
));
5596 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5597 test_compare_got(MEMCACHED_SUCCESS
,
5598 rc
= memcached_set(local_memc
, "foo", strlen("foo"), NULL
, 0, (time_t)0, (uint32_t)0),
5599 memcached_strerror(NULL
, rc
));
5601 memcached_last_error_message(local_memc
));
5605 memcached_free(local_memc
);
5607 return TEST_SUCCESS
;
5610 static test_return_t
test_cull_servers(memcached_st
*memc
)
5612 uint32_t count
= memcached_server_count(memc
);
5614 // Do not do this in your code, it is not supported.
5615 memc
->servers
[1].options
.is_dead
= true;
5616 memc
->state
.is_time_for_rebuild
= true;
5618 uint32_t new_count
= memcached_server_count(memc
);
5619 test_compare(count
, new_count
);
5622 test_true(count
== new_count
+ 1 );
5625 return TEST_SUCCESS
;
5629 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5630 const char *key
, size_t key_length
,
5631 const char *value
, size_t value_length
,
5641 return MEMCACHED_SUCCESS
;
5644 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5646 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5647 test_compare(MEMCACHED_SUCCESS
, rc
);
5649 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5650 test_compare(MEMCACHED_SUCCESS
, rc
);
5652 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5653 test_compare(MEMCACHED_SUCCESS
, rc
);
5655 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5656 test_compare(MEMCACHED_SUCCESS
, rc
);
5658 return TEST_SUCCESS
;
5662 * This test ensures that the failure counter isn't incremented during
5663 * normal termination of the memcached instance.
5665 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5667 memcached_return_t rc
;
5668 memcached_server_instance_st instance
;
5670 /* Set value to force connection to the server */
5671 const char *key
= "marmotte";
5672 const char *value
= "milka";
5675 * Please note that I'm abusing the internal structures in libmemcached
5676 * in a non-portable way and you shouldn't be doing this. I'm only
5677 * doing this in order to verify that the library works the way it should
5679 uint32_t number_of_hosts
= memcached_server_count(memc
);
5680 memc
->number_of_hosts
= 1;
5682 /* Ensure that we are connected to the server by setting a value */
5683 rc
= memcached_set(memc
, key
, strlen(key
),
5684 value
, strlen(value
),
5685 (time_t)0, (uint32_t)0);
5686 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5689 instance
= memcached_server_instance_by_position(memc
, 0);
5690 /* The test is to see that the memcached_quit doesn't increase the
5691 * the server failure conter, so let's ensure that it is zero
5692 * before sending quit
5694 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5696 memcached_quit(memc
);
5698 /* Verify that it memcached_quit didn't increment the failure counter
5699 * Please note that this isn't bullet proof, because an error could
5702 test_compare(0, instance
->server_failure_counter
);
5704 /* restore the instance */
5705 memc
->number_of_hosts
= number_of_hosts
;
5707 return TEST_SUCCESS
;
5711 * This tests ensures expected disconnections (for some behavior changes
5712 * for instance) do not wrongly increase failure counter
5714 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5716 memcached_return rc
;
5718 memcached_st
*memc_clone
;
5719 memc_clone
= memcached_clone(NULL
, memc
);
5720 test_true(memc_clone
);
5722 /* Set value to force connection to the server */
5723 const char *key
= "marmotte";
5724 const char *value
= "milka";
5725 char *string
= NULL
;
5726 size_t string_length
;
5729 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5730 value
, strlen(value
),
5731 (time_t)0, (uint32_t)0);
5732 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5735 /* put failure limit to 1 */
5736 test_compare(MEMCACHED_SUCCESS
,
5737 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1));
5739 /* Put a retry timeout to effectively activate failure_limit effect */
5740 test_compare(MEMCACHED_SUCCESS
,
5741 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
5743 /* change behavior that triggers memcached_quit()*/
5744 test_compare(MEMCACHED_SUCCESS
,
5745 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5748 /* Check if we still are connected */
5749 string
= memcached_get(memc_clone
, key
, strlen(key
),
5750 &string_length
, &flags
, &rc
);
5752 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5755 memcached_free(memc_clone
);
5757 return TEST_SUCCESS
;
5764 * Test that ensures mget_execute does not end into recursive calls that finally fails
5766 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5768 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5769 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5770 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5771 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5772 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5775 return TEST_SKIPPED
; // My MAC can't handle this test
5779 * I only want to hit _one_ server so I know the number of requests I'm
5780 * sending in the pipeline.
5782 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5783 memc
->number_of_hosts
= 1;
5784 size_t max_keys
= 20480;
5787 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5788 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5790 /* First add all of the items.. */
5791 char blob
[1024]= { 0 };
5792 for (size_t x
= 0; x
< max_keys
; ++x
)
5795 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5798 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5799 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5804 /* Try to get all of them with a large multiget */
5806 memcached_execute_function callbacks
[]= { &callback_counter
};
5807 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5808 (size_t)max_keys
, callbacks
, &counter
, 1);
5809 test_compare(MEMCACHED_SUCCESS
, rc
);
5811 char* the_value
= NULL
;
5812 char the_key
[MEMCACHED_MAX_KEY
];
5813 size_t the_key_length
;
5814 size_t the_value_length
;
5818 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5820 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5826 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5829 test_compare(MEMCACHED_END
, rc
);
5831 /* Verify that we got all of the items */
5832 test_compare(counter
, max_keys
);
5835 /* Release all allocated resources */
5836 for (size_t x
= 0; x
< max_keys
; ++x
)
5843 memc
->number_of_hosts
= number_of_hosts
;
5845 return TEST_SUCCESS
;
5848 static test_return_t
regression_bug_583031(memcached_st
*)
5850 memcached_st
*memc
= memcached_create(NULL
);
5852 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5854 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5855 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5856 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5857 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5858 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5859 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5861 memcached_return_t rc
;
5865 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5867 test_compare(0, length
);
5869 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_strerror(memc
, rc
));
5871 memcached_free(memc
);
5873 return TEST_SUCCESS
;
5876 static test_return_t
regression_bug_581030(memcached_st
*)
5879 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5880 test_false(local_stat
);
5882 memcached_stat_free(NULL
, NULL
);
5885 return TEST_SUCCESS
;
5888 #define regression_bug_655423_COUNT 6000
5889 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5891 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5892 memc
= NULL
; // Just to make sure it is not used
5897 return TEST_SKIPPED
;
5900 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5901 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5902 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5903 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5905 memset(payload
, int('x'), sizeof(payload
));
5907 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5909 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5910 snprintf(key
, sizeof(key
), "%u", x
);
5912 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5915 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5917 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5918 snprintf(key
, sizeof(key
), "%u", x
);
5920 size_t value_length
;
5921 memcached_return_t rc
;
5922 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5924 if (rc
== MEMCACHED_NOTFOUND
)
5927 test_compare(0, value_length
);
5931 test_compare(MEMCACHED_SUCCESS
, rc
);
5933 test_compare(100, value_length
);
5937 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5938 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5939 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5941 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5942 snprintf(key
, sizeof(key
), "%u", x
);
5944 keys
[x
]= strdup(key
);
5946 key_length
[x
]= strlen(key
);
5947 test_true(key_length
[x
]);
5950 memcached_return_t rc
;
5951 test_compare_got(MEMCACHED_SUCCESS
,
5952 rc
= memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
),
5953 memcached_strerror(NULL
, rc
));
5956 memcached_result_st
*result
= NULL
;
5957 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5959 test_compare(100, memcached_result_length(result
));
5963 test_true(count
> 100); // If we don't get back atleast this, something is up
5965 /* Release all allocated resources */
5966 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5974 memcached_free(clone
);
5976 return TEST_SUCCESS
;
5980 * Test that ensures that buffered set to not trigger problems during io_flush
5982 #define regression_bug_490520_COUNT 200480
5983 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5985 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5986 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5987 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5988 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5989 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5991 memc
->number_of_hosts
= 1;
5993 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5994 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5996 /* First add all of the items.. */
5997 char blob
[3333] = {0};
5998 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
6001 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
6005 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
6006 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
6009 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
6016 return TEST_SUCCESS
;
6019 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
6021 fprintf(stderr
, "Iteration #%u: ", it
);
6023 if(error
== MEMCACHED_ERRNO
)
6025 fprintf(stderr
, "system error %d from %s: %s\n",
6026 errno
, what
, strerror(errno
));
6030 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
6031 memcached_strerror(mc
, error
));
6035 #define TEST_CONSTANT_CREATION 200
6037 static test_return_t
regression_bug_(memcached_st
*memc
)
6039 const char *remote_server
;
6042 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
6044 return TEST_SKIPPED
;
6047 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
6049 memcached_st
* mc
= memcached_create(NULL
);
6050 memcached_return rc
;
6052 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
6053 if (rc
!= MEMCACHED_SUCCESS
)
6055 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6058 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
6059 if (rc
!= MEMCACHED_SUCCESS
)
6061 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6064 rc
= memcached_server_add(mc
, remote_server
, 0);
6065 if (rc
!= MEMCACHED_SUCCESS
)
6067 memcached_die(mc
, rc
, "memcached_server_add", x
);
6070 const char *set_key
= "akey";
6071 const size_t set_key_len
= strlen(set_key
);
6072 const char *set_value
= "a value";
6073 const size_t set_value_len
= strlen(set_value
);
6075 if (rc
== MEMCACHED_SUCCESS
)
6079 size_t get_value_len
;
6081 uint32_t get_value_flags
;
6083 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
6084 &get_value_flags
, &rc
);
6085 if (rc
!= MEMCACHED_SUCCESS
)
6087 memcached_die(mc
, rc
, "memcached_get", x
);
6093 (get_value_len
!= set_value_len
6094 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
6096 fprintf(stderr
, "Values don't match?\n");
6097 rc
= MEMCACHED_FAILURE
;
6103 rc
= memcached_set(mc
,
6104 set_key
, set_key_len
,
6105 set_value
, set_value_len
,
6109 if (rc
!= MEMCACHED_SUCCESS
)
6111 memcached_die(mc
, rc
, "memcached_set", x
);
6118 if (rc
!= MEMCACHED_SUCCESS
)
6124 return TEST_SUCCESS
;
6128 * Test that the sasl authentication works. We cannot use the default
6129 * pool of servers, because that would require that all servers we want
6130 * to test supports SASL authentication, and that they use the default
6133 static test_return_t
sasl_auth_test(memcached_st
*memc
)
6135 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
6136 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0));
6137 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
6138 test_compare(MEMCACHED_SUCCESS
, memcached_destroy_sasl_auth_data(memc
));
6139 test_compare(MEMCACHED_FAILURE
, memcached_destroy_sasl_auth_data(memc
));
6140 test_compare(MEMCACHED_FAILURE
, memcached_destroy_sasl_auth_data(NULL
));
6141 memcached_quit(memc
);
6143 test_compare(MEMCACHED_SUCCESS
,
6144 memcached_set_sasl_auth_data(memc
,
6145 getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
6146 getenv("LIBMEMCACHED_TEST_SASL_SERVER")));
6148 test_compare(MEMCACHED_AUTH_FAILURE
,
6149 memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0));
6150 test_compare(MEMCACHED_SUCCESS
, memcached_destroy_sasl_auth_data(memc
));
6152 memcached_quit(memc
);
6153 return TEST_SUCCESS
;
6156 return TEST_FAILURE
;
6160 /* Clean the server before beginning testing */
6162 {"util_version", 1, (test_callback_fn
*)util_version_test
},
6163 {"flush", 0, (test_callback_fn
*)flush_test
},
6164 {"init", 0, (test_callback_fn
*)init_test
},
6165 {"allocation", 0, (test_callback_fn
*)allocation_test
},
6166 {"server_list_null_test", 0, (test_callback_fn
*)server_list_null_test
},
6167 {"server_unsort", 0, (test_callback_fn
*)server_unsort_test
},
6168 {"server_sort", 0, (test_callback_fn
*)server_sort_test
},
6169 {"server_sort2", 0, (test_callback_fn
*)server_sort2_test
},
6170 {"memcached_server_remove", 0, (test_callback_fn
*)memcached_server_remove_test
},
6171 {"clone_test", 0, (test_callback_fn
*)clone_test
},
6172 {"connection_test", 0, (test_callback_fn
*)connection_test
},
6173 {"callback_test", 0, (test_callback_fn
*)callback_test
},
6174 {"userdata_test", 0, (test_callback_fn
*)userdata_test
},
6175 {"error", 0, (test_callback_fn
*)error_test
},
6176 {"set", 0, (test_callback_fn
*)set_test
},
6177 {"set2", 0, (test_callback_fn
*)set_test2
},
6178 {"set3", 0, (test_callback_fn
*)set_test3
},
6179 {"dump", 1, (test_callback_fn
*)dump_test
},
6180 {"add", 1, (test_callback_fn
*)add_test
},
6181 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", 1, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
6182 {"replace", 1, (test_callback_fn
*)replace_test
},
6183 {"delete", 1, (test_callback_fn
*)delete_test
},
6184 {"get", 1, (test_callback_fn
*)get_test
},
6185 {"get2", 0, (test_callback_fn
*)get_test2
},
6186 {"get3", 0, (test_callback_fn
*)get_test3
},
6187 {"get4", 0, (test_callback_fn
*)get_test4
},
6188 {"partial mget", 0, (test_callback_fn
*)get_test5
},
6189 {"stats_servername", 0, (test_callback_fn
*)stats_servername_test
},
6190 {"increment", 0, (test_callback_fn
*)increment_test
},
6191 {"increment_with_initial", 1, (test_callback_fn
*)increment_with_initial_test
},
6192 {"decrement", 0, (test_callback_fn
*)decrement_test
},
6193 {"decrement_with_initial", 1, (test_callback_fn
*)decrement_with_initial_test
},
6194 {"increment_by_key", 0, (test_callback_fn
*)increment_by_key_test
},
6195 {"increment_with_initial_by_key", 1, (test_callback_fn
*)increment_with_initial_by_key_test
},
6196 {"decrement_by_key", 0, (test_callback_fn
*)decrement_by_key_test
},
6197 {"decrement_with_initial_by_key", 1, (test_callback_fn
*)decrement_with_initial_by_key_test
},
6198 {"quit", 0, (test_callback_fn
*)quit_test
},
6199 {"mget", 1, (test_callback_fn
*)mget_test
},
6200 {"mget_result", 1, (test_callback_fn
*)mget_result_test
},
6201 {"mget_result_alloc", 1, (test_callback_fn
*)mget_result_alloc_test
},
6202 {"mget_result_function", 1, (test_callback_fn
*)mget_result_function
},
6203 {"mget_execute", 1, (test_callback_fn
*)mget_execute
},
6204 {"mget_end", 0, (test_callback_fn
*)mget_end
},
6205 {"get_stats", 0, (test_callback_fn
*)get_stats
},
6206 {"add_host_test", 0, (test_callback_fn
*)add_host_test
},
6207 {"add_host_test_1", 0, (test_callback_fn
*)add_host_test1
},
6208 {"get_stats_keys", 0, (test_callback_fn
*)get_stats_keys
},
6209 {"version_string_test", 0, (test_callback_fn
*)version_string_test
},
6210 {"bad_key", 1, (test_callback_fn
*)bad_key_test
},
6211 {"memcached_server_cursor", 1, (test_callback_fn
*)memcached_server_cursor_test
},
6212 {"read_through", 1, (test_callback_fn
*)read_through
},
6213 {"delete_through", 1, (test_callback_fn
*)delete_through
},
6214 {"noreply", 1, (test_callback_fn
*)noreply_test
},
6215 {"analyzer", 1, (test_callback_fn
*)analyzer_test
},
6216 {"connectionpool", 1, (test_callback_fn
*)connection_pool_test
},
6217 {"memcached_pool_test", 1, (test_callback_fn
*)memcached_pool_test
},
6218 {"ping", 1, (test_callback_fn
*)ping_test
},
6219 {"test_get_last_disconnect", 1, (test_callback_fn
*)test_get_last_disconnect
},
6220 {"verbosity", 1, (test_callback_fn
*)test_verbosity
},
6221 {"test_server_failure", 1, (test_callback_fn
*)test_server_failure
},
6222 {"cull_servers", 1, (test_callback_fn
*)test_cull_servers
},
6223 {"memcached_stat_execute", 1, (test_callback_fn
*)memcached_stat_execute_test
},
6227 test_st behavior_tests
[] ={
6228 {"libmemcached_string_behavior()", 0, (test_callback_fn
*)libmemcached_string_behavior_test
},
6229 {"libmemcached_string_distribution()", 0, (test_callback_fn
*)libmemcached_string_distribution_test
},
6230 {"behavior_test", 0, (test_callback_fn
*)behavior_test
},
6231 {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
6232 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
6233 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
6237 test_st basic_tests
[] ={
6238 {"init", 1, (test_callback_fn
*)basic_init_test
},
6239 {"clone", 1, (test_callback_fn
*)basic_clone_test
},
6240 {"reset", 1, (test_callback_fn
*)basic_reset_stack_test
},
6241 {"reset heap", 1, (test_callback_fn
*)basic_reset_heap_test
},
6242 {"reset stack clone", 1, (test_callback_fn
*)basic_reset_stack_clone_test
},
6243 {"reset heap clone", 1, (test_callback_fn
*)basic_reset_heap_clone_test
},
6247 test_st regression_binary_vs_block
[] ={
6248 {"block add", 1, (test_callback_fn
*)block_add_regression
},
6249 {"binary add", 1, (test_callback_fn
*)binary_add_regression
},
6253 test_st async_tests
[] ={
6254 {"add", 1, (test_callback_fn
*)add_wrapper
},
6258 test_st string_tests
[] ={
6259 {"string static with null", 0, (test_callback_fn
*)string_static_null
},
6260 {"string alloc with null", 0, (test_callback_fn
*)string_alloc_null
},
6261 {"string alloc with 1K", 0, (test_callback_fn
*)string_alloc_with_size
},
6262 {"string alloc with malloc failure", 0, (test_callback_fn
*)string_alloc_with_size_toobig
},
6263 {"string append", 0, (test_callback_fn
*)string_alloc_append
},
6264 {"string append failure (too big)", 0, (test_callback_fn
*)string_alloc_append_toobig
},
6265 {"string_alloc_append_multiple", 0, (test_callback_fn
*)string_alloc_append_multiple
},
6266 {0, 0, (test_callback_fn
*)0}
6269 test_st memcached_server_get_last_disconnect_tests
[] ={
6270 {"memcached_server_get_last_disconnect()", 0, (test_callback_fn
*)test_multiple_get_last_disconnect
},
6271 {0, 0, (test_callback_fn
*)0}
6275 test_st result_tests
[] ={
6276 {"result static", 0, (test_callback_fn
*)result_static
},
6277 {"result alloc", 0, (test_callback_fn
*)result_alloc
},
6278 {0, 0, (test_callback_fn
*)0}
6281 test_st version_1_2_3
[] ={
6282 {"append", 0, (test_callback_fn
*)append_test
},
6283 {"prepend", 0, (test_callback_fn
*)prepend_test
},
6284 {"cas", 0, (test_callback_fn
*)cas_test
},
6285 {"cas2", 0, (test_callback_fn
*)cas2_test
},
6286 {"append_binary", 0, (test_callback_fn
*)append_binary_test
},
6287 {0, 0, (test_callback_fn
*)0}
6290 test_st haldenbrand_tests
[] ={
6291 {"memcached_set", 0, (test_callback_fn
*)user_supplied_bug1
},
6292 {"memcached_get()", 0, (test_callback_fn
*)user_supplied_bug2
},
6293 {"memcached_mget()", 0, (test_callback_fn
*)user_supplied_bug3
},
6294 {0, 0, (test_callback_fn
*)0}
6297 test_st user_tests
[] ={
6298 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
6299 {"user_supplied_bug5", 1, (test_callback_fn
*)user_supplied_bug5
},
6300 {"user_supplied_bug6", 1, (test_callback_fn
*)user_supplied_bug6
},
6301 {"user_supplied_bug7", 1, (test_callback_fn
*)user_supplied_bug7
},
6302 {"user_supplied_bug8", 1, (test_callback_fn
*)user_supplied_bug8
},
6303 {"user_supplied_bug9", 1, (test_callback_fn
*)user_supplied_bug9
},
6304 {"user_supplied_bug10", 1, (test_callback_fn
*)user_supplied_bug10
},
6305 {"user_supplied_bug11", 1, (test_callback_fn
*)user_supplied_bug11
},
6306 {"user_supplied_bug12", 1, (test_callback_fn
*)user_supplied_bug12
},
6307 {"user_supplied_bug13", 1, (test_callback_fn
*)user_supplied_bug13
},
6308 {"user_supplied_bug14", 1, (test_callback_fn
*)user_supplied_bug14
},
6309 {"user_supplied_bug15", 1, (test_callback_fn
*)user_supplied_bug15
},
6310 {"user_supplied_bug16", 1, (test_callback_fn
*)user_supplied_bug16
},
6311 #if !defined(__sun) && !defined(__OpenBSD__)
6313 ** It seems to be something weird with the character sets..
6314 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6315 ** guess I need to find out how this is supposed to work.. Perhaps I need
6316 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6317 ** so just disable the code for now...).
6319 {"user_supplied_bug17", 1, (test_callback_fn
*)user_supplied_bug17
},
6321 {"user_supplied_bug18", 1, (test_callback_fn
*)user_supplied_bug18
},
6322 {"user_supplied_bug19", 1, (test_callback_fn
*)user_supplied_bug19
},
6323 {"user_supplied_bug20", 1, (test_callback_fn
*)user_supplied_bug20
},
6324 {"user_supplied_bug21", 1, (test_callback_fn
*)user_supplied_bug21
},
6325 {"wrong_failure_counter_test", 1, (test_callback_fn
*)wrong_failure_counter_test
},
6326 {"wrong_failure_counter_two_test", 1, (test_callback_fn
*)wrong_failure_counter_two_test
},
6327 {0, 0, (test_callback_fn
*)0}
6330 test_st replication_tests
[]= {
6331 {"set", 1, (test_callback_fn
*)replication_set_test
},
6332 {"get", 0, (test_callback_fn
*)replication_get_test
},
6333 {"mget", 0, (test_callback_fn
*)replication_mget_test
},
6334 {"delete", 0, (test_callback_fn
*)replication_delete_test
},
6335 {"rand_mget", 0, (test_callback_fn
*)replication_randomize_mget_test
},
6336 {"fail", 0, (test_callback_fn
*)replication_randomize_mget_fail_test
},
6337 {0, 0, (test_callback_fn
*)0}
6341 * The following test suite is used to verify that we don't introduce
6342 * regression bugs. If you want more information about the bug / test,
6343 * you should look in the bug report at
6344 * http://bugs.launchpad.net/libmemcached
6346 test_st regression_tests
[]= {
6347 {"lp:434484", 1, (test_callback_fn
*)regression_bug_434484
},
6348 {"lp:434843", 1, (test_callback_fn
*)regression_bug_434843
},
6349 {"lp:434843-buffered", 1, (test_callback_fn
*)regression_bug_434843_buffered
},
6350 {"lp:421108", 1, (test_callback_fn
*)regression_bug_421108
},
6351 {"lp:442914", 1, (test_callback_fn
*)regression_bug_442914
},
6352 {"lp:447342", 1, (test_callback_fn
*)regression_bug_447342
},
6353 {"lp:463297", 1, (test_callback_fn
*)regression_bug_463297
},
6354 {"lp:490486", 1, (test_callback_fn
*)regression_bug_490486
},
6355 {"lp:583031", 1, (test_callback_fn
*)regression_bug_583031
},
6356 {"lp:?", 1, (test_callback_fn
*)regression_bug_
},
6357 {"lp:728286", 1, (test_callback_fn
*)regression_bug_728286
},
6358 {"lp:581030", 1, (test_callback_fn
*)regression_bug_581030
},
6359 {"lp:71231153 connect()", 1, (test_callback_fn
*)regression_bug_71231153_connect
},
6360 {"lp:71231153 poll()", 1, (test_callback_fn
*)regression_bug_71231153_poll
},
6361 {"lp:655423", 1, (test_callback_fn
*)regression_bug_655423
},
6362 {"lp:490520", 1, (test_callback_fn
*)regression_bug_490520
},
6363 {0, 0, (test_callback_fn
*)0}
6366 test_st sasl_auth_tests
[]= {
6367 {"sasl_auth", 1, (test_callback_fn
*)sasl_auth_test
},
6368 {0, 0, (test_callback_fn
*)0}
6371 test_st ketama_compatibility
[]= {
6372 {"libmemcached", 1, (test_callback_fn
*)ketama_compatibility_libmemcached
},
6373 {"spymemcached", 1, (test_callback_fn
*)ketama_compatibility_spymemcached
},
6374 {0, 0, (test_callback_fn
*)0}
6377 test_st generate_tests
[] ={
6378 {"generate_pairs", 1, (test_callback_fn
*)generate_pairs
},
6379 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6380 {"get_read", 0, (test_callback_fn
*)get_read
},
6381 {"delete_generate", 0, (test_callback_fn
*)delete_generate
},
6382 {"generate_buffer_data", 1, (test_callback_fn
*)generate_buffer_data
},
6383 {"delete_buffer", 0, (test_callback_fn
*)delete_buffer_generate
},
6384 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6385 {"mget_read", 0, (test_callback_fn
*)mget_read
},
6386 {"mget_read_result", 0, (test_callback_fn
*)mget_read_result
},
6387 {"memcached_fetch_result() use internal result", 0, (test_callback_fn
*)mget_read_internal_result
},
6388 {"memcached_fetch_result() partial read", 0, (test_callback_fn
*)mget_read_partial_result
},
6389 {"mget_read_function", 0, (test_callback_fn
*)mget_read_function
},
6390 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6391 {"generate_large_pairs", 1, (test_callback_fn
*)generate_large_pairs
},
6392 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6393 {"generate_buffer_data", 1, (test_callback_fn
*)generate_buffer_data
},
6394 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6395 {0, 0, (test_callback_fn
*)0}
6398 test_st consistent_tests
[] ={
6399 {"generate_pairs", 1, (test_callback_fn
*)generate_pairs
},
6400 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6401 {"get_read", 0, (test_callback_fn
*)get_read_count
},
6402 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6403 {0, 0, (test_callback_fn
*)0}
6406 test_st consistent_weighted_tests
[] ={
6407 {"generate_pairs", 1, (test_callback_fn
*)generate_pairs
},
6408 {"generate_data", 1, (test_callback_fn
*)generate_data_with_stats
},
6409 {"get_read", 0, (test_callback_fn
*)get_read_count
},
6410 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6411 {0, 0, (test_callback_fn
*)0}
6414 test_st hsieh_availability
[] ={
6415 {"hsieh_avaibility_test", 0, (test_callback_fn
*)hsieh_avaibility_test
},
6416 {0, 0, (test_callback_fn
*)0}
6419 test_st murmur_availability
[] ={
6420 {"murmur_avaibility_test", 0, (test_callback_fn
*)murmur_avaibility_test
},
6421 {0, 0, (test_callback_fn
*)0}
6425 test_st hash_sanity
[] ={
6426 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
6427 {0, 0, (test_callback_fn
*)0}
6431 test_st ketama_auto_eject_hosts
[] ={
6432 {"auto_eject_hosts", 1, (test_callback_fn
*)auto_eject_hosts
},
6433 {"output_ketama_weighted_keys", 1, (test_callback_fn
*)output_ketama_weighted_keys
},
6434 {0, 0, (test_callback_fn
*)0}
6437 test_st hash_tests
[] ={
6438 {"one_at_a_time_run", 0, (test_callback_fn
*)one_at_a_time_run
},
6439 {"md5", 0, (test_callback_fn
*)md5_run
},
6440 {"crc", 0, (test_callback_fn
*)crc_run
},
6441 {"fnv1_64", 0, (test_callback_fn
*)fnv1_64_run
},
6442 {"fnv1a_64", 0, (test_callback_fn
*)fnv1a_64_run
},
6443 {"fnv1_32", 0, (test_callback_fn
*)fnv1_32_run
},
6444 {"fnv1a_32", 0, (test_callback_fn
*)fnv1a_32_run
},
6445 {"hsieh", 0, (test_callback_fn
*)hsieh_run
},
6446 {"murmur", 0, (test_callback_fn
*)murmur_run
},
6447 {"jenkis", 0, (test_callback_fn
*)jenkins_run
},
6448 {"memcached_get_hashkit", 0, (test_callback_fn
*)memcached_get_hashkit_test
},
6449 {0, 0, (test_callback_fn
*)0}
6452 test_st error_conditions
[] ={
6453 {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
6454 {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
6455 {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
6456 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6457 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6458 {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
6459 {0, 0, (test_callback_fn
*)0}
6463 test_st parser_tests
[] ={
6464 {"behavior", 0, (test_callback_fn
*)behavior_parser_test
},
6465 {"boolean_options", 0, (test_callback_fn
*)parser_boolean_options_test
},
6466 {"configure_file", 0, (test_callback_fn
*)memcached_create_with_options_with_filename
},
6467 {"distribtions", 0, (test_callback_fn
*)parser_distribution_test
},
6468 {"hash", 0, (test_callback_fn
*)parser_hash_test
},
6469 {"libmemcached_check_configuration", 0, (test_callback_fn
*)libmemcached_check_configuration_test
},
6470 {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
6471 {"number_options", 0, (test_callback_fn
*)parser_number_options_test
},
6472 {"randomly generated options", 0, (test_callback_fn
*)random_statement_build_test
},
6473 {"prefix_key", 0, (test_callback_fn
*)parser_key_prefix_test
},
6474 {"server", 0, (test_callback_fn
*)server_test
},
6475 {"bad server strings", 0, (test_callback_fn
*)servers_bad_test
},
6476 {"server with weights", 0, (test_callback_fn
*)server_with_weight_test
},
6477 {"parsing servername, port, and weight", 0, (test_callback_fn
*)test_hostname_port_weight
},
6478 {0, 0, (test_callback_fn
*)0}
6481 test_st virtual_bucket_tests
[] ={
6482 {"basic", 0, (test_callback_fn
*)virtual_back_map
},
6483 {0, 0, (test_callback_fn
*)0}
6486 test_st namespace_tests
[] ={
6487 {"basic tests", 0, (test_callback_fn
*)selection_of_namespace_tests
},
6489 {"increment", 0, (test_callback_fn
*)memcached_increment_namespace
},
6491 {0, 0, (test_callback_fn
*)0}
6494 collection_st collection
[] ={
6496 {"hash_sanity", 0, 0, hash_sanity
},
6498 {"basic", 0, 0, basic_tests
},
6499 {"hsieh_availability", 0, 0, hsieh_availability
},
6500 {"murmur_availability", 0, 0, murmur_availability
},
6501 {"block", 0, 0, tests
},
6502 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
6503 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
6504 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6505 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
6506 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
6507 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
6508 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
6509 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
6510 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
6511 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
6512 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
6513 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
6514 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
6515 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6516 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
6517 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6518 {"poll_timeout", (test_callback_fn
*)poll_timeout
, 0, tests
},
6519 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
6520 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
6521 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
6522 #ifdef MEMCACHED_ENABLE_DEPRECATED
6523 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
6525 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
6526 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
6527 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
6528 {"specific namespace", 0, 0, namespace_tests
},
6529 {"sasl_auth", (test_callback_fn
*)pre_sasl
, 0, sasl_auth_tests
},
6530 {"sasl", (test_callback_fn
*)pre_sasl
, 0, tests
},
6531 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
6532 {"string", 0, 0, string_tests
},
6533 {"result", 0, 0, result_tests
},
6534 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
6535 {"async_binary", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
6536 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
6537 {"user", 0, 0, user_tests
},
6538 {"generate", 0, 0, generate_tests
},
6539 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
6540 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
6541 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
6542 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
6543 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
6544 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
6545 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
6547 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
6548 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
6549 {"consistent_not", 0, 0, consistent_tests
},
6550 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
6551 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6552 {"ketama_compat", 0, 0, ketama_compatibility
},
6553 {"test_hashes", 0, 0, hash_tests
},
6554 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6555 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6556 {"regression", 0, 0, regression_tests
},
6557 {"behaviors", 0, 0, behavior_tests
},
6558 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6559 {"error_conditions", 0, 0, error_conditions
},
6560 {"parser", 0, 0, parser_tests
},
6561 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6562 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6566 #include "tests/libmemcached_world.h"
6568 void get_world(Framework
*world
)
6570 world
->collections
= collection
;
6572 world
->_create
= (test_callback_create_fn
*)world_create
;
6573 world
->_destroy
= (test_callback_fn
*)world_destroy
;
6575 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6576 world
->item
._flush
= (test_callback_fn
*)world_flush
;
6577 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6578 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6579 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6581 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6582 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6584 world
->runner
= &defualt_libmemcached_runner
;