1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 #include <libtest/test.hpp>
45 #define BUILDING_LIBMEMCACHED
46 // !NEVER use common.h, always use memcached.h in your own apps
47 #include <libmemcached/common.h>
54 #include <sys/types.h>
59 #include <libtest/server.h>
61 #include "clients/generator.h"
62 #include "clients/execute.h"
64 #define SMALL_STRING_LEN 1024
66 #include <libtest/test.hpp>
67 #include "tests/deprecated.h"
68 #include "tests/parser.h"
69 #include "tests/pool.h"
70 #include "tests/namespace.h"
71 #include "tests/string.h"
72 #include "tests/replication.h"
73 #include "tests/debug.h"
74 #include "tests/basic.h"
75 #include "tests/error_conditions.h"
76 #include "tests/print.h"
77 #include "tests/virtual_buckets.h"
79 using namespace libtest
;
81 #ifdef HAVE_LIBMEMCACHEDUTIL
83 #include "libmemcached/memcached_util.h"
86 #include "hash_results.h"
88 #define GLOBAL_COUNT 10000
89 #define GLOBAL2_COUNT 100
90 #define SERVERS_TO_CREATE 5
91 static uint32_t global_count
;
93 static pairs_st
*global_pairs
;
94 static const char *global_keys
[GLOBAL_COUNT
];
95 static size_t global_keys_length
[GLOBAL_COUNT
];
98 static test_return_t
pre_binary(memcached_st
*memc
);
101 static test_return_t
init_test(memcached_st
*not_used
)
106 (void)memcached_create(&memc
);
107 memcached_free(&memc
);
112 #define TEST_PORT_COUNT 7
113 in_port_t test_ports
[TEST_PORT_COUNT
];
115 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
116 const memcached_server_st
*server
,
120 size_t bigger
= *((size_t *)(context
));
122 assert(bigger
<= memcached_server_port(server
));
123 *((size_t *)(context
))= memcached_server_port(server
);
125 return MEMCACHED_SUCCESS
;
128 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
129 const memcached_server_st
*instance
,
133 FILE *stream
= (FILE *)context
;
136 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
137 memcached_server_name(instance
),
138 memcached_server_port(instance
),
139 instance
->major_version
,
140 instance
->minor_version
,
141 instance
->micro_version
);
143 return MEMCACHED_SUCCESS
;
146 static test_return_t
server_sort_test(memcached_st
*ptr
)
148 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
150 memcached_return_t rc
;
151 memcached_server_fn callbacks
[1];
152 memcached_st
*local_memc
;
155 local_memc
= memcached_create(NULL
);
156 test_true(local_memc
);
157 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
159 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
161 test_ports
[x
]= (in_port_t
)random() % 64000;
162 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
163 test_compare(memcached_server_count(local_memc
), x
+1);
165 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
167 test_compare(MEMCACHED_SUCCESS
, rc
);
170 callbacks
[0]= server_display_function
;
171 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
174 memcached_free(local_memc
);
179 static test_return_t
server_sort2_test(memcached_st
*ptr
)
181 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
182 memcached_server_fn callbacks
[1];
183 memcached_st
*local_memc
;
184 memcached_server_instance_st instance
;
187 local_memc
= memcached_create(NULL
);
188 test_true(local_memc
);
189 test_compare(MEMCACHED_SUCCESS
,
190 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
192 test_compare(MEMCACHED_SUCCESS
,
193 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
194 instance
= memcached_server_instance_by_position(local_memc
, 0);
195 test_compare(in_port_t(43043), memcached_server_port(instance
));
197 test_compare(MEMCACHED_SUCCESS
,
198 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
200 instance
= memcached_server_instance_by_position(local_memc
, 0);
201 test_compare(in_port_t(43042), memcached_server_port(instance
));
203 instance
= memcached_server_instance_by_position(local_memc
, 1);
204 test_compare(in_port_t(43043), memcached_server_port(instance
));
206 callbacks
[0]= server_display_function
;
207 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
210 memcached_free(local_memc
);
215 static test_return_t
memcached_server_remove_test(memcached_st
*)
217 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";
220 test_compare(MEMCACHED_SUCCESS
,
221 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
222 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
225 memcached_server_fn callbacks
[1];
226 callbacks
[0]= server_print_callback
;
227 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
229 memcached_free(memc
);
234 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
235 const memcached_server_st
*server
,
239 uint32_t x
= *((uint32_t *)(context
));
241 if (! (test_ports
[x
] == server
->port
))
243 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
244 return MEMCACHED_FAILURE
;
247 *((uint32_t *)(context
))= ++x
;
249 return MEMCACHED_SUCCESS
;
252 static test_return_t
server_unsort_test(memcached_st
*ptr
)
254 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
255 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
256 memcached_server_fn callbacks
[1];
257 memcached_st
*local_memc
;
260 local_memc
= memcached_create(NULL
);
261 test_true(local_memc
);
263 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
265 test_ports
[x
]= (in_port_t
)(random() % 64000);
266 test_compare(MEMCACHED_SUCCESS
,
267 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
268 test_compare(memcached_server_count(local_memc
), x
+1);
270 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
274 callbacks
[0]= server_display_unsort_function
;
275 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
277 /* Now we sort old data! */
278 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
279 callbacks
[0]= server_display_function
;
280 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
283 memcached_free(local_memc
);
288 static test_return_t
allocation_test(memcached_st
*not_used
)
292 memc
= memcached_create(NULL
);
294 memcached_free(memc
);
299 static test_return_t
clone_test(memcached_st
*memc
)
303 memcached_st
*memc_clone
;
304 memc_clone
= memcached_clone(NULL
, NULL
);
305 test_true(memc_clone
);
306 memcached_free(memc_clone
);
309 /* Can we init from null? */
311 memcached_st
*memc_clone
;
312 memc_clone
= memcached_clone(NULL
, memc
);
313 test_true(memc_clone
);
316 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
317 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
318 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
319 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
322 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
323 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
324 test_true(memc_clone
->distribution
== memc
->distribution
);
325 { // Test all of the flags
326 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
327 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
328 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
329 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
330 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
331 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
332 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
333 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
334 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
335 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
336 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
337 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
338 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
340 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
341 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
342 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
343 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
344 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
345 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
346 test_true(memc_clone
->on_clone
== memc
->on_clone
);
347 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
348 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
349 test_true(memc_clone
->recv_size
== memc
->recv_size
);
350 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
351 test_true(memc_clone
->send_size
== memc
->send_size
);
352 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
353 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
354 test_true(memc_clone
->user_data
== memc
->user_data
);
356 memcached_free(memc_clone
);
359 /* Can we init from struct? */
361 memcached_st declared_clone
;
362 memcached_st
*memc_clone
;
363 memset(&declared_clone
, 0 , sizeof(memcached_st
));
364 memc_clone
= memcached_clone(&declared_clone
, NULL
);
365 test_true(memc_clone
);
366 memcached_free(memc_clone
);
369 /* Can we init from struct? */
371 memcached_st declared_clone
;
372 memcached_st
*memc_clone
;
373 memset(&declared_clone
, 0 , sizeof(memcached_st
));
374 memc_clone
= memcached_clone(&declared_clone
, memc
);
375 test_true(memc_clone
);
376 memcached_free(memc_clone
);
382 static test_return_t
userdata_test(memcached_st
*memc
)
385 test_false(memcached_set_user_data(memc
, foo
));
386 test_true(memcached_get_user_data(memc
) == foo
);
387 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
392 static test_return_t
connection_test(memcached_st
*memc
)
394 test_compare(MEMCACHED_SUCCESS
,
395 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
400 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
402 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
404 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
406 test_compare(36, int(MEMCACHED_BEHAVIOR_MAX
));
411 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
413 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
415 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
417 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
422 static test_return_t
error_test(memcached_st
*memc
)
424 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
425 982370485U, 1263635348U, 4242906218U, 3829656100U,
426 1891735253U, 334139633U, 2257084983U, 3088286104U,
427 13199785U, 2542027183U, 1097051614U, 199566778U,
428 2748246961U, 2465192557U, 1664094137U, 2405439045U,
429 1842224848U, 692413798U, 3479807801U, 919913813U,
430 4269430871U, 610793021U, 527273862U, 1437122909U,
431 2300930706U, 2943759320U, 674306647U, 2400528935U,
432 54481931U, 4186304426U, 1741088401U, 2979625118U,
433 4159057246U, 3425930182U, 2593724503U, 1868899624U,
434 1769812374U, 2302537950U, 1110330676U, 3365377466U,
435 1336171666U, 3021258493U, 2334992265U, 3365377466U };
437 // You have updated the memcache_error messages but not updated docs/tests.
438 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
441 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
442 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
443 MEMCACHED_HASH_JENKINS
);
444 if (values
[rc
] != hash_val
)
446 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the error_test\n");
447 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
449 test_compare(values
[rc
], hash_val
);
451 test_compare(47, int(MEMCACHED_MAXIMUM_RETURN
));
456 static test_return_t
set_test(memcached_st
*memc
)
458 memcached_return_t rc
= memcached_set(memc
,
459 test_literal_param("foo"),
460 test_literal_param("when we sanitize"),
461 time_t(0), (uint32_t)0);
462 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
467 static test_return_t
append_test(memcached_st
*memc
)
469 memcached_return_t rc
;
470 const char *key
= "fig";
471 const char *in_value
= "we";
472 char *out_value
= NULL
;
476 rc
= memcached_flush(memc
, 0);
477 test_compare(MEMCACHED_SUCCESS
, rc
);
479 rc
= memcached_set(memc
, key
, strlen(key
),
480 in_value
, strlen(in_value
),
481 (time_t)0, (uint32_t)0);
482 test_compare(MEMCACHED_SUCCESS
, rc
);
484 rc
= memcached_append(memc
, key
, strlen(key
),
485 " the", strlen(" the"),
486 (time_t)0, (uint32_t)0);
487 test_compare(MEMCACHED_SUCCESS
, rc
);
489 rc
= memcached_append(memc
, key
, strlen(key
),
490 " people", strlen(" people"),
491 (time_t)0, (uint32_t)0);
492 test_compare(MEMCACHED_SUCCESS
, rc
);
494 out_value
= memcached_get(memc
, key
, strlen(key
),
495 &value_length
, &flags
, &rc
);
496 test_memcmp(out_value
, "we the people", strlen("we the people"));
497 test_compare(strlen("we the people"), value_length
);
498 test_compare(MEMCACHED_SUCCESS
, rc
);
504 static test_return_t
append_binary_test(memcached_st
*memc
)
506 memcached_return_t rc
;
507 const char *key
= "numbers";
508 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
514 rc
= memcached_flush(memc
, 0);
515 test_compare(MEMCACHED_SUCCESS
, rc
);
517 rc
= memcached_set(memc
,
520 (time_t)0, (uint32_t)0);
521 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
523 for (x
= 0; store_list
[x
] ; x
++)
525 rc
= memcached_append(memc
,
527 (char *)&store_list
[x
], sizeof(uint32_t),
528 (time_t)0, (uint32_t)0);
529 test_compare(MEMCACHED_SUCCESS
, rc
);
532 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
533 &value_length
, &flags
, &rc
);
534 test_compare(value_length
, sizeof(uint32_t) * x
);
535 test_compare(MEMCACHED_SUCCESS
, rc
);
537 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
539 test_compare(*ptr
, store_list
[x
- counter
]);
547 static test_return_t
cas2_test(memcached_st
*memc
)
549 memcached_return_t rc
;
550 const char *keys
[]= {"fudge", "son", "food"};
551 size_t key_length
[]= {5, 3, 4};
552 const char *value
= "we the people";
553 size_t value_length
= strlen("we the people");
554 memcached_result_st results_obj
;
555 memcached_result_st
*results
;
558 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
560 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
562 for (uint32_t x
= 0; x
< 3; x
++)
564 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
565 keys
[x
], key_length
[x
],
566 (time_t)50, (uint32_t)9);
567 test_compare(MEMCACHED_SUCCESS
, rc
);
570 rc
= memcached_mget(memc
, keys
, key_length
, 3);
572 results
= memcached_result_create(memc
, &results_obj
);
574 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
576 test_true(results
->item_cas
);
577 test_compare(MEMCACHED_SUCCESS
, rc
);
578 test_true(memcached_result_cas(results
));
580 test_memcmp(value
, "we the people", strlen("we the people"));
581 test_compare(strlen("we the people"), value_length
);
582 test_compare(MEMCACHED_SUCCESS
, rc
);
584 memcached_result_free(&results_obj
);
589 static test_return_t
cas_test(memcached_st
*memc
)
591 memcached_return_t rc
;
592 const char *key
= "fun";
593 size_t key_length
= strlen(key
);
594 const char *value
= "we the people";
595 const char* keys
[2] = { key
, NULL
};
596 size_t keylengths
[2] = { strlen(key
), 0 };
597 size_t value_length
= strlen(value
);
598 const char *value2
= "change the value";
599 size_t value2_length
= strlen(value2
);
601 memcached_result_st results_obj
;
602 memcached_result_st
*results
;
605 rc
= memcached_flush(memc
, 0);
606 test_compare(MEMCACHED_SUCCESS
, rc
);
608 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
610 rc
= memcached_set(memc
, key
, strlen(key
),
611 value
, strlen(value
),
612 (time_t)0, (uint32_t)0);
613 test_compare(MEMCACHED_SUCCESS
, rc
);
615 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
617 results
= memcached_result_create(memc
, &results_obj
);
619 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
621 test_compare(MEMCACHED_SUCCESS
, rc
);
622 test_true(memcached_result_cas(results
));
623 test_memcmp(value
, memcached_result_value(results
), value_length
);
624 test_compare(strlen(memcached_result_value(results
)), value_length
);
625 test_compare(MEMCACHED_SUCCESS
, rc
);
626 uint64_t cas
= memcached_result_cas(results
);
629 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
630 test_true(rc
== MEMCACHED_END
);
631 test_true(results
== NULL
);
634 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
635 test_compare(MEMCACHED_SUCCESS
, rc
);
638 * The item will have a new cas value, so try to set it again with the old
639 * value. This should fail!
641 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
642 test_compare(MEMCACHED_DATA_EXISTS
, rc
);
644 memcached_result_free(&results_obj
);
649 static test_return_t
prepend_test(memcached_st
*memc
)
651 memcached_return_t rc
;
652 const char *key
= "fig";
653 const char *value
= "people";
654 char *out_value
= NULL
;
658 rc
= memcached_flush(memc
, 0);
659 test_compare(MEMCACHED_SUCCESS
, rc
);
661 rc
= memcached_set(memc
, key
, strlen(key
),
662 value
, strlen(value
),
663 (time_t)0, (uint32_t)0);
664 test_compare(MEMCACHED_SUCCESS
, rc
);
666 rc
= memcached_prepend(memc
, key
, strlen(key
),
667 "the ", strlen("the "),
668 (time_t)0, (uint32_t)0);
669 test_compare(MEMCACHED_SUCCESS
, rc
);
671 rc
= memcached_prepend(memc
, key
, strlen(key
),
672 "we ", strlen("we "),
673 (time_t)0, (uint32_t)0);
674 test_compare(MEMCACHED_SUCCESS
, rc
);
676 out_value
= memcached_get(memc
, key
, strlen(key
),
677 &value_length
, &flags
, &rc
);
678 test_memcmp(out_value
, "we the people", strlen("we the people"));
679 test_compare(strlen("we the people"), value_length
);
680 test_compare(MEMCACHED_SUCCESS
, rc
);
687 Set the value, then quit to make sure it is flushed.
688 Come back in and test that add fails.
690 static test_return_t
add_test(memcached_st
*memc
)
692 memcached_return_t rc
;
693 const char *key
= "foo";
694 const char *value
= "when we sanitize";
695 unsigned long long setting_value
;
697 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
699 rc
= memcached_set(memc
, key
, strlen(key
),
700 value
, strlen(value
),
701 (time_t)0, (uint32_t)0);
702 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
703 memcached_quit(memc
);
704 rc
= memcached_add(memc
, key
, strlen(key
),
705 value
, strlen(value
),
706 (time_t)0, (uint32_t)0);
708 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
711 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
715 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
722 ** There was a problem of leaking filedescriptors in the initial release
723 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
724 ** systems it seems that the kernel is slow on reclaiming the resources
725 ** because the connects starts to time out (the test doesn't do much
726 ** anyway, so just loop 10 iterations)
728 static test_return_t
add_wrapper(memcached_st
*memc
)
730 unsigned int max
= 10000;
738 for (uint32_t x
= 0; x
< max
; x
++)
744 static test_return_t
replace_test(memcached_st
*memc
)
746 memcached_return_t rc
;
747 const char *key
= "foo";
748 const char *value
= "when we sanitize";
749 const char *original
= "first we insert some data";
751 rc
= memcached_set(memc
, key
, strlen(key
),
752 original
, strlen(original
),
753 (time_t)0, (uint32_t)0);
754 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
756 test_compare(MEMCACHED_SUCCESS
,
757 memcached_replace(memc
, key
, strlen(key
),
758 value
, strlen(value
),
759 (time_t)0, (uint32_t)0));
764 static test_return_t
delete_test(memcached_st
*memc
)
766 memcached_return_t rc
;
767 const char *key
= "foo";
768 const char *value
= "when we sanitize";
770 rc
= memcached_set(memc
, key
, strlen(key
),
771 value
, strlen(value
),
772 (time_t)0, (uint32_t)0);
773 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
775 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
776 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
781 static test_return_t
flush_test(memcached_st
*memc
)
783 uint64_t query_id
= memcached_query_id(memc
);
784 test_compare(MEMCACHED_SUCCESS
,
785 memcached_flush(memc
, 0));
786 test_compare(query_id
+1, memcached_query_id(memc
));
791 static memcached_return_t
server_function(const memcached_st
*ptr
,
792 const memcached_server_st
*server
,
795 (void)ptr
; (void)server
; (void)context
;
798 return MEMCACHED_SUCCESS
;
801 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
804 strncpy(context
, "foo bad", sizeof(context
));
805 memcached_server_fn callbacks
[1];
807 callbacks
[0]= server_function
;
808 memcached_server_cursor(memc
, callbacks
, context
, 1);
812 static test_return_t
bad_key_test(memcached_st
*memc
)
814 memcached_return_t rc
;
815 const char *key
= "foo bad";
817 size_t string_length
;
819 memcached_st
*memc_clone
;
821 size_t max_keylen
= 0xffff;
823 // Just skip if we are in binary mode.
824 uint64_t query_id
= memcached_query_id(memc
);
825 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
827 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
829 memc_clone
= memcached_clone(NULL
, memc
);
830 test_true(memc_clone
);
832 query_id
= memcached_query_id(memc_clone
);
833 test_compare(MEMCACHED_SUCCESS
,
834 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
835 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
837 /* All keys are valid in the binary protocol (except for length) */
838 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
840 query_id
= memcached_query_id(memc_clone
);
841 string
= memcached_get(memc_clone
, key
, strlen(key
),
842 &string_length
, &flags
, &rc
);
843 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
844 test_zero(string_length
);
848 query_id
= memcached_query_id(memc_clone
);
849 test_compare(MEMCACHED_SUCCESS
,
850 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
851 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
852 string
= memcached_get(memc_clone
, key
, strlen(key
),
853 &string_length
, &flags
, &rc
);
854 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
855 test_zero(string_length
);
858 /* Test multi key for bad keys */
859 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
860 size_t key_lengths
[] = { 7, 7, 7 };
862 query_id
= memcached_query_id(memc_clone
);
863 test_compare(MEMCACHED_SUCCESS
,
864 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
865 test_compare(query_id
, memcached_query_id(memc_clone
));
867 query_id
= memcached_query_id(memc_clone
);
868 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
869 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
870 test_compare(query_id
+1, memcached_query_id(memc_clone
));
872 query_id
= memcached_query_id(memc_clone
);
873 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
874 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
875 test_compare(query_id
+1, memcached_query_id(memc_clone
));
879 /* The following test should be moved to the end of this function when the
880 memcached server is updated to allow max size length of the keys in the
883 test_compare(MEMCACHED_SUCCESS
,
884 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
886 char *longkey
= (char *)malloc(max_keylen
+ 1);
889 memset(longkey
, 'a', max_keylen
+ 1);
890 string
= memcached_get(memc_clone
, longkey
, max_keylen
,
891 &string_length
, &flags
, &rc
);
892 test_compare(MEMCACHED_NOTFOUND
, rc
);
893 test_zero(string_length
);
896 string
= memcached_get(memc_clone
, longkey
, max_keylen
+ 1,
897 &string_length
, &flags
, &rc
);
898 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
899 test_zero(string_length
);
906 /* Make sure zero length keys are marked as bad */
908 test_compare(MEMCACHED_SUCCESS
,
909 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
910 string
= memcached_get(memc_clone
, key
, 0,
911 &string_length
, &flags
, &rc
);
912 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
913 test_zero(string_length
);
916 memcached_free(memc_clone
);
921 #define READ_THROUGH_VALUE "set for me"
922 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
925 memcached_result_st
*result
)
927 (void)memc
;(void)key
;(void)key_length
;
928 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
931 #ifndef __INTEL_COMPILER
932 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
935 static test_return_t
read_through(memcached_st
*memc
)
937 memcached_return_t rc
;
938 const char *key
= "foo";
940 size_t string_length
;
942 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
944 string
= memcached_get(memc
, key
, strlen(key
),
945 &string_length
, &flags
, &rc
);
947 test_compare(MEMCACHED_NOTFOUND
, rc
);
948 test_false(string_length
);
951 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
);
952 test_compare(MEMCACHED_SUCCESS
, rc
);
954 string
= memcached_get(memc
, key
, strlen(key
),
955 &string_length
, &flags
, &rc
);
957 test_compare(MEMCACHED_SUCCESS
, rc
);
958 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
959 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
960 test_strcmp(READ_THROUGH_VALUE
, string
);
963 string
= memcached_get(memc
, key
, strlen(key
),
964 &string_length
, &flags
, &rc
);
966 test_compare(MEMCACHED_SUCCESS
, rc
);
968 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
969 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
970 test_strcmp(READ_THROUGH_VALUE
, string
);
976 static memcached_return_t
delete_trigger(memcached_st
*,
983 return MEMCACHED_SUCCESS
;
986 static test_return_t
delete_through(memcached_st
*memc
)
988 memcached_trigger_delete_key_fn callback
;
989 memcached_return_t rc
;
991 callback
= (memcached_trigger_delete_key_fn
)delete_trigger
;
993 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
994 test_compare(MEMCACHED_SUCCESS
, rc
);
999 static test_return_t
get_test(memcached_st
*memc
)
1001 memcached_return_t rc
;
1002 const char *key
= "foo";
1004 size_t string_length
;
1007 uint64_t query_id
= memcached_query_id(memc
);
1008 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
1009 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
1010 test_compare(query_id
+1, memcached_query_id(memc
));
1012 string
= memcached_get(memc
, key
, strlen(key
),
1013 &string_length
, &flags
, &rc
);
1015 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1016 test_false(string_length
);
1019 return TEST_SUCCESS
;
1022 static test_return_t
get_test2(memcached_st
*memc
)
1024 const char *key
= "foo";
1025 const char *value
= "when we sanitize";
1027 uint64_t query_id
= memcached_query_id(memc
);
1028 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1029 value
, strlen(value
),
1030 (time_t)0, (uint32_t)0);
1031 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1032 test_compare(query_id
+1, memcached_query_id(memc
));
1034 query_id
= memcached_query_id(memc
);
1035 test_true(query_id
);
1038 size_t string_length
;
1039 char *string
= memcached_get(memc
, key
, strlen(key
),
1040 &string_length
, &flags
, &rc
);
1041 test_compare(query_id
+1, memcached_query_id(memc
));
1043 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1044 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1046 test_compare(strlen(value
), string_length
);
1047 test_memcmp(string
, value
, string_length
);
1051 return TEST_SUCCESS
;
1054 static test_return_t
set_test2(memcached_st
*memc
)
1056 const char *key
= "foo";
1057 const char *value
= "train in the brain";
1058 size_t value_length
= strlen(value
);
1060 for (uint32_t x
= 0; x
< 10; x
++)
1062 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1063 value
, value_length
,
1064 (time_t)0, (uint32_t)0);
1065 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1068 return TEST_SUCCESS
;
1071 static test_return_t
set_test3(memcached_st
*memc
)
1073 size_t value_length
= 8191;
1075 char *value
= (char*)malloc(value_length
);
1078 for (uint32_t x
= 0; x
< value_length
; x
++)
1080 value
[x
] = (char) (x
% 127);
1083 /* The dump test relies on there being at least 32 items in memcached */
1084 for (uint32_t x
= 0; x
< 32; x
++)
1088 snprintf(key
, sizeof(key
), "foo%u", x
);
1090 uint64_t query_id
= memcached_query_id(memc
);
1091 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1092 value
, value_length
,
1093 (time_t)0, (uint32_t)0);
1094 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1095 test_compare(query_id
+1, memcached_query_id(memc
));
1100 return TEST_SUCCESS
;
1103 static test_return_t
get_test3(memcached_st
*memc
)
1105 const char *key
= "foo";
1106 size_t value_length
= 8191;
1108 char *value
= (char*)malloc(value_length
);
1111 for (uint32_t x
= 0; x
< value_length
; x
++)
1113 value
[x
] = (char) (x
% 127);
1116 memcached_return_t rc
;
1117 rc
= memcached_set(memc
, key
, strlen(key
),
1118 value
, value_length
,
1119 (time_t)0, (uint32_t)0);
1120 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1122 size_t string_length
;
1124 char *string
= memcached_get(memc
, key
, strlen(key
),
1125 &string_length
, &flags
, &rc
);
1127 test_compare(MEMCACHED_SUCCESS
, rc
);
1129 test_compare(string_length
, value_length
);
1130 test_memcmp(string
, value
, string_length
);
1135 return TEST_SUCCESS
;
1138 static test_return_t
get_test4(memcached_st
*memc
)
1140 const char *key
= "foo";
1141 size_t value_length
= 8191;
1143 char *value
= (char*)malloc(value_length
);
1146 for (uint32_t x
= 0; x
< value_length
; x
++)
1148 value
[x
] = (char) (x
% 127);
1151 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1152 value
, value_length
,
1153 (time_t)0, (uint32_t)0);
1154 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1156 for (uint32_t x
= 0; x
< 10; x
++)
1159 size_t string_length
;
1160 char *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
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1195 memcached_result_st results_obj
;
1196 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1199 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 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1207 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1208 &rlen
, &flags
, &rc
);
1210 test_compare(MEMCACHED_NOTFOUND
, rc
);
1211 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1213 test_compare(MEMCACHED_SUCCESS
, rc
);
1216 return TEST_SUCCESS
;
1219 static test_return_t
mget_end(memcached_st
*memc
)
1221 const char *keys
[]= { "foo", "foo2" };
1222 size_t lengths
[]= { 3, 4 };
1223 const char *values
[]= { "fjord", "41" };
1225 memcached_return_t rc
;
1228 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1230 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[x
], lengths
[x
], values
[x
], strlen(values
[x
]), (time_t)0, (uint32_t)0));
1234 size_t string_length
;
1237 // retrieve both via mget
1238 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1240 char key
[MEMCACHED_MAX_KEY
];
1243 // this should get both
1244 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1246 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1248 test_compare(MEMCACHED_SUCCESS
, rc
);
1250 if (key_length
== 4)
1255 test_compare(string_length
, strlen(values
[val
]));
1256 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1260 // this should indicate end
1261 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1262 test_compare(MEMCACHED_END
, rc
);
1265 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1266 test_compare(MEMCACHED_SUCCESS
, rc
);
1268 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1269 test_compare(key_length
, lengths
[0]);
1270 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1271 test_compare(string_length
, strlen(values
[0]));
1272 test_true(strncmp(values
[0], string
, string_length
) == 0);
1273 test_compare(MEMCACHED_SUCCESS
, rc
);
1276 // this should indicate end
1277 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1278 test_true(rc
== MEMCACHED_END
);
1280 return TEST_SUCCESS
;
1283 /* Do not copy the style of this code, I just access hosts to testthis function */
1284 static test_return_t
stats_servername_test(memcached_st
*memc
)
1286 memcached_stat_st memc_stat
;
1287 memcached_server_instance_st instance
=
1288 memcached_server_instance_by_position(memc
, 0);
1290 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
1291 if (memcached_get_sasl_callbacks(memc
) != NULL
)
1292 return TEST_SKIPPED
;
1294 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1295 memcached_server_name(instance
),
1296 memcached_server_port(instance
)));
1298 return TEST_SUCCESS
;
1301 static test_return_t
increment_test(memcached_st
*memc
)
1303 uint64_t new_number
;
1305 test_compare(MEMCACHED_SUCCESS
,
1307 test_literal_param("number"),
1308 test_literal_param("0"),
1309 (time_t)0, (uint32_t)0));
1311 test_compare(MEMCACHED_SUCCESS
,
1312 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1313 test_compare(uint64_t(1), new_number
);
1315 test_compare(MEMCACHED_SUCCESS
,
1316 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1317 test_compare(uint64_t(2), new_number
);
1319 return TEST_SUCCESS
;
1322 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1324 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1326 uint64_t new_number
;
1327 uint64_t initial
= 0;
1329 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1331 test_compare(MEMCACHED_SUCCESS
,
1332 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1333 test_compare(new_number
, initial
);
1335 test_compare(MEMCACHED_SUCCESS
,
1336 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1337 test_compare(new_number
, (initial
+1));
1339 return TEST_SUCCESS
;
1342 static test_return_t
decrement_test(memcached_st
*memc
)
1344 uint64_t new_number
;
1345 memcached_return_t rc
;
1346 const char *value
= "3";
1348 rc
= memcached_set(memc
,
1349 test_literal_param("number"),
1350 value
, strlen(value
),
1351 (time_t)0, (uint32_t)0);
1352 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1354 test_compare(MEMCACHED_SUCCESS
,
1355 memcached_decrement(memc
,
1356 test_literal_param("number"),
1358 test_compare(uint64_t(2), new_number
);
1360 test_compare(MEMCACHED_SUCCESS
,
1361 memcached_decrement(memc
,
1362 test_literal_param("number"),
1364 test_compare(uint64_t(1), new_number
);
1366 return TEST_SUCCESS
;
1369 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1371 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1373 uint64_t new_number
;
1374 uint64_t initial
= 3;
1376 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1378 test_compare(MEMCACHED_SUCCESS
,
1379 memcached_decrement_with_initial(memc
,
1380 test_literal_param("number"),
1381 1, initial
, 0, &new_number
));
1382 test_compare(new_number
, initial
);
1384 test_compare(MEMCACHED_SUCCESS
,
1385 memcached_decrement_with_initial(memc
,
1386 test_literal_param("number"),
1387 1, initial
, 0, &new_number
));
1388 test_compare(new_number
, (initial
- 1));
1390 return TEST_SUCCESS
;
1393 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1395 uint64_t new_number
;
1396 memcached_return_t rc
;
1397 const char *master_key
= "foo";
1398 const char *key
= "number";
1399 const char *value
= "0";
1401 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1403 value
, strlen(value
),
1404 (time_t)0, (uint32_t)0);
1405 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1407 test_compare(MEMCACHED_SUCCESS
,
1408 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1409 test_compare(uint64_t(1), new_number
);
1411 test_compare(MEMCACHED_SUCCESS
,
1412 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1413 test_compare(uint64_t(2), new_number
);
1415 return TEST_SUCCESS
;
1418 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1420 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1422 uint64_t new_number
;
1423 memcached_return_t rc
;
1424 const char *master_key
= "foo";
1425 const char *key
= "number";
1426 uint64_t initial
= 0;
1428 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1430 1, initial
, 0, &new_number
);
1431 test_compare(MEMCACHED_SUCCESS
, rc
);
1432 test_compare(new_number
, initial
);
1434 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1436 1, initial
, 0, &new_number
);
1437 test_compare(MEMCACHED_SUCCESS
, rc
);
1438 test_compare(new_number
, (initial
+1));
1440 return TEST_SUCCESS
;
1443 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1445 uint64_t new_number
;
1446 memcached_return_t rc
;
1447 const char *value
= "3";
1449 rc
= memcached_set_by_key(memc
,
1450 test_literal_param("foo"),
1451 test_literal_param("number"),
1452 value
, strlen(value
),
1453 (time_t)0, (uint32_t)0);
1454 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1456 test_compare(MEMCACHED_SUCCESS
,
1457 memcached_decrement_by_key(memc
,
1458 test_literal_param("foo"),
1459 test_literal_param("number"),
1461 test_compare(uint64_t(2), new_number
);
1463 test_compare(MEMCACHED_SUCCESS
,
1464 memcached_decrement_by_key(memc
,
1465 test_literal_param("foo"),
1466 test_literal_param("number"),
1468 test_compare(uint64_t(1), new_number
);
1470 return TEST_SUCCESS
;
1473 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1475 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1477 uint64_t new_number
;
1478 uint64_t initial
= 3;
1480 test_compare(MEMCACHED_SUCCESS
,
1481 memcached_decrement_with_initial_by_key(memc
,
1482 test_literal_param("foo"),
1483 test_literal_param("number"),
1484 1, initial
, 0, &new_number
));
1485 test_compare(new_number
, initial
);
1487 test_compare(MEMCACHED_SUCCESS
,
1488 memcached_decrement_with_initial_by_key(memc
,
1489 test_literal_param("foo"),
1490 test_literal_param("number"),
1491 1, initial
, 0, &new_number
));
1492 test_compare(new_number
, (initial
- 1));
1494 return TEST_SUCCESS
;
1497 static test_return_t
quit_test(memcached_st
*memc
)
1499 memcached_return_t rc
;
1500 const char *key
= "fudge";
1501 const char *value
= "sanford and sun";
1503 rc
= memcached_set(memc
, key
, strlen(key
),
1504 value
, strlen(value
),
1505 (time_t)10, (uint32_t)3);
1506 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1507 memcached_quit(memc
);
1509 rc
= memcached_set(memc
, key
, strlen(key
),
1510 value
, strlen(value
),
1511 (time_t)50, (uint32_t)9);
1512 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1514 return TEST_SUCCESS
;
1517 static test_return_t
mget_result_test(memcached_st
*memc
)
1519 const char *keys
[]= {"fudge", "son", "food"};
1520 size_t key_length
[]= {5, 3, 4};
1522 memcached_result_st results_obj
;
1523 memcached_result_st
*results
;
1525 results
= memcached_result_create(memc
, &results_obj
);
1527 test_true(&results_obj
== results
);
1529 /* We need to empty the server before continueing test */
1530 test_compare(MEMCACHED_SUCCESS
,
1531 memcached_flush(memc
, 0));
1533 test_compare(MEMCACHED_SUCCESS
,
1534 memcached_mget(memc
, keys
, key_length
, 3));
1536 memcached_return_t rc
;
1537 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1542 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1543 test_false(results
);
1544 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1546 for (uint32_t x
= 0; x
< 3; x
++)
1548 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1549 keys
[x
], key_length
[x
],
1550 (time_t)50, (uint32_t)9);
1551 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1554 test_compare(MEMCACHED_SUCCESS
,
1555 memcached_mget(memc
, keys
, key_length
, 3));
1557 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1560 test_true(&results_obj
== results
);
1561 test_compare(MEMCACHED_SUCCESS
, rc
);
1562 test_memcmp(memcached_result_key_value(results
),
1563 memcached_result_value(results
),
1564 memcached_result_length(results
));
1565 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1568 memcached_result_free(&results_obj
);
1570 return TEST_SUCCESS
;
1573 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1575 const char *keys
[]= {"fudge", "son", "food"};
1576 size_t key_length
[]= {5, 3, 4};
1578 memcached_result_st
*results
;
1580 /* We need to empty the server before continueing test */
1581 test_compare(MEMCACHED_SUCCESS
,
1582 memcached_flush(memc
, 0));
1584 test_compare(MEMCACHED_SUCCESS
,
1585 memcached_mget(memc
, keys
, key_length
, 3));
1587 memcached_return_t rc
;
1588 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1592 test_false(results
);
1593 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1595 for (uint32_t x
= 0; x
< 3; x
++)
1597 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1598 keys
[x
], key_length
[x
],
1599 (time_t)50, (uint32_t)9);
1600 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1603 test_compare(MEMCACHED_SUCCESS
,
1604 memcached_mget(memc
, keys
, key_length
, 3));
1607 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1610 test_compare(MEMCACHED_SUCCESS
, rc
);
1611 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1612 test_memcmp(memcached_result_key_value(results
),
1613 memcached_result_value(results
),
1614 memcached_result_length(results
));
1615 memcached_result_free(results
);
1619 return TEST_SUCCESS
;
1622 /* Count the results */
1623 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1625 size_t *counter
= (size_t *)context
;
1627 *counter
= *counter
+ 1;
1629 return MEMCACHED_SUCCESS
;
1632 static test_return_t
mget_result_function(memcached_st
*memc
)
1634 const char *keys
[]= {"fudge", "son", "food"};
1635 size_t key_length
[]= {5, 3, 4};
1637 memcached_execute_fn callbacks
[1];
1639 /* We need to empty the server before continueing test */
1640 test_compare(MEMCACHED_SUCCESS
,
1641 memcached_flush(memc
, 0));
1642 for (uint32_t x
= 0; x
< 3; x
++)
1644 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1645 keys
[x
], key_length
[x
],
1646 (time_t)50, (uint32_t)9);
1647 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1650 test_compare(MEMCACHED_SUCCESS
,
1651 memcached_mget(memc
, keys
, key_length
, 3));
1653 callbacks
[0]= &callback_counter
;
1656 test_compare(MEMCACHED_SUCCESS
,
1657 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1659 test_compare(size_t(3), counter
);
1661 return TEST_SUCCESS
;
1664 static test_return_t
mget_test(memcached_st
*memc
)
1666 const char *keys
[]= {"fudge", "son", "food"};
1667 size_t key_length
[]= {5, 3, 4};
1669 char return_key
[MEMCACHED_MAX_KEY
];
1670 size_t return_key_length
;
1672 size_t return_value_length
;
1674 /* We need to empty the server before continueing test */
1675 test_compare(MEMCACHED_SUCCESS
,
1676 memcached_flush(memc
, 0));
1678 test_compare(MEMCACHED_SUCCESS
,
1679 memcached_mget(memc
, keys
, key_length
, 3));
1682 memcached_return_t rc
;
1683 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1684 &return_value_length
, &flags
, &rc
)))
1686 test_true(return_value
);
1688 test_false(return_value
);
1689 test_zero(return_value_length
);
1690 test_compare(MEMCACHED_NOTFOUND
, rc
);
1692 for (uint32_t x
= 0; x
< 3; x
++)
1694 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1695 keys
[x
], key_length
[x
],
1696 (time_t)50, (uint32_t)9);
1697 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1699 test_compare(MEMCACHED_SUCCESS
,
1700 memcached_mget(memc
, keys
, key_length
, 3));
1703 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1704 &return_value_length
, &flags
, &rc
)))
1706 test_true(return_value
);
1707 test_compare(MEMCACHED_SUCCESS
, rc
);
1708 if (not memc
->_namespace
)
1710 test_compare(return_key_length
, return_value_length
);
1711 test_memcmp(return_value
, return_key
, return_value_length
);
1717 return TEST_SUCCESS
;
1720 static test_return_t
mget_execute(memcached_st
*memc
)
1724 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1728 * I only want to hit _one_ server so I know the number of requests I'm
1729 * sending in the pipeline.
1731 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1732 memc
->number_of_hosts
= 1;
1734 size_t max_keys
= 20480;
1737 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1738 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1740 /* First add all of the items.. */
1741 char blob
[1024] = {0};
1742 memcached_return_t rc
;
1744 for (size_t x
= 0; x
< max_keys
; ++x
)
1748 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1750 test_true(keys
[x
] != NULL
);
1751 uint64_t query_id
= memcached_query_id(memc
);
1752 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1753 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1754 test_compare(query_id
+1, memcached_query_id(memc
));
1757 /* Try to get all of them with a large multiget */
1759 memcached_execute_fn callbacks
[]= { &callback_counter
};
1760 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1761 max_keys
, callbacks
, &counter
, 1);
1763 if (memcached_success(rc
))
1766 uint64_t query_id
= memcached_query_id(memc
);
1767 test_compare(MEMCACHED_SUCCESS
,
1768 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1769 test_compare(query_id
, memcached_query_id(memc
));
1771 /* Verify that we got all of the items */
1772 test_true(counter
== max_keys
);
1774 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1776 test_true(counter
== 0);
1780 test_fail("note: this test functions differently when in binary mode");
1783 /* Release all allocated resources */
1784 for (size_t x
= 0; x
< max_keys
; ++x
)
1791 memc
->number_of_hosts
= number_of_hosts
;
1792 return TEST_SUCCESS
;
1795 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1797 static test_return_t
key_setup(memcached_st
*memc
)
1799 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1801 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1803 return TEST_SUCCESS
;
1806 static test_return_t
key_teardown(memcached_st
*memc
)
1809 pairs_free(global_pairs
);
1811 return TEST_SUCCESS
;
1814 static test_return_t
block_add_regression(memcached_st
*memc
)
1816 /* First add all of the items.. */
1817 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1819 memcached_return_t rc
;
1820 char blob
[1024] = {0};
1822 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1823 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1826 return TEST_SUCCESS
;
1829 static test_return_t
binary_add_regression(memcached_st
*memc
)
1831 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1832 test_return_t rc
= block_add_regression(memc
);
1833 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1837 static test_return_t
get_stats_keys(memcached_st
*memc
)
1841 memcached_stat_st memc_stat
;
1842 memcached_return_t rc
;
1844 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1845 test_compare(MEMCACHED_SUCCESS
, rc
);
1846 for (ptr
= stat_list
; *ptr
; ptr
++)
1851 return TEST_SUCCESS
;
1854 static test_return_t
version_string_test(memcached_st
*memc
)
1856 const char *version_string
;
1859 version_string
= memcached_lib_version();
1861 test_strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
);
1863 return TEST_SUCCESS
;
1866 static test_return_t
get_stats(memcached_st
*memc
)
1868 memcached_return_t rc
;
1870 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1871 test_compare(MEMCACHED_SUCCESS
, rc
);
1872 test_true(memc_stat
);
1874 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1876 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1877 test_compare(MEMCACHED_SUCCESS
, rc
);
1878 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1883 memcached_stat_free(NULL
, memc_stat
);
1885 return TEST_SUCCESS
;
1888 static test_return_t
add_host_test(memcached_st
*memc
)
1891 memcached_server_st
*servers
;
1892 memcached_return_t rc
;
1893 char servername
[]= "0.example.com";
1895 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1897 test_true(1 == memcached_server_list_count(servers
));
1899 for (x
= 2; x
< 20; x
++)
1901 char buffer
[SMALL_STRING_LEN
];
1903 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1904 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1906 test_compare(MEMCACHED_SUCCESS
, rc
);
1907 test_true(x
== memcached_server_list_count(servers
));
1910 rc
= memcached_server_push(memc
, servers
);
1911 test_compare(MEMCACHED_SUCCESS
, rc
);
1912 rc
= memcached_server_push(memc
, servers
);
1913 test_compare(MEMCACHED_SUCCESS
, rc
);
1915 memcached_server_list_free(servers
);
1917 return TEST_SUCCESS
;
1920 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1922 memcached_return_t rc
;
1923 const char *key
= "not_found";
1924 size_t key_len
= strlen(key
);
1926 test_compare(MEMCACHED_SUCCESS
,
1927 memcached_mget(memc
, &key
, &key_len
, 1));
1929 memcached_result_st
*result
= NULL
;
1930 result
= memcached_fetch_result(memc
, result
, &rc
);
1932 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1934 memcached_result_free(result
);
1936 return TEST_SUCCESS
;
1939 static memcached_return_t
clone_test_callback(memcached_st
*parent
, memcached_st
*memc_clone
)
1941 (void)parent
;(void)memc_clone
;
1942 return MEMCACHED_SUCCESS
;
1945 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
)
1948 return MEMCACHED_SUCCESS
;
1951 static test_return_t
callback_test(memcached_st
*memc
)
1953 /* Test User Data */
1957 memcached_return_t rc
;
1959 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1960 test_compare(MEMCACHED_SUCCESS
, rc
);
1961 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1962 test_true(*test_ptr
== x
);
1965 /* Test Clone Callback */
1967 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1968 void *clone_cb_ptr
= *(void **)&clone_cb
;
1969 void *temp_function
= NULL
;
1970 memcached_return_t rc
;
1972 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1974 test_compare(MEMCACHED_SUCCESS
, rc
);
1975 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1976 test_true(temp_function
== clone_cb_ptr
);
1979 /* Test Cleanup Callback */
1981 memcached_cleanup_fn cleanup_cb
=
1982 (memcached_cleanup_fn
)cleanup_test_callback
;
1983 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
1984 void *temp_function
= NULL
;
1985 memcached_return_t rc
;
1987 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1989 test_compare(MEMCACHED_SUCCESS
, rc
);
1990 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1991 test_true(temp_function
== cleanup_cb_ptr
);
1994 return TEST_SUCCESS
;
1997 /* We don't test the behavior itself, we test the switches */
1998 static test_return_t
behavior_test(memcached_st
*memc
)
2003 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2004 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2005 test_true(value
== 1);
2007 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2008 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2009 test_true(value
== 1);
2011 set
= MEMCACHED_HASH_MD5
;
2012 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2013 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2014 test_true(value
== MEMCACHED_HASH_MD5
);
2018 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2019 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2020 test_true(value
== 0);
2022 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2023 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2024 test_true(value
== 0);
2026 set
= MEMCACHED_HASH_DEFAULT
;
2027 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2028 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2029 test_true(value
== MEMCACHED_HASH_DEFAULT
);
2031 set
= MEMCACHED_HASH_CRC
;
2032 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2033 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2034 test_true(value
== MEMCACHED_HASH_CRC
);
2036 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2037 test_true(value
> 0);
2039 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2040 test_true(value
> 0);
2042 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2043 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
2044 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2046 return TEST_SUCCESS
;
2049 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2051 memcached_return_t rc
;
2054 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
2055 test_true(rc
== MEMCACHED_DEPRECATED
);
2057 // Platform dependent
2059 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2063 return TEST_SUCCESS
;
2067 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2069 memcached_return_t rc
;
2073 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, set
);
2074 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2076 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2078 if (rc
== MEMCACHED_SUCCESS
)
2080 test_true((bool)value
== set
);
2084 test_false((bool)value
== set
);
2087 return TEST_SUCCESS
;
2091 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2093 memcached_return_t rc
;
2097 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, set
);
2098 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2100 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2102 if (rc
== MEMCACHED_SUCCESS
)
2104 test_true((bool)value
== set
);
2108 test_false((bool)value
== set
);
2111 return TEST_SUCCESS
;
2114 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, const memcached_return_t expect
)
2116 memcached_return_t rc
;
2117 char return_key
[MEMCACHED_MAX_KEY
];
2118 size_t return_key_length
;
2120 size_t return_value_length
;
2124 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2125 &return_value_length
, &flags
, &rc
)))
2127 test_true(return_value
);
2128 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2133 if (memcached_success(expect
) and memcached_success(rc
))
2135 return TEST_SUCCESS
;
2137 else if (expect
== rc
)
2139 return TEST_SUCCESS
;
2141 fprintf(stderr
, "\n%s:%u %s(#%u)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), keys_returned
);
2143 return TEST_FAILURE
;
2146 /* Test case provided by Cal Haldenbrand */
2147 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2148 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2149 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2151 /* We just keep looking at the same values over and over */
2154 unsigned int setter
= 1;
2155 test_compare(MEMCACHED_SUCCESS
,
2156 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2157 test_compare(MEMCACHED_SUCCESS
,
2158 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2162 unsigned long long total
= 0;
2163 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2165 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2166 char randomstuff
[6 * 1024];
2167 memset(randomstuff
, 0, 6 * 1024);
2168 test_true(size
< 6 * 1024); /* Being safe here */
2170 for (uint32_t j
= 0 ; j
< size
;j
++)
2172 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2177 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2178 test_compare(MEMCACHED_SUCCESS
,
2179 memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
));
2181 test_true(total
> HALDENBRAND_KEY_COUNT
);
2183 return TEST_SUCCESS
;
2186 /* Test case provided by Cal Haldenbrand */
2187 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2189 unsigned int setter
= 1;
2191 test_compare(MEMCACHED_SUCCESS
,
2192 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2194 test_compare(MEMCACHED_SUCCESS
,
2195 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2198 setter
= 20 * 1024576;
2199 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2200 setter
= 20 * 1024576;
2201 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2202 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2203 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2205 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2208 size_t total_value_length
= 0;
2209 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2214 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2215 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2217 memcached_return_t rc
;
2218 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2219 if (memcached_failed(rc
))
2221 if (rc
== MEMCACHED_NOTFOUND
)
2232 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2234 total_value_length
+= val_len
;
2239 return TEST_SUCCESS
;
2242 /* Do a large mget() over all the keys we think exist */
2243 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2245 unsigned int setter
= 1;
2246 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2247 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2249 setter
= 20 * 1024576;
2250 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2251 setter
= 20 * 1024576;
2252 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2253 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2254 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2257 size_t key_lengths
[HALDENBRAND_KEY_COUNT
];
2258 char **keys
= static_cast<char **>(calloc(HALDENBRAND_KEY_COUNT
, sizeof(char *)));
2260 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2262 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2263 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2264 keys
[x
]= strdup(key
);
2266 key_lengths
[x
]= key_length
;
2267 test_compare(size_t(key_length
), strlen(keys
[x
]));
2270 test_compare(MEMCACHED_SUCCESS
,
2271 memcached_mget(memc
, (const char **)keys
, key_lengths
, HALDENBRAND_KEY_COUNT
));
2273 unsigned int keys_returned
;
2274 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
2275 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2277 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2283 return TEST_SUCCESS
;
2286 /* Make sure we behave properly if server list has no values */
2287 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2289 const char *keys
[]= {"fudge", "son", "food"};
2290 size_t key_length
[]= {5, 3, 4};
2292 /* Here we free everything before running a bunch of mget tests */
2293 memcached_servers_reset(memc
);
2296 /* We need to empty the server before continueing test */
2297 test_compare(MEMCACHED_NO_SERVERS
,
2298 memcached_flush(memc
, 0));
2300 test_compare(MEMCACHED_NO_SERVERS
,
2301 memcached_mget(memc
, keys
, key_length
, 3));
2303 unsigned int keys_returned
;
2304 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2305 test_zero(keys_returned
);
2307 for (uint32_t x
= 0; x
< 3; x
++)
2309 test_compare(MEMCACHED_NO_SERVERS
,
2310 memcached_set(memc
, keys
[x
], key_length
[x
],
2311 keys
[x
], key_length
[x
],
2312 (time_t)50, (uint32_t)9));
2315 test_compare(MEMCACHED_NO_SERVERS
,
2316 memcached_mget(memc
, keys
, key_length
, 3));
2320 char return_key
[MEMCACHED_MAX_KEY
];
2321 memcached_return_t rc
;
2322 size_t return_key_length
;
2323 size_t return_value_length
;
2326 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2327 &return_value_length
, &flags
, &rc
)))
2329 test_true(return_value
);
2330 test_compare(MEMCACHED_SUCCESS
, rc
);
2331 test_true(return_key_length
== return_value_length
);
2332 test_memcmp(return_value
, return_key
, return_value_length
);
2338 return TEST_SUCCESS
;
2341 #define VALUE_SIZE_BUG5 1048064
2342 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2344 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2345 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2347 size_t value_length
;
2349 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2351 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2353 insert_data
[x
]= (signed char)rand();
2356 test_compare(MEMCACHED_SUCCESS
,
2357 memcached_flush(memc
, 0));
2359 memcached_return_t rc
;
2360 value
= memcached_get(memc
, keys
[0], key_length
[0],
2361 &value_length
, &flags
, &rc
);
2363 test_compare(MEMCACHED_SUCCESS
,
2364 memcached_mget(memc
, keys
, key_length
, 4));
2367 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2370 for (uint32_t x
= 0; x
< 4; x
++)
2372 test_compare(MEMCACHED_SUCCESS
,
2373 memcached_set(memc
, keys
[x
], key_length
[x
],
2374 insert_data
, VALUE_SIZE_BUG5
,
2375 (time_t)0, (uint32_t)0));
2378 for (uint32_t x
= 0; x
< 10; x
++)
2380 value
= memcached_get(memc
, keys
[0], key_length
[0],
2381 &value_length
, &flags
, &rc
);
2382 test_compare(rc
, MEMCACHED_SUCCESS
);
2386 test_compare(MEMCACHED_SUCCESS
,
2387 memcached_mget(memc
, keys
, key_length
, 4));
2389 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2390 test_compare(4U, count
);
2392 delete [] insert_data
;
2394 return TEST_SUCCESS
;
2397 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2399 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2400 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2401 char return_key
[MEMCACHED_MAX_KEY
];
2402 size_t return_key_length
;
2404 size_t value_length
;
2406 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2408 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2410 insert_data
[x
]= (signed char)rand();
2413 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2415 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2417 // We will now confirm that memcached_mget() returns success, but we will
2418 // then check to make sure that no actual keys are returned.
2419 test_compare(MEMCACHED_SUCCESS
,
2420 memcached_mget(memc
, keys
, key_length
, 4));
2422 memcached_return_t rc
;
2424 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2425 &value_length
, &flags
, &rc
)))
2430 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2432 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2434 test_compare(MEMCACHED_SUCCESS
,
2435 memcached_set(memc
, keys
[x
], key_length
[x
],
2436 insert_data
, VALUE_SIZE_BUG5
,
2437 (time_t)0, (uint32_t)0));
2439 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2441 for (uint32_t x
= 0; x
< 2; x
++)
2443 value
= memcached_get(memc
, keys
[0], key_length
[0],
2444 &value_length
, &flags
, &rc
);
2448 test_compare(MEMCACHED_SUCCESS
,
2449 memcached_mget(memc
, keys
, key_length
, 4));
2450 /* We test for purge of partial complete fetches */
2451 for (count
= 3; count
; count
--)
2453 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2454 &value_length
, &flags
, &rc
);
2455 test_compare(MEMCACHED_SUCCESS
, rc
);
2456 test_memcmp(value
, insert_data
, value_length
);
2457 test_true(value_length
);
2461 delete [] insert_data
;
2463 return TEST_SUCCESS
;
2466 static test_return_t
user_supplied_bug8(memcached_st
*)
2468 memcached_return_t rc
;
2470 memcached_st
*memc_clone
;
2472 memcached_server_st
*servers
;
2473 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";
2475 servers
= memcached_servers_parse(server_list
);
2478 mine
= memcached_create(NULL
);
2479 rc
= memcached_server_push(mine
, servers
);
2480 test_compare(MEMCACHED_SUCCESS
, rc
);
2481 memcached_server_list_free(servers
);
2484 memc_clone
= memcached_clone(NULL
, mine
);
2486 memcached_quit(mine
);
2487 memcached_quit(memc_clone
);
2490 memcached_free(mine
);
2491 memcached_free(memc_clone
);
2493 return TEST_SUCCESS
;
2496 /* Test flag store/retrieve */
2497 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2499 const char *keys
= "036790384900";
2500 size_t key_length
= strlen(keys
);
2501 char return_key
[MEMCACHED_MAX_KEY
];
2502 size_t return_key_length
;
2504 size_t value_length
;
2506 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2508 for (unsigned int x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2509 insert_data
[x
]= (signed char)rand();
2511 memcached_flush(memc
, 0);
2514 memcached_return_t rc
= memcached_set(memc
, keys
, key_length
,
2515 insert_data
, VALUE_SIZE_BUG5
,
2517 test_compare(MEMCACHED_SUCCESS
, rc
);
2520 value
= memcached_get(memc
, keys
, key_length
,
2521 &value_length
, &flags
, &rc
);
2522 test_true(flags
== 245);
2526 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2529 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2530 &value_length
, &flags
, &rc
);
2531 test_compare(uint32_t(245), flags
);
2534 delete [] insert_data
;
2537 return TEST_SUCCESS
;
2540 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2542 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2543 size_t key_length
[3];
2547 char return_key
[MEMCACHED_MAX_KEY
];
2548 size_t return_key_length
;
2550 size_t return_value_length
;
2553 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2554 key_length
[1]= strlen("fudge&*@#");
2555 key_length
[2]= strlen("for^#@&$not");
2558 for (unsigned int x
= 0; x
< 3; x
++)
2560 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2561 keys
[x
], key_length
[x
],
2562 (time_t)50, (uint32_t)9);
2563 test_compare(MEMCACHED_SUCCESS
, rc
);
2566 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2567 test_compare(MEMCACHED_SUCCESS
, rc
);
2569 /* We need to empty the server before continueing test */
2570 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2571 &return_value_length
, &flags
, &rc
)) != NULL
)
2573 test_true(return_value
);
2577 test_compare(3U, count
);
2579 return TEST_SUCCESS
;
2582 /* We are testing with aggressive timeout to get failures */
2583 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2585 const char *key
= "foo";
2586 size_t value_length
= 512;
2588 unsigned int set
= 1;
2589 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2591 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2592 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2594 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, (uint64_t)timeout
);
2596 char *value
= (char*)malloc(value_length
* sizeof(char));
2598 for (unsigned int x
= 0; x
< value_length
; x
++)
2600 value
[x
]= (char) (x
% 127);
2603 for (unsigned int x
= 1; x
<= 100000; ++x
)
2605 memcached_return_t rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2607 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
,
2608 memcached_strerror(NULL
, rc
));
2610 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2617 memcached_free(mclone
);
2619 return TEST_SUCCESS
;
2623 We are looking failures in the async protocol
2625 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2627 const char *key
= "foo";
2628 size_t value_length
= 512;
2630 unsigned int set
= 1;
2631 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2633 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2634 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2635 int32_t timeout
= -1;
2636 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, (size_t)timeout
);
2638 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2640 test_true(timeout
== -1);
2642 char *value
= (char*)malloc(value_length
* sizeof(char));
2644 for (unsigned int x
= 0; x
< value_length
; x
++)
2646 value
[x
]= (char) (x
% 127);
2649 for (unsigned int x
= 1; x
<= 100000; ++x
)
2651 memcached_return_t rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2656 memcached_free(mclone
);
2658 return TEST_SUCCESS
;
2662 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2664 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2666 memcached_return_t rc
;
2668 size_t value_length
;
2670 uint64_t number_value
;
2672 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2673 &value_length
, &flags
, &rc
);
2674 test_true(value
== NULL
);
2675 test_compare(MEMCACHED_NOTFOUND
, rc
);
2677 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2680 test_true(value
== NULL
);
2681 /* The binary protocol will set the key if it doesn't exist */
2682 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2684 test_compare(MEMCACHED_SUCCESS
, rc
);
2688 test_compare(MEMCACHED_NOTFOUND
, rc
);
2691 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2693 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2694 &value_length
, &flags
, &rc
);
2696 test_compare(MEMCACHED_SUCCESS
, rc
);
2699 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2701 test_true(number_value
== 2);
2702 test_compare(MEMCACHED_SUCCESS
, rc
);
2704 return TEST_SUCCESS
;
2708 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2709 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2711 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2713 char key
[] = "key34567890";
2714 memcached_return_t rc
;
2715 size_t overflowSize
;
2717 char commandFirst
[]= "set key34567890 0 0 ";
2718 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2719 size_t commandLength
;
2722 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2724 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2726 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2728 char *overflow
= new (std::nothrow
) char[testSize
];
2729 test_true(overflow
);
2731 memset(overflow
, 'x', testSize
);
2732 rc
= memcached_set(memc
, key
, strlen(key
),
2733 overflow
, testSize
, 0, 0);
2734 test_compare(MEMCACHED_SUCCESS
, rc
);
2738 return TEST_SUCCESS
;
2743 Test values of many different sizes
2744 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2745 set key34567890 0 0 8169 \r\n
2746 is sent followed by buffer of size 8169, followed by 8169
2748 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2751 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2752 memcached_return_t rc
;
2753 const char *key
= "foo";
2755 size_t value_length
= 18000;
2757 size_t string_length
;
2760 size_t current_length
;
2762 value
= (char*)malloc(value_length
);
2765 for (x
= 0; x
< value_length
; x
++)
2766 value
[x
] = (char) (x
% 127);
2768 for (current_length
= 0; current_length
< value_length
; current_length
++)
2770 rc
= memcached_set(memc
, key
, strlen(key
),
2771 value
, current_length
,
2772 (time_t)0, (uint32_t)0);
2773 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2775 string
= memcached_get(memc
, key
, strlen(key
),
2776 &string_length
, &flags
, &rc
);
2778 test_compare(MEMCACHED_SUCCESS
, rc
);
2779 test_true(string_length
== current_length
);
2780 test_memcmp(string
, value
, string_length
);
2787 return TEST_SUCCESS
;
2791 Look for zero length value problems
2793 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2796 memcached_return_t rc
;
2797 const char *key
= "mykey";
2801 for (x
= 0; x
< 2; x
++)
2803 rc
= memcached_set(memc
, key
, strlen(key
),
2805 (time_t)0, (uint32_t)0);
2807 test_compare(MEMCACHED_SUCCESS
, rc
);
2809 char *value
= memcached_get(memc
, key
, strlen(key
),
2810 &length
, &flags
, &rc
);
2812 test_compare(MEMCACHED_SUCCESS
, rc
);
2817 value
= memcached_get(memc
, key
, strlen(key
),
2818 &length
, &flags
, &rc
);
2820 test_compare(MEMCACHED_SUCCESS
, rc
);
2821 test_true(value
== NULL
);
2822 test_true(length
== 0);
2823 test_true(flags
== 0);
2826 return TEST_SUCCESS
;
2829 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2830 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2832 memcached_return_t rc
;
2833 const char *key
= "mykey";
2838 rc
= memcached_set(memc
, key
, strlen(key
),
2840 (time_t)0, UINT32_MAX
);
2842 test_compare(MEMCACHED_SUCCESS
, rc
);
2844 value
= memcached_get(memc
, key
, strlen(key
),
2845 &length
, &flags
, &rc
);
2847 test_compare(MEMCACHED_SUCCESS
, rc
);
2848 test_true(value
== NULL
);
2849 test_true(length
== 0);
2850 test_true(flags
== UINT32_MAX
);
2852 return TEST_SUCCESS
;
2855 #if !defined(__sun) && !defined(__OpenBSD__)
2856 /* Check the validity of chinese key*/
2857 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2859 memcached_return_t rc
;
2860 const char *key
= "豆瓣";
2861 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2866 rc
= memcached_set(memc
, key
, strlen(key
),
2867 value
, strlen(value
),
2870 test_compare(MEMCACHED_SUCCESS
, rc
);
2872 value2
= memcached_get(memc
, key
, strlen(key
),
2873 &length
, &flags
, &rc
);
2875 test_true(length
==strlen(value
));
2876 test_compare(MEMCACHED_SUCCESS
, rc
);
2877 test_memcmp(value
, value2
, length
);
2880 return TEST_SUCCESS
;
2888 static test_return_t
user_supplied_bug19(memcached_st
*)
2890 memcached_return_t res
;
2892 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2894 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2897 memcached_free(memc
);
2899 return TEST_SUCCESS
;
2902 /* CAS test from Andei */
2903 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2905 memcached_return_t status
;
2906 memcached_result_st
*result
, result_obj
;
2907 const char *key
= "abc";
2908 size_t key_len
= strlen("abc");
2909 const char *value
= "foobar";
2910 size_t value_len
= strlen(value
);
2912 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2914 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2915 test_true(status
== MEMCACHED_SUCCESS
);
2917 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2918 test_true(status
== MEMCACHED_SUCCESS
);
2920 result
= memcached_result_create(memc
, &result_obj
);
2923 memcached_result_create(memc
, &result_obj
);
2924 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2927 test_true(status
== MEMCACHED_SUCCESS
);
2929 memcached_result_free(result
);
2931 return TEST_SUCCESS
;
2934 #include "ketama_test_cases.h"
2935 static test_return_t
user_supplied_bug18(memcached_st
*trash
)
2937 memcached_return_t rc
;
2944 memc
= memcached_create(NULL
);
2947 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2948 test_compare(MEMCACHED_SUCCESS
, rc
);
2950 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2951 test_true(value
== 1);
2953 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2954 test_compare(MEMCACHED_SUCCESS
, rc
);
2956 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2957 test_true(value
== MEMCACHED_HASH_MD5
);
2959 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");
2960 memcached_server_push(memc
, server_pool
);
2962 /* verify that the server list was parsed okay. */
2963 test_true(memcached_server_count(memc
) == 8);
2964 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
2965 test_true(server_pool
[0].port
== 11211);
2966 test_true(server_pool
[0].weight
== 600);
2967 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
2968 test_true(server_pool
[2].port
== 11211);
2969 test_true(server_pool
[2].weight
== 200);
2970 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
2971 test_true(server_pool
[7].port
== 11211);
2972 test_true(server_pool
[7].weight
== 100);
2974 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2975 * us test the boundary wraparound.
2977 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
2979 /* verify the standard ketama set. */
2980 for (x
= 0; x
< 99; x
++)
2982 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
2984 memcached_server_instance_st instance
=
2985 memcached_server_instance_by_position(memc
, server_idx
);
2987 const char *hostname
= memcached_server_name(instance
);
2988 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
2991 memcached_server_list_free(server_pool
);
2992 memcached_free(memc
);
2994 return TEST_SUCCESS
;
2997 /* Large mget() of missing keys with binary proto
2999 * If many binary quiet commands (such as getq's in an mget) fill the output
3000 * buffer and the server chooses not to respond, memcached_flush hangs. See
3001 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
3004 /* sighandler_t function that always asserts false */
3005 static void fail(int)
3011 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
3016 return TEST_SKIPPED
;
3018 void (*oldalarm
)(int);
3020 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3021 test_true(memc_clone
);
3023 /* only binproto uses getq for mget */
3024 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3026 /* empty the cache to ensure misses (hence non-responses) */
3027 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
3029 size_t* key_lengths
= new (std::nothrow
) size_t[key_count
];
3030 test_true(key_lengths
);
3031 char **keys
= static_cast<char **>(calloc(key_count
, sizeof(char *)));
3033 for (unsigned int x
= 0; x
< key_count
; x
++)
3037 snprintf(buffer
, 30, "%u", x
);
3038 keys
[x
]= strdup(buffer
);
3040 key_lengths
[x
]= strlen(keys
[x
]);
3043 oldalarm
= signal(SIGALRM
, fail
);
3046 test_compare_got(MEMCACHED_SUCCESS
,
3047 memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
), memcached_last_error_message(memc_clone
));
3050 signal(SIGALRM
, oldalarm
);
3052 memcached_return_t rc
;
3054 char return_key
[MEMCACHED_MAX_KEY
];
3055 size_t return_key_length
;
3057 size_t return_value_length
;
3058 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
3059 &return_value_length
, &flags
, &rc
)))
3061 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
3063 test_compare(MEMCACHED_NOTFOUND
, rc
);
3064 test_zero(return_value_length
);
3065 test_zero(return_key_length
);
3066 test_false(return_key
[0]);
3067 test_false(return_value
);
3069 for (unsigned int x
= 0; x
< key_count
; x
++)
3074 delete [] key_lengths
;
3076 memcached_free(memc_clone
);
3078 return TEST_SUCCESS
;
3082 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3084 test_return_t test_rc
;
3085 test_rc
= pre_binary(memc
);
3087 if (test_rc
!= TEST_SUCCESS
)
3090 /* should work as of r580 */
3091 test_compare(TEST_SUCCESS
,
3092 _user_supplied_bug21(memc
, 10));
3094 /* should fail as of r580 */
3095 test_compare(TEST_SUCCESS
,
3096 _user_supplied_bug21(memc
, 1000));
3098 return TEST_SUCCESS
;
3101 static test_return_t
auto_eject_hosts(memcached_st
*trash
)
3104 memcached_server_instance_st instance
;
3106 memcached_return_t rc
;
3107 memcached_st
*memc
= memcached_create(NULL
);
3110 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3111 test_compare(MEMCACHED_SUCCESS
, rc
);
3113 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3114 test_true(value
== 1);
3116 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3117 test_compare(MEMCACHED_SUCCESS
, rc
);
3119 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3120 test_true(value
== MEMCACHED_HASH_MD5
);
3122 /* server should be removed when in delay */
3123 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
3124 test_compare(MEMCACHED_SUCCESS
, rc
);
3126 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
3127 test_true(value
== 1);
3129 memcached_server_st
*server_pool
;
3130 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");
3131 memcached_server_push(memc
, server_pool
);
3133 /* verify that the server list was parsed okay. */
3134 test_true(memcached_server_count(memc
) == 8);
3135 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
3136 test_true(server_pool
[0].port
== 11211);
3137 test_true(server_pool
[0].weight
== 600);
3138 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
3139 test_true(server_pool
[2].port
== 11211);
3140 test_true(server_pool
[2].weight
== 200);
3141 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
3142 test_true(server_pool
[7].port
== 11211);
3143 test_true(server_pool
[7].weight
== 100);
3145 instance
= memcached_server_instance_by_position(memc
, 2);
3146 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) + 15;
3147 memc
->ketama
.next_distribution_rebuild
= time(NULL
) - 1;
3150 This would not work if there were only two hosts.
3152 for (size_t x
= 0; x
< 99; x
++)
3154 memcached_autoeject(memc
);
3155 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3156 test_true(server_idx
!= 2);
3159 /* and re-added when it's back. */
3160 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) - 1;
3161 memc
->ketama
.next_distribution_rebuild
= time(NULL
) - 1;
3162 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
,
3163 memc
->distribution
);
3164 for (size_t x
= 0; x
< 99; x
++)
3166 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3167 // We re-use instance from above.
3169 memcached_server_instance_by_position(memc
, server_idx
);
3170 const char *hostname
= memcached_server_name(instance
);
3171 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
3174 memcached_server_list_free(server_pool
);
3175 memcached_free(memc
);
3177 return TEST_SUCCESS
;
3180 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
3184 memcached_return_t rc
;
3185 memcached_st
*memc
= memcached_create(NULL
);
3189 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3190 test_compare(MEMCACHED_SUCCESS
, rc
);
3192 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3193 test_true(value
== 1);
3195 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3196 test_compare(MEMCACHED_SUCCESS
, rc
);
3198 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3199 test_true(value
== MEMCACHED_HASH_MD5
);
3202 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3204 memcached_server_st
*server_pool
;
3205 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");
3206 memcached_server_push(memc
, server_pool
);
3208 // @todo this needs to be refactored to actually test something.
3211 if ((fp
= fopen("ketama_keys.txt", "w")))
3215 printf("cannot write to file ketama_keys.txt");
3216 return TEST_FAILURE
;
3219 for (int x
= 0; x
< 10000; x
++)
3222 snprintf(key
, sizeof(key
), "%d", x
);
3224 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3225 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3226 in_port_t port
= memc
->hosts
[server_idx
].port
;
3227 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3228 memcached_server_instance_st instance
=
3229 memcached_server_instance_by_position(memc
, host_index
);
3233 memcached_server_list_free(server_pool
);
3234 memcached_free(memc
);
3236 return TEST_SUCCESS
;
3240 static test_return_t
result_static(memcached_st
*memc
)
3242 memcached_result_st result
;
3243 memcached_result_st
*result_ptr
;
3245 result_ptr
= memcached_result_create(memc
, &result
);
3246 test_true(result
.options
.is_allocated
== false);
3247 test_true(memcached_is_initialized(&result
) == true);
3248 test_true(result_ptr
);
3249 test_true(result_ptr
== &result
);
3251 memcached_result_free(&result
);
3253 test_true(result
.options
.is_allocated
== false);
3254 test_true(memcached_is_initialized(&result
) == false);
3256 return TEST_SUCCESS
;
3259 static test_return_t
result_alloc(memcached_st
*memc
)
3261 memcached_result_st
*result_ptr
;
3263 result_ptr
= memcached_result_create(memc
, NULL
);
3264 test_true(result_ptr
);
3265 test_true(result_ptr
->options
.is_allocated
== true);
3266 test_true(memcached_is_initialized(result_ptr
) == true);
3267 memcached_result_free(result_ptr
);
3269 return TEST_SUCCESS
;
3272 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3275 pairs_free(global_pairs
);
3277 return TEST_SUCCESS
;
3280 static test_return_t
generate_pairs(memcached_st
*memc
)
3283 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3284 global_count
= GLOBAL_COUNT
;
3286 for (size_t x
= 0; x
< global_count
; x
++)
3288 global_keys
[x
]= global_pairs
[x
].key
;
3289 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3292 return TEST_SUCCESS
;
3295 static test_return_t
generate_large_pairs(memcached_st
*)
3297 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3298 global_count
= GLOBAL2_COUNT
;
3300 for (size_t x
= 0; x
< global_count
; x
++)
3302 global_keys
[x
]= global_pairs
[x
].key
;
3303 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3306 return TEST_SUCCESS
;
3309 static test_return_t
generate_data(memcached_st
*memc
)
3311 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3313 test_compare(check_execute
, global_count
);
3315 return TEST_SUCCESS
;
3318 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3320 uint32_t host_index
= 0;
3321 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3323 test_true(check_execute
== global_count
);
3325 // @todo hosts used size stats
3326 memcached_return_t rc
;
3327 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3330 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3332 /* This test was changes so that "make test" would work properlly */
3334 memcached_server_instance_st instance
=
3335 memcached_server_instance_by_position(memc
, host_index
);
3337 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3339 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3342 memcached_stat_free(NULL
, stat_p
);
3344 return TEST_SUCCESS
;
3346 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3351 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3352 generate_data(memc
);
3354 return TEST_SUCCESS
;
3357 static test_return_t
get_read_count(memcached_st
*memc
)
3359 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3360 test_true(memc_clone
);
3362 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3366 size_t return_value_length
;
3370 for (size_t x
= count
= 0; x
< global_count
; x
++)
3372 memcached_return_t rc
;
3373 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3374 &return_value_length
, &flags
, &rc
);
3375 if (rc
== MEMCACHED_SUCCESS
)
3386 memcached_free(memc_clone
);
3388 return TEST_SUCCESS
;
3391 static test_return_t
get_read(memcached_st
*memc
)
3393 for (size_t x
= 0; x
< global_count
; x
++)
3395 size_t return_value_length
;
3397 memcached_return_t rc
;
3398 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3399 &return_value_length
, &flags
, &rc
);
3401 test_true(return_value);
3402 test_compare(MEMCACHED_SUCCESS, rc);
3404 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3410 return TEST_SUCCESS
;
3413 static test_return_t
mget_read(memcached_st
*memc
)
3416 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3418 test_compare(MEMCACHED_SUCCESS
,
3419 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3421 // Go fetch the keys and test to see if all of them were returned
3423 unsigned int keys_returned
;
3424 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3425 test_true(keys_returned
> 0);
3426 test_compare_got(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3429 return TEST_SUCCESS
;
3432 static test_return_t
mget_read_result(memcached_st
*memc
)
3435 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3437 test_compare(MEMCACHED_SUCCESS
,
3438 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3440 /* Turn this into a help function */
3442 memcached_result_st results_obj
;
3443 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3445 memcached_return_t rc
;
3446 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3448 if (rc
== MEMCACHED_IN_PROGRESS
)
3454 test_compare(MEMCACHED_SUCCESS
, rc
);
3456 test_compare(MEMCACHED_END
, rc
);
3458 memcached_result_free(&results_obj
);
3461 return TEST_SUCCESS
;
3464 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3467 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3469 test_compare(MEMCACHED_SUCCESS
,
3470 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3472 memcached_result_st
*results
= NULL
;
3473 memcached_return_t rc
;
3474 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3477 test_compare(MEMCACHED_SUCCESS
, rc
);
3479 test_compare(MEMCACHED_END
, rc
);
3481 memcached_result_free(results
);
3484 return TEST_SUCCESS
;
3487 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3490 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3492 test_compare(MEMCACHED_SUCCESS
,
3493 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3495 // We will scan for just one key
3497 memcached_result_st results_obj
;
3498 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3500 memcached_return_t rc
;
3501 results
= memcached_fetch_result(memc
, results
, &rc
);
3503 test_compare(MEMCACHED_SUCCESS
, rc
);
3505 memcached_result_free(&results_obj
);
3508 // We already have a read happening, lets start up another one.
3509 test_compare(MEMCACHED_SUCCESS
,
3510 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3512 memcached_result_st results_obj
;
3513 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3515 memcached_return_t rc
;
3516 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3519 test_compare(MEMCACHED_SUCCESS
, rc
);
3521 test_compare(MEMCACHED_END
, rc
);
3523 memcached_result_free(&results_obj
);
3526 return TEST_SUCCESS
;
3529 static test_return_t
mget_read_function(memcached_st
*memc
)
3531 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3533 test_compare(MEMCACHED_SUCCESS
,
3534 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3536 memcached_execute_fn callbacks
[]= { &callback_counter
};
3538 test_compare(MEMCACHED_SUCCESS
,
3539 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3541 return TEST_SUCCESS
;
3544 static test_return_t
delete_generate(memcached_st
*memc
)
3546 for (size_t x
= 0; x
< global_count
; x
++)
3548 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3551 return TEST_SUCCESS
;
3554 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3557 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3559 for (size_t x
= 0; x
< global_count
; x
++)
3561 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3564 return TEST_SUCCESS
;
3567 static test_return_t
add_host_test1(memcached_st
*memc
)
3569 memcached_return_t rc
;
3570 char servername
[]= "0.example.com";
3572 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3574 test_compare(1U, memcached_server_list_count(servers
));
3576 for (uint32_t x
= 2; x
< 20; x
++)
3578 char buffer
[SMALL_STRING_LEN
];
3580 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3581 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3583 test_compare(MEMCACHED_SUCCESS
, rc
);
3584 test_compare(x
, memcached_server_list_count(servers
));
3587 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3588 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3590 memcached_server_list_free(servers
);
3592 return TEST_SUCCESS
;
3595 static test_return_t
pre_nonblock(memcached_st
*memc
)
3597 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3599 return TEST_SUCCESS
;
3602 static test_return_t
pre_cork(memcached_st
*memc
)
3605 return TEST_SKIPPED
;
3608 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3609 return TEST_SUCCESS
;
3611 return TEST_SKIPPED
;
3614 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3617 return TEST_SKIPPED
;
3619 test_return_t test_rc
;
3620 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3623 return pre_nonblock(memc
);
3626 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3628 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3629 test_true(memc_clone
);
3631 // The memcached_version needs to be done on a clone, because the server
3632 // will not toggle protocol on an connection.
3633 memcached_version(memc_clone
);
3635 memcached_return_t rc
= MEMCACHED_FAILURE
;
3636 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3638 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3639 test_compare(MEMCACHED_SUCCESS
,
3640 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3641 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3645 memcached_free(memc_clone
);
3646 return TEST_SKIPPED
;
3649 memcached_free(memc_clone
);
3651 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3654 static test_return_t
pre_murmur(memcached_st
*memc
)
3656 #ifdef HAVE_MURMUR_HASH
3657 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3658 return TEST_SUCCESS
;
3661 return TEST_SKIPPED
;
3665 static test_return_t
pre_jenkins(memcached_st
*memc
)
3667 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3669 return TEST_SUCCESS
;
3673 static test_return_t
pre_md5(memcached_st
*memc
)
3675 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3677 return TEST_SUCCESS
;
3680 static test_return_t
pre_crc(memcached_st
*memc
)
3682 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3684 return TEST_SUCCESS
;
3687 static test_return_t
pre_hsieh(memcached_st
*memc
)
3689 #ifdef HAVE_HSIEH_HASH
3690 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3691 return TEST_SUCCESS
;
3694 return TEST_SKIPPED
;
3698 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3700 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3702 return TEST_SUCCESS
;
3705 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3707 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3709 return TEST_SUCCESS
;
3712 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3714 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3716 return TEST_SUCCESS
;
3719 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3721 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3723 return TEST_SUCCESS
;
3726 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3728 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3729 test_compare(MEMCACHED_SUCCESS
, rc
);
3731 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3732 test_true(value
== 1);
3734 return TEST_SUCCESS
;
3737 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3739 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3740 test_compare(MEMCACHED_SUCCESS
, rc
);
3742 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3743 test_true(value
== 1);
3745 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3746 test_compare(MEMCACHED_SUCCESS
, rc
);
3748 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3749 test_true(value
== MEMCACHED_HASH_MD5
);
3751 return TEST_SUCCESS
;
3755 @note This should be testing to see if the server really supports the binary protocol.
3757 static test_return_t
pre_binary(memcached_st
*memc
)
3759 memcached_return_t rc
= MEMCACHED_FAILURE
;
3761 if (libmemcached_util_version_check(memc
, 1, 4, 4))
3763 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3764 test_compare(MEMCACHED_SUCCESS
, rc
);
3765 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3768 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3771 static test_return_t
pre_sasl(memcached_st
*memc
)
3773 memcached_return_t rc
= MEMCACHED_FAILURE
;
3775 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
3776 const char *server
= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
3777 const char *user
= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
3778 const char *pass
= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
3780 if (server
and user
and pass
)
3782 memcached_server_st
*servers
= memcached_servers_parse(server
);
3784 memcached_servers_reset(memc
);
3785 test_true(memcached_server_push(memc
, servers
) == MEMCACHED_SUCCESS
);
3786 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3787 rc
= memcached_set_sasl_auth_data(memc
, user
, pass
);
3788 test_compare(MEMCACHED_SUCCESS
, rc
);
3794 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3797 static test_return_t
pre_replication(memcached_st
*memc
)
3799 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3802 * Make sure that we store the item on all servers
3803 * (master + replicas == number of servers)
3805 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3806 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3808 return TEST_SUCCESS
;
3812 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3814 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3816 return pre_nonblock(memc
);
3820 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3824 #ifdef HARD_MALLOC_TESTS
3825 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3833 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3837 #ifdef HARD_MALLOC_TESTS
3838 void *ret
= malloc(size
+ 8);
3841 ret
= (void*)((caddr_t
)ret
+ 8);
3844 void *ret
= malloc(size
);
3849 memset(ret
, 0xff, size
);
3856 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3858 #ifdef HARD_MALLOC_TESTS
3859 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3860 void *nmem
= realloc(real_ptr
, size
+ 8);
3865 ret
= (void*)((caddr_t
)nmem
+ 8);
3871 return realloc(mem
, size
);
3876 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3878 #ifdef HARD_MALLOC_TESTS
3879 void *mem
= my_malloc(ptr
, nelem
* size
);
3882 memset(mem
, 0, nelem
* size
);
3888 return calloc(nelem
, size
);
3892 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3894 memcached_return_t rc
;
3895 const char *key
= "mine";
3898 /* Make sure be default none exists */
3899 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3900 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3902 /* Test a clean set */
3903 test_compare(MEMCACHED_SUCCESS
,
3904 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3906 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3908 test_memcmp(value
, key
, 4);
3909 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3911 /* Test that we can turn it off */
3912 test_compare(MEMCACHED_SUCCESS
,
3913 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3915 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3917 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3919 /* Now setup for main test */
3920 test_compare(MEMCACHED_SUCCESS
,
3921 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3923 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3925 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3926 test_memcmp(value
, key
, 4);
3928 /* Set to Zero, and then Set to something too large */
3931 memset(long_key
, 0, 255);
3933 test_compare(MEMCACHED_SUCCESS
,
3934 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3936 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3938 test_true(rc
== MEMCACHED_FAILURE
);
3939 test_true(value
== NULL
);
3941 /* Test a long key for failure */
3942 /* TODO, extend test to determine based on setting, what result should be */
3943 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3944 test_compare(MEMCACHED_SUCCESS
,
3945 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3947 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3948 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3949 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3950 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3952 /* Test for a bad prefix, but with a short key */
3953 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3954 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3956 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3957 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3960 return TEST_SUCCESS
;
3963 static test_return_t
set_namespace(memcached_st
*memc
)
3965 memcached_return_t rc
;
3966 const char *key
= "mine";
3969 /* Make sure be default none exists */
3970 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3971 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3973 /* Test a clean set */
3974 test_compare(MEMCACHED_SUCCESS
,
3975 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3977 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3979 test_memcmp(value
, key
, 4);
3980 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3982 return TEST_SUCCESS
;
3985 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3987 test_return_if(pre_binary(memc
));
3988 test_return_if(set_namespace(memc
));
3990 return TEST_SUCCESS
;
3993 #ifdef MEMCACHED_ENABLE_DEPRECATED
3994 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3996 void *test_ptr
= NULL
;
3999 memcached_malloc_fn malloc_cb
=
4000 (memcached_malloc_fn
)my_malloc
;
4001 cb_ptr
= *(void **)&malloc_cb
;
4002 memcached_return_t rc
;
4004 test_compare(MEMCACHED_SUCCESS
,
4005 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
4006 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
4007 test_compare(MEMCACHED_SUCCESS
, rc
);
4008 test_true(test_ptr
== cb_ptr
);
4012 memcached_realloc_fn realloc_cb
=
4013 (memcached_realloc_fn
)my_realloc
;
4014 cb_ptr
= *(void **)&realloc_cb
;
4015 memcached_return_t rc
;
4017 test_compare(MEMCACHED_SUCCESS
,
4018 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
4019 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
4020 test_compare(MEMCACHED_SUCCESS
, rc
);
4021 test_true(test_ptr
== cb_ptr
);
4025 memcached_free_fn free_cb
=
4026 (memcached_free_fn
)my_free
;
4027 cb_ptr
= *(void **)&free_cb
;
4028 memcached_return_t rc
;
4030 test_compare(MEMCACHED_SUCCESS
,
4031 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
4032 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
4033 test_compare(MEMCACHED_SUCCESS
, rc
);
4034 test_true(test_ptr
== cb_ptr
);
4037 return TEST_SUCCESS
;
4042 static test_return_t
set_memory_alloc(memcached_st
*memc
)
4044 test_compare(MEMCACHED_FAILURE
,
4045 memcached_set_memory_allocators(memc
, NULL
, my_free
,
4046 my_realloc
, my_calloc
, NULL
));
4048 test_compare(MEMCACHED_SUCCESS
,
4049 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
4050 my_realloc
, my_calloc
, NULL
));
4052 memcached_malloc_fn mem_malloc
;
4053 memcached_free_fn mem_free
;
4054 memcached_realloc_fn mem_realloc
;
4055 memcached_calloc_fn mem_calloc
;
4056 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
4057 &mem_realloc
, &mem_calloc
);
4059 test_true(mem_malloc
== my_malloc
);
4060 test_true(mem_realloc
== my_realloc
);
4061 test_true(mem_calloc
== my_calloc
);
4062 test_true(mem_free
== my_free
);
4064 return TEST_SUCCESS
;
4067 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
4070 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4071 memcached_hash_t hash
;
4072 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4073 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
4076 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4077 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4079 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4081 if (hash
!= MEMCACHED_HASH_CRC
)
4082 return TEST_SKIPPED
;
4084 return TEST_SUCCESS
;
4087 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
4090 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4091 memcached_hash_t hash
;
4092 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4093 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
4096 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4097 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4099 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4101 if (hash
!= MEMCACHED_HASH_HSIEH
)
4102 return TEST_SKIPPED
;
4105 return TEST_SUCCESS
;
4108 static test_return_t
enable_cas(memcached_st
*memc
)
4110 unsigned int set
= 1;
4112 if (libmemcached_util_version_check(memc
, 1, 2, 4))
4114 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
4116 return TEST_SUCCESS
;
4119 return TEST_SKIPPED
;
4122 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
4124 memcached_version(memc
);
4126 memcached_server_instance_st instance
=
4127 memcached_server_instance_by_position(memc
, 0);
4129 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
4130 or instance
->minor_version
> 2)
4132 return TEST_SUCCESS
;
4135 return TEST_SKIPPED
;
4138 static test_return_t
pre_unix_socket(memcached_st
*memc
)
4142 memcached_servers_reset(memc
);
4143 const char *socket_file
= default_socket();
4145 test_skip(0, stat(socket_file
, &buf
));
4147 test_compare(MEMCACHED_SUCCESS
,
4148 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
4150 return TEST_SUCCESS
;
4153 static test_return_t
pre_nodelay(memcached_st
*memc
)
4155 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
4156 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
4158 return TEST_SUCCESS
;
4161 static test_return_t
pre_settimer(memcached_st
*memc
)
4163 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4164 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4166 return TEST_SUCCESS
;
4169 static test_return_t
poll_timeout(memcached_st
*memc
)
4171 const uint64_t timeout
= 100; // Not using, just checking that it sets
4173 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4176 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
4178 return TEST_SUCCESS
;
4181 static test_return_t
noreply_test(memcached_st
*memc
)
4183 memcached_return_t ret
;
4184 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
4185 test_true(ret
== MEMCACHED_SUCCESS
);
4186 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4187 test_true(ret
== MEMCACHED_SUCCESS
);
4188 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
4189 test_true(ret
== MEMCACHED_SUCCESS
);
4190 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
4191 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
4192 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
4194 for (int count
=0; count
< 5; ++count
)
4196 for (size_t x
= 0; x
< 100; ++x
)
4199 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4200 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4202 size_t len
= (size_t)check_length
;
4207 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4210 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4213 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4216 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4219 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4225 test_true(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
4229 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4230 ** API and is _ONLY_ done this way to verify that the library works the
4231 ** way it is supposed to do!!!!
4234 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4236 memcached_server_instance_st instance
=
4237 memcached_server_instance_by_position(memc
, x
);
4238 no_msg
+=(int)(instance
->cursor_active
);
4241 test_true(no_msg
== 0);
4242 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4245 ** Now validate that all items was set properly!
4247 for (size_t x
= 0; x
< 100; ++x
)
4251 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4253 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4255 size_t len
= (size_t)check_length
;
4258 char* value
=memcached_get(memc
, key
, strlen(key
),
4259 &length
, &flags
, &ret
);
4260 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4263 case 0: /* FALLTHROUGH */
4264 case 1: /* FALLTHROUGH */
4266 test_true(strncmp(value
, key
, len
) == 0);
4267 test_true(len
== length
);
4270 test_true(length
== len
* 2);
4273 test_true(length
== len
* 3);
4283 /* Try setting an illegal cas value (should not return an error to
4284 * the caller (because we don't expect a return message from the server)
4286 const char* keys
[]= {"0"};
4287 size_t lengths
[]= {1};
4290 memcached_result_st results_obj
;
4291 memcached_result_st
*results
;
4292 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4293 test_true(ret
== MEMCACHED_SUCCESS
);
4295 results
= memcached_result_create(memc
, &results_obj
);
4297 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4299 test_true(ret
== MEMCACHED_SUCCESS
);
4300 uint64_t cas
= memcached_result_cas(results
);
4301 memcached_result_free(&results_obj
);
4303 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4304 test_true(ret
== MEMCACHED_SUCCESS
);
4307 * The item will have a new cas value, so try to set it again with the old
4308 * value. This should fail!
4310 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4311 test_true(ret
== MEMCACHED_SUCCESS
);
4312 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4313 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4314 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4317 return TEST_SUCCESS
;
4320 static test_return_t
analyzer_test(memcached_st
*memc
)
4322 memcached_return_t rc
;
4323 memcached_stat_st
*memc_stat
;
4324 memcached_analysis_st
*report
;
4326 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4327 test_compare(MEMCACHED_SUCCESS
, rc
);
4328 test_true(memc_stat
);
4330 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4331 test_compare(MEMCACHED_SUCCESS
, rc
);
4335 memcached_stat_free(NULL
, memc_stat
);
4337 return TEST_SUCCESS
;
4340 /* Count the objects */
4342 static test_return_t
dump_test(memcached_st
*memc
)
4344 /* No support for Binary protocol yet */
4345 test_skip(false, memc
->flags
.binary_protocol
);
4347 test_compare(TEST_SUCCESS
, set_test3(memc
));
4349 // confirm_key_count() call dump
4350 size_t counter
= confirm_key_count(memc
);
4352 /* We may have more then 32 if our previous flush has not completed */
4353 test_true(counter
>= 32);
4355 return TEST_SUCCESS
;
4358 struct test_pool_context_st
{
4359 memcached_pool_st
* pool
;
4363 static void* connection_release(void *arg
)
4365 test_pool_context_st
*resource
= static_cast<test_pool_context_st
*>(arg
);
4368 // Release all of the memc we are holding
4369 assert(memcached_success(memcached_pool_push(resource
->pool
, resource
->mmc
)));
4373 #define POOL_SIZE 10
4374 static test_return_t
connection_pool_test(memcached_st
*memc
)
4376 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4377 test_true(pool
!= NULL
);
4378 memcached_st
*mmc
[POOL_SIZE
];
4379 memcached_return_t rc
;
4381 // Fill up our array that we will store the memc that are in the pool
4382 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4384 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4385 test_true(mmc
[x
] != NULL
);
4386 test_compare(MEMCACHED_SUCCESS
, rc
);
4389 // All memc should be gone
4390 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4391 test_compare(MEMCACHED_SUCCESS
, rc
);
4394 test_pool_context_st item
= { pool
, mmc
[9] };
4396 pthread_create(&tid
, NULL
, connection_release
, &item
);
4397 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4398 test_compare(MEMCACHED_SUCCESS
, rc
);
4399 pthread_join(tid
, NULL
);
4401 const char *key
= "key";
4402 size_t keylen
= strlen(key
);
4404 // verify that I can do ops with all connections
4405 test_compare(MEMCACHED_SUCCESS
,
4406 memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0));
4408 for (uint64_t x
= 0; x
< POOL_SIZE
; ++x
)
4410 uint64_t number_value
;
4411 test_compare(MEMCACHED_SUCCESS
,
4412 memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
));
4413 test_compare(number_value
, (x
+1));
4417 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4419 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[x
]));
4423 /* verify that I can set behaviors on the pool when I don't have all
4424 * of the connections in the pool. It should however be enabled
4425 * when I push the item into the pool
4427 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4430 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4431 test_compare(MEMCACHED_SUCCESS
, rc
);
4433 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4436 test_compare(UINT64_C(9999), memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4437 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[1]));
4438 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4440 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4441 test_compare(UINT64_C(9999), memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4442 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4444 test_true(memcached_pool_destroy(pool
) == memc
);
4446 return TEST_SUCCESS
;
4449 static test_return_t
util_version_test(memcached_st
*memc
)
4451 bool if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4452 test_true(if_successful
);
4454 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4456 // We expect failure
4459 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4460 fprintf(stderr
, "\nDumping Server Information\n\n");
4461 memcached_server_fn callbacks
[1];
4463 callbacks
[0]= dump_server_information
;
4464 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4465 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4467 test_true(if_successful
== false);
4469 memcached_server_instance_st instance
=
4470 memcached_server_instance_by_position(memc
, 0);
4472 memcached_version(memc
);
4474 // We only use one binary when we test, so this should be just fine.
4475 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4476 test_true(if_successful
== true);
4478 if (instance
->micro_version
> 0)
4479 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4480 else if (instance
->minor_version
> 0)
4481 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4482 else if (instance
->major_version
> 0)
4483 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4485 test_true(if_successful
== true);
4487 if (instance
->micro_version
> 0)
4488 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4489 else if (instance
->minor_version
> 0)
4490 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4491 else if (instance
->major_version
> 0)
4492 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4494 test_true(if_successful
== false);
4496 return TEST_SUCCESS
;
4499 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4501 memcached_return_t rc
;
4502 memcached_server_instance_st instance
=
4503 memcached_server_instance_by_position(memc
, 0);
4505 // Test both the version that returns a code, and the one that does not.
4506 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4507 memcached_server_port(instance
) -1, NULL
) == -1);
4509 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4510 memcached_server_port(instance
) -1, &rc
) == -1);
4511 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4513 return TEST_SUCCESS
;
4517 static test_return_t
getpid_test(memcached_st
*memc
)
4519 memcached_return_t rc
;
4520 memcached_server_instance_st instance
=
4521 memcached_server_instance_by_position(memc
, 0);
4523 // Test both the version that returns a code, and the one that does not.
4524 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4525 memcached_server_port(instance
), NULL
) > -1);
4527 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4528 memcached_server_port(instance
), &rc
) > -1);
4529 test_compare(MEMCACHED_SUCCESS
, rc
);
4531 return TEST_SUCCESS
;
4534 static test_return_t
ping_test(memcached_st
*memc
)
4536 memcached_return_t rc
;
4537 memcached_server_instance_st instance
=
4538 memcached_server_instance_by_position(memc
, 0);
4540 // Test both the version that returns a code, and the one that does not.
4541 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4542 memcached_server_port(instance
), NULL
));
4544 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4545 memcached_server_port(instance
), &rc
));
4547 test_compare(MEMCACHED_SUCCESS
, rc
);
4549 return TEST_SUCCESS
;
4554 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4558 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4559 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4560 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4561 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4562 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4563 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4564 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4565 #ifdef HAVE_HSIEH_HASH
4566 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4568 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4569 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4570 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4572 return TEST_SUCCESS
;
4576 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4578 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4579 #ifdef HAVE_HSIEH_HASH
4580 expected_rc
= MEMCACHED_SUCCESS
;
4582 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4583 (uint64_t)MEMCACHED_HASH_HSIEH
);
4584 test_true(rc
== expected_rc
);
4586 return TEST_SUCCESS
;
4589 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4591 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4592 #ifdef HAVE_MURMUR_HASH
4593 expected_rc
= MEMCACHED_SUCCESS
;
4595 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4596 (uint64_t)MEMCACHED_HASH_MURMUR
);
4597 test_true(rc
== expected_rc
);
4599 return TEST_SUCCESS
;
4602 static test_return_t
one_at_a_time_run (memcached_st
*)
4607 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4611 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
);
4612 test_true(one_at_a_time_values
[x
] == hash_val
);
4615 return TEST_SUCCESS
;
4618 static test_return_t
md5_run (memcached_st
*)
4623 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4627 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4628 test_true(md5_values
[x
] == hash_val
);
4631 return TEST_SUCCESS
;
4634 static test_return_t
crc_run (memcached_st
*)
4639 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4643 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4644 test_true(crc_values
[x
] == hash_val
);
4647 return TEST_SUCCESS
;
4650 static test_return_t
fnv1_64_run (memcached_st
*)
4655 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4659 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4660 test_true(fnv1_64_values
[x
] == hash_val
);
4663 return TEST_SUCCESS
;
4666 static test_return_t
fnv1a_64_run (memcached_st
*)
4671 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4675 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4676 test_true(fnv1a_64_values
[x
] == hash_val
);
4679 return TEST_SUCCESS
;
4682 static test_return_t
fnv1_32_run (memcached_st
*)
4687 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4691 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4692 test_true(fnv1_32_values
[x
] == hash_val
);
4695 return TEST_SUCCESS
;
4698 static test_return_t
fnv1a_32_run (memcached_st
*)
4703 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4707 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4708 test_true(fnv1a_32_values
[x
] == hash_val
);
4711 return TEST_SUCCESS
;
4714 static test_return_t
hsieh_run (memcached_st
*)
4719 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4723 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4724 test_true(hsieh_values
[x
] == hash_val
);
4727 return TEST_SUCCESS
;
4730 static test_return_t
murmur_run (memcached_st
*)
4732 #ifdef WORDS_BIGENDIAN
4733 (void)murmur_values
;
4734 return TEST_SKIPPED
;
4739 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4743 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
4744 test_true(murmur_values
[x
] == hash_val
);
4747 return TEST_SUCCESS
;
4751 static test_return_t
jenkins_run (memcached_st
*)
4756 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4760 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4761 test_true(jenkins_values
[x
] == hash_val
);
4764 return TEST_SUCCESS
;
4767 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *context
)
4770 return libhashkit_md5(string
, string_length
);
4773 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *context
)
4776 return libhashkit_crc32(string
, string_length
);
4779 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4785 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5"));
4787 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};
4788 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};
4790 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4792 hashkit_clone(&new_kit
, kit
);
4793 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4795 memcached_set_hashkit(memc
, &new_kit
);
4798 Verify Setting the hash.
4800 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4804 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4805 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4810 Now check memcached_st.
4812 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4816 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4817 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4820 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4822 memcached_set_hashkit(memc
, &new_kit
);
4825 Verify Setting the hash.
4827 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4831 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4832 test_true(crc_values
[x
] == hash_val
);
4835 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4839 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4840 test_compare(crc_hosts
[x
], hash_val
);
4843 memcached_free(memc
);
4845 return TEST_SUCCESS
;
4849 Test case adapted from John Gorman <johngorman2@gmail.com>
4851 We are testing the error condition when we connect to a server via memcached_get()
4852 but find that the server is not available.
4854 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4856 const char *key
= "MemcachedLives";
4859 memcached_return rc
;
4862 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4864 // See if memcached is reachable.
4865 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4869 test_true(memcached_failed(rc
));
4871 memcached_free(tl_memc_h
);
4873 return TEST_SUCCESS
;
4877 We connect to a server which exists, but search for a key that does not exist.
4879 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4881 const char *key
= "MemcachedKeyNotEXIST";
4884 memcached_return rc
;
4887 // See if memcached is reachable.
4888 value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4892 test_compare(MEMCACHED_NOTFOUND
, rc
);
4894 return TEST_SUCCESS
;
4898 Test case adapted from John Gorman <johngorman2@gmail.com>
4900 We are testing the error condition when we connect to a server via memcached_get_by_key()
4901 but find that the server is not available.
4903 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4906 memcached_st
*tl_memc_h
;
4907 memcached_server_st
*servers
;
4909 const char *key
= "MemcachedLives";
4912 memcached_return rc
;
4916 tl_memc_h
= memcached_create(NULL
);
4917 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4918 memcached_server_push(tl_memc_h
, servers
);
4919 memcached_server_list_free(servers
);
4921 // See if memcached is reachable.
4922 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4926 test_true(memcached_failed(rc
));
4928 memcached_free(tl_memc_h
);
4930 return TEST_SUCCESS
;
4934 We connect to a server which exists, but search for a key that does not exist.
4936 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4938 const char *key
= "MemcachedKeyNotEXIST";
4941 memcached_return rc
;
4944 // See if memcached is reachable.
4945 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4949 test_compare(MEMCACHED_NOTFOUND
, rc
);
4951 return TEST_SUCCESS
;
4955 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*)
4957 memcached_st
*memc
= memcached_create(NULL
);
4960 test_compare(MEMCACHED_SUCCESS
,
4961 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1));
4963 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
4965 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
4966 test_compare(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
, memcached_behavior_get_distribution(memc
));
4968 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");
4969 memcached_server_push(memc
, server_pool
);
4971 /* verify that the server list was parsed okay. */
4972 test_compare(8U, memcached_server_count(memc
));
4973 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
4974 test_compare(in_port_t(11211), server_pool
[0].port
);
4975 test_compare(600U, server_pool
[0].weight
);
4976 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
4977 test_compare(in_port_t(11211), server_pool
[2].port
);
4978 test_compare(200U, server_pool
[2].weight
);
4979 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
4980 test_compare(in_port_t(11211), server_pool
[7].port
);
4981 test_compare(100U, server_pool
[7].weight
);
4983 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
4984 * us test the boundary wraparound.
4986 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
4988 /* verify the standard ketama set. */
4989 for (uint32_t x
= 0; x
< 99; x
++)
4991 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
4992 memcached_server_instance_st instance
=
4993 memcached_server_instance_by_position(memc
, server_idx
);
4994 const char *hostname
= memcached_server_name(instance
);
4996 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
4999 memcached_server_list_free(server_pool
);
5000 memcached_free(memc
);
5002 return TEST_SUCCESS
;
5005 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*)
5007 memcached_st
*memc
= memcached_create(NULL
);
5010 test_compare(MEMCACHED_SUCCESS
,
5011 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1));
5013 test_compare(UINT64_C(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
5015 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
));
5016 test_compare(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
, memcached_behavior_get_distribution(memc
));
5018 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");
5019 test_true(server_pool
);
5020 memcached_server_push(memc
, server_pool
);
5022 /* verify that the server list was parsed okay. */
5023 test_compare(8U, memcached_server_count(memc
));
5024 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5025 test_compare(in_port_t(11211), server_pool
[0].port
);
5026 test_compare(600U, server_pool
[0].weight
);
5027 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5028 test_compare(in_port_t(11211), server_pool
[2].port
);
5029 test_compare(200U, server_pool
[2].weight
);
5030 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5031 test_compare(in_port_t(11211), server_pool
[7].port
);
5032 test_compare(100U, server_pool
[7].weight
);
5034 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5035 * us test the boundary wraparound.
5037 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
5039 /* verify the standard ketama set. */
5040 for (uint32_t x
= 0; x
< 99; x
++)
5042 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
5044 memcached_server_instance_st instance
=
5045 memcached_server_instance_by_position(memc
, server_idx
);
5047 const char *hostname
= memcached_server_name(instance
);
5049 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
5052 memcached_server_list_free(server_pool
);
5053 memcached_free(memc
);
5055 return TEST_SUCCESS
;
5058 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5060 test_return_t test_rc
;
5061 test_rc
= pre_binary(memc
);
5063 if (test_rc
!= TEST_SUCCESS
)
5066 const char *key
= "regression_bug_434484";
5067 size_t keylen
= strlen(key
);
5069 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5070 test_compare(MEMCACHED_NOTSTORED
, ret
);
5072 size_t size
= 2048 * 1024;
5073 char *data
= (char*)calloc(1, size
);
5075 test_compare(MEMCACHED_E2BIG
,
5076 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
5079 return TEST_SUCCESS
;
5082 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5084 test_return_t test_rc
;
5085 test_rc
= pre_binary(memc
);
5087 if (test_rc
!= TEST_SUCCESS
)
5090 memcached_return_t rc
;
5092 memcached_execute_fn callbacks
[]= { &callback_counter
};
5095 * I only want to hit only _one_ server so I know the number of requests I'm
5096 * sending in the pipleine to the server. Let's try to do a multiget of
5097 * 1024 (that should satisfy most users don't you think?). Future versions
5098 * will include a mget_execute function call if you need a higher number.
5100 uint32_t number_of_hosts
= memcached_server_count(memc
);
5101 memc
->number_of_hosts
= 1;
5102 const size_t max_keys
= 1024;
5103 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
5104 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5106 for (size_t x
= 0; x
< max_keys
; ++x
)
5110 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5116 * Run two times.. the first time we should have 100% cache miss,
5117 * and the second time we should have 100% cache hits
5119 for (size_t y
= 0; y
< 2; y
++)
5121 test_compare(MEMCACHED_SUCCESS
,
5122 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
5124 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
5125 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5129 /* The first iteration should give me a 100% cache miss. verify that*/
5130 char blob
[1024]= { 0 };
5132 test_false(counter
);
5134 for (size_t x
= 0; x
< max_keys
; ++x
)
5136 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5137 blob
, sizeof(blob
), 0, 0);
5138 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5143 /* Verify that we received all of the key/value pairs */
5144 test_compare(counter
, max_keys
);
5148 /* Release allocated resources */
5149 for (size_t x
= 0; x
< max_keys
; ++x
)
5156 memc
->number_of_hosts
= number_of_hosts
;
5158 return TEST_SUCCESS
;
5161 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5163 memcached_return_t rc
;
5164 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5165 test_compare(MEMCACHED_SUCCESS
, rc
);
5167 return regression_bug_434843(memc
);
5170 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5172 memcached_return_t rc
;
5173 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5174 test_compare(MEMCACHED_SUCCESS
, rc
);
5176 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5177 test_compare(MEMCACHED_SUCCESS
, rc
);
5178 test_true(bytes_str
);
5179 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
5181 test_compare(MEMCACHED_SUCCESS
, rc
);
5182 test_true(bytes_read_str
);
5184 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
5185 "bytes_written", &rc
);
5186 test_compare(MEMCACHED_SUCCESS
, rc
);
5187 test_true(bytes_written_str
);
5189 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
5190 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
5191 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
5193 test_true(bytes
!= bytes_read
);
5194 test_true(bytes
!= bytes_written
);
5196 /* Release allocated resources */
5198 free(bytes_read_str
);
5199 free(bytes_written_str
);
5200 memcached_stat_free(NULL
, memc_stat
);
5202 return TEST_SUCCESS
;
5206 * The test case isn't obvious so I should probably document why
5207 * it works the way it does. Bug 442914 was caused by a bug
5208 * in the logic in memcached_purge (it did not handle the case
5209 * where the number of bytes sent was equal to the watermark).
5210 * In this test case, create messages so that we hit that case
5211 * and then disable noreply mode and issue a new command to
5212 * verify that it isn't stuck. If we change the format for the
5213 * delete command or the watermarks, we need to update this
5216 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5218 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5219 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5221 uint32_t number_of_hosts
= memcached_server_count(memc
);
5222 memc
->number_of_hosts
= 1;
5227 for (uint32_t x
= 0; x
< 250; ++x
)
5229 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5230 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
5231 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5234 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5237 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
5238 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5240 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5241 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
5243 memc
->number_of_hosts
= number_of_hosts
;
5245 return TEST_SUCCESS
;
5248 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5250 memcached_server_instance_st instance_one
;
5251 memcached_server_instance_st instance_two
;
5253 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
5254 return TEST_SKIPPED
;
5256 test_compare(MEMCACHED_SUCCESS
,
5257 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
5259 const unsigned int max_keys
= 100;
5260 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
5261 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5263 for (unsigned int x
= 0; x
< max_keys
; ++x
)
5267 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5270 test_compare(MEMCACHED_SUCCESS
,
5271 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
5275 ** We are using the quiet commands to store the replicas, so we need
5276 ** to ensure that all of them are processed before we can continue.
5277 ** In the test we go directly from storing the object to trying to
5278 ** receive the object from all of the different servers, so we
5279 ** could end up in a race condition (the memcached server hasn't yet
5280 ** processed the quiet command from the replication set when it process
5281 ** the request from the other client (created by the clone)). As a
5282 ** workaround for that we call memcached_quit to send the quit command
5283 ** to the server and wait for the response ;-) If you use the test code
5284 ** as an example for your own code, please note that you shouldn't need
5287 memcached_quit(memc
);
5289 /* Verify that all messages are stored, and we didn't stuff too much
5292 test_compare(MEMCACHED_SUCCESS
,
5293 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5295 unsigned int counter
= 0;
5296 memcached_execute_fn callbacks
[]= { &callback_counter
};
5297 test_compare(MEMCACHED_SUCCESS
,
5298 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5300 /* Verify that we received all of the key/value pairs */
5301 test_compare(counter
, max_keys
);
5303 memcached_quit(memc
);
5305 * Don't do the following in your code. I am abusing the internal details
5306 * within the library, and this is not a supported interface.
5307 * This is to verify correct behavior in the library. Fake that two servers
5310 instance_one
= memcached_server_instance_by_position(memc
, 0);
5311 instance_two
= memcached_server_instance_by_position(memc
, 2);
5312 in_port_t port0
= instance_one
->port
;
5313 in_port_t port2
= instance_two
->port
;
5315 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5316 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5318 test_compare(MEMCACHED_SUCCESS
,
5319 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5322 test_compare(MEMCACHED_SUCCESS
,
5323 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5324 test_compare(counter
, (unsigned int)max_keys
);
5326 /* restore the memc handle */
5327 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5328 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5330 memcached_quit(memc
);
5332 /* Remove half of the objects */
5333 for (size_t x
= 0; x
< max_keys
; ++x
)
5337 test_compare(MEMCACHED_SUCCESS
,
5338 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
5342 memcached_quit(memc
);
5343 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5344 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5346 /* now retry the command, this time we should have cache misses */
5347 test_compare(MEMCACHED_SUCCESS
,
5348 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5351 test_compare(MEMCACHED_SUCCESS
,
5352 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5353 test_compare(counter
, (unsigned int)(max_keys
>> 1));
5355 /* Release allocated resources */
5356 for (size_t x
= 0; x
< max_keys
; ++x
)
5363 /* restore the memc handle */
5364 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5365 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5367 return TEST_SUCCESS
;
5370 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5372 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5373 test_true(memc_clone
);
5374 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5376 memcached_server_instance_st instance
=
5377 memcached_server_instance_by_position(memc_clone
, 0);
5379 if (instance
->major_version
> 1 ||
5380 (instance
->major_version
== 1 &&
5381 instance
->minor_version
> 2))
5383 /* Binary protocol doesn't support deferred delete */
5384 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5385 test_true(bin_clone
);
5386 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5387 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
5388 memcached_free(bin_clone
);
5390 memcached_quit(memc_clone
);
5392 /* If we know the server version, deferred delete should fail
5393 * with invalid arguments */
5394 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
5396 /* If we don't know the server version, we should get a protocol error */
5397 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5399 /* but there is a bug in some of the memcached servers (1.4) that treats
5400 * the counter as noreply so it doesn't send the proper error message
5402 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5404 /* And buffered mode should be disabled and we should get protocol error */
5405 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5406 rc
= memcached_delete(memc
, "foo", 3, 1);
5407 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5409 /* Same goes for noreply... */
5410 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5411 rc
= memcached_delete(memc
, "foo", 3, 1);
5412 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5414 /* but a normal request should go through (and be buffered) */
5415 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
5416 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
5418 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
5419 /* unbuffered noreply should be success */
5420 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
5421 /* unbuffered with reply should be not found... */
5422 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5423 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
5426 memcached_free(memc_clone
);
5427 return TEST_SUCCESS
;
5431 /* Test memcached_server_get_last_disconnect
5432 * For a working server set, shall be NULL
5433 * For a set of non existing server, shall not be NULL
5435 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5437 memcached_return_t rc
;
5438 memcached_server_instance_st disconnected_server
;
5440 /* With the working set of server */
5441 const char *key
= "marmotte";
5442 const char *value
= "milka";
5444 memcached_reset_last_disconnected_server(memc
);
5445 test_false(memc
->last_disconnected_server
);
5446 rc
= memcached_set(memc
, key
, strlen(key
),
5447 value
, strlen(value
),
5448 (time_t)0, (uint32_t)0);
5449 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5451 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5452 test_false(disconnected_server
);
5454 /* With a non existing server */
5456 memcached_server_st
*servers
;
5458 const char *server_list
= "localhost:9";
5460 servers
= memcached_servers_parse(server_list
);
5462 mine
= memcached_create(NULL
);
5463 rc
= memcached_server_push(mine
, servers
);
5464 test_compare(MEMCACHED_SUCCESS
, rc
);
5465 memcached_server_list_free(servers
);
5468 rc
= memcached_set(mine
, key
, strlen(key
),
5469 value
, strlen(value
),
5470 (time_t)0, (uint32_t)0);
5471 test_true(memcached_failed(rc
));
5473 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5474 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5475 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5476 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5478 memcached_quit(mine
);
5479 memcached_free(mine
);
5481 return TEST_SUCCESS
;
5484 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5486 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5487 char buffer
[BUFSIZ
];
5489 test_compare(MEMCACHED_SUCCESS
,
5490 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5492 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5495 // We will just use the error strings as our keys
5496 uint32_t counter
= 100;
5499 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5501 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5502 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5503 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, ret
, memcached_last_error_message(memc
));
5505 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5506 test_true(disconnected_server
);
5507 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5508 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5512 memcached_reset_last_disconnected_server(memc
);
5517 memcached_free(memc
);
5519 return TEST_SUCCESS
;
5522 static test_return_t
test_verbosity(memcached_st
*memc
)
5524 memcached_verbosity(memc
, 3);
5526 return TEST_SUCCESS
;
5529 static test_return_t
test_server_failure(memcached_st
*memc
)
5531 if (memcached_server_count(memc
) < 2)
5532 return TEST_SKIPPED
;
5534 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
5536 memcached_st
*local_memc
= memcached_create(NULL
);
5538 memcached_server_add(local_memc
, memcached_server_name(instance
), memcached_server_port(instance
));
5539 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 2);
5541 uint32_t server_count
= memcached_server_count(local_memc
);
5542 test_compare(1U, server_count
);
5544 // Disable the server
5545 instance
= memcached_server_instance_by_position(local_memc
, 0);
5546 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 2;
5548 memcached_return_t rc
;
5549 test_compare_got(MEMCACHED_SERVER_MARKED_DEAD
,
5550 rc
= memcached_set(local_memc
, "foo", strlen("foo"), NULL
, 0, (time_t)0, (uint32_t)0),
5551 memcached_last_error_message(local_memc
));
5553 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5554 test_compare(MEMCACHED_SUCCESS
,
5555 memcached_set(local_memc
, "foo", strlen("foo"), NULL
, 0, (time_t)0, (uint32_t)0));
5557 memcached_last_error_message(local_memc
));
5561 memcached_free(local_memc
);
5563 return TEST_SUCCESS
;
5566 static test_return_t
test_cull_servers(memcached_st
*memc
)
5568 uint32_t count
= memcached_server_count(memc
);
5572 return TEST_SKIPPED
;
5575 // Do not do this in your code, it is not supported.
5576 memc
->servers
[1].options
.is_dead
= true;
5577 memc
->state
.is_time_for_rebuild
= true;
5579 uint32_t new_count
= memcached_server_count(memc
);
5580 test_compare(count
, new_count
);
5583 test_true(count
== new_count
+ 1 );
5586 return TEST_SUCCESS
;
5590 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5591 const char *key
, size_t key_length
,
5592 const char *value
, size_t value_length
,
5602 return MEMCACHED_SUCCESS
;
5605 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5607 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5608 test_compare(MEMCACHED_SUCCESS
, rc
);
5610 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5611 test_compare(MEMCACHED_SUCCESS
, rc
);
5613 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5614 test_compare(MEMCACHED_SUCCESS
, rc
);
5616 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5617 test_compare(MEMCACHED_SUCCESS
, rc
);
5619 return TEST_SUCCESS
;
5623 * This test ensures that the failure counter isn't incremented during
5624 * normal termination of the memcached instance.
5626 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5628 memcached_return_t rc
;
5629 memcached_server_instance_st instance
;
5631 /* Set value to force connection to the server */
5632 const char *key
= "marmotte";
5633 const char *value
= "milka";
5636 * Please note that I'm abusing the internal structures in libmemcached
5637 * in a non-portable way and you shouldn't be doing this. I'm only
5638 * doing this in order to verify that the library works the way it should
5640 uint32_t number_of_hosts
= memcached_server_count(memc
);
5641 memc
->number_of_hosts
= 1;
5643 /* Ensure that we are connected to the server by setting a value */
5644 rc
= memcached_set(memc
, key
, strlen(key
),
5645 value
, strlen(value
),
5646 (time_t)0, (uint32_t)0);
5647 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5650 instance
= memcached_server_instance_by_position(memc
, 0);
5651 /* The test is to see that the memcached_quit doesn't increase the
5652 * the server failure conter, so let's ensure that it is zero
5653 * before sending quit
5655 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5657 memcached_quit(memc
);
5659 /* Verify that it memcached_quit didn't increment the failure counter
5660 * Please note that this isn't bullet proof, because an error could
5663 test_zero(instance
->server_failure_counter
);
5665 /* restore the instance */
5666 memc
->number_of_hosts
= number_of_hosts
;
5668 return TEST_SUCCESS
;
5672 * This tests ensures expected disconnections (for some behavior changes
5673 * for instance) do not wrongly increase failure counter
5675 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5677 memcached_return rc
;
5679 memcached_st
*memc_clone
;
5680 memc_clone
= memcached_clone(NULL
, memc
);
5681 test_true(memc_clone
);
5683 /* Set value to force connection to the server */
5684 const char *key
= "marmotte";
5685 const char *value
= "milka";
5686 char *string
= NULL
;
5687 size_t string_length
;
5690 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5691 value
, strlen(value
),
5692 (time_t)0, (uint32_t)0);
5693 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5696 /* put failure limit to 1 */
5697 test_compare(MEMCACHED_SUCCESS
,
5698 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1));
5700 /* Put a retry timeout to effectively activate failure_limit effect */
5701 test_compare(MEMCACHED_SUCCESS
,
5702 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
5704 /* change behavior that triggers memcached_quit()*/
5705 test_compare(MEMCACHED_SUCCESS
,
5706 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5709 /* Check if we still are connected */
5710 string
= memcached_get(memc_clone
, key
, strlen(key
),
5711 &string_length
, &flags
, &rc
);
5713 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5716 memcached_free(memc_clone
);
5718 return TEST_SUCCESS
;
5725 * Test that ensures mget_execute does not end into recursive calls that finally fails
5727 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5729 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5730 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5731 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5732 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5733 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5736 return TEST_SKIPPED
; // My MAC can't handle this test
5740 * I only want to hit _one_ server so I know the number of requests I'm
5741 * sending in the pipeline.
5743 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5744 memc
->number_of_hosts
= 1;
5745 size_t max_keys
= 20480;
5748 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5749 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5751 /* First add all of the items.. */
5752 char blob
[1024]= { 0 };
5753 for (size_t x
= 0; x
< max_keys
; ++x
)
5756 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5759 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5760 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5765 /* Try to get all of them with a large multiget */
5767 memcached_execute_function callbacks
[]= { &callback_counter
};
5768 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5769 (size_t)max_keys
, callbacks
, &counter
, 1);
5770 test_compare(MEMCACHED_SUCCESS
, rc
);
5772 char* the_value
= NULL
;
5773 char the_key
[MEMCACHED_MAX_KEY
];
5774 size_t the_key_length
;
5775 size_t the_value_length
;
5779 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5781 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5787 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5790 test_compare(MEMCACHED_END
, rc
);
5792 /* Verify that we got all of the items */
5793 test_compare(counter
, max_keys
);
5796 /* Release all allocated resources */
5797 for (size_t x
= 0; x
< max_keys
; ++x
)
5804 memc
->number_of_hosts
= number_of_hosts
;
5806 return TEST_SUCCESS
;
5809 static test_return_t
regression_bug_583031(memcached_st
*)
5811 memcached_st
*memc
= memcached_create(NULL
);
5813 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5815 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5816 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5817 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5818 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5819 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5820 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5822 memcached_return_t rc
;
5826 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5830 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5832 memcached_free(memc
);
5834 return TEST_SUCCESS
;
5837 static test_return_t
regression_bug_581030(memcached_st
*)
5840 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5841 test_false(local_stat
);
5843 memcached_stat_free(NULL
, NULL
);
5846 return TEST_SUCCESS
;
5849 #define regression_bug_655423_COUNT 6000
5850 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5852 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5853 memc
= NULL
; // Just to make sure it is not used
5858 return TEST_SKIPPED
;
5861 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5862 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5863 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5864 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5866 memset(payload
, int('x'), sizeof(payload
));
5868 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5870 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5871 snprintf(key
, sizeof(key
), "%u", x
);
5873 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5876 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5878 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5879 snprintf(key
, sizeof(key
), "%u", x
);
5881 size_t value_length
;
5882 memcached_return_t rc
;
5883 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5885 if (rc
== MEMCACHED_NOTFOUND
)
5888 test_zero(value_length
);
5892 test_compare(MEMCACHED_SUCCESS
, rc
);
5894 test_compare(100UL, value_length
);
5898 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5899 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5900 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5902 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5903 snprintf(key
, sizeof(key
), "%u", x
);
5905 keys
[x
]= strdup(key
);
5907 key_length
[x
]= strlen(key
);
5908 test_true(key_length
[x
]);
5911 test_compare(MEMCACHED_SUCCESS
,
5912 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5915 memcached_result_st
*result
= NULL
;
5916 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5918 test_compare(size_t(100), memcached_result_length(result
));
5922 test_true(count
> 100); // If we don't get back atleast this, something is up
5924 /* Release all allocated resources */
5925 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5933 memcached_free(clone
);
5935 return TEST_SUCCESS
;
5939 * Test that ensures that buffered set to not trigger problems during io_flush
5941 #define regression_bug_490520_COUNT 200480
5942 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5944 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5945 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5946 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5947 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5948 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5950 memc
->number_of_hosts
= 1;
5952 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5953 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5955 /* First add all of the items.. */
5956 char blob
[3333] = {0};
5957 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5960 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5964 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5965 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5968 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5975 return TEST_SUCCESS
;
5978 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5980 fprintf(stderr
, "Iteration #%u: ", it
);
5982 if(error
== MEMCACHED_ERRNO
)
5984 fprintf(stderr
, "system error %d from %s: %s\n",
5985 errno
, what
, strerror(errno
));
5989 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5990 memcached_strerror(mc
, error
));
5994 #define TEST_CONSTANT_CREATION 200
5996 static test_return_t
regression_bug_(memcached_st
*memc
)
5998 const char *remote_server
;
6001 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
6003 return TEST_SKIPPED
;
6006 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
6008 memcached_st
* mc
= memcached_create(NULL
);
6009 memcached_return rc
;
6011 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
6012 if (rc
!= MEMCACHED_SUCCESS
)
6014 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6017 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
6018 if (rc
!= MEMCACHED_SUCCESS
)
6020 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6023 rc
= memcached_server_add(mc
, remote_server
, 0);
6024 if (rc
!= MEMCACHED_SUCCESS
)
6026 memcached_die(mc
, rc
, "memcached_server_add", x
);
6029 const char *set_key
= "akey";
6030 const size_t set_key_len
= strlen(set_key
);
6031 const char *set_value
= "a value";
6032 const size_t set_value_len
= strlen(set_value
);
6034 if (rc
== MEMCACHED_SUCCESS
)
6038 size_t get_value_len
;
6040 uint32_t get_value_flags
;
6042 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
6043 &get_value_flags
, &rc
);
6044 if (rc
!= MEMCACHED_SUCCESS
)
6046 memcached_die(mc
, rc
, "memcached_get", x
);
6052 (get_value_len
!= set_value_len
6053 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
6055 fprintf(stderr
, "Values don't match?\n");
6056 rc
= MEMCACHED_FAILURE
;
6062 rc
= memcached_set(mc
,
6063 set_key
, set_key_len
,
6064 set_value
, set_value_len
,
6068 if (rc
!= MEMCACHED_SUCCESS
)
6070 memcached_die(mc
, rc
, "memcached_set", x
);
6077 if (rc
!= MEMCACHED_SUCCESS
)
6083 return TEST_SUCCESS
;
6087 * Test that the sasl authentication works. We cannot use the default
6088 * pool of servers, because that would require that all servers we want
6089 * to test supports SASL authentication, and that they use the default
6092 static test_return_t
sasl_auth_test(memcached_st
*memc
)
6094 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
6095 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0));
6096 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
6097 test_compare(MEMCACHED_SUCCESS
, memcached_destroy_sasl_auth_data(memc
));
6098 test_compare(MEMCACHED_FAILURE
, memcached_destroy_sasl_auth_data(memc
));
6099 test_compare(MEMCACHED_FAILURE
, memcached_destroy_sasl_auth_data(NULL
));
6100 memcached_quit(memc
);
6102 test_compare(MEMCACHED_SUCCESS
,
6103 memcached_set_sasl_auth_data(memc
,
6104 getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
6105 getenv("LIBMEMCACHED_TEST_SASL_SERVER")));
6107 test_compare(MEMCACHED_AUTH_FAILURE
,
6108 memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0));
6109 test_compare(MEMCACHED_SUCCESS
, memcached_destroy_sasl_auth_data(memc
));
6111 memcached_quit(memc
);
6112 return TEST_SUCCESS
;
6115 return TEST_FAILURE
;
6119 /* Clean the server before beginning testing */
6121 {"util_version", true, (test_callback_fn
*)util_version_test
},
6122 {"flush", false, (test_callback_fn
*)flush_test
},
6123 {"init", false, (test_callback_fn
*)init_test
},
6124 {"allocation", false, (test_callback_fn
*)allocation_test
},
6125 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
6126 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
6127 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
6128 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
6129 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
6130 {"clone_test", false, (test_callback_fn
*)clone_test
},
6131 {"connection_test", false, (test_callback_fn
*)connection_test
},
6132 {"callback_test", false, (test_callback_fn
*)callback_test
},
6133 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
6134 {"error", false, (test_callback_fn
*)error_test
},
6135 {"set", false, (test_callback_fn
*)set_test
},
6136 {"set2", false, (test_callback_fn
*)set_test2
},
6137 {"set3", false, (test_callback_fn
*)set_test3
},
6138 {"dump", true, (test_callback_fn
*)dump_test
},
6139 {"add", true, (test_callback_fn
*)add_test
},
6140 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
6141 {"replace", true, (test_callback_fn
*)replace_test
},
6142 {"delete", true, (test_callback_fn
*)delete_test
},
6143 {"get", true, (test_callback_fn
*)get_test
},
6144 {"get2", false, (test_callback_fn
*)get_test2
},
6145 {"get3", false, (test_callback_fn
*)get_test3
},
6146 {"get4", false, (test_callback_fn
*)get_test4
},
6147 {"partial mget", false, (test_callback_fn
*)get_test5
},
6148 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
6149 {"increment", false, (test_callback_fn
*)increment_test
},
6150 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
6151 {"decrement", false, (test_callback_fn
*)decrement_test
},
6152 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
6153 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
6154 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
6155 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
6156 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
6157 {"quit", false, (test_callback_fn
*)quit_test
},
6158 {"mget", true, (test_callback_fn
*)mget_test
},
6159 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
6160 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
6161 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
6162 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
6163 {"mget_end", false, (test_callback_fn
*)mget_end
},
6164 {"get_stats", false, (test_callback_fn
*)get_stats
},
6165 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
6166 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
6167 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
6168 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
6169 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
6170 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
6171 {"read_through", true, (test_callback_fn
*)read_through
},
6172 {"delete_through", true, (test_callback_fn
*)delete_through
},
6173 {"noreply", true, (test_callback_fn
*)noreply_test
},
6174 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
6175 {"connectionpool", true, (test_callback_fn
*)connection_pool_test
},
6176 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
6177 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
6178 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
6179 {"test_server_failure", true, (test_callback_fn
*)test_server_failure
},
6180 {"cull_servers", true, (test_callback_fn
*)test_cull_servers
},
6181 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
6185 test_st behavior_tests
[] ={
6186 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
6187 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
6188 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
6189 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
6190 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
6191 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
6195 test_st libmemcachedutil_tests
[] ={
6196 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
6197 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
6198 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
6202 test_st basic_tests
[] ={
6203 {"init", true, (test_callback_fn
*)basic_init_test
},
6204 {"clone", true, (test_callback_fn
*)basic_clone_test
},
6205 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
6206 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
6207 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
6208 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
6212 test_st regression_binary_vs_block
[] ={
6213 {"block add", true, (test_callback_fn
*)block_add_regression
},
6214 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
6218 test_st async_tests
[] ={
6219 {"add", true, (test_callback_fn
*)add_wrapper
},
6223 test_st string_tests
[] ={
6224 {"string static with null", false, (test_callback_fn
*)string_static_null
},
6225 {"string alloc with null", false, (test_callback_fn
*)string_alloc_null
},
6226 {"string alloc with 1K", false, (test_callback_fn
*)string_alloc_with_size
},
6227 {"string alloc with malloc failure", false, (test_callback_fn
*)string_alloc_with_size_toobig
},
6228 {"string append", false, (test_callback_fn
*)string_alloc_append
},
6229 {"string append failure (too big)", false, (test_callback_fn
*)string_alloc_append_toobig
},
6230 {"string_alloc_append_multiple", false, (test_callback_fn
*)string_alloc_append_multiple
},
6231 {0, 0, (test_callback_fn
*)0}
6234 test_st memcached_server_get_last_disconnect_tests
[] ={
6235 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
6236 {0, 0, (test_callback_fn
*)0}
6240 test_st result_tests
[] ={
6241 {"result static", false, (test_callback_fn
*)result_static
},
6242 {"result alloc", false, (test_callback_fn
*)result_alloc
},
6243 {0, 0, (test_callback_fn
*)0}
6246 test_st version_1_2_3
[] ={
6247 {"append", false, (test_callback_fn
*)append_test
},
6248 {"prepend", false, (test_callback_fn
*)prepend_test
},
6249 {"cas", false, (test_callback_fn
*)cas_test
},
6250 {"cas2", false, (test_callback_fn
*)cas2_test
},
6251 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
6252 {0, 0, (test_callback_fn
*)0}
6255 test_st haldenbrand_tests
[] ={
6256 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
6257 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
6258 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
6259 {0, 0, (test_callback_fn
*)0}
6262 test_st user_tests
[] ={
6263 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
6264 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
6265 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
6266 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
6267 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
6268 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
6269 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
6270 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
6271 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
6272 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
6273 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
6274 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
6275 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
6276 #if !defined(__sun) && !defined(__OpenBSD__)
6278 ** It seems to be something weird with the character sets..
6279 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6280 ** guess I need to find out how this is supposed to work.. Perhaps I need
6281 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6282 ** so just disable the code for now...).
6284 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
6286 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
6287 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
6288 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
6289 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
6290 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
6291 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
6292 {0, 0, (test_callback_fn
*)0}
6295 test_st replication_tests
[]= {
6296 {"set", true, (test_callback_fn
*)replication_set_test
},
6297 {"get", false, (test_callback_fn
*)replication_get_test
},
6298 {"mget", false, (test_callback_fn
*)replication_mget_test
},
6299 {"delete", true, (test_callback_fn
*)replication_delete_test
},
6300 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
6301 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
6302 {0, 0, (test_callback_fn
*)0}
6306 * The following test suite is used to verify that we don't introduce
6307 * regression bugs. If you want more information about the bug / test,
6308 * you should look in the bug report at
6309 * http://bugs.launchpad.net/libmemcached
6311 test_st regression_tests
[]= {
6312 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
6313 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
6314 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
6315 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
6316 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
6317 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
6318 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
6319 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
6320 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
6321 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
6322 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
6323 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
6324 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
6325 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
6326 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
6327 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
6328 {0, false, (test_callback_fn
*)0}
6331 test_st sasl_auth_tests
[]= {
6332 {"sasl_auth", true, (test_callback_fn
*)sasl_auth_test
},
6333 {0, 0, (test_callback_fn
*)0}
6336 test_st ketama_compatibility
[]= {
6337 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
6338 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
6339 {0, 0, (test_callback_fn
*)0}
6342 test_st generate_tests
[] ={
6343 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6344 {"generate_data", true, (test_callback_fn
*)generate_data
},
6345 {"get_read", false, (test_callback_fn
*)get_read
},
6346 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
6347 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
6348 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
6349 {"generate_data", true, (test_callback_fn
*)generate_data
},
6350 {"mget_read", false, (test_callback_fn
*)mget_read
},
6351 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
6352 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
6353 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
6354 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
6355 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6356 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
6357 {"generate_data", true, (test_callback_fn
*)generate_data
},
6358 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
6359 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6360 {0, 0, (test_callback_fn
*)0}
6363 test_st consistent_tests
[] ={
6364 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6365 {"generate_data", true, (test_callback_fn
*)generate_data
},
6366 {"get_read", 0, (test_callback_fn
*)get_read_count
},
6367 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6368 {0, 0, (test_callback_fn
*)0}
6371 test_st consistent_weighted_tests
[] ={
6372 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6373 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
6374 {"get_read", false, (test_callback_fn
*)get_read_count
},
6375 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6376 {0, 0, (test_callback_fn
*)0}
6379 test_st hsieh_availability
[] ={
6380 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
6381 {0, 0, (test_callback_fn
*)0}
6384 test_st murmur_availability
[] ={
6385 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
6386 {0, 0, (test_callback_fn
*)0}
6390 test_st hash_sanity
[] ={
6391 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
6392 {0, 0, (test_callback_fn
*)0}
6396 test_st ketama_auto_eject_hosts
[] ={
6397 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
6398 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
6399 {0, 0, (test_callback_fn
*)0}
6402 test_st hash_tests
[] ={
6403 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
6404 {"md5", false, (test_callback_fn
*)md5_run
},
6405 {"crc", false, (test_callback_fn
*)crc_run
},
6406 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
6407 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
6408 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
6409 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
6410 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
6411 {"murmur", false, (test_callback_fn
*)murmur_run
},
6412 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
6413 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
6414 {0, 0, (test_callback_fn
*)0}
6417 test_st error_conditions
[] ={
6418 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
6419 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
6420 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
6421 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6422 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6423 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
6424 {0, 0, (test_callback_fn
*)0}
6428 test_st parser_tests
[] ={
6429 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
6430 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
6431 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
6432 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
6433 {"hash", false, (test_callback_fn
*)parser_hash_test
},
6434 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
6435 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
6436 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
6437 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
6438 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
6439 {"server", false, (test_callback_fn
*)server_test
},
6440 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
6441 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
6442 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
6443 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
6444 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
6445 {0, 0, (test_callback_fn
*)0}
6448 test_st virtual_bucket_tests
[] ={
6449 {"basic", false, (test_callback_fn
*)virtual_back_map
},
6450 {0, 0, (test_callback_fn
*)0}
6453 test_st namespace_tests
[] ={
6454 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
6455 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
6456 {0, 0, (test_callback_fn
*)0}
6459 collection_st collection
[] ={
6461 {"hash_sanity", 0, 0, hash_sanity
},
6463 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
6464 {"basic", 0, 0, basic_tests
},
6465 {"hsieh_availability", 0, 0, hsieh_availability
},
6466 {"murmur_availability", 0, 0, murmur_availability
},
6467 {"block", 0, 0, tests
},
6468 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
6469 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
6470 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6471 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
6472 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
6473 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
6474 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
6475 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
6476 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
6477 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
6478 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
6479 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
6480 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
6481 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6482 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
6483 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6484 {"poll_timeout", (test_callback_fn
*)poll_timeout
, 0, tests
},
6485 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
6486 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
6487 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
6488 #ifdef MEMCACHED_ENABLE_DEPRECATED
6489 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
6491 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
6492 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
6493 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
6494 {"specific namespace", 0, 0, namespace_tests
},
6495 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
6496 {"sasl_auth", (test_callback_fn
*)pre_sasl
, 0, sasl_auth_tests
},
6497 {"sasl", (test_callback_fn
*)pre_sasl
, 0, tests
},
6498 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
6499 {"string", 0, 0, string_tests
},
6500 {"result", 0, 0, result_tests
},
6501 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
6502 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
6503 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
6504 {"user", 0, 0, user_tests
},
6505 {"generate", 0, 0, generate_tests
},
6506 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
6507 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
6508 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
6509 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
6510 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
6511 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
6512 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
6514 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
6515 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
6516 {"consistent_not", 0, 0, consistent_tests
},
6517 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
6518 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6519 {"ketama_compat", 0, 0, ketama_compatibility
},
6520 {"test_hashes", 0, 0, hash_tests
},
6521 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6522 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6523 {"regression", 0, 0, regression_tests
},
6524 {"behaviors", 0, 0, behavior_tests
},
6525 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6526 {"error_conditions", 0, 0, error_conditions
},
6527 {"parser", 0, 0, parser_tests
},
6528 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6529 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6533 #include "tests/libmemcached_world.h"
6535 void get_world(Framework
*world
)
6537 world
->collections
= collection
;
6539 world
->_create
= (test_callback_create_fn
*)world_create
;
6540 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6542 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6543 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6544 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6545 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6546 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6548 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6549 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6551 world
->set_runner(&defualt_libmemcached_runner
);
6553 world
->set_socket();