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 memcached_literal_param("foo"),
460 memcached_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
)
3384 memcached_free(memc_clone
);
3386 return TEST_SUCCESS
;
3389 static test_return_t
get_read(memcached_st
*memc
)
3391 for (size_t x
= 0; x
< global_count
; x
++)
3393 size_t return_value_length
;
3395 memcached_return_t rc
;
3396 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3397 &return_value_length
, &flags
, &rc
);
3399 test_true(return_value);
3400 test_compare(MEMCACHED_SUCCESS, rc);
3402 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3406 return TEST_SUCCESS
;
3409 static test_return_t
mget_read(memcached_st
*memc
)
3412 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3414 test_compare(MEMCACHED_SUCCESS
,
3415 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3417 // Go fetch the keys and test to see if all of them were returned
3419 unsigned int keys_returned
;
3420 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3421 test_true(keys_returned
> 0);
3422 test_compare(global_count
, keys_returned
);
3425 return TEST_SUCCESS
;
3428 static test_return_t
mget_read_result(memcached_st
*memc
)
3431 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3433 test_compare(MEMCACHED_SUCCESS
,
3434 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3436 /* Turn this into a help function */
3438 memcached_result_st results_obj
;
3439 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3441 memcached_return_t rc
;
3442 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3445 test_compare(MEMCACHED_SUCCESS
, rc
);
3447 test_compare(MEMCACHED_END
, rc
);
3449 memcached_result_free(&results_obj
);
3452 return TEST_SUCCESS
;
3455 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3458 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3460 test_compare(MEMCACHED_SUCCESS
,
3461 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3463 memcached_result_st
*results
= NULL
;
3464 memcached_return_t rc
;
3465 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3468 test_compare(MEMCACHED_SUCCESS
, rc
);
3470 test_compare(MEMCACHED_END
, rc
);
3472 memcached_result_free(results
);
3475 return TEST_SUCCESS
;
3478 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3481 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3483 test_compare(MEMCACHED_SUCCESS
,
3484 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3486 // We will scan for just one key
3488 memcached_result_st results_obj
;
3489 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3491 memcached_return_t rc
;
3492 results
= memcached_fetch_result(memc
, results
, &rc
);
3494 test_compare(MEMCACHED_SUCCESS
, rc
);
3496 memcached_result_free(&results_obj
);
3499 // We already have a read happening, lets start up another one.
3500 test_compare(MEMCACHED_SUCCESS
,
3501 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3503 memcached_result_st results_obj
;
3504 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3506 memcached_return_t rc
;
3507 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3510 test_compare(MEMCACHED_SUCCESS
, rc
);
3512 test_compare(MEMCACHED_END
, rc
);
3514 memcached_result_free(&results_obj
);
3517 return TEST_SUCCESS
;
3520 static test_return_t
mget_read_function(memcached_st
*memc
)
3522 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3524 test_compare(MEMCACHED_SUCCESS
,
3525 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3527 memcached_execute_fn callbacks
[]= { &callback_counter
};
3529 test_compare(MEMCACHED_SUCCESS
,
3530 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3532 return TEST_SUCCESS
;
3535 static test_return_t
delete_generate(memcached_st
*memc
)
3537 for (size_t x
= 0; x
< global_count
; x
++)
3539 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3542 return TEST_SUCCESS
;
3545 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3548 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3550 for (size_t x
= 0; x
< global_count
; x
++)
3552 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3555 return TEST_SUCCESS
;
3558 static test_return_t
add_host_test1(memcached_st
*memc
)
3560 memcached_return_t rc
;
3561 char servername
[]= "0.example.com";
3563 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3565 test_compare(1U, memcached_server_list_count(servers
));
3567 for (uint32_t x
= 2; x
< 20; x
++)
3569 char buffer
[SMALL_STRING_LEN
];
3571 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3572 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3574 test_compare(MEMCACHED_SUCCESS
, rc
);
3575 test_compare(x
, memcached_server_list_count(servers
));
3578 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3579 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3581 memcached_server_list_free(servers
);
3583 return TEST_SUCCESS
;
3586 static test_return_t
pre_nonblock(memcached_st
*memc
)
3588 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3590 return TEST_SUCCESS
;
3593 static test_return_t
pre_cork(memcached_st
*memc
)
3596 return TEST_SKIPPED
;
3599 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3600 return TEST_SUCCESS
;
3602 return TEST_SKIPPED
;
3605 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3608 return TEST_SKIPPED
;
3610 test_return_t test_rc
;
3611 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3614 return pre_nonblock(memc
);
3617 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3619 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3620 test_true(memc_clone
);
3622 // The memcached_version needs to be done on a clone, because the server
3623 // will not toggle protocol on an connection.
3624 memcached_version(memc_clone
);
3626 memcached_return_t rc
= MEMCACHED_FAILURE
;
3627 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3629 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3630 test_compare(MEMCACHED_SUCCESS
,
3631 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3632 test_compare(1UL, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3636 memcached_free(memc_clone
);
3637 return TEST_SKIPPED
;
3640 memcached_free(memc_clone
);
3642 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3645 static test_return_t
pre_murmur(memcached_st
*memc
)
3647 #ifdef HAVE_MURMUR_HASH
3648 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3649 return TEST_SUCCESS
;
3652 return TEST_SKIPPED
;
3656 static test_return_t
pre_jenkins(memcached_st
*memc
)
3658 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3660 return TEST_SUCCESS
;
3664 static test_return_t
pre_md5(memcached_st
*memc
)
3666 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3668 return TEST_SUCCESS
;
3671 static test_return_t
pre_crc(memcached_st
*memc
)
3673 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3675 return TEST_SUCCESS
;
3678 static test_return_t
pre_hsieh(memcached_st
*memc
)
3680 #ifdef HAVE_HSIEH_HASH
3681 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3682 return TEST_SUCCESS
;
3685 return TEST_SKIPPED
;
3689 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3691 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3693 return TEST_SUCCESS
;
3696 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3698 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3700 return TEST_SUCCESS
;
3703 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3705 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3707 return TEST_SUCCESS
;
3710 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3712 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3714 return TEST_SUCCESS
;
3717 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3719 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3720 test_compare(MEMCACHED_SUCCESS
, rc
);
3722 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3723 test_true(value
== 1);
3725 return TEST_SUCCESS
;
3728 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3730 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3731 test_compare(MEMCACHED_SUCCESS
, rc
);
3733 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3734 test_true(value
== 1);
3736 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3737 test_compare(MEMCACHED_SUCCESS
, rc
);
3739 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3740 test_true(value
== MEMCACHED_HASH_MD5
);
3742 return TEST_SUCCESS
;
3746 @note This should be testing to see if the server really supports the binary protocol.
3748 static test_return_t
pre_binary(memcached_st
*memc
)
3750 memcached_return_t rc
= MEMCACHED_FAILURE
;
3752 if (libmemcached_util_version_check(memc
, 1, 4, 4))
3754 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3755 test_compare(MEMCACHED_SUCCESS
, rc
);
3756 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3759 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3762 static test_return_t
pre_sasl(memcached_st
*memc
)
3764 memcached_return_t rc
= MEMCACHED_FAILURE
;
3766 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
3767 const char *server
= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
3768 const char *user
= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
3769 const char *pass
= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
3771 if (server
and user
and pass
)
3773 memcached_server_st
*servers
= memcached_servers_parse(server
);
3775 memcached_servers_reset(memc
);
3776 test_true(memcached_server_push(memc
, servers
) == MEMCACHED_SUCCESS
);
3777 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3778 rc
= memcached_set_sasl_auth_data(memc
, user
, pass
);
3779 test_compare(MEMCACHED_SUCCESS
, rc
);
3785 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3788 static test_return_t
pre_replication(memcached_st
*memc
)
3790 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3793 * Make sure that we store the item on all servers
3794 * (master + replicas == number of servers)
3796 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3797 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3799 return TEST_SUCCESS
;
3803 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3805 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3807 return pre_nonblock(memc
);
3811 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3815 #ifdef HARD_MALLOC_TESTS
3816 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3824 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3828 #ifdef HARD_MALLOC_TESTS
3829 void *ret
= malloc(size
+ 8);
3832 ret
= (void*)((caddr_t
)ret
+ 8);
3835 void *ret
= malloc(size
);
3840 memset(ret
, 0xff, size
);
3847 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3849 #ifdef HARD_MALLOC_TESTS
3850 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3851 void *nmem
= realloc(real_ptr
, size
+ 8);
3856 ret
= (void*)((caddr_t
)nmem
+ 8);
3862 return realloc(mem
, size
);
3867 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3869 #ifdef HARD_MALLOC_TESTS
3870 void *mem
= my_malloc(ptr
, nelem
* size
);
3873 memset(mem
, 0, nelem
* size
);
3879 return calloc(nelem
, size
);
3883 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3885 memcached_return_t rc
;
3886 const char *key
= "mine";
3889 /* Make sure be default none exists */
3890 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3891 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3893 /* Test a clean set */
3894 test_compare(MEMCACHED_SUCCESS
,
3895 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3897 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3899 test_memcmp(value
, key
, 4);
3900 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3902 /* Test that we can turn it off */
3903 test_compare(MEMCACHED_SUCCESS
,
3904 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3906 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3908 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3910 /* Now setup for main test */
3911 test_compare(MEMCACHED_SUCCESS
,
3912 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3914 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3916 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3917 test_memcmp(value
, key
, 4);
3919 /* Set to Zero, and then Set to something too large */
3922 memset(long_key
, 0, 255);
3924 test_compare(MEMCACHED_SUCCESS
,
3925 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3927 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3929 test_true(rc
== MEMCACHED_FAILURE
);
3930 test_true(value
== NULL
);
3932 /* Test a long key for failure */
3933 /* TODO, extend test to determine based on setting, what result should be */
3934 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3935 test_compare(MEMCACHED_SUCCESS
,
3936 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3938 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3939 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3940 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3941 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3943 /* Test for a bad prefix, but with a short key */
3944 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3945 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3947 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3948 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3951 return TEST_SUCCESS
;
3954 static test_return_t
set_namespace(memcached_st
*memc
)
3956 memcached_return_t rc
;
3957 const char *key
= "mine";
3960 /* Make sure be default none exists */
3961 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3962 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3964 /* Test a clean set */
3965 test_compare(MEMCACHED_SUCCESS
,
3966 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3968 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3970 test_memcmp(value
, key
, 4);
3971 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3973 return TEST_SUCCESS
;
3976 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3978 test_return_if(pre_binary(memc
));
3979 test_return_if(set_namespace(memc
));
3981 return TEST_SUCCESS
;
3984 #ifdef MEMCACHED_ENABLE_DEPRECATED
3985 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3987 void *test_ptr
= NULL
;
3990 memcached_malloc_fn malloc_cb
=
3991 (memcached_malloc_fn
)my_malloc
;
3992 cb_ptr
= *(void **)&malloc_cb
;
3993 memcached_return_t rc
;
3995 test_compare(MEMCACHED_SUCCESS
,
3996 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3997 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3998 test_compare(MEMCACHED_SUCCESS
, rc
);
3999 test_true(test_ptr
== cb_ptr
);
4003 memcached_realloc_fn realloc_cb
=
4004 (memcached_realloc_fn
)my_realloc
;
4005 cb_ptr
= *(void **)&realloc_cb
;
4006 memcached_return_t rc
;
4008 test_compare(MEMCACHED_SUCCESS
,
4009 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
4010 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
4011 test_compare(MEMCACHED_SUCCESS
, rc
);
4012 test_true(test_ptr
== cb_ptr
);
4016 memcached_free_fn free_cb
=
4017 (memcached_free_fn
)my_free
;
4018 cb_ptr
= *(void **)&free_cb
;
4019 memcached_return_t rc
;
4021 test_compare(MEMCACHED_SUCCESS
,
4022 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
4023 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
4024 test_compare(MEMCACHED_SUCCESS
, rc
);
4025 test_true(test_ptr
== cb_ptr
);
4028 return TEST_SUCCESS
;
4033 static test_return_t
set_memory_alloc(memcached_st
*memc
)
4035 test_compare(MEMCACHED_FAILURE
,
4036 memcached_set_memory_allocators(memc
, NULL
, my_free
,
4037 my_realloc
, my_calloc
, NULL
));
4039 test_compare(MEMCACHED_SUCCESS
,
4040 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
4041 my_realloc
, my_calloc
, NULL
));
4043 memcached_malloc_fn mem_malloc
;
4044 memcached_free_fn mem_free
;
4045 memcached_realloc_fn mem_realloc
;
4046 memcached_calloc_fn mem_calloc
;
4047 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
4048 &mem_realloc
, &mem_calloc
);
4050 test_true(mem_malloc
== my_malloc
);
4051 test_true(mem_realloc
== my_realloc
);
4052 test_true(mem_calloc
== my_calloc
);
4053 test_true(mem_free
== my_free
);
4055 return TEST_SUCCESS
;
4058 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
4061 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4062 memcached_hash_t hash
;
4063 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4064 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
4067 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4068 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4070 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4072 if (hash
!= MEMCACHED_HASH_CRC
)
4073 return TEST_SKIPPED
;
4075 return TEST_SUCCESS
;
4078 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
4081 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4082 memcached_hash_t hash
;
4083 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4084 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
4087 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4088 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4090 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4092 if (hash
!= MEMCACHED_HASH_HSIEH
)
4093 return TEST_SKIPPED
;
4096 return TEST_SUCCESS
;
4099 static test_return_t
enable_cas(memcached_st
*memc
)
4101 unsigned int set
= 1;
4103 if (libmemcached_util_version_check(memc
, 1, 2, 4))
4105 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
4107 return TEST_SUCCESS
;
4110 return TEST_SKIPPED
;
4113 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
4115 memcached_version(memc
);
4117 memcached_server_instance_st instance
=
4118 memcached_server_instance_by_position(memc
, 0);
4120 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
4121 or instance
->minor_version
> 2)
4123 return TEST_SUCCESS
;
4126 return TEST_SKIPPED
;
4129 static test_return_t
pre_unix_socket(memcached_st
*memc
)
4133 memcached_servers_reset(memc
);
4134 const char *socket_file
= default_socket();
4136 test_skip(0, stat(socket_file
, &buf
));
4138 test_compare(MEMCACHED_SUCCESS
,
4139 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
4141 return TEST_SUCCESS
;
4144 static test_return_t
pre_nodelay(memcached_st
*memc
)
4146 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
4147 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
4149 return TEST_SUCCESS
;
4152 static test_return_t
pre_settimer(memcached_st
*memc
)
4154 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4155 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4157 return TEST_SUCCESS
;
4160 static test_return_t
poll_timeout(memcached_st
*memc
)
4162 const uint64_t timeout
= 100; // Not using, just checking that it sets
4164 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4167 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
4169 return TEST_SUCCESS
;
4172 static test_return_t
noreply_test(memcached_st
*memc
)
4174 memcached_return_t ret
;
4175 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
4176 test_true(ret
== MEMCACHED_SUCCESS
);
4177 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4178 test_true(ret
== MEMCACHED_SUCCESS
);
4179 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
4180 test_true(ret
== MEMCACHED_SUCCESS
);
4181 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
4182 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
4183 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
4185 for (int count
=0; count
< 5; ++count
)
4187 for (size_t x
= 0; x
< 100; ++x
)
4190 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4191 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4193 size_t len
= (size_t)check_length
;
4198 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4201 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4204 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4207 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4210 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4216 test_true(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
4220 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4221 ** API and is _ONLY_ done this way to verify that the library works the
4222 ** way it is supposed to do!!!!
4225 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4227 memcached_server_instance_st instance
=
4228 memcached_server_instance_by_position(memc
, x
);
4229 no_msg
+=(int)(instance
->cursor_active
);
4232 test_true(no_msg
== 0);
4233 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4236 ** Now validate that all items was set properly!
4238 for (size_t x
= 0; x
< 100; ++x
)
4242 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4244 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4246 size_t len
= (size_t)check_length
;
4249 char* value
=memcached_get(memc
, key
, strlen(key
),
4250 &length
, &flags
, &ret
);
4251 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4254 case 0: /* FALLTHROUGH */
4255 case 1: /* FALLTHROUGH */
4257 test_true(strncmp(value
, key
, len
) == 0);
4258 test_true(len
== length
);
4261 test_true(length
== len
* 2);
4264 test_true(length
== len
* 3);
4274 /* Try setting an illegal cas value (should not return an error to
4275 * the caller (because we don't expect a return message from the server)
4277 const char* keys
[]= {"0"};
4278 size_t lengths
[]= {1};
4281 memcached_result_st results_obj
;
4282 memcached_result_st
*results
;
4283 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4284 test_true(ret
== MEMCACHED_SUCCESS
);
4286 results
= memcached_result_create(memc
, &results_obj
);
4288 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4290 test_true(ret
== MEMCACHED_SUCCESS
);
4291 uint64_t cas
= memcached_result_cas(results
);
4292 memcached_result_free(&results_obj
);
4294 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4295 test_true(ret
== MEMCACHED_SUCCESS
);
4298 * The item will have a new cas value, so try to set it again with the old
4299 * value. This should fail!
4301 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4302 test_true(ret
== MEMCACHED_SUCCESS
);
4303 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4304 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4305 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4308 return TEST_SUCCESS
;
4311 static test_return_t
analyzer_test(memcached_st
*memc
)
4313 memcached_return_t rc
;
4314 memcached_stat_st
*memc_stat
;
4315 memcached_analysis_st
*report
;
4317 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4318 test_compare(MEMCACHED_SUCCESS
, rc
);
4319 test_true(memc_stat
);
4321 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4322 test_compare(MEMCACHED_SUCCESS
, rc
);
4326 memcached_stat_free(NULL
, memc_stat
);
4328 return TEST_SUCCESS
;
4331 /* Count the objects */
4333 static test_return_t
dump_test(memcached_st
*memc
)
4335 /* No support for Binary protocol yet */
4336 test_skip(false, memc
->flags
.binary_protocol
);
4338 test_compare(TEST_SUCCESS
, set_test3(memc
));
4340 // confirm_key_count() call dump
4341 size_t counter
= confirm_key_count(memc
);
4343 /* We may have more then 32 if our previous flush has not completed */
4344 test_true(counter
>= 32);
4346 return TEST_SUCCESS
;
4349 struct test_pool_context_st
{
4350 memcached_pool_st
* pool
;
4354 static void* connection_release(void *arg
)
4356 test_pool_context_st
*resource
= static_cast<test_pool_context_st
*>(arg
);
4359 // Release all of the memc we are holding
4360 assert(memcached_success(memcached_pool_push(resource
->pool
, resource
->mmc
)));
4364 #define POOL_SIZE 10
4365 static test_return_t
connection_pool_test(memcached_st
*memc
)
4367 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4368 test_true(pool
!= NULL
);
4369 memcached_st
*mmc
[POOL_SIZE
];
4370 memcached_return_t rc
;
4372 // Fill up our array that we will store the memc that are in the pool
4373 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4375 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4376 test_true(mmc
[x
] != NULL
);
4377 test_compare(MEMCACHED_SUCCESS
, rc
);
4380 // All memc should be gone
4381 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4382 test_compare(MEMCACHED_SUCCESS
, rc
);
4385 test_pool_context_st item
= { pool
, mmc
[9] };
4387 pthread_create(&tid
, NULL
, connection_release
, &item
);
4388 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4389 test_compare(MEMCACHED_SUCCESS
, rc
);
4390 pthread_join(tid
, NULL
);
4392 const char *key
= "key";
4393 size_t keylen
= strlen(key
);
4395 // verify that I can do ops with all connections
4396 test_compare(MEMCACHED_SUCCESS
,
4397 memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0));
4399 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4401 uint64_t number_value
;
4402 test_compare(MEMCACHED_SUCCESS
,
4403 memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
));
4404 test_compare(number_value
, (x
+1));
4408 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4410 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[x
]));
4414 /* verify that I can set behaviors on the pool when I don't have all
4415 * of the connections in the pool. It should however be enabled
4416 * when I push the item into the pool
4418 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4421 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4422 test_compare(MEMCACHED_SUCCESS
, rc
);
4424 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4427 test_compare(UINT64_C(9999), memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4428 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[1]));
4429 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4431 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4432 test_compare(UINT64_C(9999), memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4433 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4435 test_true(memcached_pool_destroy(pool
) == memc
);
4437 return TEST_SUCCESS
;
4440 static test_return_t
util_version_test(memcached_st
*memc
)
4442 bool if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4443 test_true(if_successful
);
4445 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4447 // We expect failure
4450 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4451 fprintf(stderr
, "\nDumping Server Information\n\n");
4452 memcached_server_fn callbacks
[1];
4454 callbacks
[0]= dump_server_information
;
4455 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4456 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4458 test_true(if_successful
== false);
4460 memcached_server_instance_st instance
=
4461 memcached_server_instance_by_position(memc
, 0);
4463 memcached_version(memc
);
4465 // We only use one binary when we test, so this should be just fine.
4466 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4467 test_true(if_successful
== true);
4469 if (instance
->micro_version
> 0)
4470 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4471 else if (instance
->minor_version
> 0)
4472 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4473 else if (instance
->major_version
> 0)
4474 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), 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
== false);
4487 return TEST_SUCCESS
;
4490 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4492 memcached_return_t rc
;
4493 memcached_server_instance_st instance
=
4494 memcached_server_instance_by_position(memc
, 0);
4496 // Test both the version that returns a code, and the one that does not.
4497 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4498 memcached_server_port(instance
) -1, NULL
) == -1);
4500 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4501 memcached_server_port(instance
) -1, &rc
) == -1);
4502 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4504 return TEST_SUCCESS
;
4508 static test_return_t
getpid_test(memcached_st
*memc
)
4510 memcached_return_t rc
;
4511 memcached_server_instance_st instance
=
4512 memcached_server_instance_by_position(memc
, 0);
4514 // Test both the version that returns a code, and the one that does not.
4515 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4516 memcached_server_port(instance
), NULL
) > -1);
4518 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4519 memcached_server_port(instance
), &rc
) > -1);
4520 test_compare(MEMCACHED_SUCCESS
, rc
);
4522 return TEST_SUCCESS
;
4525 static test_return_t
ping_test(memcached_st
*memc
)
4527 memcached_return_t rc
;
4528 memcached_server_instance_st instance
=
4529 memcached_server_instance_by_position(memc
, 0);
4531 // Test both the version that returns a code, and the one that does not.
4532 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4533 memcached_server_port(instance
), NULL
));
4535 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4536 memcached_server_port(instance
), &rc
));
4538 test_compare(MEMCACHED_SUCCESS
, rc
);
4540 return TEST_SUCCESS
;
4545 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4549 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4550 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4551 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4552 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4553 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4554 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4555 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4556 #ifdef HAVE_HSIEH_HASH
4557 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4559 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4560 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4561 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4563 return TEST_SUCCESS
;
4567 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4569 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4570 #ifdef HAVE_HSIEH_HASH
4571 expected_rc
= MEMCACHED_SUCCESS
;
4573 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4574 (uint64_t)MEMCACHED_HASH_HSIEH
);
4575 test_true(rc
== expected_rc
);
4577 return TEST_SUCCESS
;
4580 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4582 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4583 #ifdef HAVE_MURMUR_HASH
4584 expected_rc
= MEMCACHED_SUCCESS
;
4586 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4587 (uint64_t)MEMCACHED_HASH_MURMUR
);
4588 test_true(rc
== expected_rc
);
4590 return TEST_SUCCESS
;
4593 static test_return_t
one_at_a_time_run (memcached_st
*)
4598 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4602 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
);
4603 test_true(one_at_a_time_values
[x
] == hash_val
);
4606 return TEST_SUCCESS
;
4609 static test_return_t
md5_run (memcached_st
*)
4614 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4618 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4619 test_true(md5_values
[x
] == hash_val
);
4622 return TEST_SUCCESS
;
4625 static test_return_t
crc_run (memcached_st
*)
4630 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4634 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4635 test_true(crc_values
[x
] == hash_val
);
4638 return TEST_SUCCESS
;
4641 static test_return_t
fnv1_64_run (memcached_st
*)
4646 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4650 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4651 test_true(fnv1_64_values
[x
] == hash_val
);
4654 return TEST_SUCCESS
;
4657 static test_return_t
fnv1a_64_run (memcached_st
*)
4662 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4666 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4667 test_true(fnv1a_64_values
[x
] == hash_val
);
4670 return TEST_SUCCESS
;
4673 static test_return_t
fnv1_32_run (memcached_st
*)
4678 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4682 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4683 test_true(fnv1_32_values
[x
] == hash_val
);
4686 return TEST_SUCCESS
;
4689 static test_return_t
fnv1a_32_run (memcached_st
*)
4694 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4698 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4699 test_true(fnv1a_32_values
[x
] == hash_val
);
4702 return TEST_SUCCESS
;
4705 static test_return_t
hsieh_run (memcached_st
*)
4710 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4714 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4715 test_true(hsieh_values
[x
] == hash_val
);
4718 return TEST_SUCCESS
;
4721 static test_return_t
murmur_run (memcached_st
*)
4723 #ifdef WORDS_BIGENDIAN
4724 (void)murmur_values
;
4725 return TEST_SKIPPED
;
4730 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4734 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
4735 test_true(murmur_values
[x
] == hash_val
);
4738 return TEST_SUCCESS
;
4742 static test_return_t
jenkins_run (memcached_st
*)
4747 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4751 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4752 test_true(jenkins_values
[x
] == hash_val
);
4755 return TEST_SUCCESS
;
4758 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *context
)
4761 return libhashkit_md5(string
, string_length
);
4764 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *context
)
4767 return libhashkit_crc32(string
, string_length
);
4770 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4776 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5"));
4778 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};
4779 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};
4781 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4783 hashkit_clone(&new_kit
, kit
);
4784 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4786 memcached_set_hashkit(memc
, &new_kit
);
4789 Verify Setting the hash.
4791 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4795 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4796 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4801 Now check memcached_st.
4803 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4807 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4808 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4811 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4813 memcached_set_hashkit(memc
, &new_kit
);
4816 Verify Setting the hash.
4818 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4822 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4823 test_true(crc_values
[x
] == hash_val
);
4826 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4830 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4831 test_compare(crc_hosts
[x
], hash_val
);
4834 memcached_free(memc
);
4836 return TEST_SUCCESS
;
4840 Test case adapted from John Gorman <johngorman2@gmail.com>
4842 We are testing the error condition when we connect to a server via memcached_get()
4843 but find that the server is not available.
4845 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4847 const char *key
= "MemcachedLives";
4850 memcached_return rc
;
4853 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4855 // See if memcached is reachable.
4856 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4860 test_true(memcached_failed(rc
));
4862 memcached_free(tl_memc_h
);
4864 return TEST_SUCCESS
;
4868 We connect to a server which exists, but search for a key that does not exist.
4870 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4872 const char *key
= "MemcachedKeyNotEXIST";
4875 memcached_return rc
;
4878 // See if memcached is reachable.
4879 value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4883 test_compare(MEMCACHED_NOTFOUND
, rc
);
4885 return TEST_SUCCESS
;
4889 Test case adapted from John Gorman <johngorman2@gmail.com>
4891 We are testing the error condition when we connect to a server via memcached_get_by_key()
4892 but find that the server is not available.
4894 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4897 memcached_st
*tl_memc_h
;
4898 memcached_server_st
*servers
;
4900 const char *key
= "MemcachedLives";
4903 memcached_return rc
;
4907 tl_memc_h
= memcached_create(NULL
);
4908 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4909 memcached_server_push(tl_memc_h
, servers
);
4910 memcached_server_list_free(servers
);
4912 // See if memcached is reachable.
4913 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4917 test_true(memcached_failed(rc
));
4919 memcached_free(tl_memc_h
);
4921 return TEST_SUCCESS
;
4925 We connect to a server which exists, but search for a key that does not exist.
4927 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4929 const char *key
= "MemcachedKeyNotEXIST";
4932 memcached_return rc
;
4935 // See if memcached is reachable.
4936 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4940 test_compare(MEMCACHED_NOTFOUND
, rc
);
4942 return TEST_SUCCESS
;
4946 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*)
4948 memcached_st
*memc
= memcached_create(NULL
);
4951 test_compare(MEMCACHED_SUCCESS
,
4952 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1));
4954 test_compare(1UL, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
4956 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
4957 test_compare(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
, memcached_behavior_get_distribution(memc
));
4959 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");
4960 memcached_server_push(memc
, server_pool
);
4962 /* verify that the server list was parsed okay. */
4963 test_compare(8U, memcached_server_count(memc
));
4964 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
4965 test_compare(in_port_t(11211), server_pool
[0].port
);
4966 test_compare(600U, server_pool
[0].weight
);
4967 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
4968 test_compare(in_port_t(11211), server_pool
[2].port
);
4969 test_compare(200U, server_pool
[2].weight
);
4970 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
4971 test_compare(in_port_t(11211), server_pool
[7].port
);
4972 test_compare(100U, server_pool
[7].weight
);
4974 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
4975 * us test the boundary wraparound.
4977 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
4979 /* verify the standard ketama set. */
4980 for (uint32_t x
= 0; x
< 99; x
++)
4982 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
4983 memcached_server_instance_st instance
=
4984 memcached_server_instance_by_position(memc
, server_idx
);
4985 const char *hostname
= memcached_server_name(instance
);
4987 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
4990 memcached_server_list_free(server_pool
);
4991 memcached_free(memc
);
4993 return TEST_SUCCESS
;
4996 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*)
4998 memcached_st
*memc
= memcached_create(NULL
);
5001 test_compare(MEMCACHED_SUCCESS
,
5002 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1));
5004 test_compare(UINT64_C(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
5006 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
));
5007 test_compare(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
, memcached_behavior_get_distribution(memc
));
5009 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");
5010 test_true(server_pool
);
5011 memcached_server_push(memc
, server_pool
);
5013 /* verify that the server list was parsed okay. */
5014 test_compare(8U, memcached_server_count(memc
));
5015 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5016 test_compare(in_port_t(11211), server_pool
[0].port
);
5017 test_compare(600U, server_pool
[0].weight
);
5018 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5019 test_compare(in_port_t(11211), server_pool
[2].port
);
5020 test_compare(200U, server_pool
[2].weight
);
5021 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5022 test_compare(in_port_t(11211), server_pool
[7].port
);
5023 test_compare(100U, server_pool
[7].weight
);
5025 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5026 * us test the boundary wraparound.
5028 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
5030 /* verify the standard ketama set. */
5031 for (uint32_t x
= 0; x
< 99; x
++)
5033 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
5035 memcached_server_instance_st instance
=
5036 memcached_server_instance_by_position(memc
, server_idx
);
5038 const char *hostname
= memcached_server_name(instance
);
5040 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
5043 memcached_server_list_free(server_pool
);
5044 memcached_free(memc
);
5046 return TEST_SUCCESS
;
5049 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5051 test_return_t test_rc
;
5052 test_rc
= pre_binary(memc
);
5054 if (test_rc
!= TEST_SUCCESS
)
5057 const char *key
= "regression_bug_434484";
5058 size_t keylen
= strlen(key
);
5060 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5061 test_compare(MEMCACHED_NOTSTORED
, ret
);
5063 size_t size
= 2048 * 1024;
5064 char *data
= (char*)calloc(1, size
);
5066 test_compare(MEMCACHED_E2BIG
,
5067 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
5070 return TEST_SUCCESS
;
5073 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5075 test_return_t test_rc
;
5076 test_rc
= pre_binary(memc
);
5078 if (test_rc
!= TEST_SUCCESS
)
5081 memcached_return_t rc
;
5083 memcached_execute_fn callbacks
[]= { &callback_counter
};
5086 * I only want to hit only _one_ server so I know the number of requests I'm
5087 * sending in the pipleine to the server. Let's try to do a multiget of
5088 * 1024 (that should satisfy most users don't you think?). Future versions
5089 * will include a mget_execute function call if you need a higher number.
5091 uint32_t number_of_hosts
= memcached_server_count(memc
);
5092 memc
->number_of_hosts
= 1;
5093 const size_t max_keys
= 1024;
5094 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
5095 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5097 for (size_t x
= 0; x
< max_keys
; ++x
)
5101 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5107 * Run two times.. the first time we should have 100% cache miss,
5108 * and the second time we should have 100% cache hits
5110 for (size_t y
= 0; y
< 2; y
++)
5112 test_compare(MEMCACHED_SUCCESS
,
5113 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
5115 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
5116 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5120 /* The first iteration should give me a 100% cache miss. verify that*/
5121 char blob
[1024]= { 0 };
5123 test_false(counter
);
5125 for (size_t x
= 0; x
< max_keys
; ++x
)
5127 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5128 blob
, sizeof(blob
), 0, 0);
5129 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5134 /* Verify that we received all of the key/value pairs */
5135 test_compare(counter
, max_keys
);
5139 /* Release allocated resources */
5140 for (size_t x
= 0; x
< max_keys
; ++x
)
5147 memc
->number_of_hosts
= number_of_hosts
;
5149 return TEST_SUCCESS
;
5152 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5154 memcached_return_t rc
;
5155 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5156 test_compare(MEMCACHED_SUCCESS
, rc
);
5158 return regression_bug_434843(memc
);
5161 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5163 memcached_return_t rc
;
5164 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5165 test_compare(MEMCACHED_SUCCESS
, rc
);
5167 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5168 test_compare(MEMCACHED_SUCCESS
, rc
);
5169 test_true(bytes_str
);
5170 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
5172 test_compare(MEMCACHED_SUCCESS
, rc
);
5173 test_true(bytes_read_str
);
5175 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
5176 "bytes_written", &rc
);
5177 test_compare(MEMCACHED_SUCCESS
, rc
);
5178 test_true(bytes_written_str
);
5180 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
5181 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
5182 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
5184 test_true(bytes
!= bytes_read
);
5185 test_true(bytes
!= bytes_written
);
5187 /* Release allocated resources */
5189 free(bytes_read_str
);
5190 free(bytes_written_str
);
5191 memcached_stat_free(NULL
, memc_stat
);
5193 return TEST_SUCCESS
;
5197 * The test case isn't obvious so I should probably document why
5198 * it works the way it does. Bug 442914 was caused by a bug
5199 * in the logic in memcached_purge (it did not handle the case
5200 * where the number of bytes sent was equal to the watermark).
5201 * In this test case, create messages so that we hit that case
5202 * and then disable noreply mode and issue a new command to
5203 * verify that it isn't stuck. If we change the format for the
5204 * delete command or the watermarks, we need to update this
5207 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5209 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5210 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5212 uint32_t number_of_hosts
= memcached_server_count(memc
);
5213 memc
->number_of_hosts
= 1;
5218 for (uint32_t x
= 0; x
< 250; ++x
)
5220 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5221 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
5222 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5225 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5228 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
5229 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5231 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5232 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
5234 memc
->number_of_hosts
= number_of_hosts
;
5236 return TEST_SUCCESS
;
5239 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5241 memcached_server_instance_st instance_one
;
5242 memcached_server_instance_st instance_two
;
5244 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
5245 return TEST_SKIPPED
;
5247 test_compare(MEMCACHED_SUCCESS
,
5248 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
5250 const unsigned int max_keys
= 100;
5251 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
5252 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5254 for (unsigned int x
= 0; x
< max_keys
; ++x
)
5258 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5261 test_compare(MEMCACHED_SUCCESS
,
5262 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
5266 ** We are using the quiet commands to store the replicas, so we need
5267 ** to ensure that all of them are processed before we can continue.
5268 ** In the test we go directly from storing the object to trying to
5269 ** receive the object from all of the different servers, so we
5270 ** could end up in a race condition (the memcached server hasn't yet
5271 ** processed the quiet command from the replication set when it process
5272 ** the request from the other client (created by the clone)). As a
5273 ** workaround for that we call memcached_quit to send the quit command
5274 ** to the server and wait for the response ;-) If you use the test code
5275 ** as an example for your own code, please note that you shouldn't need
5278 memcached_quit(memc
);
5280 /* Verify that all messages are stored, and we didn't stuff too much
5283 test_compare(MEMCACHED_SUCCESS
,
5284 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5286 unsigned int counter
= 0;
5287 memcached_execute_fn callbacks
[]= { &callback_counter
};
5288 test_compare(MEMCACHED_SUCCESS
,
5289 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5291 /* Verify that we received all of the key/value pairs */
5292 test_compare(counter
, max_keys
);
5294 memcached_quit(memc
);
5296 * Don't do the following in your code. I am abusing the internal details
5297 * within the library, and this is not a supported interface.
5298 * This is to verify correct behavior in the library. Fake that two servers
5301 instance_one
= memcached_server_instance_by_position(memc
, 0);
5302 instance_two
= memcached_server_instance_by_position(memc
, 2);
5303 in_port_t port0
= instance_one
->port
;
5304 in_port_t port2
= instance_two
->port
;
5306 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5307 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5309 test_compare(MEMCACHED_SUCCESS
,
5310 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5313 test_compare(MEMCACHED_SUCCESS
,
5314 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5315 test_compare(counter
, (unsigned int)max_keys
);
5317 /* restore the memc handle */
5318 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5319 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5321 memcached_quit(memc
);
5323 /* Remove half of the objects */
5324 for (size_t x
= 0; x
< max_keys
; ++x
)
5328 test_compare(MEMCACHED_SUCCESS
,
5329 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
5333 memcached_quit(memc
);
5334 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5335 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5337 /* now retry the command, this time we should have cache misses */
5338 test_compare(MEMCACHED_SUCCESS
,
5339 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5342 test_compare(MEMCACHED_SUCCESS
,
5343 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5344 test_compare(counter
, (unsigned int)(max_keys
>> 1));
5346 /* Release allocated resources */
5347 for (size_t x
= 0; x
< max_keys
; ++x
)
5354 /* restore the memc handle */
5355 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5356 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5358 return TEST_SUCCESS
;
5361 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5363 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5364 test_true(memc_clone
);
5365 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5367 memcached_server_instance_st instance
=
5368 memcached_server_instance_by_position(memc_clone
, 0);
5370 if (instance
->major_version
> 1 ||
5371 (instance
->major_version
== 1 &&
5372 instance
->minor_version
> 2))
5374 /* Binary protocol doesn't support deferred delete */
5375 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5376 test_true(bin_clone
);
5377 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5378 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
5379 memcached_free(bin_clone
);
5381 memcached_quit(memc_clone
);
5383 /* If we know the server version, deferred delete should fail
5384 * with invalid arguments */
5385 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
5387 /* If we don't know the server version, we should get a protocol error */
5388 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5390 /* but there is a bug in some of the memcached servers (1.4) that treats
5391 * the counter as noreply so it doesn't send the proper error message
5393 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5395 /* And buffered mode should be disabled and we should get protocol error */
5396 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5397 rc
= memcached_delete(memc
, "foo", 3, 1);
5398 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5400 /* Same goes for noreply... */
5401 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5402 rc
= memcached_delete(memc
, "foo", 3, 1);
5403 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5405 /* but a normal request should go through (and be buffered) */
5406 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
5407 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
5409 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
5410 /* unbuffered noreply should be success */
5411 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
5412 /* unbuffered with reply should be not found... */
5413 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5414 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
5417 memcached_free(memc_clone
);
5418 return TEST_SUCCESS
;
5422 /* Test memcached_server_get_last_disconnect
5423 * For a working server set, shall be NULL
5424 * For a set of non existing server, shall not be NULL
5426 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5428 memcached_return_t rc
;
5429 memcached_server_instance_st disconnected_server
;
5431 /* With the working set of server */
5432 const char *key
= "marmotte";
5433 const char *value
= "milka";
5435 memcached_reset_last_disconnected_server(memc
);
5436 test_false(memc
->last_disconnected_server
);
5437 rc
= memcached_set(memc
, key
, strlen(key
),
5438 value
, strlen(value
),
5439 (time_t)0, (uint32_t)0);
5440 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5442 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5443 test_false(disconnected_server
);
5445 /* With a non existing server */
5447 memcached_server_st
*servers
;
5449 const char *server_list
= "localhost:9";
5451 servers
= memcached_servers_parse(server_list
);
5453 mine
= memcached_create(NULL
);
5454 rc
= memcached_server_push(mine
, servers
);
5455 test_compare(MEMCACHED_SUCCESS
, rc
);
5456 memcached_server_list_free(servers
);
5459 rc
= memcached_set(mine
, key
, strlen(key
),
5460 value
, strlen(value
),
5461 (time_t)0, (uint32_t)0);
5462 test_true(memcached_failed(rc
));
5464 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5465 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5466 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5467 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5469 memcached_quit(mine
);
5470 memcached_free(mine
);
5472 return TEST_SUCCESS
;
5475 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5477 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5478 char buffer
[BUFSIZ
];
5480 test_compare(MEMCACHED_SUCCESS
,
5481 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5483 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5486 // We will just use the error strings as our keys
5487 uint32_t counter
= 100;
5490 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5492 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5493 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5494 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, ret
, memcached_last_error_message(memc
));
5496 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5497 test_true(disconnected_server
);
5498 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5499 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5503 memcached_reset_last_disconnected_server(memc
);
5508 memcached_free(memc
);
5510 return TEST_SUCCESS
;
5513 static test_return_t
test_verbosity(memcached_st
*memc
)
5515 memcached_verbosity(memc
, 3);
5517 return TEST_SUCCESS
;
5520 static test_return_t
test_server_failure(memcached_st
*memc
)
5522 if (memcached_server_count(memc
) < 2)
5523 return TEST_SKIPPED
;
5525 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
5527 memcached_st
*local_memc
= memcached_create(NULL
);
5529 memcached_server_add(local_memc
, memcached_server_name(instance
), memcached_server_port(instance
));
5530 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 2);
5532 uint32_t server_count
= memcached_server_count(local_memc
);
5533 test_compare(1U, server_count
);
5535 // Disable the server
5536 instance
= memcached_server_instance_by_position(local_memc
, 0);
5537 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 2;
5539 memcached_return_t rc
;
5540 test_compare_got(MEMCACHED_SERVER_MARKED_DEAD
,
5541 rc
= memcached_set(local_memc
, "foo", strlen("foo"), NULL
, 0, (time_t)0, (uint32_t)0),
5542 memcached_last_error_message(local_memc
));
5544 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5545 test_compare(MEMCACHED_SUCCESS
,
5546 memcached_set(local_memc
, "foo", strlen("foo"), NULL
, 0, (time_t)0, (uint32_t)0));
5548 memcached_last_error_message(local_memc
));
5552 memcached_free(local_memc
);
5554 return TEST_SUCCESS
;
5557 static test_return_t
test_cull_servers(memcached_st
*memc
)
5559 uint32_t count
= memcached_server_count(memc
);
5563 return TEST_SKIPPED
;
5566 // Do not do this in your code, it is not supported.
5567 memc
->servers
[1].options
.is_dead
= true;
5568 memc
->state
.is_time_for_rebuild
= true;
5570 uint32_t new_count
= memcached_server_count(memc
);
5571 test_compare(count
, new_count
);
5574 test_true(count
== new_count
+ 1 );
5577 return TEST_SUCCESS
;
5581 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5582 const char *key
, size_t key_length
,
5583 const char *value
, size_t value_length
,
5593 return MEMCACHED_SUCCESS
;
5596 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5598 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5599 test_compare(MEMCACHED_SUCCESS
, rc
);
5601 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5602 test_compare(MEMCACHED_SUCCESS
, rc
);
5604 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5605 test_compare(MEMCACHED_SUCCESS
, rc
);
5607 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5608 test_compare(MEMCACHED_SUCCESS
, rc
);
5610 return TEST_SUCCESS
;
5614 * This test ensures that the failure counter isn't incremented during
5615 * normal termination of the memcached instance.
5617 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5619 memcached_return_t rc
;
5620 memcached_server_instance_st instance
;
5622 /* Set value to force connection to the server */
5623 const char *key
= "marmotte";
5624 const char *value
= "milka";
5627 * Please note that I'm abusing the internal structures in libmemcached
5628 * in a non-portable way and you shouldn't be doing this. I'm only
5629 * doing this in order to verify that the library works the way it should
5631 uint32_t number_of_hosts
= memcached_server_count(memc
);
5632 memc
->number_of_hosts
= 1;
5634 /* Ensure that we are connected to the server by setting a value */
5635 rc
= memcached_set(memc
, key
, strlen(key
),
5636 value
, strlen(value
),
5637 (time_t)0, (uint32_t)0);
5638 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5641 instance
= memcached_server_instance_by_position(memc
, 0);
5642 /* The test is to see that the memcached_quit doesn't increase the
5643 * the server failure conter, so let's ensure that it is zero
5644 * before sending quit
5646 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5648 memcached_quit(memc
);
5650 /* Verify that it memcached_quit didn't increment the failure counter
5651 * Please note that this isn't bullet proof, because an error could
5654 test_zero(instance
->server_failure_counter
);
5656 /* restore the instance */
5657 memc
->number_of_hosts
= number_of_hosts
;
5659 return TEST_SUCCESS
;
5663 * This tests ensures expected disconnections (for some behavior changes
5664 * for instance) do not wrongly increase failure counter
5666 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5668 memcached_return rc
;
5670 memcached_st
*memc_clone
;
5671 memc_clone
= memcached_clone(NULL
, memc
);
5672 test_true(memc_clone
);
5674 /* Set value to force connection to the server */
5675 const char *key
= "marmotte";
5676 const char *value
= "milka";
5677 char *string
= NULL
;
5678 size_t string_length
;
5681 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5682 value
, strlen(value
),
5683 (time_t)0, (uint32_t)0);
5684 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5687 /* put failure limit to 1 */
5688 test_compare(MEMCACHED_SUCCESS
,
5689 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1));
5691 /* Put a retry timeout to effectively activate failure_limit effect */
5692 test_compare(MEMCACHED_SUCCESS
,
5693 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
5695 /* change behavior that triggers memcached_quit()*/
5696 test_compare(MEMCACHED_SUCCESS
,
5697 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5700 /* Check if we still are connected */
5701 string
= memcached_get(memc_clone
, key
, strlen(key
),
5702 &string_length
, &flags
, &rc
);
5704 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5707 memcached_free(memc_clone
);
5709 return TEST_SUCCESS
;
5716 * Test that ensures mget_execute does not end into recursive calls that finally fails
5718 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5720 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5721 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5722 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5723 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5724 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5727 return TEST_SKIPPED
; // My MAC can't handle this test
5731 * I only want to hit _one_ server so I know the number of requests I'm
5732 * sending in the pipeline.
5734 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5735 memc
->number_of_hosts
= 1;
5736 size_t max_keys
= 20480;
5739 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5740 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5742 /* First add all of the items.. */
5743 char blob
[1024]= { 0 };
5744 for (size_t x
= 0; x
< max_keys
; ++x
)
5747 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5750 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5751 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5756 /* Try to get all of them with a large multiget */
5758 memcached_execute_function callbacks
[]= { &callback_counter
};
5759 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5760 (size_t)max_keys
, callbacks
, &counter
, 1);
5761 test_compare(MEMCACHED_SUCCESS
, rc
);
5763 char* the_value
= NULL
;
5764 char the_key
[MEMCACHED_MAX_KEY
];
5765 size_t the_key_length
;
5766 size_t the_value_length
;
5770 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5772 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5778 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5781 test_compare(MEMCACHED_END
, rc
);
5783 /* Verify that we got all of the items */
5784 test_compare(counter
, max_keys
);
5787 /* Release all allocated resources */
5788 for (size_t x
= 0; x
< max_keys
; ++x
)
5795 memc
->number_of_hosts
= number_of_hosts
;
5797 return TEST_SUCCESS
;
5800 static test_return_t
regression_bug_583031(memcached_st
*)
5802 memcached_st
*memc
= memcached_create(NULL
);
5804 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5806 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5807 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5808 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5809 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5810 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5811 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5813 memcached_return_t rc
;
5817 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5821 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_strerror(memc
, rc
));
5823 memcached_free(memc
);
5825 return TEST_SUCCESS
;
5828 static test_return_t
regression_bug_581030(memcached_st
*)
5831 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5832 test_false(local_stat
);
5834 memcached_stat_free(NULL
, NULL
);
5837 return TEST_SUCCESS
;
5840 #define regression_bug_655423_COUNT 6000
5841 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5843 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5844 memc
= NULL
; // Just to make sure it is not used
5849 return TEST_SKIPPED
;
5852 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5853 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5854 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5855 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5857 memset(payload
, int('x'), sizeof(payload
));
5859 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5861 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5862 snprintf(key
, sizeof(key
), "%u", x
);
5864 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5867 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5869 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5870 snprintf(key
, sizeof(key
), "%u", x
);
5872 size_t value_length
;
5873 memcached_return_t rc
;
5874 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5876 if (rc
== MEMCACHED_NOTFOUND
)
5879 test_zero(value_length
);
5883 test_compare(MEMCACHED_SUCCESS
, rc
);
5885 test_compare(100UL, value_length
);
5889 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5890 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5891 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5893 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5894 snprintf(key
, sizeof(key
), "%u", x
);
5896 keys
[x
]= strdup(key
);
5898 key_length
[x
]= strlen(key
);
5899 test_true(key_length
[x
]);
5902 test_compare(MEMCACHED_SUCCESS
,
5903 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5906 memcached_result_st
*result
= NULL
;
5907 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5909 test_compare(size_t(100), memcached_result_length(result
));
5913 test_true(count
> 100); // If we don't get back atleast this, something is up
5915 /* Release all allocated resources */
5916 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5924 memcached_free(clone
);
5926 return TEST_SUCCESS
;
5930 * Test that ensures that buffered set to not trigger problems during io_flush
5932 #define regression_bug_490520_COUNT 200480
5933 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5935 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5936 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5937 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5938 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5939 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5941 memc
->number_of_hosts
= 1;
5943 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5944 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5946 /* First add all of the items.. */
5947 char blob
[3333] = {0};
5948 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5951 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5955 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5956 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5959 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5966 return TEST_SUCCESS
;
5969 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5971 fprintf(stderr
, "Iteration #%u: ", it
);
5973 if(error
== MEMCACHED_ERRNO
)
5975 fprintf(stderr
, "system error %d from %s: %s\n",
5976 errno
, what
, strerror(errno
));
5980 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5981 memcached_strerror(mc
, error
));
5985 #define TEST_CONSTANT_CREATION 200
5987 static test_return_t
regression_bug_(memcached_st
*memc
)
5989 const char *remote_server
;
5992 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5994 return TEST_SKIPPED
;
5997 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5999 memcached_st
* mc
= memcached_create(NULL
);
6000 memcached_return rc
;
6002 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
6003 if (rc
!= MEMCACHED_SUCCESS
)
6005 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6008 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
6009 if (rc
!= MEMCACHED_SUCCESS
)
6011 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6014 rc
= memcached_server_add(mc
, remote_server
, 0);
6015 if (rc
!= MEMCACHED_SUCCESS
)
6017 memcached_die(mc
, rc
, "memcached_server_add", x
);
6020 const char *set_key
= "akey";
6021 const size_t set_key_len
= strlen(set_key
);
6022 const char *set_value
= "a value";
6023 const size_t set_value_len
= strlen(set_value
);
6025 if (rc
== MEMCACHED_SUCCESS
)
6029 size_t get_value_len
;
6031 uint32_t get_value_flags
;
6033 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
6034 &get_value_flags
, &rc
);
6035 if (rc
!= MEMCACHED_SUCCESS
)
6037 memcached_die(mc
, rc
, "memcached_get", x
);
6043 (get_value_len
!= set_value_len
6044 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
6046 fprintf(stderr
, "Values don't match?\n");
6047 rc
= MEMCACHED_FAILURE
;
6053 rc
= memcached_set(mc
,
6054 set_key
, set_key_len
,
6055 set_value
, set_value_len
,
6059 if (rc
!= MEMCACHED_SUCCESS
)
6061 memcached_die(mc
, rc
, "memcached_set", x
);
6068 if (rc
!= MEMCACHED_SUCCESS
)
6074 return TEST_SUCCESS
;
6078 * Test that the sasl authentication works. We cannot use the default
6079 * pool of servers, because that would require that all servers we want
6080 * to test supports SASL authentication, and that they use the default
6083 static test_return_t
sasl_auth_test(memcached_st
*memc
)
6085 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
6086 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0));
6087 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
6088 test_compare(MEMCACHED_SUCCESS
, memcached_destroy_sasl_auth_data(memc
));
6089 test_compare(MEMCACHED_FAILURE
, memcached_destroy_sasl_auth_data(memc
));
6090 test_compare(MEMCACHED_FAILURE
, memcached_destroy_sasl_auth_data(NULL
));
6091 memcached_quit(memc
);
6093 test_compare(MEMCACHED_SUCCESS
,
6094 memcached_set_sasl_auth_data(memc
,
6095 getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
6096 getenv("LIBMEMCACHED_TEST_SASL_SERVER")));
6098 test_compare(MEMCACHED_AUTH_FAILURE
,
6099 memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0));
6100 test_compare(MEMCACHED_SUCCESS
, memcached_destroy_sasl_auth_data(memc
));
6102 memcached_quit(memc
);
6103 return TEST_SUCCESS
;
6106 return TEST_FAILURE
;
6110 /* Clean the server before beginning testing */
6112 {"util_version", 1, (test_callback_fn
*)util_version_test
},
6113 {"flush", 0, (test_callback_fn
*)flush_test
},
6114 {"init", 0, (test_callback_fn
*)init_test
},
6115 {"allocation", 0, (test_callback_fn
*)allocation_test
},
6116 {"server_list_null_test", 0, (test_callback_fn
*)server_list_null_test
},
6117 {"server_unsort", 0, (test_callback_fn
*)server_unsort_test
},
6118 {"server_sort", 0, (test_callback_fn
*)server_sort_test
},
6119 {"server_sort2", 0, (test_callback_fn
*)server_sort2_test
},
6120 {"memcached_server_remove", 0, (test_callback_fn
*)memcached_server_remove_test
},
6121 {"clone_test", 0, (test_callback_fn
*)clone_test
},
6122 {"connection_test", 0, (test_callback_fn
*)connection_test
},
6123 {"callback_test", 0, (test_callback_fn
*)callback_test
},
6124 {"userdata_test", 0, (test_callback_fn
*)userdata_test
},
6125 {"error", 0, (test_callback_fn
*)error_test
},
6126 {"set", 0, (test_callback_fn
*)set_test
},
6127 {"set2", 0, (test_callback_fn
*)set_test2
},
6128 {"set3", 0, (test_callback_fn
*)set_test3
},
6129 {"dump", 1, (test_callback_fn
*)dump_test
},
6130 {"add", 1, (test_callback_fn
*)add_test
},
6131 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", 1, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
6132 {"replace", 1, (test_callback_fn
*)replace_test
},
6133 {"delete", 1, (test_callback_fn
*)delete_test
},
6134 {"get", 1, (test_callback_fn
*)get_test
},
6135 {"get2", 0, (test_callback_fn
*)get_test2
},
6136 {"get3", 0, (test_callback_fn
*)get_test3
},
6137 {"get4", 0, (test_callback_fn
*)get_test4
},
6138 {"partial mget", 0, (test_callback_fn
*)get_test5
},
6139 {"stats_servername", 0, (test_callback_fn
*)stats_servername_test
},
6140 {"increment", 0, (test_callback_fn
*)increment_test
},
6141 {"increment_with_initial", 1, (test_callback_fn
*)increment_with_initial_test
},
6142 {"decrement", 0, (test_callback_fn
*)decrement_test
},
6143 {"decrement_with_initial", 1, (test_callback_fn
*)decrement_with_initial_test
},
6144 {"increment_by_key", 0, (test_callback_fn
*)increment_by_key_test
},
6145 {"increment_with_initial_by_key", 1, (test_callback_fn
*)increment_with_initial_by_key_test
},
6146 {"decrement_by_key", 0, (test_callback_fn
*)decrement_by_key_test
},
6147 {"decrement_with_initial_by_key", 1, (test_callback_fn
*)decrement_with_initial_by_key_test
},
6148 {"quit", 0, (test_callback_fn
*)quit_test
},
6149 {"mget", 1, (test_callback_fn
*)mget_test
},
6150 {"mget_result", 1, (test_callback_fn
*)mget_result_test
},
6151 {"mget_result_alloc", 1, (test_callback_fn
*)mget_result_alloc_test
},
6152 {"mget_result_function", 1, (test_callback_fn
*)mget_result_function
},
6153 {"mget_execute", 1, (test_callback_fn
*)mget_execute
},
6154 {"mget_end", 0, (test_callback_fn
*)mget_end
},
6155 {"get_stats", 0, (test_callback_fn
*)get_stats
},
6156 {"add_host_test", 0, (test_callback_fn
*)add_host_test
},
6157 {"add_host_test_1", 0, (test_callback_fn
*)add_host_test1
},
6158 {"get_stats_keys", 0, (test_callback_fn
*)get_stats_keys
},
6159 {"version_string_test", 0, (test_callback_fn
*)version_string_test
},
6160 {"bad_key", 1, (test_callback_fn
*)bad_key_test
},
6161 {"memcached_server_cursor", 1, (test_callback_fn
*)memcached_server_cursor_test
},
6162 {"read_through", 1, (test_callback_fn
*)read_through
},
6163 {"delete_through", 1, (test_callback_fn
*)delete_through
},
6164 {"noreply", 1, (test_callback_fn
*)noreply_test
},
6165 {"analyzer", 1, (test_callback_fn
*)analyzer_test
},
6166 {"connectionpool", 1, (test_callback_fn
*)connection_pool_test
},
6167 {"memcached_pool_test", 1, (test_callback_fn
*)memcached_pool_test
},
6168 {"test_get_last_disconnect", 1, (test_callback_fn
*)test_get_last_disconnect
},
6169 {"verbosity", 1, (test_callback_fn
*)test_verbosity
},
6170 {"test_server_failure", 1, (test_callback_fn
*)test_server_failure
},
6171 {"cull_servers", 1, (test_callback_fn
*)test_cull_servers
},
6172 {"memcached_stat_execute", 1, (test_callback_fn
*)memcached_stat_execute_test
},
6176 test_st behavior_tests
[] ={
6177 {"libmemcached_string_behavior()", 0, (test_callback_fn
*)libmemcached_string_behavior_test
},
6178 {"libmemcached_string_distribution()", 0, (test_callback_fn
*)libmemcached_string_distribution_test
},
6179 {"behavior_test", 0, (test_callback_fn
*)behavior_test
},
6180 {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
6181 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
6182 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
6186 test_st libmemcachedutil_tests
[] ={
6187 {"libmemcached_util_ping()", 1, (test_callback_fn
*)ping_test
},
6188 {"libmemcached_util_getpid()", 1, (test_callback_fn
*)getpid_test
},
6189 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", 1, (test_callback_fn
*)getpid_connection_failure_test
},
6193 test_st basic_tests
[] ={
6194 {"init", 1, (test_callback_fn
*)basic_init_test
},
6195 {"clone", 1, (test_callback_fn
*)basic_clone_test
},
6196 {"reset", 1, (test_callback_fn
*)basic_reset_stack_test
},
6197 {"reset heap", 1, (test_callback_fn
*)basic_reset_heap_test
},
6198 {"reset stack clone", 1, (test_callback_fn
*)basic_reset_stack_clone_test
},
6199 {"reset heap clone", 1, (test_callback_fn
*)basic_reset_heap_clone_test
},
6203 test_st regression_binary_vs_block
[] ={
6204 {"block add", 1, (test_callback_fn
*)block_add_regression
},
6205 {"binary add", 1, (test_callback_fn
*)binary_add_regression
},
6209 test_st async_tests
[] ={
6210 {"add", 1, (test_callback_fn
*)add_wrapper
},
6214 test_st string_tests
[] ={
6215 {"string static with null", 0, (test_callback_fn
*)string_static_null
},
6216 {"string alloc with null", 0, (test_callback_fn
*)string_alloc_null
},
6217 {"string alloc with 1K", 0, (test_callback_fn
*)string_alloc_with_size
},
6218 {"string alloc with malloc failure", 0, (test_callback_fn
*)string_alloc_with_size_toobig
},
6219 {"string append", 0, (test_callback_fn
*)string_alloc_append
},
6220 {"string append failure (too big)", 0, (test_callback_fn
*)string_alloc_append_toobig
},
6221 {"string_alloc_append_multiple", 0, (test_callback_fn
*)string_alloc_append_multiple
},
6222 {0, 0, (test_callback_fn
*)0}
6225 test_st memcached_server_get_last_disconnect_tests
[] ={
6226 {"memcached_server_get_last_disconnect()", 0, (test_callback_fn
*)test_multiple_get_last_disconnect
},
6227 {0, 0, (test_callback_fn
*)0}
6231 test_st result_tests
[] ={
6232 {"result static", 0, (test_callback_fn
*)result_static
},
6233 {"result alloc", 0, (test_callback_fn
*)result_alloc
},
6234 {0, 0, (test_callback_fn
*)0}
6237 test_st version_1_2_3
[] ={
6238 {"append", 0, (test_callback_fn
*)append_test
},
6239 {"prepend", 0, (test_callback_fn
*)prepend_test
},
6240 {"cas", 0, (test_callback_fn
*)cas_test
},
6241 {"cas2", 0, (test_callback_fn
*)cas2_test
},
6242 {"append_binary", 0, (test_callback_fn
*)append_binary_test
},
6243 {0, 0, (test_callback_fn
*)0}
6246 test_st haldenbrand_tests
[] ={
6247 {"memcached_set", 0, (test_callback_fn
*)user_supplied_bug1
},
6248 {"memcached_get()", 0, (test_callback_fn
*)user_supplied_bug2
},
6249 {"memcached_mget()", 0, (test_callback_fn
*)user_supplied_bug3
},
6250 {0, 0, (test_callback_fn
*)0}
6253 test_st user_tests
[] ={
6254 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
6255 {"user_supplied_bug5", 1, (test_callback_fn
*)user_supplied_bug5
},
6256 {"user_supplied_bug6", 1, (test_callback_fn
*)user_supplied_bug6
},
6257 {"user_supplied_bug7", 1, (test_callback_fn
*)user_supplied_bug7
},
6258 {"user_supplied_bug8", 1, (test_callback_fn
*)user_supplied_bug8
},
6259 {"user_supplied_bug9", 1, (test_callback_fn
*)user_supplied_bug9
},
6260 {"user_supplied_bug10", 1, (test_callback_fn
*)user_supplied_bug10
},
6261 {"user_supplied_bug11", 1, (test_callback_fn
*)user_supplied_bug11
},
6262 {"user_supplied_bug12", 1, (test_callback_fn
*)user_supplied_bug12
},
6263 {"user_supplied_bug13", 1, (test_callback_fn
*)user_supplied_bug13
},
6264 {"user_supplied_bug14", 1, (test_callback_fn
*)user_supplied_bug14
},
6265 {"user_supplied_bug15", 1, (test_callback_fn
*)user_supplied_bug15
},
6266 {"user_supplied_bug16", 1, (test_callback_fn
*)user_supplied_bug16
},
6267 #if !defined(__sun) && !defined(__OpenBSD__)
6269 ** It seems to be something weird with the character sets..
6270 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6271 ** guess I need to find out how this is supposed to work.. Perhaps I need
6272 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6273 ** so just disable the code for now...).
6275 {"user_supplied_bug17", 1, (test_callback_fn
*)user_supplied_bug17
},
6277 {"user_supplied_bug18", 1, (test_callback_fn
*)user_supplied_bug18
},
6278 {"user_supplied_bug19", 1, (test_callback_fn
*)user_supplied_bug19
},
6279 {"user_supplied_bug20", 1, (test_callback_fn
*)user_supplied_bug20
},
6280 {"user_supplied_bug21", 1, (test_callback_fn
*)user_supplied_bug21
},
6281 {"wrong_failure_counter_test", 1, (test_callback_fn
*)wrong_failure_counter_test
},
6282 {"wrong_failure_counter_two_test", 1, (test_callback_fn
*)wrong_failure_counter_two_test
},
6283 {0, 0, (test_callback_fn
*)0}
6286 test_st replication_tests
[]= {
6287 {"set", 1, (test_callback_fn
*)replication_set_test
},
6288 {"get", 0, (test_callback_fn
*)replication_get_test
},
6289 {"mget", 0, (test_callback_fn
*)replication_mget_test
},
6290 {"delete", true, (test_callback_fn
*)replication_delete_test
},
6291 {"rand_mget", 0, (test_callback_fn
*)replication_randomize_mget_test
},
6292 {"fail", 0, (test_callback_fn
*)replication_randomize_mget_fail_test
},
6293 {0, 0, (test_callback_fn
*)0}
6297 * The following test suite is used to verify that we don't introduce
6298 * regression bugs. If you want more information about the bug / test,
6299 * you should look in the bug report at
6300 * http://bugs.launchpad.net/libmemcached
6302 test_st regression_tests
[]= {
6303 {"lp:434484", 1, (test_callback_fn
*)regression_bug_434484
},
6304 {"lp:434843", 1, (test_callback_fn
*)regression_bug_434843
},
6305 {"lp:434843-buffered", 1, (test_callback_fn
*)regression_bug_434843_buffered
},
6306 {"lp:421108", 1, (test_callback_fn
*)regression_bug_421108
},
6307 {"lp:442914", 1, (test_callback_fn
*)regression_bug_442914
},
6308 {"lp:447342", 1, (test_callback_fn
*)regression_bug_447342
},
6309 {"lp:463297", 1, (test_callback_fn
*)regression_bug_463297
},
6310 {"lp:490486", 1, (test_callback_fn
*)regression_bug_490486
},
6311 {"lp:583031", 1, (test_callback_fn
*)regression_bug_583031
},
6312 {"lp:?", 1, (test_callback_fn
*)regression_bug_
},
6313 {"lp:728286", 1, (test_callback_fn
*)regression_bug_728286
},
6314 {"lp:581030", 1, (test_callback_fn
*)regression_bug_581030
},
6315 {"lp:71231153 connect()", 1, (test_callback_fn
*)regression_bug_71231153_connect
},
6316 {"lp:71231153 poll()", 1, (test_callback_fn
*)regression_bug_71231153_poll
},
6317 {"lp:655423", 1, (test_callback_fn
*)regression_bug_655423
},
6318 {"lp:490520", 1, (test_callback_fn
*)regression_bug_490520
},
6319 {0, 0, (test_callback_fn
*)0}
6322 test_st sasl_auth_tests
[]= {
6323 {"sasl_auth", 1, (test_callback_fn
*)sasl_auth_test
},
6324 {0, 0, (test_callback_fn
*)0}
6327 test_st ketama_compatibility
[]= {
6328 {"libmemcached", 1, (test_callback_fn
*)ketama_compatibility_libmemcached
},
6329 {"spymemcached", 1, (test_callback_fn
*)ketama_compatibility_spymemcached
},
6330 {0, 0, (test_callback_fn
*)0}
6333 test_st generate_tests
[] ={
6334 {"generate_pairs", 1, (test_callback_fn
*)generate_pairs
},
6335 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6336 {"get_read", 0, (test_callback_fn
*)get_read
},
6337 {"delete_generate", 0, (test_callback_fn
*)delete_generate
},
6338 {"generate_buffer_data", 1, (test_callback_fn
*)generate_buffer_data
},
6339 {"delete_buffer", 0, (test_callback_fn
*)delete_buffer_generate
},
6340 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6341 {"mget_read", 0, (test_callback_fn
*)mget_read
},
6342 {"mget_read_result", 0, (test_callback_fn
*)mget_read_result
},
6343 {"memcached_fetch_result() use internal result", 0, (test_callback_fn
*)mget_read_internal_result
},
6344 {"memcached_fetch_result() partial read", 0, (test_callback_fn
*)mget_read_partial_result
},
6345 {"mget_read_function", 0, (test_callback_fn
*)mget_read_function
},
6346 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6347 {"generate_large_pairs", 1, (test_callback_fn
*)generate_large_pairs
},
6348 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6349 {"generate_buffer_data", 1, (test_callback_fn
*)generate_buffer_data
},
6350 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6351 {0, 0, (test_callback_fn
*)0}
6354 test_st consistent_tests
[] ={
6355 {"generate_pairs", 1, (test_callback_fn
*)generate_pairs
},
6356 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6357 {"get_read", 0, (test_callback_fn
*)get_read_count
},
6358 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6359 {0, 0, (test_callback_fn
*)0}
6362 test_st consistent_weighted_tests
[] ={
6363 {"generate_pairs", 1, (test_callback_fn
*)generate_pairs
},
6364 {"generate_data", 1, (test_callback_fn
*)generate_data_with_stats
},
6365 {"get_read", 0, (test_callback_fn
*)get_read_count
},
6366 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6367 {0, 0, (test_callback_fn
*)0}
6370 test_st hsieh_availability
[] ={
6371 {"hsieh_avaibility_test", 0, (test_callback_fn
*)hsieh_avaibility_test
},
6372 {0, 0, (test_callback_fn
*)0}
6375 test_st murmur_availability
[] ={
6376 {"murmur_avaibility_test", 0, (test_callback_fn
*)murmur_avaibility_test
},
6377 {0, 0, (test_callback_fn
*)0}
6381 test_st hash_sanity
[] ={
6382 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
6383 {0, 0, (test_callback_fn
*)0}
6387 test_st ketama_auto_eject_hosts
[] ={
6388 {"auto_eject_hosts", 1, (test_callback_fn
*)auto_eject_hosts
},
6389 {"output_ketama_weighted_keys", 1, (test_callback_fn
*)output_ketama_weighted_keys
},
6390 {0, 0, (test_callback_fn
*)0}
6393 test_st hash_tests
[] ={
6394 {"one_at_a_time_run", 0, (test_callback_fn
*)one_at_a_time_run
},
6395 {"md5", 0, (test_callback_fn
*)md5_run
},
6396 {"crc", 0, (test_callback_fn
*)crc_run
},
6397 {"fnv1_64", 0, (test_callback_fn
*)fnv1_64_run
},
6398 {"fnv1a_64", 0, (test_callback_fn
*)fnv1a_64_run
},
6399 {"fnv1_32", 0, (test_callback_fn
*)fnv1_32_run
},
6400 {"fnv1a_32", 0, (test_callback_fn
*)fnv1a_32_run
},
6401 {"hsieh", 0, (test_callback_fn
*)hsieh_run
},
6402 {"murmur", 0, (test_callback_fn
*)murmur_run
},
6403 {"jenkis", 0, (test_callback_fn
*)jenkins_run
},
6404 {"memcached_get_hashkit", 0, (test_callback_fn
*)memcached_get_hashkit_test
},
6405 {0, 0, (test_callback_fn
*)0}
6408 test_st error_conditions
[] ={
6409 {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
6410 {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
6411 {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
6412 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6413 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6414 {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
6415 {0, 0, (test_callback_fn
*)0}
6419 test_st parser_tests
[] ={
6420 {"behavior", 0, (test_callback_fn
*)behavior_parser_test
},
6421 {"boolean_options", 0, (test_callback_fn
*)parser_boolean_options_test
},
6422 {"configure_file", 0, (test_callback_fn
*)memcached_create_with_options_with_filename
},
6423 {"distribtions", 0, (test_callback_fn
*)parser_distribution_test
},
6424 {"hash", 0, (test_callback_fn
*)parser_hash_test
},
6425 {"libmemcached_check_configuration", 0, (test_callback_fn
*)libmemcached_check_configuration_test
},
6426 {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
6427 {"number_options", 0, (test_callback_fn
*)parser_number_options_test
},
6428 {"randomly generated options", 0, (test_callback_fn
*)random_statement_build_test
},
6429 {"namespace", 0, (test_callback_fn
*)parser_key_prefix_test
},
6430 {"server", 0, (test_callback_fn
*)server_test
},
6431 {"bad server strings", 0, (test_callback_fn
*)servers_bad_test
},
6432 {"server with weights", 0, (test_callback_fn
*)server_with_weight_test
},
6433 {"parsing servername, port, and weight", 0, (test_callback_fn
*)test_hostname_port_weight
},
6434 {"--socket=", 0, (test_callback_fn
*)test_parse_socket
},
6435 {"--namespace=", 0, (test_callback_fn
*)test_namespace_keyword
},
6436 {0, 0, (test_callback_fn
*)0}
6439 test_st virtual_bucket_tests
[] ={
6440 {"basic", 0, (test_callback_fn
*)virtual_back_map
},
6441 {0, 0, (test_callback_fn
*)0}
6444 test_st namespace_tests
[] ={
6445 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
6446 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
6447 {0, 0, (test_callback_fn
*)0}
6450 collection_st collection
[] ={
6452 {"hash_sanity", 0, 0, hash_sanity
},
6454 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
6455 {"basic", 0, 0, basic_tests
},
6456 {"hsieh_availability", 0, 0, hsieh_availability
},
6457 {"murmur_availability", 0, 0, murmur_availability
},
6458 {"block", 0, 0, tests
},
6459 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
6460 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
6461 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6462 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
6463 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
6464 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
6465 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
6466 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
6467 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
6468 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
6469 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
6470 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
6471 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
6472 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6473 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
6474 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6475 {"poll_timeout", (test_callback_fn
*)poll_timeout
, 0, tests
},
6476 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
6477 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
6478 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
6479 #ifdef MEMCACHED_ENABLE_DEPRECATED
6480 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
6482 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
6483 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
6484 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
6485 {"specific namespace", 0, 0, namespace_tests
},
6486 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
6487 {"sasl_auth", (test_callback_fn
*)pre_sasl
, 0, sasl_auth_tests
},
6488 {"sasl", (test_callback_fn
*)pre_sasl
, 0, tests
},
6489 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
6490 {"string", 0, 0, string_tests
},
6491 {"result", 0, 0, result_tests
},
6492 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
6493 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
6494 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
6495 {"user", 0, 0, user_tests
},
6496 {"generate", 0, 0, generate_tests
},
6497 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
6498 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
6499 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
6500 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
6501 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
6502 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
6503 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
6505 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
6506 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
6507 {"consistent_not", 0, 0, consistent_tests
},
6508 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
6509 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6510 {"ketama_compat", 0, 0, ketama_compatibility
},
6511 {"test_hashes", 0, 0, hash_tests
},
6512 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6513 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6514 {"regression", 0, 0, regression_tests
},
6515 {"behaviors", 0, 0, behavior_tests
},
6516 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6517 {"error_conditions", 0, 0, error_conditions
},
6518 {"parser", 0, 0, parser_tests
},
6519 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6520 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6524 #include "tests/libmemcached_world.h"
6526 void get_world(Framework
*world
)
6528 world
->collections
= collection
;
6530 world
->_create
= (test_callback_create_fn
*)world_create
;
6531 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6533 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6534 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6535 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6536 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6537 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6539 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6540 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6542 world
->set_runner(&defualt_libmemcached_runner
);