1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 #include <libtest/common.h>
44 #define BUILDING_LIBMEMCACHED
45 // !NEVER use common.h, always use memcached.h in your own apps
46 #include <libmemcached/common.h>
53 #include <sys/types.h>
58 #include <libtest/server.h>
60 #include "clients/generator.h"
61 #include "clients/execute.h"
63 #define SMALL_STRING_LEN 1024
65 #include <libtest/test.hpp>
66 #include "tests/deprecated.h"
67 #include "tests/parser.h"
68 #include "tests/pool.h"
69 #include "tests/namespace.h"
70 #include "tests/string.h"
71 #include "tests/replication.h"
72 #include "tests/basic.h"
73 #include "tests/error_conditions.h"
74 #include "tests/print.h"
75 #include "tests/virtual_buckets.h"
78 #ifdef HAVE_LIBMEMCACHEDUTIL
80 #include "libmemcached/memcached_util.h"
83 #include "hash_results.h"
85 #define GLOBAL_COUNT 10000
86 #define GLOBAL2_COUNT 100
87 #define SERVERS_TO_CREATE 5
88 static uint32_t global_count
;
90 static pairs_st
*global_pairs
;
91 static const char *global_keys
[GLOBAL_COUNT
];
92 static size_t global_keys_length
[GLOBAL_COUNT
];
95 static test_return_t
pre_binary(memcached_st
*memc
);
98 static test_return_t
init_test(memcached_st
*not_used
)
103 (void)memcached_create(&memc
);
104 memcached_free(&memc
);
109 #define TEST_PORT_COUNT 7
110 in_port_t test_ports
[TEST_PORT_COUNT
];
112 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
113 const memcached_server_st
*server
,
117 size_t bigger
= *((size_t *)(context
));
119 assert(bigger
<= memcached_server_port(server
));
120 *((size_t *)(context
))= memcached_server_port(server
);
122 return MEMCACHED_SUCCESS
;
125 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
126 const memcached_server_st
*instance
,
130 FILE *stream
= (FILE *)context
;
133 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
134 memcached_server_name(instance
),
135 memcached_server_port(instance
),
136 instance
->major_version
,
137 instance
->minor_version
,
138 instance
->micro_version
);
140 return MEMCACHED_SUCCESS
;
143 static test_return_t
server_sort_test(memcached_st
*ptr
)
145 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
147 memcached_return_t rc
;
148 memcached_server_fn callbacks
[1];
149 memcached_st
*local_memc
;
152 local_memc
= memcached_create(NULL
);
153 test_true(local_memc
);
154 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
156 for (size_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
158 test_ports
[x
]= (in_port_t
)random() % 64000;
159 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
160 test_compare(memcached_server_count(local_memc
), x
+1);
162 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
164 test_compare(MEMCACHED_SUCCESS
, rc
);
167 callbacks
[0]= server_display_function
;
168 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
171 memcached_free(local_memc
);
176 static test_return_t
server_sort2_test(memcached_st
*ptr
)
178 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
179 memcached_server_fn callbacks
[1];
180 memcached_st
*local_memc
;
181 memcached_server_instance_st instance
;
184 local_memc
= memcached_create(NULL
);
185 test_true(local_memc
);
186 test_compare(MEMCACHED_SUCCESS
,
187 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
189 test_compare(MEMCACHED_SUCCESS
,
190 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
191 instance
= memcached_server_instance_by_position(local_memc
, 0);
192 test_compare(43043, memcached_server_port(instance
));
194 test_compare(MEMCACHED_SUCCESS
,
195 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
197 instance
= memcached_server_instance_by_position(local_memc
, 0);
198 test_compare(43042, memcached_server_port(instance
));
200 instance
= memcached_server_instance_by_position(local_memc
, 1);
201 test_compare(43043, memcached_server_port(instance
));
203 callbacks
[0]= server_display_function
;
204 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
207 memcached_free(local_memc
);
212 static test_return_t
memcached_server_remove_test(memcached_st
*)
214 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";
217 memcached_return_t rc
;
218 test_compare_got(MEMCACHED_SUCCESS
,
219 rc
= libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)),
220 memcached_strerror(NULL
, rc
));
221 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
224 memcached_server_fn callbacks
[1];
225 callbacks
[0]= server_print_callback
;
226 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
228 memcached_free(memc
);
233 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
234 const memcached_server_st
*server
,
238 uint32_t x
= *((uint32_t *)(context
));
240 if (! (test_ports
[x
] == server
->port
))
242 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
243 return MEMCACHED_FAILURE
;
246 *((uint32_t *)(context
))= ++x
;
248 return MEMCACHED_SUCCESS
;
251 static test_return_t
server_unsort_test(memcached_st
*ptr
)
253 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
254 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
255 memcached_server_fn callbacks
[1];
256 memcached_st
*local_memc
;
259 local_memc
= memcached_create(NULL
);
260 test_true(local_memc
);
262 for (size_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
264 test_ports
[x
]= (in_port_t
)(random() % 64000);
265 test_compare(MEMCACHED_SUCCESS
,
266 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
267 test_compare(memcached_server_count(local_memc
), x
+1);
269 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
273 callbacks
[0]= server_display_unsort_function
;
274 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
276 /* Now we sort old data! */
277 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
278 callbacks
[0]= server_display_function
;
279 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
282 memcached_free(local_memc
);
287 static test_return_t
allocation_test(memcached_st
*not_used
)
291 memc
= memcached_create(NULL
);
293 memcached_free(memc
);
298 static test_return_t
clone_test(memcached_st
*memc
)
302 memcached_st
*memc_clone
;
303 memc_clone
= memcached_clone(NULL
, NULL
);
304 test_true(memc_clone
);
305 memcached_free(memc_clone
);
308 /* Can we init from null? */
310 memcached_st
*memc_clone
;
311 memc_clone
= memcached_clone(NULL
, memc
);
312 test_true(memc_clone
);
315 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
316 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
317 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
318 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
321 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
322 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
323 test_true(memc_clone
->distribution
== memc
->distribution
);
324 { // Test all of the flags
325 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
326 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
327 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
328 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
329 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
330 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
331 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
332 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
333 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
334 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
335 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
336 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
337 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
339 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
340 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
341 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
342 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
343 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
344 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
345 test_true(memc_clone
->on_clone
== memc
->on_clone
);
346 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
347 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
348 test_true(memc_clone
->recv_size
== memc
->recv_size
);
349 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
350 test_true(memc_clone
->send_size
== memc
->send_size
);
351 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
352 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
353 test_true(memc_clone
->user_data
== memc
->user_data
);
355 memcached_free(memc_clone
);
358 /* Can we init from struct? */
360 memcached_st declared_clone
;
361 memcached_st
*memc_clone
;
362 memset(&declared_clone
, 0 , sizeof(memcached_st
));
363 memc_clone
= memcached_clone(&declared_clone
, NULL
);
364 test_true(memc_clone
);
365 memcached_free(memc_clone
);
368 /* Can we init from struct? */
370 memcached_st declared_clone
;
371 memcached_st
*memc_clone
;
372 memset(&declared_clone
, 0 , sizeof(memcached_st
));
373 memc_clone
= memcached_clone(&declared_clone
, memc
);
374 test_true(memc_clone
);
375 memcached_free(memc_clone
);
381 static test_return_t
userdata_test(memcached_st
*memc
)
384 test_false(memcached_set_user_data(memc
, foo
));
385 test_true(memcached_get_user_data(memc
) == foo
);
386 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
391 static test_return_t
connection_test(memcached_st
*memc
)
393 test_compare(MEMCACHED_SUCCESS
,
394 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
399 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
401 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
403 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
405 test_compare(36, MEMCACHED_BEHAVIOR_MAX
);
410 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
412 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
414 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
416 test_compare(7, MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
);
421 static test_return_t
error_test(memcached_st
*memc
)
423 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
424 982370485U, 1263635348U, 4242906218U, 3829656100U,
425 1891735253U, 334139633U, 2257084983U, 3088286104U,
426 13199785U, 2542027183U, 1097051614U, 199566778U,
427 2748246961U, 2465192557U, 1664094137U, 2405439045U,
428 1842224848U, 692413798U, 3479807801U, 919913813U,
429 4269430871U, 610793021U, 527273862U, 1437122909U,
430 2300930706U, 2943759320U, 674306647U, 2400528935U,
431 54481931U, 4186304426U, 1741088401U, 2979625118U,
432 4159057246U, 3425930182U, 2593724503U, 1868899624U,
433 1769812374U, 2302537950U, 1110330676U, 3365377466U,
434 1336171666U, 3021258493U, 2334992265U, 3365377466U };
436 // You have updated the memcache_error messages but not updated docs/tests.
437 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
440 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
441 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
442 MEMCACHED_HASH_JENKINS
);
443 if (values
[rc
] != hash_val
)
445 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the error_test\n");
446 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
448 test_compare(values
[rc
], hash_val
);
450 test_compare(MEMCACHED_MAXIMUM_RETURN
, 47);
455 static test_return_t
set_test(memcached_st
*memc
)
457 memcached_return_t rc
= memcached_set(memc
,
458 memcached_literal_param("foo"),
459 memcached_literal_param("when we sanitize"),
460 time_t(0), (uint32_t)0);
461 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
466 static test_return_t
append_test(memcached_st
*memc
)
468 memcached_return_t rc
;
469 const char *key
= "fig";
470 const char *in_value
= "we";
471 char *out_value
= NULL
;
475 rc
= memcached_flush(memc
, 0);
476 test_compare(MEMCACHED_SUCCESS
, rc
);
478 rc
= memcached_set(memc
, key
, strlen(key
),
479 in_value
, strlen(in_value
),
480 (time_t)0, (uint32_t)0);
481 test_compare(MEMCACHED_SUCCESS
, rc
);
483 rc
= memcached_append(memc
, key
, strlen(key
),
484 " the", strlen(" the"),
485 (time_t)0, (uint32_t)0);
486 test_compare(MEMCACHED_SUCCESS
, rc
);
488 rc
= memcached_append(memc
, key
, strlen(key
),
489 " people", strlen(" people"),
490 (time_t)0, (uint32_t)0);
491 test_compare(MEMCACHED_SUCCESS
, rc
);
493 out_value
= memcached_get(memc
, key
, strlen(key
),
494 &value_length
, &flags
, &rc
);
495 test_memcmp(out_value
, "we the people", strlen("we the people"));
496 test_compare(strlen("we the people"), value_length
);
497 test_compare(MEMCACHED_SUCCESS
, rc
);
503 static test_return_t
append_binary_test(memcached_st
*memc
)
505 memcached_return_t rc
;
506 const char *key
= "numbers";
507 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
513 rc
= memcached_flush(memc
, 0);
514 test_compare(MEMCACHED_SUCCESS
, rc
);
516 rc
= memcached_set(memc
,
519 (time_t)0, (uint32_t)0);
520 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
522 for (x
= 0; store_list
[x
] ; x
++)
524 rc
= memcached_append(memc
,
526 (char *)&store_list
[x
], sizeof(uint32_t),
527 (time_t)0, (uint32_t)0);
528 test_compare(MEMCACHED_SUCCESS
, rc
);
531 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
532 &value_length
, &flags
, &rc
);
533 test_compare(value_length
, sizeof(uint32_t) * x
);
534 test_compare(MEMCACHED_SUCCESS
, rc
);
536 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
538 test_compare(*ptr
, store_list
[x
- counter
]);
546 static test_return_t
cas2_test(memcached_st
*memc
)
548 memcached_return_t rc
;
549 const char *keys
[]= {"fudge", "son", "food"};
550 size_t key_length
[]= {5, 3, 4};
551 const char *value
= "we the people";
552 size_t value_length
= strlen("we the people");
553 memcached_result_st results_obj
;
554 memcached_result_st
*results
;
557 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
559 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
561 for (uint32_t x
= 0; x
< 3; x
++)
563 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
564 keys
[x
], key_length
[x
],
565 (time_t)50, (uint32_t)9);
566 test_compare(MEMCACHED_SUCCESS
, rc
);
569 rc
= memcached_mget(memc
, keys
, key_length
, 3);
571 results
= memcached_result_create(memc
, &results_obj
);
573 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
575 test_true(results
->item_cas
);
576 test_compare(MEMCACHED_SUCCESS
, rc
);
577 test_true(memcached_result_cas(results
));
579 test_memcmp(value
, "we the people", strlen("we the people"));
580 test_compare(strlen("we the people"), value_length
);
581 test_compare(MEMCACHED_SUCCESS
, rc
);
583 memcached_result_free(&results_obj
);
588 static test_return_t
cas_test(memcached_st
*memc
)
590 memcached_return_t rc
;
591 const char *key
= "fun";
592 size_t key_length
= strlen(key
);
593 const char *value
= "we the people";
594 const char* keys
[2] = { key
, NULL
};
595 size_t keylengths
[2] = { strlen(key
), 0 };
596 size_t value_length
= strlen(value
);
597 const char *value2
= "change the value";
598 size_t value2_length
= strlen(value2
);
600 memcached_result_st results_obj
;
601 memcached_result_st
*results
;
604 rc
= memcached_flush(memc
, 0);
605 test_compare(MEMCACHED_SUCCESS
, rc
);
607 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
609 rc
= memcached_set(memc
, key
, strlen(key
),
610 value
, strlen(value
),
611 (time_t)0, (uint32_t)0);
612 test_compare(MEMCACHED_SUCCESS
, rc
);
614 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
616 results
= memcached_result_create(memc
, &results_obj
);
618 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
620 test_compare(MEMCACHED_SUCCESS
, rc
);
621 test_true(memcached_result_cas(results
));
622 test_memcmp(value
, memcached_result_value(results
), value_length
);
623 test_compare(strlen(memcached_result_value(results
)), value_length
);
624 test_compare(MEMCACHED_SUCCESS
, rc
);
625 uint64_t cas
= memcached_result_cas(results
);
628 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
629 test_true(rc
== MEMCACHED_END
);
630 test_true(results
== NULL
);
633 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
634 test_compare(MEMCACHED_SUCCESS
, rc
);
637 * The item will have a new cas value, so try to set it again with the old
638 * value. This should fail!
640 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
641 test_compare(MEMCACHED_DATA_EXISTS
, rc
);
643 memcached_result_free(&results_obj
);
648 static test_return_t
prepend_test(memcached_st
*memc
)
650 memcached_return_t rc
;
651 const char *key
= "fig";
652 const char *value
= "people";
653 char *out_value
= NULL
;
657 rc
= memcached_flush(memc
, 0);
658 test_compare(MEMCACHED_SUCCESS
, rc
);
660 rc
= memcached_set(memc
, key
, strlen(key
),
661 value
, strlen(value
),
662 (time_t)0, (uint32_t)0);
663 test_compare(MEMCACHED_SUCCESS
, rc
);
665 rc
= memcached_prepend(memc
, key
, strlen(key
),
666 "the ", strlen("the "),
667 (time_t)0, (uint32_t)0);
668 test_compare(MEMCACHED_SUCCESS
, rc
);
670 rc
= memcached_prepend(memc
, key
, strlen(key
),
671 "we ", strlen("we "),
672 (time_t)0, (uint32_t)0);
673 test_compare(MEMCACHED_SUCCESS
, rc
);
675 out_value
= memcached_get(memc
, key
, strlen(key
),
676 &value_length
, &flags
, &rc
);
677 test_memcmp(out_value
, "we the people", strlen("we the people"));
678 test_compare(strlen("we the people"), value_length
);
679 test_compare(MEMCACHED_SUCCESS
, rc
);
686 Set the value, then quit to make sure it is flushed.
687 Come back in and test that add fails.
689 static test_return_t
add_test(memcached_st
*memc
)
691 memcached_return_t rc
;
692 const char *key
= "foo";
693 const char *value
= "when we sanitize";
694 unsigned long long setting_value
;
696 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
698 rc
= memcached_set(memc
, key
, strlen(key
),
699 value
, strlen(value
),
700 (time_t)0, (uint32_t)0);
701 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
702 memcached_quit(memc
);
703 rc
= memcached_add(memc
, key
, strlen(key
),
704 value
, strlen(value
),
705 (time_t)0, (uint32_t)0);
707 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
710 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
714 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
721 ** There was a problem of leaking filedescriptors in the initial release
722 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
723 ** systems it seems that the kernel is slow on reclaiming the resources
724 ** because the connects starts to time out (the test doesn't do much
725 ** anyway, so just loop 10 iterations)
727 static test_return_t
add_wrapper(memcached_st
*memc
)
729 unsigned int max
= 10000;
737 for (uint32_t x
= 0; x
< max
; x
++)
743 static test_return_t
replace_test(memcached_st
*memc
)
745 memcached_return_t rc
;
746 const char *key
= "foo";
747 const char *value
= "when we sanitize";
748 const char *original
= "first we insert some data";
750 rc
= memcached_set(memc
, key
, strlen(key
),
751 original
, strlen(original
),
752 (time_t)0, (uint32_t)0);
753 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
755 test_compare(MEMCACHED_SUCCESS
,
756 memcached_replace(memc
, key
, strlen(key
),
757 value
, strlen(value
),
758 (time_t)0, (uint32_t)0));
763 static test_return_t
delete_test(memcached_st
*memc
)
765 memcached_return_t rc
;
766 const char *key
= "foo";
767 const char *value
= "when we sanitize";
769 rc
= memcached_set(memc
, key
, strlen(key
),
770 value
, strlen(value
),
771 (time_t)0, (uint32_t)0);
772 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
774 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
775 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
780 static test_return_t
flush_test(memcached_st
*memc
)
782 uint64_t query_id
= memcached_query_id(memc
);
783 test_compare(MEMCACHED_SUCCESS
,
784 memcached_flush(memc
, 0));
785 test_compare(query_id
+1, memcached_query_id(memc
));
790 static memcached_return_t
server_function(const memcached_st
*ptr
,
791 const memcached_server_st
*server
,
794 (void)ptr
; (void)server
; (void)context
;
797 return MEMCACHED_SUCCESS
;
800 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
803 strncpy(context
, "foo bad", sizeof(context
));
804 memcached_server_fn callbacks
[1];
806 callbacks
[0]= server_function
;
807 memcached_server_cursor(memc
, callbacks
, context
, 1);
811 static test_return_t
bad_key_test(memcached_st
*memc
)
813 memcached_return_t rc
;
814 const char *key
= "foo bad";
816 size_t string_length
;
818 memcached_st
*memc_clone
;
820 size_t max_keylen
= 0xffff;
822 // Just skip if we are in binary mode.
823 uint64_t query_id
= memcached_query_id(memc
);
824 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
826 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
828 memc_clone
= memcached_clone(NULL
, memc
);
829 test_true(memc_clone
);
831 query_id
= memcached_query_id(memc_clone
);
832 test_compare(MEMCACHED_SUCCESS
,
833 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
834 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
836 /* All keys are valid in the binary protocol (except for length) */
837 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
839 query_id
= memcached_query_id(memc_clone
);
840 string
= memcached_get(memc_clone
, key
, strlen(key
),
841 &string_length
, &flags
, &rc
);
842 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
843 test_compare(0, string_length
);
847 query_id
= memcached_query_id(memc_clone
);
848 test_compare(MEMCACHED_SUCCESS
,
849 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
850 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
851 string
= memcached_get(memc_clone
, key
, strlen(key
),
852 &string_length
, &flags
, &rc
);
853 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
854 test_compare(0, string_length
);
857 /* Test multi key for bad keys */
858 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
859 size_t key_lengths
[] = { 7, 7, 7 };
861 query_id
= memcached_query_id(memc_clone
);
862 test_compare(MEMCACHED_SUCCESS
,
863 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
864 test_compare(query_id
, memcached_query_id(memc_clone
));
866 query_id
= memcached_query_id(memc_clone
);
867 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
868 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
869 test_compare(query_id
+1, memcached_query_id(memc_clone
));
871 query_id
= memcached_query_id(memc_clone
);
872 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
873 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
874 test_compare(query_id
+1, memcached_query_id(memc_clone
));
878 /* The following test should be moved to the end of this function when the
879 memcached server is updated to allow max size length of the keys in the
882 test_compare(MEMCACHED_SUCCESS
,
883 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
885 char *longkey
= (char *)malloc(max_keylen
+ 1);
888 memset(longkey
, 'a', max_keylen
+ 1);
889 string
= memcached_get(memc_clone
, longkey
, max_keylen
,
890 &string_length
, &flags
, &rc
);
891 test_compare(MEMCACHED_NOTFOUND
, rc
);
892 test_compare(0, string_length
);
895 string
= memcached_get(memc_clone
, longkey
, max_keylen
+ 1,
896 &string_length
, &flags
, &rc
);
897 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
898 test_compare(0, string_length
);
905 /* Make sure zero length keys are marked as bad */
907 test_compare(MEMCACHED_SUCCESS
,
908 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
909 string
= memcached_get(memc_clone
, key
, 0,
910 &string_length
, &flags
, &rc
);
911 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
912 test_compare(0, string_length
);
915 memcached_free(memc_clone
);
920 #define READ_THROUGH_VALUE "set for me"
921 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
924 memcached_result_st
*result
)
926 (void)memc
;(void)key
;(void)key_length
;
927 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
930 #ifndef __INTEL_COMPILER
931 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
934 static test_return_t
read_through(memcached_st
*memc
)
936 memcached_return_t rc
;
937 const char *key
= "foo";
939 size_t string_length
;
941 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
943 string
= memcached_get(memc
, key
, strlen(key
),
944 &string_length
, &flags
, &rc
);
946 test_compare(MEMCACHED_NOTFOUND
, rc
);
947 test_false(string_length
);
950 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
);
951 test_compare(MEMCACHED_SUCCESS
, rc
);
953 string
= memcached_get(memc
, key
, strlen(key
),
954 &string_length
, &flags
, &rc
);
956 test_compare(MEMCACHED_SUCCESS
, rc
);
957 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
958 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
959 test_strcmp(READ_THROUGH_VALUE
, string
);
962 string
= memcached_get(memc
, key
, strlen(key
),
963 &string_length
, &flags
, &rc
);
965 test_compare(MEMCACHED_SUCCESS
, rc
);
967 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
968 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
969 test_strcmp(READ_THROUGH_VALUE
, string
);
975 static memcached_return_t
delete_trigger(memcached_st
*,
982 return MEMCACHED_SUCCESS
;
985 static test_return_t
delete_through(memcached_st
*memc
)
987 memcached_trigger_delete_key_fn callback
;
988 memcached_return_t rc
;
990 callback
= (memcached_trigger_delete_key_fn
)delete_trigger
;
992 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
993 test_compare(MEMCACHED_SUCCESS
, rc
);
998 static test_return_t
get_test(memcached_st
*memc
)
1000 memcached_return_t rc
;
1001 const char *key
= "foo";
1003 size_t string_length
;
1006 uint64_t query_id
= memcached_query_id(memc
);
1007 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
1008 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
1009 test_compare(query_id
+1, memcached_query_id(memc
));
1011 string
= memcached_get(memc
, key
, strlen(key
),
1012 &string_length
, &flags
, &rc
);
1014 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1015 test_false(string_length
);
1018 return TEST_SUCCESS
;
1021 static test_return_t
get_test2(memcached_st
*memc
)
1023 const char *key
= "foo";
1024 const char *value
= "when we sanitize";
1026 uint64_t query_id
= memcached_query_id(memc
);
1027 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1028 value
, strlen(value
),
1029 (time_t)0, (uint32_t)0);
1030 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1031 test_compare(query_id
+1, memcached_query_id(memc
));
1033 query_id
= memcached_query_id(memc
);
1034 test_true(query_id
);
1037 size_t string_length
;
1038 char *string
= memcached_get(memc
, key
, strlen(key
),
1039 &string_length
, &flags
, &rc
);
1040 test_compare(query_id
+1, memcached_query_id(memc
));
1042 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1043 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1045 test_compare(strlen(value
), string_length
);
1046 test_memcmp(string
, value
, string_length
);
1050 return TEST_SUCCESS
;
1053 static test_return_t
set_test2(memcached_st
*memc
)
1055 const char *key
= "foo";
1056 const char *value
= "train in the brain";
1057 size_t value_length
= strlen(value
);
1059 for (uint32_t x
= 0; x
< 10; x
++)
1061 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1062 value
, value_length
,
1063 (time_t)0, (uint32_t)0);
1064 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1067 return TEST_SUCCESS
;
1070 static test_return_t
set_test3(memcached_st
*memc
)
1072 size_t value_length
= 8191;
1074 char *value
= (char*)malloc(value_length
);
1077 for (uint32_t x
= 0; x
< value_length
; x
++)
1079 value
[x
] = (char) (x
% 127);
1082 /* The dump test relies on there being at least 32 items in memcached */
1083 for (uint32_t x
= 0; x
< 32; x
++)
1087 snprintf(key
, sizeof(key
), "foo%u", x
);
1089 uint64_t query_id
= memcached_query_id(memc
);
1090 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1091 value
, value_length
,
1092 (time_t)0, (uint32_t)0);
1093 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1094 test_compare(query_id
+1, memcached_query_id(memc
));
1099 return TEST_SUCCESS
;
1102 static test_return_t
get_test3(memcached_st
*memc
)
1104 const char *key
= "foo";
1105 size_t value_length
= 8191;
1107 char *value
= (char*)malloc(value_length
);
1110 for (uint32_t x
= 0; x
< value_length
; x
++)
1112 value
[x
] = (char) (x
% 127);
1115 memcached_return_t rc
;
1116 rc
= memcached_set(memc
, key
, strlen(key
),
1117 value
, value_length
,
1118 (time_t)0, (uint32_t)0);
1119 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1121 size_t string_length
;
1123 char *string
= memcached_get(memc
, key
, strlen(key
),
1124 &string_length
, &flags
, &rc
);
1126 test_compare(MEMCACHED_SUCCESS
, rc
);
1128 test_compare(string_length
, value_length
);
1129 test_memcmp(string
, value
, string_length
);
1134 return TEST_SUCCESS
;
1137 static test_return_t
get_test4(memcached_st
*memc
)
1139 const char *key
= "foo";
1140 size_t value_length
= 8191;
1142 char *value
= (char*)malloc(value_length
);
1145 for (uint32_t x
= 0; x
< value_length
; x
++)
1147 value
[x
] = (char) (x
% 127);
1150 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1151 value
, value_length
,
1152 (time_t)0, (uint32_t)0);
1153 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1155 for (uint32_t x
= 0; x
< 10; x
++)
1158 size_t string_length
;
1159 char *string
= memcached_get(memc
, key
, strlen(key
),
1160 &string_length
, &flags
, &rc
);
1162 test_compare(MEMCACHED_SUCCESS
, rc
);
1164 test_compare(string_length
, value_length
);
1165 test_memcmp(string
, value
, string_length
);
1171 return TEST_SUCCESS
;
1175 * This test verifies that memcached_read_one_response doesn't try to
1176 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1177 * responses before you execute a storage command.
1179 static test_return_t
get_test5(memcached_st
*memc
)
1182 ** Request the same key twice, to ensure that we hash to the same server
1183 ** (so that we have multiple response values queued up) ;-)
1185 const char *keys
[]= { "key", "key" };
1186 size_t lengths
[]= { 3, 3 };
1190 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1191 keys
[0], lengths
[0], 0, 0);
1192 test_compare(MEMCACHED_SUCCESS
, rc
);
1193 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1195 memcached_result_st results_obj
;
1196 memcached_result_st
*results
;
1197 results
=memcached_result_create(memc
, &results_obj
);
1199 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
1201 memcached_result_free(&results_obj
);
1203 /* Don't read out the second result, but issue a set instead.. */
1204 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
1205 test_compare(MEMCACHED_SUCCESS
, rc
);
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 (int i
= 0; i
< 2; i
++)
1230 rc
= memcached_set(memc
, keys
[i
], lengths
[i
], values
[i
], strlen(values
[i
]),
1231 (time_t)0, (uint32_t)0);
1232 test_compare(MEMCACHED_SUCCESS
, rc
);
1236 size_t string_length
;
1239 // retrieve both via mget
1240 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1241 test_compare(MEMCACHED_SUCCESS
, rc
);
1243 char key
[MEMCACHED_MAX_KEY
];
1246 // this should get both
1247 for (int i
= 0; i
< 2; i
++)
1249 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1251 test_compare(MEMCACHED_SUCCESS
, rc
);
1253 if (key_length
== 4)
1258 test_compare(string_length
, strlen(values
[val
]));
1259 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1263 // this should indicate end
1264 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1265 test_compare(MEMCACHED_END
, rc
);
1268 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1269 test_compare(MEMCACHED_SUCCESS
, rc
);
1271 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1272 test_compare(key_length
, lengths
[0]);
1273 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1274 test_compare(string_length
, strlen(values
[0]));
1275 test_true(strncmp(values
[0], string
, string_length
) == 0);
1276 test_compare(MEMCACHED_SUCCESS
, rc
);
1279 // this should indicate end
1280 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1281 test_true(rc
== MEMCACHED_END
);
1283 return TEST_SUCCESS
;
1286 /* Do not copy the style of this code, I just access hosts to testthis function */
1287 static test_return_t
stats_servername_test(memcached_st
*memc
)
1289 memcached_return_t rc
;
1290 memcached_stat_st memc_stat
;
1291 memcached_server_instance_st instance
=
1292 memcached_server_instance_by_position(memc
, 0);
1294 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
1295 if (memcached_get_sasl_callbacks(memc
) != NULL
)
1296 return TEST_SKIPPED
;
1298 rc
= memcached_stat_servername(&memc_stat
, NULL
,
1299 memcached_server_name(instance
),
1300 memcached_server_port(instance
));
1302 return TEST_SUCCESS
;
1305 static test_return_t
increment_test(memcached_st
*memc
)
1307 uint64_t new_number
;
1309 test_compare(MEMCACHED_SUCCESS
,
1311 test_literal_param("number"),
1312 test_literal_param("0"),
1313 (time_t)0, (uint32_t)0));
1315 memcached_return_t rc
;
1316 test_compare_got(MEMCACHED_SUCCESS
,
1317 rc
= memcached_increment(memc
,
1318 test_literal_param("number"),
1320 memcached_strerror(NULL
, rc
));
1321 test_compare(1, new_number
);
1323 test_compare(MEMCACHED_SUCCESS
,
1324 memcached_increment(memc
,
1325 test_literal_param("number"),
1327 test_compare(2, new_number
);
1329 return TEST_SUCCESS
;
1332 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1334 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1336 uint64_t new_number
;
1337 uint64_t initial
= 0;
1339 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1341 memcached_return_t rc
;
1342 test_compare_got(MEMCACHED_SUCCESS
,
1343 rc
= memcached_increment_with_initial(memc
,
1344 test_literal_param("number"),
1345 1, initial
, 0, &new_number
),
1346 memcached_strerror(NULL
, rc
));
1347 test_compare(new_number
, initial
);
1349 test_compare(MEMCACHED_SUCCESS
,
1350 memcached_increment_with_initial(memc
,
1351 test_literal_param("number"),
1352 1, initial
, 0, &new_number
));
1353 test_compare(new_number
, (initial
+ 1));
1355 return TEST_SUCCESS
;
1358 static test_return_t
decrement_test(memcached_st
*memc
)
1360 uint64_t new_number
;
1361 memcached_return_t rc
;
1362 const char *value
= "3";
1364 rc
= memcached_set(memc
,
1365 test_literal_param("number"),
1366 value
, strlen(value
),
1367 (time_t)0, (uint32_t)0);
1368 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1370 test_compare(MEMCACHED_SUCCESS
,
1371 memcached_decrement(memc
,
1372 test_literal_param("number"),
1374 test_compare(new_number
, 2);
1376 test_compare(MEMCACHED_SUCCESS
,
1377 memcached_decrement(memc
,
1378 test_literal_param("number"),
1380 test_compare(new_number
, 1);
1382 return TEST_SUCCESS
;
1385 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1387 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1389 uint64_t new_number
;
1390 uint64_t initial
= 3;
1392 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1394 test_compare(MEMCACHED_SUCCESS
,
1395 memcached_decrement_with_initial(memc
,
1396 test_literal_param("number"),
1397 1, initial
, 0, &new_number
));
1398 test_compare(new_number
, initial
);
1400 test_compare(MEMCACHED_SUCCESS
,
1401 memcached_decrement_with_initial(memc
,
1402 test_literal_param("number"),
1403 1, initial
, 0, &new_number
));
1404 test_compare(new_number
, (initial
- 1));
1406 return TEST_SUCCESS
;
1409 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1411 uint64_t new_number
;
1412 memcached_return_t rc
;
1413 const char *master_key
= "foo";
1414 const char *key
= "number";
1415 const char *value
= "0";
1417 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1419 value
, strlen(value
),
1420 (time_t)0, (uint32_t)0);
1421 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1423 test_compare(MEMCACHED_SUCCESS
,
1424 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1426 test_compare(new_number
, 1);
1428 test_compare(MEMCACHED_SUCCESS
,
1429 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1431 test_compare(new_number
, 2);
1433 return TEST_SUCCESS
;
1436 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1438 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1440 uint64_t new_number
;
1441 memcached_return_t rc
;
1442 const char *master_key
= "foo";
1443 const char *key
= "number";
1444 uint64_t initial
= 0;
1446 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1448 1, initial
, 0, &new_number
);
1449 test_compare(MEMCACHED_SUCCESS
, rc
);
1450 test_true(new_number
== initial
);
1452 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1454 1, initial
, 0, &new_number
);
1455 test_compare(MEMCACHED_SUCCESS
, rc
);
1456 test_true(new_number
== (initial
+ 1));
1458 return TEST_SUCCESS
;
1461 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1463 uint64_t new_number
;
1464 memcached_return_t rc
;
1465 const char *value
= "3";
1467 rc
= memcached_set_by_key(memc
,
1468 test_literal_param("foo"),
1469 test_literal_param("number"),
1470 value
, strlen(value
),
1471 (time_t)0, (uint32_t)0);
1472 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1474 test_compare(MEMCACHED_SUCCESS
,
1475 memcached_decrement_by_key(memc
,
1476 test_literal_param("foo"),
1477 test_literal_param("number"),
1479 test_compare(new_number
, 2);
1481 test_compare(MEMCACHED_SUCCESS
,
1482 memcached_decrement_by_key(memc
,
1483 test_literal_param("foo"),
1484 test_literal_param("number"),
1486 test_compare(new_number
, 1);
1488 return TEST_SUCCESS
;
1491 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1493 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1495 uint64_t new_number
;
1496 uint64_t initial
= 3;
1498 test_compare(MEMCACHED_SUCCESS
,
1499 memcached_decrement_with_initial_by_key(memc
,
1500 test_literal_param("foo"),
1501 test_literal_param("number"),
1502 1, initial
, 0, &new_number
));
1503 test_compare(new_number
, initial
);
1505 test_compare(MEMCACHED_SUCCESS
,
1506 memcached_decrement_with_initial_by_key(memc
,
1507 test_literal_param("foo"),
1508 test_literal_param("number"),
1509 1, initial
, 0, &new_number
));
1510 test_compare(new_number
, (initial
- 1));
1512 return TEST_SUCCESS
;
1515 static test_return_t
quit_test(memcached_st
*memc
)
1517 memcached_return_t rc
;
1518 const char *key
= "fudge";
1519 const char *value
= "sanford and sun";
1521 rc
= memcached_set(memc
, key
, strlen(key
),
1522 value
, strlen(value
),
1523 (time_t)10, (uint32_t)3);
1524 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1525 memcached_quit(memc
);
1527 rc
= memcached_set(memc
, key
, strlen(key
),
1528 value
, strlen(value
),
1529 (time_t)50, (uint32_t)9);
1530 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1532 return TEST_SUCCESS
;
1535 static test_return_t
mget_result_test(memcached_st
*memc
)
1537 const char *keys
[]= {"fudge", "son", "food"};
1538 size_t key_length
[]= {5, 3, 4};
1540 memcached_result_st results_obj
;
1541 memcached_result_st
*results
;
1543 results
= memcached_result_create(memc
, &results_obj
);
1545 test_true(&results_obj
== results
);
1547 /* We need to empty the server before continueing test */
1548 test_compare(MEMCACHED_SUCCESS
,
1549 memcached_flush(memc
, 0));
1551 test_compare(MEMCACHED_SUCCESS
,
1552 memcached_mget(memc
, keys
, key_length
, 3));
1554 memcached_return_t rc
;
1555 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1560 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1561 test_false(results
);
1562 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1564 for (uint32_t x
= 0; x
< 3; x
++)
1566 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1567 keys
[x
], key_length
[x
],
1568 (time_t)50, (uint32_t)9);
1569 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1572 test_compare(MEMCACHED_SUCCESS
,
1573 memcached_mget(memc
, keys
, key_length
, 3));
1575 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1578 test_true(&results_obj
== results
);
1579 test_compare(MEMCACHED_SUCCESS
, rc
);
1580 test_memcmp(memcached_result_key_value(results
),
1581 memcached_result_value(results
),
1582 memcached_result_length(results
));
1583 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1586 memcached_result_free(&results_obj
);
1588 return TEST_SUCCESS
;
1591 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1593 const char *keys
[]= {"fudge", "son", "food"};
1594 size_t key_length
[]= {5, 3, 4};
1596 memcached_result_st
*results
;
1598 /* We need to empty the server before continueing test */
1599 test_compare(MEMCACHED_SUCCESS
,
1600 memcached_flush(memc
, 0));
1602 test_compare(MEMCACHED_SUCCESS
,
1603 memcached_mget(memc
, keys
, key_length
, 3));
1605 memcached_return_t rc
;
1606 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1610 test_false(results
);
1611 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1613 for (uint32_t x
= 0; x
< 3; x
++)
1615 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1616 keys
[x
], key_length
[x
],
1617 (time_t)50, (uint32_t)9);
1618 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1621 test_compare(MEMCACHED_SUCCESS
,
1622 memcached_mget(memc
, keys
, key_length
, 3));
1625 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1628 test_compare(MEMCACHED_SUCCESS
, rc
);
1629 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1630 test_memcmp(memcached_result_key_value(results
),
1631 memcached_result_value(results
),
1632 memcached_result_length(results
));
1633 memcached_result_free(results
);
1637 return TEST_SUCCESS
;
1640 /* Count the results */
1641 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1643 size_t *counter
= (size_t *)context
;
1645 *counter
= *counter
+ 1;
1647 return MEMCACHED_SUCCESS
;
1650 static test_return_t
mget_result_function(memcached_st
*memc
)
1652 const char *keys
[]= {"fudge", "son", "food"};
1653 size_t key_length
[]= {5, 3, 4};
1655 memcached_execute_fn callbacks
[1];
1657 /* We need to empty the server before continueing test */
1658 test_compare(MEMCACHED_SUCCESS
,
1659 memcached_flush(memc
, 0));
1660 for (uint32_t x
= 0; x
< 3; x
++)
1662 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1663 keys
[x
], key_length
[x
],
1664 (time_t)50, (uint32_t)9);
1665 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1668 test_compare(MEMCACHED_SUCCESS
,
1669 memcached_mget(memc
, keys
, key_length
, 3));
1671 callbacks
[0]= &callback_counter
;
1674 memcached_return_t rc
;
1675 test_compare_got(MEMCACHED_SUCCESS
,
1676 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1),
1677 memcached_strerror(NULL
, rc
));
1679 test_compare(counter
, 3);
1681 return TEST_SUCCESS
;
1684 static test_return_t
mget_test(memcached_st
*memc
)
1686 const char *keys
[]= {"fudge", "son", "food"};
1687 size_t key_length
[]= {5, 3, 4};
1689 char return_key
[MEMCACHED_MAX_KEY
];
1690 size_t return_key_length
;
1692 size_t return_value_length
;
1694 /* We need to empty the server before continueing test */
1695 test_compare(MEMCACHED_SUCCESS
,
1696 memcached_flush(memc
, 0));
1698 test_compare(MEMCACHED_SUCCESS
,
1699 memcached_mget(memc
, keys
, key_length
, 3));
1702 memcached_return_t rc
;
1703 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1704 &return_value_length
, &flags
, &rc
)))
1706 test_true(return_value
);
1708 test_false(return_value
);
1709 test_compare(0, return_value_length
);
1710 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1712 for (uint32_t x
= 0; x
< 3; x
++)
1714 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1715 keys
[x
], key_length
[x
],
1716 (time_t)50, (uint32_t)9);
1717 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1719 test_compare(MEMCACHED_SUCCESS
,
1720 memcached_mget(memc
, keys
, key_length
, 3));
1723 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1724 &return_value_length
, &flags
, &rc
)))
1726 test_true(return_value
);
1727 test_compare(MEMCACHED_SUCCESS
, rc
);
1728 if (not memc
->_namespace
)
1730 test_compare(return_key_length
, return_value_length
);
1731 test_memcmp(return_value
, return_key
, return_value_length
);
1737 return TEST_SUCCESS
;
1740 static test_return_t
mget_execute(memcached_st
*memc
)
1744 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1748 * I only want to hit _one_ server so I know the number of requests I'm
1749 * sending in the pipeline.
1751 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1752 memc
->number_of_hosts
= 1;
1754 size_t max_keys
= 20480;
1757 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1758 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1760 /* First add all of the items.. */
1761 char blob
[1024] = {0};
1762 memcached_return_t rc
;
1764 for (size_t x
= 0; x
< max_keys
; ++x
)
1768 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1770 test_true(keys
[x
] != NULL
);
1771 uint64_t query_id
= memcached_query_id(memc
);
1772 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1773 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1774 test_compare(query_id
+1, memcached_query_id(memc
));
1777 /* Try to get all of them with a large multiget */
1779 memcached_execute_fn callbacks
[]= { &callback_counter
};
1780 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1781 max_keys
, callbacks
, &counter
, 1);
1783 if (memcached_success(rc
))
1786 uint64_t query_id
= memcached_query_id(memc
);
1787 test_compare(MEMCACHED_SUCCESS
,
1788 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1789 test_compare(query_id
, memcached_query_id(memc
));
1791 /* Verify that we got all of the items */
1792 test_true(counter
== max_keys
);
1794 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1796 test_true(counter
== 0);
1800 test_fail("note: this test functions differently when in binary mode");
1803 /* Release all allocated resources */
1804 for (size_t x
= 0; x
< max_keys
; ++x
)
1811 memc
->number_of_hosts
= number_of_hosts
;
1812 return TEST_SUCCESS
;
1815 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1817 static test_return_t
key_setup(memcached_st
*memc
)
1819 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1821 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1823 return TEST_SUCCESS
;
1826 static test_return_t
key_teardown(memcached_st
*memc
)
1829 pairs_free(global_pairs
);
1831 return TEST_SUCCESS
;
1834 static test_return_t
block_add_regression(memcached_st
*memc
)
1836 /* First add all of the items.. */
1837 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1839 memcached_return_t rc
;
1840 char blob
[1024] = {0};
1842 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1843 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1846 return TEST_SUCCESS
;
1849 static test_return_t
binary_add_regression(memcached_st
*memc
)
1851 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1852 test_return_t rc
= block_add_regression(memc
);
1853 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1857 static test_return_t
get_stats_keys(memcached_st
*memc
)
1861 memcached_stat_st memc_stat
;
1862 memcached_return_t rc
;
1864 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1865 test_compare(MEMCACHED_SUCCESS
, rc
);
1866 for (ptr
= stat_list
; *ptr
; ptr
++)
1871 return TEST_SUCCESS
;
1874 static test_return_t
version_string_test(memcached_st
*memc
)
1876 const char *version_string
;
1879 version_string
= memcached_lib_version();
1881 test_strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
);
1883 return TEST_SUCCESS
;
1886 static test_return_t
get_stats(memcached_st
*memc
)
1888 memcached_return_t rc
;
1890 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1891 test_compare(MEMCACHED_SUCCESS
, rc
);
1892 test_true(memc_stat
);
1894 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1896 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1897 test_compare(MEMCACHED_SUCCESS
, rc
);
1898 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1903 memcached_stat_free(NULL
, memc_stat
);
1905 return TEST_SUCCESS
;
1908 static test_return_t
add_host_test(memcached_st
*memc
)
1911 memcached_server_st
*servers
;
1912 memcached_return_t rc
;
1913 char servername
[]= "0.example.com";
1915 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1917 test_true(1 == memcached_server_list_count(servers
));
1919 for (x
= 2; x
< 20; x
++)
1921 char buffer
[SMALL_STRING_LEN
];
1923 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1924 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1926 test_compare(MEMCACHED_SUCCESS
, rc
);
1927 test_true(x
== memcached_server_list_count(servers
));
1930 rc
= memcached_server_push(memc
, servers
);
1931 test_compare(MEMCACHED_SUCCESS
, rc
);
1932 rc
= memcached_server_push(memc
, servers
);
1933 test_compare(MEMCACHED_SUCCESS
, rc
);
1935 memcached_server_list_free(servers
);
1937 return TEST_SUCCESS
;
1940 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1942 memcached_return_t rc
;
1943 const char *key
= "not_found";
1944 size_t key_len
= strlen(key
);
1946 test_compare(MEMCACHED_SUCCESS
,
1947 memcached_mget(memc
, &key
, &key_len
, 1));
1949 memcached_result_st
*result
= NULL
;
1950 result
= memcached_fetch_result(memc
, result
, &rc
);
1952 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1954 memcached_result_free(result
);
1956 return TEST_SUCCESS
;
1959 static memcached_return_t
clone_test_callback(memcached_st
*parent
, memcached_st
*memc_clone
)
1961 (void)parent
;(void)memc_clone
;
1962 return MEMCACHED_SUCCESS
;
1965 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
)
1968 return MEMCACHED_SUCCESS
;
1971 static test_return_t
callback_test(memcached_st
*memc
)
1973 /* Test User Data */
1977 memcached_return_t rc
;
1979 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1980 test_compare(MEMCACHED_SUCCESS
, rc
);
1981 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1982 test_true(*test_ptr
== x
);
1985 /* Test Clone Callback */
1987 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1988 void *clone_cb_ptr
= *(void **)&clone_cb
;
1989 void *temp_function
= NULL
;
1990 memcached_return_t rc
;
1992 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1994 test_compare(MEMCACHED_SUCCESS
, rc
);
1995 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1996 test_true(temp_function
== clone_cb_ptr
);
1999 /* Test Cleanup Callback */
2001 memcached_cleanup_fn cleanup_cb
=
2002 (memcached_cleanup_fn
)cleanup_test_callback
;
2003 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2004 void *temp_function
= NULL
;
2005 memcached_return_t rc
;
2007 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2009 test_compare(MEMCACHED_SUCCESS
, rc
);
2010 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2011 test_true(temp_function
== cleanup_cb_ptr
);
2014 return TEST_SUCCESS
;
2017 /* We don't test the behavior itself, we test the switches */
2018 static test_return_t
behavior_test(memcached_st
*memc
)
2023 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2024 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2025 test_true(value
== 1);
2027 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2028 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2029 test_true(value
== 1);
2031 set
= MEMCACHED_HASH_MD5
;
2032 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2033 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2034 test_true(value
== MEMCACHED_HASH_MD5
);
2038 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2039 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2040 test_true(value
== 0);
2042 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2043 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2044 test_true(value
== 0);
2046 set
= MEMCACHED_HASH_DEFAULT
;
2047 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2048 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2049 test_true(value
== MEMCACHED_HASH_DEFAULT
);
2051 set
= MEMCACHED_HASH_CRC
;
2052 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2053 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2054 test_true(value
== MEMCACHED_HASH_CRC
);
2056 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2057 test_true(value
> 0);
2059 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2060 test_true(value
> 0);
2062 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2063 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
2064 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2066 return TEST_SUCCESS
;
2069 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2071 memcached_return_t rc
;
2074 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
2075 test_true(rc
== MEMCACHED_DEPRECATED
);
2077 // Platform dependent
2079 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2083 return TEST_SUCCESS
;
2087 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2089 memcached_return_t rc
;
2093 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, set
);
2094 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2096 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2098 if (rc
== MEMCACHED_SUCCESS
)
2100 test_true((bool)value
== set
);
2104 test_false((bool)value
== set
);
2107 return TEST_SUCCESS
;
2111 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2113 memcached_return_t rc
;
2117 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, set
);
2118 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2120 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2122 if (rc
== MEMCACHED_SUCCESS
)
2124 test_true((bool)value
== set
);
2128 test_false((bool)value
== set
);
2131 return TEST_SUCCESS
;
2134 static test_return_t
fetch_all_results(memcached_st
*memc
, size_t &keys_returned
, const memcached_return_t expect
)
2136 memcached_return_t rc
;
2137 char return_key
[MEMCACHED_MAX_KEY
];
2138 size_t return_key_length
;
2140 size_t return_value_length
;
2144 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2145 &return_value_length
, &flags
, &rc
)))
2147 test_true(return_value
);
2148 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2153 if (memcached_success(expect
) and memcached_success(rc
))
2155 return TEST_SUCCESS
;
2157 else if (expect
== rc
)
2159 return TEST_SUCCESS
;
2161 fprintf(stderr
, "\n%s:%u %s(#%lu)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), (unsigned long)(keys_returned
));
2163 return TEST_FAILURE
;
2166 /* Test case provided by Cal Haldenbrand */
2167 #define HALDENBRAND_KEY_COUNT 3000 // * 1024576
2168 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2169 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2171 /* We just keep looking at the same values over and over */
2174 unsigned int setter
= 1;
2175 test_compare(MEMCACHED_SUCCESS
,
2176 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2177 test_compare(MEMCACHED_SUCCESS
,
2178 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2182 unsigned long long total
= 0;
2183 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2185 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2186 char randomstuff
[6 * 1024];
2187 memset(randomstuff
, 0, 6 * 1024);
2188 test_true(size
< 6 * 1024); /* Being safe here */
2190 for (uint32_t j
= 0 ; j
< size
;j
++)
2192 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2197 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2198 memcached_return_t rc
;
2199 test_compare_got(MEMCACHED_SUCCESS
,
2200 rc
= memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
),
2201 memcached_strerror(NULL
, rc
));
2203 test_true(total
> HALDENBRAND_KEY_COUNT
);
2205 return TEST_SUCCESS
;
2208 /* Test case provided by Cal Haldenbrand */
2209 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2211 unsigned int setter
= 1;
2213 test_compare(MEMCACHED_SUCCESS
,
2214 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2216 test_compare(MEMCACHED_SUCCESS
,
2217 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2220 setter
= 20 * 1024576;
2221 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2222 setter
= 20 * 1024576;
2223 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2224 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2225 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2227 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2230 size_t total_value_length
= 0;
2231 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2236 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2237 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2239 memcached_return_t rc
;
2240 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2241 if (memcached_failed(rc
))
2243 if (rc
== MEMCACHED_NOTFOUND
)
2254 test_compare(HALDENBRAND_FLAG_KEY
, flags
);
2256 total_value_length
+= val_len
;
2261 return TEST_SUCCESS
;
2264 /* Do a large mget() over all the keys we think exist */
2265 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2267 unsigned int setter
= 1;
2268 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2269 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2271 setter
= 20 * 1024576;
2272 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2273 setter
= 20 * 1024576;
2274 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2275 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2276 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2279 size_t key_lengths
[HALDENBRAND_KEY_COUNT
];
2280 char **keys
= static_cast<char **>(calloc(HALDENBRAND_KEY_COUNT
, sizeof(char *)));
2282 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2284 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2285 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2286 keys
[x
]= strdup(key
);
2288 key_lengths
[x
]= key_length
;
2289 test_compare(size_t(key_length
), strlen(keys
[x
]));
2292 test_compare(MEMCACHED_SUCCESS
,
2293 memcached_mget(memc
, (const char **)keys
, key_lengths
, HALDENBRAND_KEY_COUNT
));
2296 size_t keys_returned
;
2297 test_compare_got(TEST_SUCCESS
, foo
= fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
), test_strerror(foo
));
2298 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2300 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2306 return TEST_SUCCESS
;
2309 /* Make sure we behave properly if server list has no values */
2310 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2312 const char *keys
[]= {"fudge", "son", "food"};
2313 size_t key_length
[]= {5, 3, 4};
2315 /* Here we free everything before running a bunch of mget tests */
2316 memcached_servers_reset(memc
);
2319 /* We need to empty the server before continueing test */
2320 test_compare(MEMCACHED_NO_SERVERS
,
2321 memcached_flush(memc
, 0));
2323 test_compare(MEMCACHED_NO_SERVERS
,
2324 memcached_mget(memc
, keys
, key_length
, 3));
2326 size_t keys_returned
;
2327 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2328 test_compare(0, keys_returned
);
2330 for (uint32_t x
= 0; x
< 3; x
++)
2332 test_compare(MEMCACHED_NO_SERVERS
,
2333 memcached_set(memc
, keys
[x
], key_length
[x
],
2334 keys
[x
], key_length
[x
],
2335 (time_t)50, (uint32_t)9));
2338 test_compare(MEMCACHED_NO_SERVERS
,
2339 memcached_mget(memc
, keys
, key_length
, 3));
2343 char return_key
[MEMCACHED_MAX_KEY
];
2344 memcached_return_t rc
;
2345 size_t return_key_length
;
2346 size_t return_value_length
;
2349 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2350 &return_value_length
, &flags
, &rc
)))
2352 test_true(return_value
);
2353 test_compare(MEMCACHED_SUCCESS
, rc
);
2354 test_true(return_key_length
== return_value_length
);
2355 test_memcmp(return_value
, return_key
, return_value_length
);
2361 return TEST_SUCCESS
;
2364 #define VALUE_SIZE_BUG5 1048064
2365 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2367 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2368 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2370 size_t value_length
;
2372 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2374 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2376 insert_data
[x
]= (signed char)rand();
2379 test_compare(MEMCACHED_SUCCESS
,
2380 memcached_flush(memc
, 0));
2382 memcached_return_t rc
;
2383 value
= memcached_get(memc
, keys
[0], key_length
[0],
2384 &value_length
, &flags
, &rc
);
2386 test_compare(MEMCACHED_SUCCESS
,
2387 memcached_mget(memc
, keys
, key_length
, 4));
2390 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2391 test_compare(0, count
);
2393 for (uint32_t x
= 0; x
< 4; x
++)
2395 test_compare(MEMCACHED_SUCCESS
,
2396 memcached_set(memc
, keys
[x
], key_length
[x
],
2397 insert_data
, VALUE_SIZE_BUG5
,
2398 (time_t)0, (uint32_t)0));
2401 for (uint32_t x
= 0; x
< 10; x
++)
2403 value
= memcached_get(memc
, keys
[0], key_length
[0],
2404 &value_length
, &flags
, &rc
);
2405 test_compare(rc
, MEMCACHED_SUCCESS
);
2409 test_compare(MEMCACHED_SUCCESS
,
2410 memcached_mget(memc
, keys
, key_length
, 4));
2412 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2413 test_compare(4, count
);
2415 delete [] insert_data
;
2417 return TEST_SUCCESS
;
2420 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2422 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2423 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2424 char return_key
[MEMCACHED_MAX_KEY
];
2425 size_t return_key_length
;
2427 size_t value_length
;
2429 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2431 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2433 insert_data
[x
]= (signed char)rand();
2436 test_compare(MEMCACHED_SUCCESS
,
2437 memcached_flush(memc
, 0));
2439 memcached_return_t rc
;
2440 value
= memcached_get(memc
, keys
[0], key_length
[0],
2441 &value_length
, &flags
, &rc
);
2443 test_compare(MEMCACHED_NOTFOUND
, rc
);
2445 test_compare(MEMCACHED_SUCCESS
,
2446 memcached_mget(memc
, keys
, key_length
, 4));
2449 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2450 &value_length
, &flags
, &rc
)))
2454 test_compare(0, count
);
2455 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2457 for (uint32_t x
= 0; x
< 4; x
++)
2459 test_compare(MEMCACHED_SUCCESS
,
2460 memcached_set(memc
, keys
[x
], key_length
[x
],
2461 insert_data
, VALUE_SIZE_BUG5
,
2462 (time_t)0, (uint32_t)0));
2465 for (uint32_t x
= 0; x
< 2; x
++)
2467 value
= memcached_get(memc
, keys
[0], key_length
[0],
2468 &value_length
, &flags
, &rc
);
2472 test_compare(MEMCACHED_SUCCESS
,
2473 memcached_mget(memc
, keys
, key_length
, 4));
2475 /* We test for purge of partial complete fetches */
2476 for (count
= 3; count
; count
--)
2478 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2479 &value_length
, &flags
, &rc
);
2480 test_compare(MEMCACHED_SUCCESS
, rc
);
2481 test_memcmp(value
, insert_data
, value_length
);
2482 test_true(value_length
);
2486 delete [] insert_data
;
2488 return TEST_SUCCESS
;
2491 static test_return_t
user_supplied_bug8(memcached_st
*)
2493 memcached_return_t rc
;
2495 memcached_st
*memc_clone
;
2497 memcached_server_st
*servers
;
2498 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";
2500 servers
= memcached_servers_parse(server_list
);
2503 mine
= memcached_create(NULL
);
2504 rc
= memcached_server_push(mine
, servers
);
2505 test_compare(MEMCACHED_SUCCESS
, rc
);
2506 memcached_server_list_free(servers
);
2509 memc_clone
= memcached_clone(NULL
, mine
);
2511 memcached_quit(mine
);
2512 memcached_quit(memc_clone
);
2515 memcached_free(mine
);
2516 memcached_free(memc_clone
);
2518 return TEST_SUCCESS
;
2521 /* Test flag store/retrieve */
2522 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2524 const char *keys
= "036790384900";
2525 size_t key_length
= strlen(keys
);
2526 char return_key
[MEMCACHED_MAX_KEY
];
2527 size_t return_key_length
;
2529 size_t value_length
;
2531 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2533 for (unsigned int x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2534 insert_data
[x
]= (signed char)rand();
2536 memcached_flush(memc
, 0);
2539 memcached_return_t rc
= memcached_set(memc
, keys
, key_length
,
2540 insert_data
, VALUE_SIZE_BUG5
,
2542 test_compare(MEMCACHED_SUCCESS
, rc
);
2545 value
= memcached_get(memc
, keys
, key_length
,
2546 &value_length
, &flags
, &rc
);
2547 test_true(flags
== 245);
2551 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2554 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2555 &value_length
, &flags
, &rc
);
2556 test_compare(245, flags
);
2559 delete [] insert_data
;
2562 return TEST_SUCCESS
;
2565 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2567 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2568 size_t key_length
[3];
2572 char return_key
[MEMCACHED_MAX_KEY
];
2573 size_t return_key_length
;
2575 size_t return_value_length
;
2578 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2579 key_length
[1]= strlen("fudge&*@#");
2580 key_length
[2]= strlen("for^#@&$not");
2583 for (unsigned int x
= 0; x
< 3; x
++)
2585 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2586 keys
[x
], key_length
[x
],
2587 (time_t)50, (uint32_t)9);
2588 test_compare(MEMCACHED_SUCCESS
, rc
);
2591 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2592 test_compare(MEMCACHED_SUCCESS
, rc
);
2594 /* We need to empty the server before continueing test */
2595 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2596 &return_value_length
, &flags
, &rc
)) != NULL
)
2598 test_true(return_value
);
2602 test_compare(3, count
);
2604 return TEST_SUCCESS
;
2607 /* We are testing with aggressive timeout to get failures */
2608 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2610 const char *key
= "foo";
2611 size_t value_length
= 512;
2613 unsigned int set
= 1;
2614 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2616 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2617 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2619 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, (uint64_t)timeout
);
2621 char *value
= (char*)malloc(value_length
* sizeof(char));
2623 for (unsigned int x
= 0; x
< value_length
; x
++)
2625 value
[x
]= (char) (x
% 127);
2628 for (unsigned int x
= 1; x
<= 100000; ++x
)
2630 memcached_return_t rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2632 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
,
2633 memcached_strerror(NULL
, rc
));
2635 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2642 memcached_free(mclone
);
2644 return TEST_SUCCESS
;
2648 We are looking failures in the async protocol
2650 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2652 const char *key
= "foo";
2653 size_t value_length
= 512;
2655 unsigned int set
= 1;
2656 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2658 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2659 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2660 int32_t timeout
= -1;
2661 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, (size_t)timeout
);
2663 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2665 test_true(timeout
== -1);
2667 char *value
= (char*)malloc(value_length
* sizeof(char));
2669 for (unsigned int x
= 0; x
< value_length
; x
++)
2671 value
[x
]= (char) (x
% 127);
2674 for (unsigned int x
= 1; x
<= 100000; ++x
)
2676 memcached_return_t rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2681 memcached_free(mclone
);
2683 return TEST_SUCCESS
;
2687 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2689 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2691 memcached_return_t rc
;
2693 size_t value_length
;
2695 uint64_t number_value
;
2697 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2698 &value_length
, &flags
, &rc
);
2699 test_true(value
== NULL
);
2700 test_compare(MEMCACHED_NOTFOUND
, rc
);
2702 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2705 test_true(value
== NULL
);
2706 /* The binary protocol will set the key if it doesn't exist */
2707 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2709 test_compare(MEMCACHED_SUCCESS
, rc
);
2713 test_compare(MEMCACHED_NOTFOUND
, rc
);
2716 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2718 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2719 &value_length
, &flags
, &rc
);
2721 test_compare(MEMCACHED_SUCCESS
, rc
);
2724 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2726 test_true(number_value
== 2);
2727 test_compare(MEMCACHED_SUCCESS
, rc
);
2729 return TEST_SUCCESS
;
2733 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2734 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2736 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2738 char key
[] = "key34567890";
2739 memcached_return_t rc
;
2740 size_t overflowSize
;
2742 char commandFirst
[]= "set key34567890 0 0 ";
2743 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2744 size_t commandLength
;
2747 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2749 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2751 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2753 char *overflow
= new (std::nothrow
) char[testSize
];
2754 test_true(overflow
);
2756 memset(overflow
, 'x', testSize
);
2757 rc
= memcached_set(memc
, key
, strlen(key
),
2758 overflow
, testSize
, 0, 0);
2759 test_compare(MEMCACHED_SUCCESS
, rc
);
2763 return TEST_SUCCESS
;
2768 Test values of many different sizes
2769 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2770 set key34567890 0 0 8169 \r\n
2771 is sent followed by buffer of size 8169, followed by 8169
2773 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2776 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2777 memcached_return_t rc
;
2778 const char *key
= "foo";
2780 size_t value_length
= 18000;
2782 size_t string_length
;
2785 size_t current_length
;
2787 value
= (char*)malloc(value_length
);
2790 for (x
= 0; x
< value_length
; x
++)
2791 value
[x
] = (char) (x
% 127);
2793 for (current_length
= 0; current_length
< value_length
; current_length
++)
2795 rc
= memcached_set(memc
, key
, strlen(key
),
2796 value
, current_length
,
2797 (time_t)0, (uint32_t)0);
2798 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2800 string
= memcached_get(memc
, key
, strlen(key
),
2801 &string_length
, &flags
, &rc
);
2803 test_compare(MEMCACHED_SUCCESS
, rc
);
2804 test_true(string_length
== current_length
);
2805 test_memcmp(string
, value
, string_length
);
2812 return TEST_SUCCESS
;
2816 Look for zero length value problems
2818 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2821 memcached_return_t rc
;
2822 const char *key
= "mykey";
2826 for (x
= 0; x
< 2; x
++)
2828 rc
= memcached_set(memc
, key
, strlen(key
),
2830 (time_t)0, (uint32_t)0);
2832 test_compare(MEMCACHED_SUCCESS
, rc
);
2834 char *value
= memcached_get(memc
, key
, strlen(key
),
2835 &length
, &flags
, &rc
);
2837 test_compare(MEMCACHED_SUCCESS
, rc
);
2842 value
= memcached_get(memc
, key
, strlen(key
),
2843 &length
, &flags
, &rc
);
2845 test_compare(MEMCACHED_SUCCESS
, rc
);
2846 test_true(value
== NULL
);
2847 test_true(length
== 0);
2848 test_true(flags
== 0);
2851 return TEST_SUCCESS
;
2854 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2855 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2857 memcached_return_t rc
;
2858 const char *key
= "mykey";
2863 rc
= memcached_set(memc
, key
, strlen(key
),
2865 (time_t)0, UINT32_MAX
);
2867 test_compare(MEMCACHED_SUCCESS
, rc
);
2869 value
= memcached_get(memc
, key
, strlen(key
),
2870 &length
, &flags
, &rc
);
2872 test_compare(MEMCACHED_SUCCESS
, rc
);
2873 test_true(value
== NULL
);
2874 test_true(length
== 0);
2875 test_true(flags
== UINT32_MAX
);
2877 return TEST_SUCCESS
;
2880 #if !defined(__sun) && !defined(__OpenBSD__)
2881 /* Check the validity of chinese key*/
2882 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2884 memcached_return_t rc
;
2885 const char *key
= "豆瓣";
2886 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2891 rc
= memcached_set(memc
, key
, strlen(key
),
2892 value
, strlen(value
),
2895 test_compare(MEMCACHED_SUCCESS
, rc
);
2897 value2
= memcached_get(memc
, key
, strlen(key
),
2898 &length
, &flags
, &rc
);
2900 test_true(length
==strlen(value
));
2901 test_compare(MEMCACHED_SUCCESS
, rc
);
2902 test_memcmp(value
, value2
, length
);
2905 return TEST_SUCCESS
;
2913 static test_return_t
user_supplied_bug19(memcached_st
*)
2915 memcached_return_t res
;
2917 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2919 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2922 memcached_free(memc
);
2924 return TEST_SUCCESS
;
2927 /* CAS test from Andei */
2928 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2930 memcached_return_t status
;
2931 memcached_result_st
*result
, result_obj
;
2932 const char *key
= "abc";
2933 size_t key_len
= strlen("abc");
2934 const char *value
= "foobar";
2935 size_t value_len
= strlen(value
);
2937 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2939 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2940 test_true(status
== MEMCACHED_SUCCESS
);
2942 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2943 test_true(status
== MEMCACHED_SUCCESS
);
2945 result
= memcached_result_create(memc
, &result_obj
);
2948 memcached_result_create(memc
, &result_obj
);
2949 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2952 test_true(status
== MEMCACHED_SUCCESS
);
2954 memcached_result_free(result
);
2956 return TEST_SUCCESS
;
2959 #include "ketama_test_cases.h"
2960 static test_return_t
user_supplied_bug18(memcached_st
*trash
)
2962 memcached_return_t rc
;
2969 memc
= memcached_create(NULL
);
2972 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2973 test_compare(MEMCACHED_SUCCESS
, rc
);
2975 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2976 test_true(value
== 1);
2978 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2979 test_compare(MEMCACHED_SUCCESS
, rc
);
2981 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2982 test_true(value
== MEMCACHED_HASH_MD5
);
2984 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");
2985 memcached_server_push(memc
, server_pool
);
2987 /* verify that the server list was parsed okay. */
2988 test_true(memcached_server_count(memc
) == 8);
2989 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
2990 test_true(server_pool
[0].port
== 11211);
2991 test_true(server_pool
[0].weight
== 600);
2992 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
2993 test_true(server_pool
[2].port
== 11211);
2994 test_true(server_pool
[2].weight
== 200);
2995 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
2996 test_true(server_pool
[7].port
== 11211);
2997 test_true(server_pool
[7].weight
== 100);
2999 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
3000 * us test the boundary wraparound.
3002 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
3004 /* verify the standard ketama set. */
3005 for (x
= 0; x
< 99; x
++)
3007 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3009 memcached_server_instance_st instance
=
3010 memcached_server_instance_by_position(memc
, server_idx
);
3012 const char *hostname
= memcached_server_name(instance
);
3013 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
3016 memcached_server_list_free(server_pool
);
3017 memcached_free(memc
);
3019 return TEST_SUCCESS
;
3022 /* Large mget() of missing keys with binary proto
3024 * If many binary quiet commands (such as getq's in an mget) fill the output
3025 * buffer and the server chooses not to respond, memcached_flush hangs. See
3026 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
3029 /* sighandler_t function that always asserts false */
3030 static void fail(int)
3036 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
3041 return TEST_SKIPPED
;
3043 void (*oldalarm
)(int);
3045 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3046 test_true(memc_clone
);
3048 /* only binproto uses getq for mget */
3049 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3051 /* empty the cache to ensure misses (hence non-responses) */
3052 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
3054 size_t* key_lengths
= new (std::nothrow
) size_t[key_count
];
3055 test_true(key_lengths
);
3056 char **keys
= static_cast<char **>(calloc(key_count
, sizeof(char *)));
3058 for (unsigned int x
= 0; x
< key_count
; x
++)
3062 snprintf(buffer
, 30, "%u", x
);
3063 keys
[x
]= strdup(buffer
);
3065 key_lengths
[x
]= strlen(keys
[x
]);
3068 oldalarm
= signal(SIGALRM
, fail
);
3071 test_compare_got(MEMCACHED_SUCCESS
,
3072 memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
), memcached_last_error_message(memc_clone
));
3075 signal(SIGALRM
, oldalarm
);
3077 memcached_return_t rc
;
3079 char return_key
[MEMCACHED_MAX_KEY
];
3080 size_t return_key_length
;
3082 size_t return_value_length
;
3083 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
3084 &return_value_length
, &flags
, &rc
)))
3086 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
3088 test_compare(MEMCACHED_NOTFOUND
, rc
);
3089 test_compare(0, return_value_length
);
3090 test_compare(0, return_key_length
);
3091 test_false(return_key
[0]);
3092 test_false(return_value
);
3094 for (unsigned int x
= 0; x
< key_count
; x
++)
3099 delete [] key_lengths
;
3101 memcached_free(memc_clone
);
3103 return TEST_SUCCESS
;
3107 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3109 test_return_t test_rc
;
3110 test_rc
= pre_binary(memc
);
3112 if (test_rc
!= TEST_SUCCESS
)
3115 /* should work as of r580 */
3116 test_compare(TEST_SUCCESS
,
3117 _user_supplied_bug21(memc
, 10));
3119 /* should fail as of r580 */
3120 test_compare(TEST_SUCCESS
,
3121 _user_supplied_bug21(memc
, 1000));
3123 return TEST_SUCCESS
;
3126 static test_return_t
auto_eject_hosts(memcached_st
*trash
)
3129 memcached_server_instance_st instance
;
3131 memcached_return_t rc
;
3132 memcached_st
*memc
= memcached_create(NULL
);
3135 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3136 test_compare(MEMCACHED_SUCCESS
, rc
);
3138 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3139 test_true(value
== 1);
3141 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3142 test_compare(MEMCACHED_SUCCESS
, rc
);
3144 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3145 test_true(value
== MEMCACHED_HASH_MD5
);
3147 /* server should be removed when in delay */
3148 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
3149 test_compare(MEMCACHED_SUCCESS
, rc
);
3151 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
3152 test_true(value
== 1);
3154 memcached_server_st
*server_pool
;
3155 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");
3156 memcached_server_push(memc
, server_pool
);
3158 /* verify that the server list was parsed okay. */
3159 test_true(memcached_server_count(memc
) == 8);
3160 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
3161 test_true(server_pool
[0].port
== 11211);
3162 test_true(server_pool
[0].weight
== 600);
3163 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
3164 test_true(server_pool
[2].port
== 11211);
3165 test_true(server_pool
[2].weight
== 200);
3166 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
3167 test_true(server_pool
[7].port
== 11211);
3168 test_true(server_pool
[7].weight
== 100);
3170 instance
= memcached_server_instance_by_position(memc
, 2);
3171 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) + 15;
3172 memc
->ketama
.next_distribution_rebuild
= time(NULL
) - 1;
3175 This would not work if there were only two hosts.
3177 for (size_t x
= 0; x
< 99; x
++)
3179 memcached_autoeject(memc
);
3180 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3181 test_true(server_idx
!= 2);
3184 /* and re-added when it's back. */
3185 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) - 1;
3186 memc
->ketama
.next_distribution_rebuild
= time(NULL
) - 1;
3187 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
,
3188 memc
->distribution
);
3189 for (size_t x
= 0; x
< 99; x
++)
3191 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3192 // We re-use instance from above.
3194 memcached_server_instance_by_position(memc
, server_idx
);
3195 const char *hostname
= memcached_server_name(instance
);
3196 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
3199 memcached_server_list_free(server_pool
);
3200 memcached_free(memc
);
3202 return TEST_SUCCESS
;
3205 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
3209 memcached_return_t rc
;
3210 memcached_st
*memc
= memcached_create(NULL
);
3214 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3215 test_compare(MEMCACHED_SUCCESS
, rc
);
3217 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3218 test_true(value
== 1);
3220 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3221 test_compare(MEMCACHED_SUCCESS
, rc
);
3223 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3224 test_true(value
== MEMCACHED_HASH_MD5
);
3227 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3229 memcached_server_st
*server_pool
;
3230 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");
3231 memcached_server_push(memc
, server_pool
);
3233 // @todo this needs to be refactored to actually test something.
3236 if ((fp
= fopen("ketama_keys.txt", "w")))
3240 printf("cannot write to file ketama_keys.txt");
3241 return TEST_FAILURE
;
3244 for (int x
= 0; x
< 10000; x
++)
3247 snprintf(key
, sizeof(key
), "%d", x
);
3249 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3250 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3251 in_port_t port
= memc
->hosts
[server_idx
].port
;
3252 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3253 memcached_server_instance_st instance
=
3254 memcached_server_instance_by_position(memc
, host_index
);
3258 memcached_server_list_free(server_pool
);
3259 memcached_free(memc
);
3261 return TEST_SUCCESS
;
3265 static test_return_t
result_static(memcached_st
*memc
)
3267 memcached_result_st result
;
3268 memcached_result_st
*result_ptr
;
3270 result_ptr
= memcached_result_create(memc
, &result
);
3271 test_true(result
.options
.is_allocated
== false);
3272 test_true(memcached_is_initialized(&result
) == true);
3273 test_true(result_ptr
);
3274 test_true(result_ptr
== &result
);
3276 memcached_result_free(&result
);
3278 test_true(result
.options
.is_allocated
== false);
3279 test_true(memcached_is_initialized(&result
) == false);
3281 return TEST_SUCCESS
;
3284 static test_return_t
result_alloc(memcached_st
*memc
)
3286 memcached_result_st
*result_ptr
;
3288 result_ptr
= memcached_result_create(memc
, NULL
);
3289 test_true(result_ptr
);
3290 test_true(result_ptr
->options
.is_allocated
== true);
3291 test_true(memcached_is_initialized(result_ptr
) == true);
3292 memcached_result_free(result_ptr
);
3294 return TEST_SUCCESS
;
3297 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3300 pairs_free(global_pairs
);
3302 return TEST_SUCCESS
;
3305 static test_return_t
generate_pairs(memcached_st
*memc
)
3308 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3309 global_count
= GLOBAL_COUNT
;
3311 for (size_t x
= 0; x
< global_count
; x
++)
3313 global_keys
[x
]= global_pairs
[x
].key
;
3314 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3317 return TEST_SUCCESS
;
3320 static test_return_t
generate_large_pairs(memcached_st
*)
3322 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3323 global_count
= GLOBAL2_COUNT
;
3325 for (size_t x
= 0; x
< global_count
; x
++)
3327 global_keys
[x
]= global_pairs
[x
].key
;
3328 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3331 return TEST_SUCCESS
;
3334 static test_return_t
generate_data(memcached_st
*memc
)
3336 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3338 test_true(check_execute
== global_count
);
3340 return TEST_SUCCESS
;
3343 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3345 uint32_t host_index
= 0;
3346 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3348 test_true(check_execute
== global_count
);
3350 // @todo hosts used size stats
3351 memcached_return_t rc
;
3352 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3355 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3357 /* This test was changes so that "make test" would work properlly */
3359 memcached_server_instance_st instance
=
3360 memcached_server_instance_by_position(memc
, host_index
);
3362 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3364 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3367 memcached_stat_free(NULL
, stat_p
);
3369 return TEST_SUCCESS
;
3371 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3376 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3377 generate_data(memc
);
3379 return TEST_SUCCESS
;
3382 static test_return_t
get_read_count(memcached_st
*memc
)
3384 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3385 test_true(memc_clone
);
3387 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3391 size_t return_value_length
;
3395 for (size_t x
= count
= 0; x
< global_count
; x
++)
3397 memcached_return_t rc
;
3398 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3399 &return_value_length
, &flags
, &rc
);
3400 if (rc
== MEMCACHED_SUCCESS
)
3409 memcached_free(memc_clone
);
3411 return TEST_SUCCESS
;
3414 static test_return_t
get_read(memcached_st
*memc
)
3416 for (size_t x
= 0; x
< global_count
; x
++)
3418 size_t return_value_length
;
3420 memcached_return_t rc
;
3421 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3422 &return_value_length
, &flags
, &rc
);
3424 test_true(return_value);
3425 test_compare(MEMCACHED_SUCCESS, rc);
3427 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3431 return TEST_SUCCESS
;
3434 static test_return_t
mget_read(memcached_st
*memc
)
3437 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3439 memcached_return_t rc
;
3440 test_compare_got(MEMCACHED_SUCCESS
,
3441 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
),
3442 memcached_strerror(NULL
, rc
));
3444 // Go fetch the keys and test to see if all of them were returned
3446 size_t keys_returned
;
3447 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3448 test_true(keys_returned
> 0);
3450 snprintf(buffer
, sizeof(buffer
), "%lu", (unsigned long)keys_returned
);
3451 test_compare_got(global_count
, keys_returned
, buffer
);
3454 return TEST_SUCCESS
;
3457 static test_return_t
mget_read_result(memcached_st
*memc
)
3460 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3462 test_compare(MEMCACHED_SUCCESS
,
3463 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3465 /* Turn this into a help function */
3467 memcached_result_st results_obj
;
3468 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3470 memcached_return_t rc
;
3471 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3474 test_compare(MEMCACHED_SUCCESS
, rc
);
3476 test_compare(MEMCACHED_END
, rc
);
3478 memcached_result_free(&results_obj
);
3481 return TEST_SUCCESS
;
3484 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3487 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3489 test_compare(MEMCACHED_SUCCESS
,
3490 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3492 memcached_result_st
*results
= NULL
;
3493 memcached_return_t rc
;
3494 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3497 test_compare(MEMCACHED_SUCCESS
, rc
);
3499 test_compare(MEMCACHED_END
, rc
);
3501 memcached_result_free(results
);
3504 return TEST_SUCCESS
;
3507 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3510 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3512 test_compare(MEMCACHED_SUCCESS
,
3513 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3515 // We will scan for just one key
3517 memcached_result_st results_obj
;
3518 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3520 memcached_return_t rc
;
3521 results
= memcached_fetch_result(memc
, results
, &rc
);
3523 test_compare(MEMCACHED_SUCCESS
, rc
);
3525 memcached_result_free(&results_obj
);
3528 // We already have a read happening, lets start up another one.
3529 test_compare(MEMCACHED_SUCCESS
,
3530 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3532 memcached_result_st results_obj
;
3533 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3535 memcached_return_t rc
;
3536 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3539 test_compare(MEMCACHED_SUCCESS
, rc
);
3541 test_compare(MEMCACHED_END
, rc
);
3543 memcached_result_free(&results_obj
);
3546 return TEST_SUCCESS
;
3549 static test_return_t
mget_read_function(memcached_st
*memc
)
3551 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3553 test_compare(MEMCACHED_SUCCESS
,
3554 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3556 memcached_execute_fn callbacks
[]= { &callback_counter
};
3558 test_compare(MEMCACHED_SUCCESS
,
3559 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3561 return TEST_SUCCESS
;
3564 static test_return_t
delete_generate(memcached_st
*memc
)
3566 for (size_t x
= 0; x
< global_count
; x
++)
3568 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3571 return TEST_SUCCESS
;
3574 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3577 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3579 for (size_t x
= 0; x
< global_count
; x
++)
3581 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3584 return TEST_SUCCESS
;
3587 static test_return_t
add_host_test1(memcached_st
*memc
)
3589 memcached_return_t rc
;
3590 char servername
[]= "0.example.com";
3592 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3594 test_compare(1, memcached_server_list_count(servers
));
3596 for (size_t x
= 2; x
< 20; x
++)
3598 char buffer
[SMALL_STRING_LEN
];
3600 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3601 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3603 test_compare(MEMCACHED_SUCCESS
, rc
);
3604 test_compare(x
, memcached_server_list_count(servers
));
3607 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3608 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3610 memcached_server_list_free(servers
);
3612 return TEST_SUCCESS
;
3615 static test_return_t
pre_nonblock(memcached_st
*memc
)
3617 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3619 return TEST_SUCCESS
;
3622 static test_return_t
pre_cork(memcached_st
*memc
)
3625 return TEST_SKIPPED
;
3628 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3629 return TEST_SUCCESS
;
3631 return TEST_SKIPPED
;
3634 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3637 return TEST_SKIPPED
;
3639 test_return_t test_rc
;
3640 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3643 return pre_nonblock(memc
);
3646 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3648 memcached_return_t rc
= MEMCACHED_FAILURE
;
3649 memcached_st
*memc_clone
;
3651 memc_clone
= memcached_clone(NULL
, memc
);
3652 test_true(memc_clone
);
3653 // The memcached_version needs to be done on a clone, because the server
3654 // will not toggle protocol on an connection.
3655 memcached_version(memc_clone
);
3657 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3659 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3660 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3661 test_compare(MEMCACHED_SUCCESS
, rc
);
3662 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3666 return TEST_SKIPPED
;
3669 memcached_free(memc_clone
);
3671 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3674 static test_return_t
pre_murmur(memcached_st
*memc
)
3676 #ifdef HAVE_MURMUR_HASH
3677 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3678 return TEST_SUCCESS
;
3681 return TEST_SKIPPED
;
3685 static test_return_t
pre_jenkins(memcached_st
*memc
)
3687 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3689 return TEST_SUCCESS
;
3693 static test_return_t
pre_md5(memcached_st
*memc
)
3695 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3697 return TEST_SUCCESS
;
3700 static test_return_t
pre_crc(memcached_st
*memc
)
3702 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3704 return TEST_SUCCESS
;
3707 static test_return_t
pre_hsieh(memcached_st
*memc
)
3709 #ifdef HAVE_HSIEH_HASH
3710 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3711 return TEST_SUCCESS
;
3714 return TEST_SKIPPED
;
3718 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3720 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3722 return TEST_SUCCESS
;
3725 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3727 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3729 return TEST_SUCCESS
;
3732 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3734 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3736 return TEST_SUCCESS
;
3739 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3741 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3743 return TEST_SUCCESS
;
3746 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3748 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3749 test_compare(MEMCACHED_SUCCESS
, rc
);
3751 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3752 test_true(value
== 1);
3754 return TEST_SUCCESS
;
3757 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3759 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3760 test_compare(MEMCACHED_SUCCESS
, rc
);
3762 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3763 test_true(value
== 1);
3765 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3766 test_compare(MEMCACHED_SUCCESS
, rc
);
3768 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3769 test_true(value
== MEMCACHED_HASH_MD5
);
3771 return TEST_SUCCESS
;
3775 @note This should be testing to see if the server really supports the binary protocol.
3777 static test_return_t
pre_binary(memcached_st
*memc
)
3779 memcached_return_t rc
= MEMCACHED_FAILURE
;
3781 if (libmemcached_util_version_check(memc
, 1, 4, 4))
3783 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3784 test_compare(MEMCACHED_SUCCESS
, rc
);
3785 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3788 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3791 static test_return_t
pre_sasl(memcached_st
*memc
)
3793 memcached_return_t rc
= MEMCACHED_FAILURE
;
3795 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
3796 const char *server
= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
3797 const char *user
= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
3798 const char *pass
= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
3800 if (server
and user
and pass
)
3802 memcached_server_st
*servers
= memcached_servers_parse(server
);
3804 memcached_servers_reset(memc
);
3805 test_true(memcached_server_push(memc
, servers
) == MEMCACHED_SUCCESS
);
3806 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3807 rc
= memcached_set_sasl_auth_data(memc
, user
, pass
);
3808 test_compare(MEMCACHED_SUCCESS
, rc
);
3814 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3817 static test_return_t
pre_replication(memcached_st
*memc
)
3819 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3822 * Make sure that we store the item on all servers
3823 * (master + replicas == number of servers)
3825 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3826 memcached_server_count(memc
) - 1);
3827 test_compare(MEMCACHED_SUCCESS
, rc
);
3828 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memcached_server_count(memc
) - 1);
3830 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3834 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3836 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3838 return pre_nonblock(memc
);
3842 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3846 #ifdef HARD_MALLOC_TESTS
3847 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3855 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3859 #ifdef HARD_MALLOC_TESTS
3860 void *ret
= malloc(size
+ 8);
3863 ret
= (void*)((caddr_t
)ret
+ 8);
3866 void *ret
= malloc(size
);
3871 memset(ret
, 0xff, size
);
3878 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3880 #ifdef HARD_MALLOC_TESTS
3881 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3882 void *nmem
= realloc(real_ptr
, size
+ 8);
3887 ret
= (void*)((caddr_t
)nmem
+ 8);
3893 return realloc(mem
, size
);
3898 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3900 #ifdef HARD_MALLOC_TESTS
3901 void *mem
= my_malloc(ptr
, nelem
* size
);
3904 memset(mem
, 0, nelem
* size
);
3910 return calloc(nelem
, size
);
3914 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3916 memcached_return_t rc
;
3917 const char *key
= "mine";
3920 /* Make sure be default none exists */
3921 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3922 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3924 /* Test a clean set */
3925 test_compare(MEMCACHED_SUCCESS
,
3926 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3928 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3930 test_memcmp(value
, key
, 4);
3931 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3933 /* Test that we can turn it off */
3934 test_compare(MEMCACHED_SUCCESS
,
3935 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3937 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3939 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3941 /* Now setup for main test */
3942 test_compare(MEMCACHED_SUCCESS
,
3943 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3945 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3947 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3948 test_memcmp(value
, key
, 4);
3950 /* Set to Zero, and then Set to something too large */
3953 memset(long_key
, 0, 255);
3955 test_compare(MEMCACHED_SUCCESS
,
3956 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3958 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3960 test_true(rc
== MEMCACHED_FAILURE
);
3961 test_true(value
== NULL
);
3963 /* Test a long key for failure */
3964 /* TODO, extend test to determine based on setting, what result should be */
3965 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3966 test_compare(MEMCACHED_SUCCESS
,
3967 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3969 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3970 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3971 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3972 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3974 /* Test for a bad prefix, but with a short key */
3975 test_compare_got(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3976 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1),
3977 memcached_strerror(NULL
, rc
));
3979 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3980 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3983 return TEST_SUCCESS
;
3986 static test_return_t
set_namespace(memcached_st
*memc
)
3988 memcached_return_t rc
;
3989 const char *key
= "mine";
3992 /* Make sure be default none exists */
3993 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3994 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3996 /* Test a clean set */
3997 test_compare(MEMCACHED_SUCCESS
,
3998 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
4000 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
4002 test_memcmp(value
, key
, 4);
4003 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4005 return TEST_SUCCESS
;
4008 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
4010 test_return_if(pre_binary(memc
));
4011 test_return_if(set_namespace(memc
));
4013 return TEST_SUCCESS
;
4016 #ifdef MEMCACHED_ENABLE_DEPRECATED
4017 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
4019 void *test_ptr
= NULL
;
4022 memcached_malloc_fn malloc_cb
=
4023 (memcached_malloc_fn
)my_malloc
;
4024 cb_ptr
= *(void **)&malloc_cb
;
4025 memcached_return_t rc
;
4027 test_compare(MEMCACHED_SUCCESS
,
4028 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
4029 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
4030 test_compare(MEMCACHED_SUCCESS
, rc
);
4031 test_true(test_ptr
== cb_ptr
);
4035 memcached_realloc_fn realloc_cb
=
4036 (memcached_realloc_fn
)my_realloc
;
4037 cb_ptr
= *(void **)&realloc_cb
;
4038 memcached_return_t rc
;
4040 test_compare(MEMCACHED_SUCCESS
,
4041 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
4042 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
4043 test_compare(MEMCACHED_SUCCESS
, rc
);
4044 test_true(test_ptr
== cb_ptr
);
4048 memcached_free_fn free_cb
=
4049 (memcached_free_fn
)my_free
;
4050 cb_ptr
= *(void **)&free_cb
;
4051 memcached_return_t rc
;
4053 test_compare(MEMCACHED_SUCCESS
,
4054 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
4055 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
4056 test_compare(MEMCACHED_SUCCESS
, rc
);
4057 test_true(test_ptr
== cb_ptr
);
4060 return TEST_SUCCESS
;
4065 static test_return_t
set_memory_alloc(memcached_st
*memc
)
4067 test_compare(MEMCACHED_FAILURE
,
4068 memcached_set_memory_allocators(memc
, NULL
, my_free
,
4069 my_realloc
, my_calloc
, NULL
));
4071 test_compare(MEMCACHED_SUCCESS
,
4072 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
4073 my_realloc
, my_calloc
, NULL
));
4075 memcached_malloc_fn mem_malloc
;
4076 memcached_free_fn mem_free
;
4077 memcached_realloc_fn mem_realloc
;
4078 memcached_calloc_fn mem_calloc
;
4079 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
4080 &mem_realloc
, &mem_calloc
);
4082 test_true(mem_malloc
== my_malloc
);
4083 test_true(mem_realloc
== my_realloc
);
4084 test_true(mem_calloc
== my_calloc
);
4085 test_true(mem_free
== my_free
);
4087 return TEST_SUCCESS
;
4090 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
4093 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4094 memcached_hash_t hash
;
4095 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4096 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
4099 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4100 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4102 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4104 if (hash
!= MEMCACHED_HASH_CRC
)
4105 return TEST_SKIPPED
;
4107 return TEST_SUCCESS
;
4110 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
4113 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4114 memcached_hash_t hash
;
4115 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4116 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
4119 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4120 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4122 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4124 if (hash
!= MEMCACHED_HASH_HSIEH
)
4125 return TEST_SKIPPED
;
4128 return TEST_SUCCESS
;
4131 static test_return_t
enable_cas(memcached_st
*memc
)
4133 unsigned int set
= 1;
4135 if (libmemcached_util_version_check(memc
, 1, 2, 4))
4137 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
4139 return TEST_SUCCESS
;
4142 return TEST_SKIPPED
;
4145 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
4147 memcached_version(memc
);
4149 memcached_server_instance_st instance
=
4150 memcached_server_instance_by_position(memc
, 0);
4152 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
4153 or instance
->minor_version
> 2)
4155 return TEST_SUCCESS
;
4158 return TEST_SKIPPED
;
4161 static test_return_t
pre_unix_socket(memcached_st
*memc
)
4165 memcached_servers_reset(memc
);
4166 const char *socket_file
= default_socket();
4168 test_skip(0, stat(socket_file
, &buf
));
4170 test_compare(MEMCACHED_SUCCESS
,
4171 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
4173 return TEST_SUCCESS
;
4176 static test_return_t
pre_nodelay(memcached_st
*memc
)
4178 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
4179 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
4181 return TEST_SUCCESS
;
4184 static test_return_t
pre_settimer(memcached_st
*memc
)
4186 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4187 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4189 return TEST_SUCCESS
;
4192 static test_return_t
poll_timeout(memcached_st
*memc
)
4194 size_t timeout
= 100; // Not using, just checking that it sets
4196 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4198 timeout
= (size_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
4200 test_compare(100, timeout
);
4202 return TEST_SUCCESS
;
4205 static test_return_t
noreply_test(memcached_st
*memc
)
4207 memcached_return_t ret
;
4208 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
4209 test_true(ret
== MEMCACHED_SUCCESS
);
4210 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4211 test_true(ret
== MEMCACHED_SUCCESS
);
4212 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
4213 test_true(ret
== MEMCACHED_SUCCESS
);
4214 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
4215 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
4216 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
4218 for (int count
=0; count
< 5; ++count
)
4220 for (size_t x
= 0; x
< 100; ++x
)
4223 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4224 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4226 size_t len
= (size_t)check_length
;
4231 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4234 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4237 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4240 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4243 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4249 test_true(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
4253 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4254 ** API and is _ONLY_ done this way to verify that the library works the
4255 ** way it is supposed to do!!!!
4258 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4260 memcached_server_instance_st instance
=
4261 memcached_server_instance_by_position(memc
, x
);
4262 no_msg
+=(int)(instance
->cursor_active
);
4265 test_true(no_msg
== 0);
4266 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4269 ** Now validate that all items was set properly!
4271 for (size_t x
= 0; x
< 100; ++x
)
4275 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4277 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4279 size_t len
= (size_t)check_length
;
4282 char* value
=memcached_get(memc
, key
, strlen(key
),
4283 &length
, &flags
, &ret
);
4284 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4287 case 0: /* FALLTHROUGH */
4288 case 1: /* FALLTHROUGH */
4290 test_true(strncmp(value
, key
, len
) == 0);
4291 test_true(len
== length
);
4294 test_true(length
== len
* 2);
4297 test_true(length
== len
* 3);
4307 /* Try setting an illegal cas value (should not return an error to
4308 * the caller (because we don't expect a return message from the server)
4310 const char* keys
[]= {"0"};
4311 size_t lengths
[]= {1};
4314 memcached_result_st results_obj
;
4315 memcached_result_st
*results
;
4316 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4317 test_true(ret
== MEMCACHED_SUCCESS
);
4319 results
= memcached_result_create(memc
, &results_obj
);
4321 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4323 test_true(ret
== MEMCACHED_SUCCESS
);
4324 uint64_t cas
= memcached_result_cas(results
);
4325 memcached_result_free(&results_obj
);
4327 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4328 test_true(ret
== MEMCACHED_SUCCESS
);
4331 * The item will have a new cas value, so try to set it again with the old
4332 * value. This should fail!
4334 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4335 test_true(ret
== MEMCACHED_SUCCESS
);
4336 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4337 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4338 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4341 return TEST_SUCCESS
;
4344 static test_return_t
analyzer_test(memcached_st
*memc
)
4346 memcached_return_t rc
;
4347 memcached_stat_st
*memc_stat
;
4348 memcached_analysis_st
*report
;
4350 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4351 test_compare(MEMCACHED_SUCCESS
, rc
);
4352 test_true(memc_stat
);
4354 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4355 test_compare(MEMCACHED_SUCCESS
, rc
);
4359 memcached_stat_free(NULL
, memc_stat
);
4361 return TEST_SUCCESS
;
4364 /* Count the objects */
4365 static memcached_return_t
callback_dump_counter(const memcached_st
*ptr
,
4370 (void)ptr
; (void)key
; (void)key_length
;
4371 size_t *counter
= (size_t *)context
;
4373 *counter
= *counter
+ 1;
4375 return MEMCACHED_SUCCESS
;
4378 static test_return_t
dump_test(memcached_st
*memc
)
4381 memcached_dump_fn callbacks
[1];
4383 callbacks
[0]= &callback_dump_counter
;
4385 /* No support for Binary protocol yet */
4386 test_skip(false, memc
->flags
.binary_protocol
);
4388 test_compare(TEST_SUCCESS
, set_test3(memc
));
4390 test_compare(MEMCACHED_SUCCESS
,
4391 memcached_dump(memc
, callbacks
, (void *)&counter
, 1));
4393 /* We may have more then 32 if our previous flush has not completed */
4394 test_true(counter
>= 32);
4396 return TEST_SUCCESS
;
4399 #ifdef HAVE_LIBMEMCACHEDUTIL
4401 struct test_pool_context_st
{
4402 memcached_pool_st
* pool
;
4406 static void* connection_release(void *arg
)
4408 test_pool_context_st
*resource
= static_cast<test_pool_context_st
*>(arg
);
4411 // Release all of the memc we are holding
4412 assert(memcached_success(memcached_pool_push(resource
->pool
, resource
->mmc
)));
4416 #define POOL_SIZE 10
4417 static test_return_t
connection_pool_test(memcached_st
*memc
)
4419 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4420 test_true(pool
!= NULL
);
4421 memcached_st
*mmc
[POOL_SIZE
];
4422 memcached_return_t rc
;
4424 // Fill up our array that we will store the memc that are in the pool
4425 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4427 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4428 test_true(mmc
[x
] != NULL
);
4429 test_compare(MEMCACHED_SUCCESS
, rc
);
4432 // All memc should be gone
4433 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4434 test_compare(MEMCACHED_SUCCESS
, rc
);
4437 test_pool_context_st item
= { pool
, mmc
[9] };
4439 pthread_create(&tid
, NULL
, connection_release
, &item
);
4440 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4441 test_compare(MEMCACHED_SUCCESS
, rc
);
4442 pthread_join(tid
, NULL
);
4444 const char *key
= "key";
4445 size_t keylen
= strlen(key
);
4447 // verify that I can do ops with all connections
4448 test_compare(MEMCACHED_SUCCESS
,
4449 memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0));
4451 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4453 uint64_t number_value
;
4454 test_compare(MEMCACHED_SUCCESS
,
4455 memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
));
4456 test_compare(number_value
, (x
+1));
4460 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4462 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[x
]));
4466 /* verify that I can set behaviors on the pool when I don't have all
4467 * of the connections in the pool. It should however be enabled
4468 * when I push the item into the pool
4470 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4473 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4474 test_compare(MEMCACHED_SUCCESS
, rc
);
4476 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4479 test_compare(9999, memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4480 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[1]));
4481 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4483 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4484 test_compare(9999, memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4485 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4487 test_true(memcached_pool_destroy(pool
) == memc
);
4489 return TEST_SUCCESS
;
4492 static test_return_t
util_version_test(memcached_st
*memc
)
4494 bool if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4495 test_true(if_successful
);
4497 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4499 // We expect failure
4502 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4503 fprintf(stderr
, "\nDumping Server Information\n\n");
4504 memcached_server_fn callbacks
[1];
4506 callbacks
[0]= dump_server_information
;
4507 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4508 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4510 test_true(if_successful
== false);
4512 memcached_server_instance_st instance
=
4513 memcached_server_instance_by_position(memc
, 0);
4515 memcached_version(memc
);
4517 // We only use one binary when we test, so this should be just fine.
4518 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4519 test_true(if_successful
== true);
4521 if (instance
->micro_version
> 0)
4522 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4523 else if (instance
->minor_version
> 0)
4524 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4525 else if (instance
->major_version
> 0)
4526 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4528 test_true(if_successful
== true);
4530 if (instance
->micro_version
> 0)
4531 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4532 else if (instance
->minor_version
> 0)
4533 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4534 else if (instance
->major_version
> 0)
4535 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4537 test_true(if_successful
== false);
4539 return TEST_SUCCESS
;
4542 static test_return_t
ping_test(memcached_st
*memc
)
4544 memcached_return_t rc
;
4545 memcached_server_instance_st instance
=
4546 memcached_server_instance_by_position(memc
, 0);
4548 // Test both the version that returns a code, and the one that does not.
4549 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4550 memcached_server_port(instance
), NULL
));
4552 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4553 memcached_server_port(instance
), &rc
));
4555 test_compare(MEMCACHED_SUCCESS
, rc
);
4557 return TEST_SUCCESS
;
4563 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4567 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4568 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4569 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4570 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4571 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4572 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4573 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4574 #ifdef HAVE_HSIEH_HASH
4575 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4577 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4578 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4579 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4581 return TEST_SUCCESS
;
4585 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4587 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4588 #ifdef HAVE_HSIEH_HASH
4589 expected_rc
= MEMCACHED_SUCCESS
;
4591 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4592 (uint64_t)MEMCACHED_HASH_HSIEH
);
4593 test_true(rc
== expected_rc
);
4595 return TEST_SUCCESS
;
4598 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4600 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4601 #ifdef HAVE_MURMUR_HASH
4602 expected_rc
= MEMCACHED_SUCCESS
;
4604 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4605 (uint64_t)MEMCACHED_HASH_MURMUR
);
4606 test_true(rc
== expected_rc
);
4608 return TEST_SUCCESS
;
4611 static test_return_t
one_at_a_time_run (memcached_st
*memc
)
4617 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4621 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
);
4622 test_true(one_at_a_time_values
[x
] == hash_val
);
4625 return TEST_SUCCESS
;
4628 static test_return_t
md5_run (memcached_st
*memc
)
4634 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4638 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4639 test_true(md5_values
[x
] == hash_val
);
4642 return TEST_SUCCESS
;
4645 static test_return_t
crc_run (memcached_st
*memc
)
4651 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4655 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4656 test_true(crc_values
[x
] == hash_val
);
4659 return TEST_SUCCESS
;
4662 static test_return_t
fnv1_64_run (memcached_st
*memc
)
4668 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4672 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4673 test_true(fnv1_64_values
[x
] == hash_val
);
4676 return TEST_SUCCESS
;
4679 static test_return_t
fnv1a_64_run (memcached_st
*memc
)
4685 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4689 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4690 test_true(fnv1a_64_values
[x
] == hash_val
);
4693 return TEST_SUCCESS
;
4696 static test_return_t
fnv1_32_run (memcached_st
*memc
)
4702 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4706 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4707 test_true(fnv1_32_values
[x
] == hash_val
);
4710 return TEST_SUCCESS
;
4713 static test_return_t
fnv1a_32_run (memcached_st
*memc
)
4719 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4723 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4724 test_true(fnv1a_32_values
[x
] == hash_val
);
4727 return TEST_SUCCESS
;
4730 static test_return_t
hsieh_run (memcached_st
*memc
)
4736 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4740 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4741 test_true(hsieh_values
[x
] == hash_val
);
4744 return TEST_SUCCESS
;
4747 static test_return_t
murmur_run (memcached_st
*memc
)
4749 #ifdef WORDS_BIGENDIAN
4750 (void)murmur_values
;
4751 return TEST_SKIPPED
;
4757 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4761 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
4762 test_true(murmur_values
[x
] == hash_val
);
4765 return TEST_SUCCESS
;
4769 static test_return_t
jenkins_run (memcached_st
*memc
)
4775 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4779 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4780 test_true(jenkins_values
[x
] == hash_val
);
4783 return TEST_SUCCESS
;
4786 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *context
)
4789 return libhashkit_md5(string
, string_length
);
4792 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *context
)
4795 return libhashkit_crc32(string
, string_length
);
4798 static test_return_t
memcached_get_hashkit_test (memcached_st
*memc
)
4802 const hashkit_st
*kit
;
4804 hashkit_return_t hash_rc
;
4806 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};
4807 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};
4809 kit
= memcached_get_hashkit(memc
);
4811 hashkit_clone(&new_kit
, kit
);
4812 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
);
4813 test_true(hash_rc
== HASHKIT_SUCCESS
);
4815 memcached_set_hashkit(memc
, &new_kit
);
4818 Verify Setting the hash.
4820 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4824 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4825 test_true(md5_values
[x
] == hash_val
);
4830 Now check memcached_st.
4832 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4836 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4837 test_true(md5_hosts
[x
] == hash_val
);
4840 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
);
4841 test_true(hash_rc
== HASHKIT_SUCCESS
);
4843 memcached_set_hashkit(memc
, &new_kit
);
4846 Verify Setting the hash.
4848 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4852 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4853 test_true(crc_values
[x
] == hash_val
);
4856 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4860 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4861 test_true(crc_hosts
[x
] == hash_val
);
4864 return TEST_SUCCESS
;
4868 Test case adapted from John Gorman <johngorman2@gmail.com>
4870 We are testing the error condition when we connect to a server via memcached_get()
4871 but find that the server is not available.
4873 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4875 const char *key
= "MemcachedLives";
4878 memcached_return rc
;
4881 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4883 // See if memcached is reachable.
4884 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4887 test_compare(0, len
);
4888 test_true(memcached_failed(rc
));
4890 memcached_free(tl_memc_h
);
4892 return TEST_SUCCESS
;
4896 We connect to a server which exists, but search for a key that does not exist.
4898 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4900 const char *key
= "MemcachedKeyNotEXIST";
4903 memcached_return rc
;
4906 // See if memcached is reachable.
4907 value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4910 test_compare(0, len
);
4911 test_compare(MEMCACHED_NOTFOUND
, rc
);
4913 return TEST_SUCCESS
;
4917 Test case adapted from John Gorman <johngorman2@gmail.com>
4919 We are testing the error condition when we connect to a server via memcached_get_by_key()
4920 but find that the server is not available.
4922 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4925 memcached_st
*tl_memc_h
;
4926 memcached_server_st
*servers
;
4928 const char *key
= "MemcachedLives";
4931 memcached_return rc
;
4935 tl_memc_h
= memcached_create(NULL
);
4936 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4937 memcached_server_push(tl_memc_h
, servers
);
4938 memcached_server_list_free(servers
);
4940 // See if memcached is reachable.
4941 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4944 test_compare(0, len
);
4945 test_true(memcached_failed(rc
));
4947 memcached_free(tl_memc_h
);
4949 return TEST_SUCCESS
;
4953 We connect to a server which exists, but search for a key that does not exist.
4955 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4957 const char *key
= "MemcachedKeyNotEXIST";
4960 memcached_return rc
;
4963 // See if memcached is reachable.
4964 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4967 test_compare(0, len
);
4968 test_compare(MEMCACHED_NOTFOUND
, rc
);
4970 return TEST_SUCCESS
;
4974 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*)
4976 memcached_st
*memc
= memcached_create(NULL
);
4979 test_compare(MEMCACHED_SUCCESS
,
4980 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1));
4983 test_compare(1, value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
4985 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
4986 test_compare(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
, memcached_behavior_get_distribution(memc
));
4989 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");
4990 memcached_server_push(memc
, server_pool
);
4992 /* verify that the server list was parsed okay. */
4993 test_compare(8, memcached_server_count(memc
));
4994 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
4995 test_compare(11211, server_pool
[0].port
);
4996 test_compare(600, server_pool
[0].weight
);
4997 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
4998 test_compare(11211, server_pool
[2].port
);
4999 test_compare(200, server_pool
[2].weight
);
5000 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5001 test_compare(11211, server_pool
[7].port
);
5002 test_compare(100, server_pool
[7].weight
);
5004 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5005 * us test the boundary wraparound.
5007 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
5009 /* verify the standard ketama set. */
5010 for (uint32_t x
= 0; x
< 99; x
++)
5012 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
5013 memcached_server_instance_st instance
=
5014 memcached_server_instance_by_position(memc
, server_idx
);
5015 const char *hostname
= memcached_server_name(instance
);
5017 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
5020 memcached_server_list_free(server_pool
);
5021 memcached_free(memc
);
5023 return TEST_SUCCESS
;
5026 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*)
5030 memcached_st
*memc
= memcached_create(NULL
);
5033 test_compare(MEMCACHED_SUCCESS
,
5034 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1));
5036 test_compare(1, value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
5038 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
));
5039 test_compare(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
, memcached_behavior_get_distribution(memc
));
5041 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");
5042 test_true(server_pool
);
5043 memcached_server_push(memc
, server_pool
);
5045 /* verify that the server list was parsed okay. */
5046 test_compare(8, memcached_server_count(memc
));
5047 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5048 test_compare(11211, server_pool
[0].port
);
5049 test_compare(600, server_pool
[0].weight
);
5050 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5051 test_compare(11211, server_pool
[2].port
);
5052 test_compare(200, server_pool
[2].weight
);
5053 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5054 test_compare(11211, server_pool
[7].port
);
5055 test_compare(100, server_pool
[7].weight
);
5057 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5058 * us test the boundary wraparound.
5060 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
5062 /* verify the standard ketama set. */
5063 for (uint32_t x
= 0; x
< 99; x
++)
5065 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
5067 memcached_server_instance_st instance
=
5068 memcached_server_instance_by_position(memc
, server_idx
);
5070 const char *hostname
= memcached_server_name(instance
);
5072 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
5075 memcached_server_list_free(server_pool
);
5076 memcached_free(memc
);
5078 return TEST_SUCCESS
;
5081 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5083 test_return_t test_rc
;
5084 test_rc
= pre_binary(memc
);
5086 if (test_rc
!= TEST_SUCCESS
)
5089 const char *key
= "regression_bug_434484";
5090 size_t keylen
= strlen(key
);
5092 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5093 test_compare(MEMCACHED_NOTSTORED
, ret
);
5095 size_t size
= 2048 * 1024;
5096 char *data
= (char*)calloc(1, size
);
5098 test_compare(MEMCACHED_E2BIG
,
5099 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
5102 return TEST_SUCCESS
;
5105 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5107 test_return_t test_rc
;
5108 test_rc
= pre_binary(memc
);
5110 if (test_rc
!= TEST_SUCCESS
)
5113 memcached_return_t rc
;
5115 memcached_execute_fn callbacks
[]= { &callback_counter
};
5118 * I only want to hit only _one_ server so I know the number of requests I'm
5119 * sending in the pipleine to the server. Let's try to do a multiget of
5120 * 1024 (that should satisfy most users don't you think?). Future versions
5121 * will include a mget_execute function call if you need a higher number.
5123 uint32_t number_of_hosts
= memcached_server_count(memc
);
5124 memc
->number_of_hosts
= 1;
5125 const size_t max_keys
= 1024;
5126 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
5127 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5129 for (size_t x
= 0; x
< max_keys
; ++x
)
5133 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5139 * Run two times.. the first time we should have 100% cache miss,
5140 * and the second time we should have 100% cache hits
5142 for (size_t y
= 0; y
< 2; y
++)
5144 test_compare(MEMCACHED_SUCCESS
,
5145 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
5147 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
5148 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5152 /* The first iteration should give me a 100% cache miss. verify that*/
5153 char blob
[1024]= { 0 };
5155 test_false(counter
);
5157 for (size_t x
= 0; x
< max_keys
; ++x
)
5159 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5160 blob
, sizeof(blob
), 0, 0);
5161 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5166 /* Verify that we received all of the key/value pairs */
5167 test_compare(counter
, max_keys
);
5171 /* Release allocated resources */
5172 for (size_t x
= 0; x
< max_keys
; ++x
)
5179 memc
->number_of_hosts
= number_of_hosts
;
5181 return TEST_SUCCESS
;
5184 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5186 memcached_return_t rc
;
5187 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5188 test_compare(MEMCACHED_SUCCESS
, rc
);
5190 return regression_bug_434843(memc
);
5193 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5195 memcached_return_t rc
;
5196 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5197 test_compare(MEMCACHED_SUCCESS
, rc
);
5199 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5200 test_compare(MEMCACHED_SUCCESS
, rc
);
5201 test_true(bytes_str
);
5202 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
5204 test_compare(MEMCACHED_SUCCESS
, rc
);
5205 test_true(bytes_read_str
);
5207 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
5208 "bytes_written", &rc
);
5209 test_compare(MEMCACHED_SUCCESS
, rc
);
5210 test_true(bytes_written_str
);
5212 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
5213 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
5214 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
5216 test_true(bytes
!= bytes_read
);
5217 test_true(bytes
!= bytes_written
);
5219 /* Release allocated resources */
5221 free(bytes_read_str
);
5222 free(bytes_written_str
);
5223 memcached_stat_free(NULL
, memc_stat
);
5225 return TEST_SUCCESS
;
5229 * The test case isn't obvious so I should probably document why
5230 * it works the way it does. Bug 442914 was caused by a bug
5231 * in the logic in memcached_purge (it did not handle the case
5232 * where the number of bytes sent was equal to the watermark).
5233 * In this test case, create messages so that we hit that case
5234 * and then disable noreply mode and issue a new command to
5235 * verify that it isn't stuck. If we change the format for the
5236 * delete command or the watermarks, we need to update this
5239 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5241 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5242 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5244 uint32_t number_of_hosts
= memcached_server_count(memc
);
5245 memc
->number_of_hosts
= 1;
5250 for (uint32_t x
= 0; x
< 250; ++x
)
5252 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5253 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
5254 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5257 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5260 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
5261 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5263 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5264 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
5266 memc
->number_of_hosts
= number_of_hosts
;
5268 return TEST_SUCCESS
;
5271 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5273 memcached_server_instance_st instance_one
;
5274 memcached_server_instance_st instance_two
;
5276 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
5277 return TEST_SKIPPED
;
5279 test_compare(MEMCACHED_SUCCESS
,
5280 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
5282 const size_t max_keys
= 100;
5283 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
5284 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5286 for (size_t x
= 0; x
< max_keys
; ++x
)
5290 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5293 test_compare(MEMCACHED_SUCCESS
,
5294 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
5298 ** We are using the quiet commands to store the replicas, so we need
5299 ** to ensure that all of them are processed before we can continue.
5300 ** In the test we go directly from storing the object to trying to
5301 ** receive the object from all of the different servers, so we
5302 ** could end up in a race condition (the memcached server hasn't yet
5303 ** processed the quiet command from the replication set when it process
5304 ** the request from the other client (created by the clone)). As a
5305 ** workaround for that we call memcached_quit to send the quit command
5306 ** to the server and wait for the response ;-) If you use the test code
5307 ** as an example for your own code, please note that you shouldn't need
5310 memcached_quit(memc
);
5312 /* Verify that all messages are stored, and we didn't stuff too much
5315 test_compare(MEMCACHED_SUCCESS
,
5316 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5319 memcached_execute_fn callbacks
[]= { &callback_counter
};
5320 memcached_return_t rc
;
5321 test_compare_got(MEMCACHED_SUCCESS
,
5322 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1),
5323 memcached_strerror(NULL
, rc
));
5325 /* Verify that we received all of the key/value pairs */
5326 test_compare(counter
, max_keys
);
5328 memcached_quit(memc
);
5330 * Don't do the following in your code. I am abusing the internal details
5331 * within the library, and this is not a supported interface.
5332 * This is to verify correct behavior in the library. Fake that two servers
5335 instance_one
= memcached_server_instance_by_position(memc
, 0);
5336 instance_two
= memcached_server_instance_by_position(memc
, 2);
5337 in_port_t port0
= instance_one
->port
;
5338 in_port_t port2
= instance_two
->port
;
5340 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5341 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5343 test_compare(MEMCACHED_SUCCESS
,
5344 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5347 test_compare(MEMCACHED_SUCCESS
,
5348 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5349 test_compare(counter
, (unsigned int)max_keys
);
5351 /* restore the memc handle */
5352 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5353 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5355 memcached_quit(memc
);
5357 /* Remove half of the objects */
5358 for (size_t x
= 0; x
< max_keys
; ++x
)
5362 test_compare(MEMCACHED_SUCCESS
,
5363 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
5367 memcached_quit(memc
);
5368 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5369 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5371 /* now retry the command, this time we should have cache misses */
5372 test_compare(MEMCACHED_SUCCESS
,
5373 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5376 test_compare_got(MEMCACHED_SUCCESS
,
5377 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1),
5378 memcached_strerror(NULL
, rc
));
5379 test_compare(counter
, (unsigned int)(max_keys
>> 1));
5381 /* Release allocated resources */
5382 for (size_t x
= 0; x
< max_keys
; ++x
)
5389 /* restore the memc handle */
5390 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5391 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5393 return TEST_SUCCESS
;
5396 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5398 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5399 test_true(memc_clone
);
5400 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5402 memcached_server_instance_st instance
=
5403 memcached_server_instance_by_position(memc_clone
, 0);
5405 if (instance
->major_version
> 1 ||
5406 (instance
->major_version
== 1 &&
5407 instance
->minor_version
> 2))
5409 /* Binary protocol doesn't support deferred delete */
5410 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5411 test_true(bin_clone
);
5412 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5413 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
5414 memcached_free(bin_clone
);
5416 memcached_quit(memc_clone
);
5418 /* If we know the server version, deferred delete should fail
5419 * with invalid arguments */
5420 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
5422 /* If we don't know the server version, we should get a protocol error */
5423 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5425 /* but there is a bug in some of the memcached servers (1.4) that treats
5426 * the counter as noreply so it doesn't send the proper error message
5428 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5430 /* And buffered mode should be disabled and we should get protocol error */
5431 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5432 rc
= memcached_delete(memc
, "foo", 3, 1);
5433 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5435 /* Same goes for noreply... */
5436 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5437 rc
= memcached_delete(memc
, "foo", 3, 1);
5438 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5440 /* but a normal request should go through (and be buffered) */
5441 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
5442 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
5444 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
5445 /* unbuffered noreply should be success */
5446 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
5447 /* unbuffered with reply should be not found... */
5448 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5449 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
5452 memcached_free(memc_clone
);
5453 return TEST_SUCCESS
;
5457 /* Test memcached_server_get_last_disconnect
5458 * For a working server set, shall be NULL
5459 * For a set of non existing server, shall not be NULL
5461 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5463 memcached_return_t rc
;
5464 memcached_server_instance_st disconnected_server
;
5466 /* With the working set of server */
5467 const char *key
= "marmotte";
5468 const char *value
= "milka";
5470 memcached_reset_last_disconnected_server(memc
);
5471 test_false(memc
->last_disconnected_server
);
5472 rc
= memcached_set(memc
, key
, strlen(key
),
5473 value
, strlen(value
),
5474 (time_t)0, (uint32_t)0);
5475 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5477 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5478 test_false(disconnected_server
);
5480 /* With a non existing server */
5482 memcached_server_st
*servers
;
5484 const char *server_list
= "localhost:9";
5486 servers
= memcached_servers_parse(server_list
);
5488 mine
= memcached_create(NULL
);
5489 rc
= memcached_server_push(mine
, servers
);
5490 test_compare(MEMCACHED_SUCCESS
, rc
);
5491 memcached_server_list_free(servers
);
5494 rc
= memcached_set(mine
, key
, strlen(key
),
5495 value
, strlen(value
),
5496 (time_t)0, (uint32_t)0);
5497 test_true(memcached_failed(rc
));
5499 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5500 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5501 test_compare(9, memcached_server_port(disconnected_server
));
5502 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5504 memcached_quit(mine
);
5505 memcached_free(mine
);
5507 return TEST_SUCCESS
;
5510 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5512 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5513 char buffer
[BUFSIZ
];
5515 memcached_return_t rc
;
5516 test_compare_got(MEMCACHED_SUCCESS
,
5517 rc
= libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)),
5518 memcached_strerror(NULL
, rc
));
5520 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5523 // We will just use the error strings as our keys
5524 uint32_t counter
= 100;
5527 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5529 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5530 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5531 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, ret
, memcached_last_error_message(memc
));
5533 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5534 test_true(disconnected_server
);
5535 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5536 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5540 memcached_reset_last_disconnected_server(memc
);
5545 memcached_free(memc
);
5547 return TEST_SUCCESS
;
5550 static test_return_t
test_verbosity(memcached_st
*memc
)
5552 memcached_verbosity(memc
, 3);
5554 return TEST_SUCCESS
;
5557 static test_return_t
test_server_failure(memcached_st
*memc
)
5559 if (memcached_server_count(memc
) < 2)
5560 return TEST_SKIPPED
;
5562 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
5564 memcached_st
*local_memc
= memcached_create(NULL
);
5566 memcached_server_add(local_memc
, memcached_server_name(instance
), memcached_server_port(instance
));
5567 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 2);
5569 uint32_t server_count
= memcached_server_count(local_memc
);
5570 test_compare(1, server_count
);
5572 // Disable the server
5573 instance
= memcached_server_instance_by_position(local_memc
, 0);
5574 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 2;
5576 memcached_return_t rc
;
5577 test_compare_got(MEMCACHED_SERVER_MARKED_DEAD
,
5578 rc
= memcached_set(local_memc
, "foo", strlen("foo"), NULL
, 0, (time_t)0, (uint32_t)0),
5579 memcached_last_error_message(local_memc
));
5581 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5582 test_compare_got(MEMCACHED_SUCCESS
,
5583 rc
= memcached_set(local_memc
, "foo", strlen("foo"), NULL
, 0, (time_t)0, (uint32_t)0),
5584 memcached_strerror(NULL
, rc
));
5586 memcached_last_error_message(local_memc
));
5590 memcached_free(local_memc
);
5592 return TEST_SUCCESS
;
5595 static test_return_t
test_cull_servers(memcached_st
*memc
)
5597 uint32_t count
= memcached_server_count(memc
);
5601 return TEST_SKIPPED
;
5604 // Do not do this in your code, it is not supported.
5605 memc
->servers
[1].options
.is_dead
= true;
5606 memc
->state
.is_time_for_rebuild
= true;
5608 uint32_t new_count
= memcached_server_count(memc
);
5609 test_compare(count
, new_count
);
5612 test_true(count
== new_count
+ 1 );
5615 return TEST_SUCCESS
;
5619 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5620 const char *key
, size_t key_length
,
5621 const char *value
, size_t value_length
,
5631 return MEMCACHED_SUCCESS
;
5634 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5636 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5637 test_compare(MEMCACHED_SUCCESS
, rc
);
5639 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5640 test_compare(MEMCACHED_SUCCESS
, rc
);
5642 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5643 test_compare(MEMCACHED_SUCCESS
, rc
);
5645 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5646 test_compare(MEMCACHED_SUCCESS
, rc
);
5648 return TEST_SUCCESS
;
5652 * This test ensures that the failure counter isn't incremented during
5653 * normal termination of the memcached instance.
5655 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5657 memcached_return_t rc
;
5658 memcached_server_instance_st instance
;
5660 /* Set value to force connection to the server */
5661 const char *key
= "marmotte";
5662 const char *value
= "milka";
5665 * Please note that I'm abusing the internal structures in libmemcached
5666 * in a non-portable way and you shouldn't be doing this. I'm only
5667 * doing this in order to verify that the library works the way it should
5669 uint32_t number_of_hosts
= memcached_server_count(memc
);
5670 memc
->number_of_hosts
= 1;
5672 /* Ensure that we are connected to the server by setting a value */
5673 rc
= memcached_set(memc
, key
, strlen(key
),
5674 value
, strlen(value
),
5675 (time_t)0, (uint32_t)0);
5676 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5679 instance
= memcached_server_instance_by_position(memc
, 0);
5680 /* The test is to see that the memcached_quit doesn't increase the
5681 * the server failure conter, so let's ensure that it is zero
5682 * before sending quit
5684 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5686 memcached_quit(memc
);
5688 /* Verify that it memcached_quit didn't increment the failure counter
5689 * Please note that this isn't bullet proof, because an error could
5692 test_compare(0, instance
->server_failure_counter
);
5694 /* restore the instance */
5695 memc
->number_of_hosts
= number_of_hosts
;
5697 return TEST_SUCCESS
;
5701 * This tests ensures expected disconnections (for some behavior changes
5702 * for instance) do not wrongly increase failure counter
5704 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5706 memcached_return rc
;
5708 memcached_st
*memc_clone
;
5709 memc_clone
= memcached_clone(NULL
, memc
);
5710 test_true(memc_clone
);
5712 /* Set value to force connection to the server */
5713 const char *key
= "marmotte";
5714 const char *value
= "milka";
5715 char *string
= NULL
;
5716 size_t string_length
;
5719 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5720 value
, strlen(value
),
5721 (time_t)0, (uint32_t)0);
5722 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5725 /* put failure limit to 1 */
5726 test_compare(MEMCACHED_SUCCESS
,
5727 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1));
5729 /* Put a retry timeout to effectively activate failure_limit effect */
5730 test_compare(MEMCACHED_SUCCESS
,
5731 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
5733 /* change behavior that triggers memcached_quit()*/
5734 test_compare(MEMCACHED_SUCCESS
,
5735 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5738 /* Check if we still are connected */
5739 string
= memcached_get(memc_clone
, key
, strlen(key
),
5740 &string_length
, &flags
, &rc
);
5742 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5745 memcached_free(memc_clone
);
5747 return TEST_SUCCESS
;
5754 * Test that ensures mget_execute does not end into recursive calls that finally fails
5756 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5758 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5759 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5760 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5761 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5762 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5765 return TEST_SKIPPED
; // My MAC can't handle this test
5769 * I only want to hit _one_ server so I know the number of requests I'm
5770 * sending in the pipeline.
5772 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5773 memc
->number_of_hosts
= 1;
5774 size_t max_keys
= 20480;
5777 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5778 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5780 /* First add all of the items.. */
5781 char blob
[1024]= { 0 };
5782 for (size_t x
= 0; x
< max_keys
; ++x
)
5785 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5788 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5789 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5794 /* Try to get all of them with a large multiget */
5796 memcached_execute_function callbacks
[]= { &callback_counter
};
5797 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5798 (size_t)max_keys
, callbacks
, &counter
, 1);
5799 test_compare(MEMCACHED_SUCCESS
, rc
);
5801 char* the_value
= NULL
;
5802 char the_key
[MEMCACHED_MAX_KEY
];
5803 size_t the_key_length
;
5804 size_t the_value_length
;
5808 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5810 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5816 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5819 test_compare(MEMCACHED_END
, rc
);
5821 /* Verify that we got all of the items */
5822 test_compare(counter
, max_keys
);
5825 /* Release all allocated resources */
5826 for (size_t x
= 0; x
< max_keys
; ++x
)
5833 memc
->number_of_hosts
= number_of_hosts
;
5835 return TEST_SUCCESS
;
5838 static test_return_t
regression_bug_583031(memcached_st
*)
5840 memcached_st
*memc
= memcached_create(NULL
);
5842 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5844 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5845 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5846 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5847 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5848 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5849 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5851 memcached_return_t rc
;
5855 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5857 test_compare(0, length
);
5859 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_strerror(memc
, rc
));
5861 memcached_free(memc
);
5863 return TEST_SUCCESS
;
5866 static test_return_t
regression_bug_581030(memcached_st
*)
5869 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5870 test_false(local_stat
);
5872 memcached_stat_free(NULL
, NULL
);
5875 return TEST_SUCCESS
;
5878 #define regression_bug_655423_COUNT 6000
5879 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5881 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5882 memc
= NULL
; // Just to make sure it is not used
5887 return TEST_SKIPPED
;
5890 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5891 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5892 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5893 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5895 memset(payload
, int('x'), sizeof(payload
));
5897 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5899 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5900 snprintf(key
, sizeof(key
), "%u", x
);
5902 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5905 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5907 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5908 snprintf(key
, sizeof(key
), "%u", x
);
5910 size_t value_length
;
5911 memcached_return_t rc
;
5912 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5914 if (rc
== MEMCACHED_NOTFOUND
)
5917 test_compare(0, value_length
);
5921 test_compare(MEMCACHED_SUCCESS
, rc
);
5923 test_compare(100, value_length
);
5927 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5928 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5929 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5931 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5932 snprintf(key
, sizeof(key
), "%u", x
);
5934 keys
[x
]= strdup(key
);
5936 key_length
[x
]= strlen(key
);
5937 test_true(key_length
[x
]);
5940 memcached_return_t rc
;
5941 test_compare_got(MEMCACHED_SUCCESS
,
5942 rc
= memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
),
5943 memcached_strerror(NULL
, rc
));
5946 memcached_result_st
*result
= NULL
;
5947 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5949 test_compare(100, memcached_result_length(result
));
5953 test_true(count
> 100); // If we don't get back atleast this, something is up
5955 /* Release all allocated resources */
5956 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5964 memcached_free(clone
);
5966 return TEST_SUCCESS
;
5970 * Test that ensures that buffered set to not trigger problems during io_flush
5972 #define regression_bug_490520_COUNT 200480
5973 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5975 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5976 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5977 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5978 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5979 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5981 memc
->number_of_hosts
= 1;
5983 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5984 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5986 /* First add all of the items.. */
5987 char blob
[3333] = {0};
5988 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5991 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5995 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5996 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5999 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
6006 return TEST_SUCCESS
;
6009 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
6011 fprintf(stderr
, "Iteration #%u: ", it
);
6013 if(error
== MEMCACHED_ERRNO
)
6015 fprintf(stderr
, "system error %d from %s: %s\n",
6016 errno
, what
, strerror(errno
));
6020 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
6021 memcached_strerror(mc
, error
));
6025 #define TEST_CONSTANT_CREATION 200
6027 static test_return_t
regression_bug_(memcached_st
*memc
)
6029 const char *remote_server
;
6032 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
6034 return TEST_SKIPPED
;
6037 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
6039 memcached_st
* mc
= memcached_create(NULL
);
6040 memcached_return rc
;
6042 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
6043 if (rc
!= MEMCACHED_SUCCESS
)
6045 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6048 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
6049 if (rc
!= MEMCACHED_SUCCESS
)
6051 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6054 rc
= memcached_server_add(mc
, remote_server
, 0);
6055 if (rc
!= MEMCACHED_SUCCESS
)
6057 memcached_die(mc
, rc
, "memcached_server_add", x
);
6060 const char *set_key
= "akey";
6061 const size_t set_key_len
= strlen(set_key
);
6062 const char *set_value
= "a value";
6063 const size_t set_value_len
= strlen(set_value
);
6065 if (rc
== MEMCACHED_SUCCESS
)
6069 size_t get_value_len
;
6071 uint32_t get_value_flags
;
6073 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
6074 &get_value_flags
, &rc
);
6075 if (rc
!= MEMCACHED_SUCCESS
)
6077 memcached_die(mc
, rc
, "memcached_get", x
);
6083 (get_value_len
!= set_value_len
6084 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
6086 fprintf(stderr
, "Values don't match?\n");
6087 rc
= MEMCACHED_FAILURE
;
6093 rc
= memcached_set(mc
,
6094 set_key
, set_key_len
,
6095 set_value
, set_value_len
,
6099 if (rc
!= MEMCACHED_SUCCESS
)
6101 memcached_die(mc
, rc
, "memcached_set", x
);
6108 if (rc
!= MEMCACHED_SUCCESS
)
6114 return TEST_SUCCESS
;
6118 * Test that the sasl authentication works. We cannot use the default
6119 * pool of servers, because that would require that all servers we want
6120 * to test supports SASL authentication, and that they use the default
6123 static test_return_t
sasl_auth_test(memcached_st
*memc
)
6125 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
6126 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0));
6127 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
6128 test_compare(MEMCACHED_SUCCESS
, memcached_destroy_sasl_auth_data(memc
));
6129 test_compare(MEMCACHED_FAILURE
, memcached_destroy_sasl_auth_data(memc
));
6130 test_compare(MEMCACHED_FAILURE
, memcached_destroy_sasl_auth_data(NULL
));
6131 memcached_quit(memc
);
6133 test_compare(MEMCACHED_SUCCESS
,
6134 memcached_set_sasl_auth_data(memc
,
6135 getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
6136 getenv("LIBMEMCACHED_TEST_SASL_SERVER")));
6138 test_compare(MEMCACHED_AUTH_FAILURE
,
6139 memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0));
6140 test_compare(MEMCACHED_SUCCESS
, memcached_destroy_sasl_auth_data(memc
));
6142 memcached_quit(memc
);
6143 return TEST_SUCCESS
;
6146 return TEST_FAILURE
;
6150 /* Clean the server before beginning testing */
6152 {"util_version", 1, (test_callback_fn
*)util_version_test
},
6153 {"flush", 0, (test_callback_fn
*)flush_test
},
6154 {"init", 0, (test_callback_fn
*)init_test
},
6155 {"allocation", 0, (test_callback_fn
*)allocation_test
},
6156 {"server_list_null_test", 0, (test_callback_fn
*)server_list_null_test
},
6157 {"server_unsort", 0, (test_callback_fn
*)server_unsort_test
},
6158 {"server_sort", 0, (test_callback_fn
*)server_sort_test
},
6159 {"server_sort2", 0, (test_callback_fn
*)server_sort2_test
},
6160 {"memcached_server_remove", 0, (test_callback_fn
*)memcached_server_remove_test
},
6161 {"clone_test", 0, (test_callback_fn
*)clone_test
},
6162 {"connection_test", 0, (test_callback_fn
*)connection_test
},
6163 {"callback_test", 0, (test_callback_fn
*)callback_test
},
6164 {"userdata_test", 0, (test_callback_fn
*)userdata_test
},
6165 {"error", 0, (test_callback_fn
*)error_test
},
6166 {"set", 0, (test_callback_fn
*)set_test
},
6167 {"set2", 0, (test_callback_fn
*)set_test2
},
6168 {"set3", 0, (test_callback_fn
*)set_test3
},
6169 {"dump", 1, (test_callback_fn
*)dump_test
},
6170 {"add", 1, (test_callback_fn
*)add_test
},
6171 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", 1, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
6172 {"replace", 1, (test_callback_fn
*)replace_test
},
6173 {"delete", 1, (test_callback_fn
*)delete_test
},
6174 {"get", 1, (test_callback_fn
*)get_test
},
6175 {"get2", 0, (test_callback_fn
*)get_test2
},
6176 {"get3", 0, (test_callback_fn
*)get_test3
},
6177 {"get4", 0, (test_callback_fn
*)get_test4
},
6178 {"partial mget", 0, (test_callback_fn
*)get_test5
},
6179 {"stats_servername", 0, (test_callback_fn
*)stats_servername_test
},
6180 {"increment", 0, (test_callback_fn
*)increment_test
},
6181 {"increment_with_initial", 1, (test_callback_fn
*)increment_with_initial_test
},
6182 {"decrement", 0, (test_callback_fn
*)decrement_test
},
6183 {"decrement_with_initial", 1, (test_callback_fn
*)decrement_with_initial_test
},
6184 {"increment_by_key", 0, (test_callback_fn
*)increment_by_key_test
},
6185 {"increment_with_initial_by_key", 1, (test_callback_fn
*)increment_with_initial_by_key_test
},
6186 {"decrement_by_key", 0, (test_callback_fn
*)decrement_by_key_test
},
6187 {"decrement_with_initial_by_key", 1, (test_callback_fn
*)decrement_with_initial_by_key_test
},
6188 {"quit", 0, (test_callback_fn
*)quit_test
},
6189 {"mget", 1, (test_callback_fn
*)mget_test
},
6190 {"mget_result", 1, (test_callback_fn
*)mget_result_test
},
6191 {"mget_result_alloc", 1, (test_callback_fn
*)mget_result_alloc_test
},
6192 {"mget_result_function", 1, (test_callback_fn
*)mget_result_function
},
6193 {"mget_execute", 1, (test_callback_fn
*)mget_execute
},
6194 {"mget_end", 0, (test_callback_fn
*)mget_end
},
6195 {"get_stats", 0, (test_callback_fn
*)get_stats
},
6196 {"add_host_test", 0, (test_callback_fn
*)add_host_test
},
6197 {"add_host_test_1", 0, (test_callback_fn
*)add_host_test1
},
6198 {"get_stats_keys", 0, (test_callback_fn
*)get_stats_keys
},
6199 {"version_string_test", 0, (test_callback_fn
*)version_string_test
},
6200 {"bad_key", 1, (test_callback_fn
*)bad_key_test
},
6201 {"memcached_server_cursor", 1, (test_callback_fn
*)memcached_server_cursor_test
},
6202 {"read_through", 1, (test_callback_fn
*)read_through
},
6203 {"delete_through", 1, (test_callback_fn
*)delete_through
},
6204 {"noreply", 1, (test_callback_fn
*)noreply_test
},
6205 {"analyzer", 1, (test_callback_fn
*)analyzer_test
},
6206 {"connectionpool", 1, (test_callback_fn
*)connection_pool_test
},
6207 {"memcached_pool_test", 1, (test_callback_fn
*)memcached_pool_test
},
6208 {"ping", 1, (test_callback_fn
*)ping_test
},
6209 {"test_get_last_disconnect", 1, (test_callback_fn
*)test_get_last_disconnect
},
6210 {"verbosity", 1, (test_callback_fn
*)test_verbosity
},
6211 {"test_server_failure", 1, (test_callback_fn
*)test_server_failure
},
6212 {"cull_servers", 1, (test_callback_fn
*)test_cull_servers
},
6213 {"memcached_stat_execute", 1, (test_callback_fn
*)memcached_stat_execute_test
},
6217 test_st behavior_tests
[] ={
6218 {"libmemcached_string_behavior()", 0, (test_callback_fn
*)libmemcached_string_behavior_test
},
6219 {"libmemcached_string_distribution()", 0, (test_callback_fn
*)libmemcached_string_distribution_test
},
6220 {"behavior_test", 0, (test_callback_fn
*)behavior_test
},
6221 {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
6222 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
6223 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
6227 test_st basic_tests
[] ={
6228 {"init", 1, (test_callback_fn
*)basic_init_test
},
6229 {"clone", 1, (test_callback_fn
*)basic_clone_test
},
6230 {"reset", 1, (test_callback_fn
*)basic_reset_stack_test
},
6231 {"reset heap", 1, (test_callback_fn
*)basic_reset_heap_test
},
6232 {"reset stack clone", 1, (test_callback_fn
*)basic_reset_stack_clone_test
},
6233 {"reset heap clone", 1, (test_callback_fn
*)basic_reset_heap_clone_test
},
6237 test_st regression_binary_vs_block
[] ={
6238 {"block add", 1, (test_callback_fn
*)block_add_regression
},
6239 {"binary add", 1, (test_callback_fn
*)binary_add_regression
},
6243 test_st async_tests
[] ={
6244 {"add", 1, (test_callback_fn
*)add_wrapper
},
6248 test_st string_tests
[] ={
6249 {"string static with null", 0, (test_callback_fn
*)string_static_null
},
6250 {"string alloc with null", 0, (test_callback_fn
*)string_alloc_null
},
6251 {"string alloc with 1K", 0, (test_callback_fn
*)string_alloc_with_size
},
6252 {"string alloc with malloc failure", 0, (test_callback_fn
*)string_alloc_with_size_toobig
},
6253 {"string append", 0, (test_callback_fn
*)string_alloc_append
},
6254 {"string append failure (too big)", 0, (test_callback_fn
*)string_alloc_append_toobig
},
6255 {"string_alloc_append_multiple", 0, (test_callback_fn
*)string_alloc_append_multiple
},
6256 {0, 0, (test_callback_fn
*)0}
6259 test_st memcached_server_get_last_disconnect_tests
[] ={
6260 {"memcached_server_get_last_disconnect()", 0, (test_callback_fn
*)test_multiple_get_last_disconnect
},
6261 {0, 0, (test_callback_fn
*)0}
6265 test_st result_tests
[] ={
6266 {"result static", 0, (test_callback_fn
*)result_static
},
6267 {"result alloc", 0, (test_callback_fn
*)result_alloc
},
6268 {0, 0, (test_callback_fn
*)0}
6271 test_st version_1_2_3
[] ={
6272 {"append", 0, (test_callback_fn
*)append_test
},
6273 {"prepend", 0, (test_callback_fn
*)prepend_test
},
6274 {"cas", 0, (test_callback_fn
*)cas_test
},
6275 {"cas2", 0, (test_callback_fn
*)cas2_test
},
6276 {"append_binary", 0, (test_callback_fn
*)append_binary_test
},
6277 {0, 0, (test_callback_fn
*)0}
6280 test_st haldenbrand_tests
[] ={
6281 {"memcached_set", 0, (test_callback_fn
*)user_supplied_bug1
},
6282 {"memcached_get()", 0, (test_callback_fn
*)user_supplied_bug2
},
6283 {"memcached_mget()", 0, (test_callback_fn
*)user_supplied_bug3
},
6284 {0, 0, (test_callback_fn
*)0}
6287 test_st user_tests
[] ={
6288 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
6289 {"user_supplied_bug5", 1, (test_callback_fn
*)user_supplied_bug5
},
6290 {"user_supplied_bug6", 1, (test_callback_fn
*)user_supplied_bug6
},
6291 {"user_supplied_bug7", 1, (test_callback_fn
*)user_supplied_bug7
},
6292 {"user_supplied_bug8", 1, (test_callback_fn
*)user_supplied_bug8
},
6293 {"user_supplied_bug9", 1, (test_callback_fn
*)user_supplied_bug9
},
6294 {"user_supplied_bug10", 1, (test_callback_fn
*)user_supplied_bug10
},
6295 {"user_supplied_bug11", 1, (test_callback_fn
*)user_supplied_bug11
},
6296 {"user_supplied_bug12", 1, (test_callback_fn
*)user_supplied_bug12
},
6297 {"user_supplied_bug13", 1, (test_callback_fn
*)user_supplied_bug13
},
6298 {"user_supplied_bug14", 1, (test_callback_fn
*)user_supplied_bug14
},
6299 {"user_supplied_bug15", 1, (test_callback_fn
*)user_supplied_bug15
},
6300 {"user_supplied_bug16", 1, (test_callback_fn
*)user_supplied_bug16
},
6301 #if !defined(__sun) && !defined(__OpenBSD__)
6303 ** It seems to be something weird with the character sets..
6304 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6305 ** guess I need to find out how this is supposed to work.. Perhaps I need
6306 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6307 ** so just disable the code for now...).
6309 {"user_supplied_bug17", 1, (test_callback_fn
*)user_supplied_bug17
},
6311 {"user_supplied_bug18", 1, (test_callback_fn
*)user_supplied_bug18
},
6312 {"user_supplied_bug19", 1, (test_callback_fn
*)user_supplied_bug19
},
6313 {"user_supplied_bug20", 1, (test_callback_fn
*)user_supplied_bug20
},
6314 {"user_supplied_bug21", 1, (test_callback_fn
*)user_supplied_bug21
},
6315 {"wrong_failure_counter_test", 1, (test_callback_fn
*)wrong_failure_counter_test
},
6316 {"wrong_failure_counter_two_test", 1, (test_callback_fn
*)wrong_failure_counter_two_test
},
6317 {0, 0, (test_callback_fn
*)0}
6320 test_st replication_tests
[]= {
6321 {"set", 1, (test_callback_fn
*)replication_set_test
},
6322 {"get", 0, (test_callback_fn
*)replication_get_test
},
6323 {"mget", 0, (test_callback_fn
*)replication_mget_test
},
6324 {"delete", 0, (test_callback_fn
*)replication_delete_test
},
6325 {"rand_mget", 0, (test_callback_fn
*)replication_randomize_mget_test
},
6326 {"fail", 0, (test_callback_fn
*)replication_randomize_mget_fail_test
},
6327 {0, 0, (test_callback_fn
*)0}
6331 * The following test suite is used to verify that we don't introduce
6332 * regression bugs. If you want more information about the bug / test,
6333 * you should look in the bug report at
6334 * http://bugs.launchpad.net/libmemcached
6336 test_st regression_tests
[]= {
6337 {"lp:434484", 1, (test_callback_fn
*)regression_bug_434484
},
6338 {"lp:434843", 1, (test_callback_fn
*)regression_bug_434843
},
6339 {"lp:434843-buffered", 1, (test_callback_fn
*)regression_bug_434843_buffered
},
6340 {"lp:421108", 1, (test_callback_fn
*)regression_bug_421108
},
6341 {"lp:442914", 1, (test_callback_fn
*)regression_bug_442914
},
6342 {"lp:447342", 1, (test_callback_fn
*)regression_bug_447342
},
6343 {"lp:463297", 1, (test_callback_fn
*)regression_bug_463297
},
6344 {"lp:490486", 1, (test_callback_fn
*)regression_bug_490486
},
6345 {"lp:583031", 1, (test_callback_fn
*)regression_bug_583031
},
6346 {"lp:?", 1, (test_callback_fn
*)regression_bug_
},
6347 {"lp:728286", 1, (test_callback_fn
*)regression_bug_728286
},
6348 {"lp:581030", 1, (test_callback_fn
*)regression_bug_581030
},
6349 {"lp:71231153 connect()", 1, (test_callback_fn
*)regression_bug_71231153_connect
},
6350 {"lp:71231153 poll()", 1, (test_callback_fn
*)regression_bug_71231153_poll
},
6351 {"lp:655423", 1, (test_callback_fn
*)regression_bug_655423
},
6352 {"lp:490520", 1, (test_callback_fn
*)regression_bug_490520
},
6353 {0, 0, (test_callback_fn
*)0}
6356 test_st sasl_auth_tests
[]= {
6357 {"sasl_auth", 1, (test_callback_fn
*)sasl_auth_test
},
6358 {0, 0, (test_callback_fn
*)0}
6361 test_st ketama_compatibility
[]= {
6362 {"libmemcached", 1, (test_callback_fn
*)ketama_compatibility_libmemcached
},
6363 {"spymemcached", 1, (test_callback_fn
*)ketama_compatibility_spymemcached
},
6364 {0, 0, (test_callback_fn
*)0}
6367 test_st generate_tests
[] ={
6368 {"generate_pairs", 1, (test_callback_fn
*)generate_pairs
},
6369 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6370 {"get_read", 0, (test_callback_fn
*)get_read
},
6371 {"delete_generate", 0, (test_callback_fn
*)delete_generate
},
6372 {"generate_buffer_data", 1, (test_callback_fn
*)generate_buffer_data
},
6373 {"delete_buffer", 0, (test_callback_fn
*)delete_buffer_generate
},
6374 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6375 {"mget_read", 0, (test_callback_fn
*)mget_read
},
6376 {"mget_read_result", 0, (test_callback_fn
*)mget_read_result
},
6377 {"memcached_fetch_result() use internal result", 0, (test_callback_fn
*)mget_read_internal_result
},
6378 {"memcached_fetch_result() partial read", 0, (test_callback_fn
*)mget_read_partial_result
},
6379 {"mget_read_function", 0, (test_callback_fn
*)mget_read_function
},
6380 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6381 {"generate_large_pairs", 1, (test_callback_fn
*)generate_large_pairs
},
6382 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6383 {"generate_buffer_data", 1, (test_callback_fn
*)generate_buffer_data
},
6384 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6385 {0, 0, (test_callback_fn
*)0}
6388 test_st consistent_tests
[] ={
6389 {"generate_pairs", 1, (test_callback_fn
*)generate_pairs
},
6390 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6391 {"get_read", 0, (test_callback_fn
*)get_read_count
},
6392 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6393 {0, 0, (test_callback_fn
*)0}
6396 test_st consistent_weighted_tests
[] ={
6397 {"generate_pairs", 1, (test_callback_fn
*)generate_pairs
},
6398 {"generate_data", 1, (test_callback_fn
*)generate_data_with_stats
},
6399 {"get_read", 0, (test_callback_fn
*)get_read_count
},
6400 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6401 {0, 0, (test_callback_fn
*)0}
6404 test_st hsieh_availability
[] ={
6405 {"hsieh_avaibility_test", 0, (test_callback_fn
*)hsieh_avaibility_test
},
6406 {0, 0, (test_callback_fn
*)0}
6409 test_st murmur_availability
[] ={
6410 {"murmur_avaibility_test", 0, (test_callback_fn
*)murmur_avaibility_test
},
6411 {0, 0, (test_callback_fn
*)0}
6415 test_st hash_sanity
[] ={
6416 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
6417 {0, 0, (test_callback_fn
*)0}
6421 test_st ketama_auto_eject_hosts
[] ={
6422 {"auto_eject_hosts", 1, (test_callback_fn
*)auto_eject_hosts
},
6423 {"output_ketama_weighted_keys", 1, (test_callback_fn
*)output_ketama_weighted_keys
},
6424 {0, 0, (test_callback_fn
*)0}
6427 test_st hash_tests
[] ={
6428 {"one_at_a_time_run", 0, (test_callback_fn
*)one_at_a_time_run
},
6429 {"md5", 0, (test_callback_fn
*)md5_run
},
6430 {"crc", 0, (test_callback_fn
*)crc_run
},
6431 {"fnv1_64", 0, (test_callback_fn
*)fnv1_64_run
},
6432 {"fnv1a_64", 0, (test_callback_fn
*)fnv1a_64_run
},
6433 {"fnv1_32", 0, (test_callback_fn
*)fnv1_32_run
},
6434 {"fnv1a_32", 0, (test_callback_fn
*)fnv1a_32_run
},
6435 {"hsieh", 0, (test_callback_fn
*)hsieh_run
},
6436 {"murmur", 0, (test_callback_fn
*)murmur_run
},
6437 {"jenkis", 0, (test_callback_fn
*)jenkins_run
},
6438 {"memcached_get_hashkit", 0, (test_callback_fn
*)memcached_get_hashkit_test
},
6439 {0, 0, (test_callback_fn
*)0}
6442 test_st error_conditions
[] ={
6443 {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
6444 {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
6445 {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
6446 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6447 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6448 {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
6449 {0, 0, (test_callback_fn
*)0}
6453 test_st parser_tests
[] ={
6454 {"behavior", 0, (test_callback_fn
*)behavior_parser_test
},
6455 {"boolean_options", 0, (test_callback_fn
*)parser_boolean_options_test
},
6456 {"configure_file", 0, (test_callback_fn
*)memcached_create_with_options_with_filename
},
6457 {"distribtions", 0, (test_callback_fn
*)parser_distribution_test
},
6458 {"hash", 0, (test_callback_fn
*)parser_hash_test
},
6459 {"libmemcached_check_configuration", 0, (test_callback_fn
*)libmemcached_check_configuration_test
},
6460 {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
6461 {"number_options", 0, (test_callback_fn
*)parser_number_options_test
},
6462 {"randomly generated options", 0, (test_callback_fn
*)random_statement_build_test
},
6463 {"namespace", 0, (test_callback_fn
*)parser_key_prefix_test
},
6464 {"server", 0, (test_callback_fn
*)server_test
},
6465 {"bad server strings", 0, (test_callback_fn
*)servers_bad_test
},
6466 {"server with weights", 0, (test_callback_fn
*)server_with_weight_test
},
6467 {"parsing servername, port, and weight", 0, (test_callback_fn
*)test_hostname_port_weight
},
6468 {"--socket=", 0, (test_callback_fn
*)test_parse_socket
},
6469 {"--namespace=", 0, (test_callback_fn
*)test_namespace_keyword
},
6470 {0, 0, (test_callback_fn
*)0}
6473 test_st virtual_bucket_tests
[] ={
6474 {"basic", 0, (test_callback_fn
*)virtual_back_map
},
6475 {0, 0, (test_callback_fn
*)0}
6478 test_st namespace_tests
[] ={
6479 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
6480 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
6481 {0, 0, (test_callback_fn
*)0}
6484 collection_st collection
[] ={
6486 {"hash_sanity", 0, 0, hash_sanity
},
6488 {"basic", 0, 0, basic_tests
},
6489 {"hsieh_availability", 0, 0, hsieh_availability
},
6490 {"murmur_availability", 0, 0, murmur_availability
},
6491 {"block", 0, 0, tests
},
6492 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
6493 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
6494 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6495 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
6496 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
6497 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
6498 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
6499 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
6500 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
6501 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
6502 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
6503 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
6504 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
6505 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6506 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
6507 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6508 {"poll_timeout", (test_callback_fn
*)poll_timeout
, 0, tests
},
6509 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
6510 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
6511 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
6512 #ifdef MEMCACHED_ENABLE_DEPRECATED
6513 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
6515 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
6516 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
6517 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
6518 {"specific namespace", 0, 0, namespace_tests
},
6519 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
6520 {"sasl_auth", (test_callback_fn
*)pre_sasl
, 0, sasl_auth_tests
},
6521 {"sasl", (test_callback_fn
*)pre_sasl
, 0, tests
},
6522 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
6523 {"string", 0, 0, string_tests
},
6524 {"result", 0, 0, result_tests
},
6525 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
6526 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
6527 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
6528 {"user", 0, 0, user_tests
},
6529 {"generate", 0, 0, generate_tests
},
6530 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
6531 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
6532 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
6533 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
6534 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
6535 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
6536 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
6538 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
6539 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
6540 {"consistent_not", 0, 0, consistent_tests
},
6541 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
6542 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6543 {"ketama_compat", 0, 0, ketama_compatibility
},
6544 {"test_hashes", 0, 0, hash_tests
},
6545 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6546 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6547 {"regression", 0, 0, regression_tests
},
6548 {"behaviors", 0, 0, behavior_tests
},
6549 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6550 {"error_conditions", 0, 0, error_conditions
},
6551 {"parser", 0, 0, parser_tests
},
6552 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6553 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6557 #include "tests/libmemcached_world.h"
6559 void get_world(Framework
*world
)
6561 world
->collections
= collection
;
6563 world
->_create
= (test_callback_create_fn
*)world_create
;
6564 world
->_destroy
= (test_callback_fn
*)world_destroy
;
6566 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6567 world
->item
._flush
= (test_callback_fn
*)world_flush
;
6568 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6569 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6570 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6572 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6573 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6575 world
->runner
= &defualt_libmemcached_runner
;