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_prefix_key
== memc
->flags
.hash_with_prefix_key
);
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 memcached_return_t rc
;
1140 const char *key
= "foo";
1142 size_t value_length
= 8191;
1144 size_t string_length
;
1148 value
= (char*)malloc(value_length
);
1151 for (x
= 0; x
< value_length
; x
++)
1152 value
[x
] = (char) (x
% 127);
1154 rc
= memcached_set(memc
, key
, strlen(key
),
1155 value
, value_length
,
1156 (time_t)0, (uint32_t)0);
1157 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1159 for (x
= 0; x
< 10; x
++)
1161 string
= memcached_get(memc
, key
, strlen(key
),
1162 &string_length
, &flags
, &rc
);
1164 test_compare(MEMCACHED_SUCCESS
, rc
);
1166 test_compare(string_length
, value_length
);
1167 test_memcmp(string
, value
, string_length
);
1173 return TEST_SUCCESS
;
1177 * This test verifies that memcached_read_one_response doesn't try to
1178 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1179 * responses before you execute a storage command.
1181 static test_return_t
get_test5(memcached_st
*memc
)
1184 ** Request the same key twice, to ensure that we hash to the same server
1185 ** (so that we have multiple response values queued up) ;-)
1187 const char *keys
[]= { "key", "key" };
1188 size_t lengths
[]= { 3, 3 };
1192 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1193 keys
[0], lengths
[0], 0, 0);
1194 test_compare(MEMCACHED_SUCCESS
, rc
);
1195 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1197 memcached_result_st results_obj
;
1198 memcached_result_st
*results
;
1199 results
=memcached_result_create(memc
, &results_obj
);
1201 results
=memcached_fetch_result(memc
, &results_obj
, &rc
);
1203 memcached_result_free(&results_obj
);
1205 /* Don't read out the second result, but issue a set instead.. */
1206 rc
= memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0);
1207 test_compare(MEMCACHED_SUCCESS
, rc
);
1209 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1210 &rlen
, &flags
, &rc
);
1212 test_compare(MEMCACHED_NOTFOUND
, rc
);
1213 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1215 test_compare(MEMCACHED_SUCCESS
, rc
);
1218 return TEST_SUCCESS
;
1221 static test_return_t
mget_end(memcached_st
*memc
)
1223 const char *keys
[]= { "foo", "foo2" };
1224 size_t lengths
[]= { 3, 4 };
1225 const char *values
[]= { "fjord", "41" };
1227 memcached_return_t rc
;
1230 for (int i
= 0; i
< 2; i
++)
1232 rc
= memcached_set(memc
, keys
[i
], lengths
[i
], values
[i
], strlen(values
[i
]),
1233 (time_t)0, (uint32_t)0);
1234 test_compare(MEMCACHED_SUCCESS
, rc
);
1238 size_t string_length
;
1241 // retrieve both via mget
1242 rc
= memcached_mget(memc
, keys
, lengths
, 2);
1243 test_compare(MEMCACHED_SUCCESS
, rc
);
1245 char key
[MEMCACHED_MAX_KEY
];
1248 // this should get both
1249 for (int i
= 0; i
< 2; i
++)
1251 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1253 test_compare(MEMCACHED_SUCCESS
, rc
);
1255 if (key_length
== 4)
1260 test_compare(string_length
, strlen(values
[val
]));
1261 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1265 // this should indicate end
1266 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1267 test_compare(MEMCACHED_END
, rc
);
1270 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1271 test_compare(MEMCACHED_SUCCESS
, rc
);
1273 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1274 test_compare(key_length
, lengths
[0]);
1275 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1276 test_compare(string_length
, strlen(values
[0]));
1277 test_true(strncmp(values
[0], string
, string_length
) == 0);
1278 test_compare(MEMCACHED_SUCCESS
, rc
);
1281 // this should indicate end
1282 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1283 test_true(rc
== MEMCACHED_END
);
1285 return TEST_SUCCESS
;
1288 /* Do not copy the style of this code, I just access hosts to testthis function */
1289 static test_return_t
stats_servername_test(memcached_st
*memc
)
1291 memcached_return_t rc
;
1292 memcached_stat_st memc_stat
;
1293 memcached_server_instance_st instance
=
1294 memcached_server_instance_by_position(memc
, 0);
1296 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
1297 if (memcached_get_sasl_callbacks(memc
) != NULL
)
1298 return TEST_SKIPPED
;
1300 rc
= memcached_stat_servername(&memc_stat
, NULL
,
1301 memcached_server_name(instance
),
1302 memcached_server_port(instance
));
1304 return TEST_SUCCESS
;
1307 static test_return_t
increment_test(memcached_st
*memc
)
1309 uint64_t new_number
;
1311 test_compare(MEMCACHED_SUCCESS
,
1313 test_literal_param("number"),
1314 test_literal_param("0"),
1315 (time_t)0, (uint32_t)0));
1317 memcached_return_t rc
;
1318 test_compare_got(MEMCACHED_SUCCESS
,
1319 rc
= memcached_increment(memc
,
1320 test_literal_param("number"),
1322 memcached_strerror(NULL
, rc
));
1323 test_compare(1, new_number
);
1325 test_compare(MEMCACHED_SUCCESS
,
1326 memcached_increment(memc
,
1327 test_literal_param("number"),
1329 test_compare(2, new_number
);
1331 return TEST_SUCCESS
;
1334 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1336 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1338 uint64_t new_number
;
1339 uint64_t initial
= 0;
1341 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1343 memcached_return_t rc
;
1344 test_compare_got(MEMCACHED_SUCCESS
,
1345 rc
= memcached_increment_with_initial(memc
,
1346 test_literal_param("number"),
1347 1, initial
, 0, &new_number
),
1348 memcached_strerror(NULL
, rc
));
1349 test_compare(new_number
, initial
);
1351 test_compare(MEMCACHED_SUCCESS
,
1352 memcached_increment_with_initial(memc
,
1353 test_literal_param("number"),
1354 1, initial
, 0, &new_number
));
1355 test_compare(new_number
, (initial
+ 1));
1357 return TEST_SUCCESS
;
1360 static test_return_t
decrement_test(memcached_st
*memc
)
1362 uint64_t new_number
;
1363 memcached_return_t rc
;
1364 const char *value
= "3";
1366 rc
= memcached_set(memc
,
1367 test_literal_param("number"),
1368 value
, strlen(value
),
1369 (time_t)0, (uint32_t)0);
1370 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1372 test_compare(MEMCACHED_SUCCESS
,
1373 memcached_decrement(memc
,
1374 test_literal_param("number"),
1376 test_compare(new_number
, 2);
1378 test_compare(MEMCACHED_SUCCESS
,
1379 memcached_decrement(memc
,
1380 test_literal_param("number"),
1382 test_compare(new_number
, 1);
1384 return TEST_SUCCESS
;
1387 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1389 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1391 uint64_t new_number
;
1392 uint64_t initial
= 3;
1394 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1396 test_compare(MEMCACHED_SUCCESS
,
1397 memcached_decrement_with_initial(memc
,
1398 test_literal_param("number"),
1399 1, initial
, 0, &new_number
));
1400 test_compare(new_number
, initial
);
1402 test_compare(MEMCACHED_SUCCESS
,
1403 memcached_decrement_with_initial(memc
,
1404 test_literal_param("number"),
1405 1, initial
, 0, &new_number
));
1406 test_compare(new_number
, (initial
- 1));
1408 return TEST_SUCCESS
;
1411 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1413 uint64_t new_number
;
1414 memcached_return_t rc
;
1415 const char *master_key
= "foo";
1416 const char *key
= "number";
1417 const char *value
= "0";
1419 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1421 value
, strlen(value
),
1422 (time_t)0, (uint32_t)0);
1423 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1425 test_compare(MEMCACHED_SUCCESS
,
1426 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1428 test_compare(new_number
, 1);
1430 test_compare(MEMCACHED_SUCCESS
,
1431 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
),
1433 test_compare(new_number
, 2);
1435 return TEST_SUCCESS
;
1438 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1440 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1442 uint64_t new_number
;
1443 memcached_return_t rc
;
1444 const char *master_key
= "foo";
1445 const char *key
= "number";
1446 uint64_t initial
= 0;
1448 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1450 1, initial
, 0, &new_number
);
1451 test_compare(MEMCACHED_SUCCESS
, rc
);
1452 test_true(new_number
== initial
);
1454 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1456 1, initial
, 0, &new_number
);
1457 test_compare(MEMCACHED_SUCCESS
, rc
);
1458 test_true(new_number
== (initial
+ 1));
1460 return TEST_SUCCESS
;
1463 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1465 uint64_t new_number
;
1466 memcached_return_t rc
;
1467 const char *value
= "3";
1469 rc
= memcached_set_by_key(memc
,
1470 test_literal_param("foo"),
1471 test_literal_param("number"),
1472 value
, strlen(value
),
1473 (time_t)0, (uint32_t)0);
1474 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1476 test_compare(MEMCACHED_SUCCESS
,
1477 memcached_decrement_by_key(memc
,
1478 test_literal_param("foo"),
1479 test_literal_param("number"),
1481 test_compare(new_number
, 2);
1483 test_compare(MEMCACHED_SUCCESS
,
1484 memcached_decrement_by_key(memc
,
1485 test_literal_param("foo"),
1486 test_literal_param("number"),
1488 test_compare(new_number
, 1);
1490 return TEST_SUCCESS
;
1493 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1495 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1497 uint64_t new_number
;
1498 uint64_t initial
= 3;
1500 test_compare(MEMCACHED_SUCCESS
,
1501 memcached_decrement_with_initial_by_key(memc
,
1502 test_literal_param("foo"),
1503 test_literal_param("number"),
1504 1, initial
, 0, &new_number
));
1505 test_compare(new_number
, initial
);
1507 test_compare(MEMCACHED_SUCCESS
,
1508 memcached_decrement_with_initial_by_key(memc
,
1509 test_literal_param("foo"),
1510 test_literal_param("number"),
1511 1, initial
, 0, &new_number
));
1512 test_compare(new_number
, (initial
- 1));
1514 return TEST_SUCCESS
;
1517 static test_return_t
quit_test(memcached_st
*memc
)
1519 memcached_return_t rc
;
1520 const char *key
= "fudge";
1521 const char *value
= "sanford and sun";
1523 rc
= memcached_set(memc
, key
, strlen(key
),
1524 value
, strlen(value
),
1525 (time_t)10, (uint32_t)3);
1526 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1527 memcached_quit(memc
);
1529 rc
= memcached_set(memc
, key
, strlen(key
),
1530 value
, strlen(value
),
1531 (time_t)50, (uint32_t)9);
1532 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1534 return TEST_SUCCESS
;
1537 static test_return_t
mget_result_test(memcached_st
*memc
)
1539 const char *keys
[]= {"fudge", "son", "food"};
1540 size_t key_length
[]= {5, 3, 4};
1542 memcached_result_st results_obj
;
1543 memcached_result_st
*results
;
1545 results
= memcached_result_create(memc
, &results_obj
);
1547 test_true(&results_obj
== results
);
1549 /* We need to empty the server before continueing test */
1550 test_compare(MEMCACHED_SUCCESS
,
1551 memcached_flush(memc
, 0));
1553 test_compare(MEMCACHED_SUCCESS
,
1554 memcached_mget(memc
, keys
, key_length
, 3));
1556 memcached_return_t rc
;
1557 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1562 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1563 test_false(results
);
1564 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1566 for (uint32_t x
= 0; x
< 3; x
++)
1568 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1569 keys
[x
], key_length
[x
],
1570 (time_t)50, (uint32_t)9);
1571 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1574 test_compare(MEMCACHED_SUCCESS
,
1575 memcached_mget(memc
, keys
, key_length
, 3));
1577 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1580 test_true(&results_obj
== results
);
1581 test_compare(MEMCACHED_SUCCESS
, rc
);
1582 test_memcmp(memcached_result_key_value(results
),
1583 memcached_result_value(results
),
1584 memcached_result_length(results
));
1585 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1588 memcached_result_free(&results_obj
);
1590 return TEST_SUCCESS
;
1593 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1595 const char *keys
[]= {"fudge", "son", "food"};
1596 size_t key_length
[]= {5, 3, 4};
1598 memcached_result_st
*results
;
1600 /* We need to empty the server before continueing test */
1601 test_compare(MEMCACHED_SUCCESS
,
1602 memcached_flush(memc
, 0));
1604 test_compare(MEMCACHED_SUCCESS
,
1605 memcached_mget(memc
, keys
, key_length
, 3));
1607 memcached_return_t rc
;
1608 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1612 test_false(results
);
1613 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1615 for (uint32_t x
= 0; x
< 3; x
++)
1617 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1618 keys
[x
], key_length
[x
],
1619 (time_t)50, (uint32_t)9);
1620 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1623 test_compare(MEMCACHED_SUCCESS
,
1624 memcached_mget(memc
, keys
, key_length
, 3));
1627 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1630 test_compare(MEMCACHED_SUCCESS
, rc
);
1631 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1632 test_memcmp(memcached_result_key_value(results
),
1633 memcached_result_value(results
),
1634 memcached_result_length(results
));
1635 memcached_result_free(results
);
1639 return TEST_SUCCESS
;
1642 /* Count the results */
1643 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1645 size_t *counter
= (size_t *)context
;
1647 *counter
= *counter
+ 1;
1649 return MEMCACHED_SUCCESS
;
1652 static test_return_t
mget_result_function(memcached_st
*memc
)
1654 const char *keys
[]= {"fudge", "son", "food"};
1655 size_t key_length
[]= {5, 3, 4};
1657 memcached_execute_fn callbacks
[1];
1659 /* We need to empty the server before continueing test */
1660 test_compare(MEMCACHED_SUCCESS
,
1661 memcached_flush(memc
, 0));
1662 for (uint32_t x
= 0; x
< 3; x
++)
1664 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1665 keys
[x
], key_length
[x
],
1666 (time_t)50, (uint32_t)9);
1667 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1670 test_compare(MEMCACHED_SUCCESS
,
1671 memcached_mget(memc
, keys
, key_length
, 3));
1673 callbacks
[0]= &callback_counter
;
1676 memcached_return_t rc
;
1677 test_compare_got(MEMCACHED_SUCCESS
,
1678 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1),
1679 memcached_strerror(NULL
, rc
));
1681 test_compare(counter
, 3);
1683 return TEST_SUCCESS
;
1686 static test_return_t
mget_test(memcached_st
*memc
)
1688 const char *keys
[]= {"fudge", "son", "food"};
1689 size_t key_length
[]= {5, 3, 4};
1691 char return_key
[MEMCACHED_MAX_KEY
];
1692 size_t return_key_length
;
1694 size_t return_value_length
;
1696 /* We need to empty the server before continueing test */
1697 test_compare(MEMCACHED_SUCCESS
,
1698 memcached_flush(memc
, 0));
1700 test_compare(MEMCACHED_SUCCESS
,
1701 memcached_mget(memc
, keys
, key_length
, 3));
1704 memcached_return_t rc
;
1705 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1706 &return_value_length
, &flags
, &rc
)))
1708 test_true(return_value
);
1710 test_false(return_value
);
1711 test_compare(0, return_value_length
);
1712 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1714 for (uint32_t x
= 0; x
< 3; x
++)
1716 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1717 keys
[x
], key_length
[x
],
1718 (time_t)50, (uint32_t)9);
1719 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1721 test_compare(MEMCACHED_SUCCESS
,
1722 memcached_mget(memc
, keys
, key_length
, 3));
1725 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1726 &return_value_length
, &flags
, &rc
)))
1728 test_true(return_value
);
1729 test_compare(MEMCACHED_SUCCESS
, rc
);
1730 if (not memc
->prefix_key
)
1732 test_compare(return_key_length
, return_value_length
);
1733 test_memcmp(return_value
, return_key
, return_value_length
);
1739 return TEST_SUCCESS
;
1742 static test_return_t
mget_execute(memcached_st
*memc
)
1746 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1750 * I only want to hit _one_ server so I know the number of requests I'm
1751 * sending in the pipeline.
1753 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1754 memc
->number_of_hosts
= 1;
1756 size_t max_keys
= 20480;
1759 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1760 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1762 /* First add all of the items.. */
1763 char blob
[1024] = {0};
1764 memcached_return_t rc
;
1766 for (size_t x
= 0; x
< max_keys
; ++x
)
1770 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1772 test_true(keys
[x
] != NULL
);
1773 uint64_t query_id
= memcached_query_id(memc
);
1774 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1775 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1776 test_compare(query_id
+1, memcached_query_id(memc
));
1779 /* Try to get all of them with a large multiget */
1781 memcached_execute_fn callbacks
[]= { &callback_counter
};
1782 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1783 max_keys
, callbacks
, &counter
, 1);
1785 if (memcached_success(rc
))
1788 uint64_t query_id
= memcached_query_id(memc
);
1789 test_compare(MEMCACHED_SUCCESS
,
1790 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1791 test_compare(query_id
, memcached_query_id(memc
));
1793 /* Verify that we got all of the items */
1794 test_true(counter
== max_keys
);
1796 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1798 test_true(counter
== 0);
1802 test_fail("note: this test functions differently when in binary mode");
1805 /* Release all allocated resources */
1806 for (size_t x
= 0; x
< max_keys
; ++x
)
1813 memc
->number_of_hosts
= number_of_hosts
;
1814 return TEST_SUCCESS
;
1817 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1819 static test_return_t
key_setup(memcached_st
*memc
)
1821 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1823 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1825 return TEST_SUCCESS
;
1828 static test_return_t
key_teardown(memcached_st
*memc
)
1831 pairs_free(global_pairs
);
1833 return TEST_SUCCESS
;
1836 static test_return_t
block_add_regression(memcached_st
*memc
)
1838 /* First add all of the items.. */
1839 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1841 memcached_return_t rc
;
1842 char blob
[1024] = {0};
1844 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1845 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1848 return TEST_SUCCESS
;
1851 static test_return_t
binary_add_regression(memcached_st
*memc
)
1853 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1854 test_return_t rc
= block_add_regression(memc
);
1855 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1859 static test_return_t
get_stats_keys(memcached_st
*memc
)
1863 memcached_stat_st memc_stat
;
1864 memcached_return_t rc
;
1866 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1867 test_compare(MEMCACHED_SUCCESS
, rc
);
1868 for (ptr
= stat_list
; *ptr
; ptr
++)
1873 return TEST_SUCCESS
;
1876 static test_return_t
version_string_test(memcached_st
*memc
)
1878 const char *version_string
;
1881 version_string
= memcached_lib_version();
1883 test_strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
);
1885 return TEST_SUCCESS
;
1888 static test_return_t
get_stats(memcached_st
*memc
)
1890 memcached_return_t rc
;
1892 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1893 test_compare(MEMCACHED_SUCCESS
, rc
);
1894 test_true(memc_stat
);
1896 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1898 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1899 test_compare(MEMCACHED_SUCCESS
, rc
);
1900 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1905 memcached_stat_free(NULL
, memc_stat
);
1907 return TEST_SUCCESS
;
1910 static test_return_t
add_host_test(memcached_st
*memc
)
1913 memcached_server_st
*servers
;
1914 memcached_return_t rc
;
1915 char servername
[]= "0.example.com";
1917 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1919 test_true(1 == memcached_server_list_count(servers
));
1921 for (x
= 2; x
< 20; x
++)
1923 char buffer
[SMALL_STRING_LEN
];
1925 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1926 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1928 test_compare(MEMCACHED_SUCCESS
, rc
);
1929 test_true(x
== memcached_server_list_count(servers
));
1932 rc
= memcached_server_push(memc
, servers
);
1933 test_compare(MEMCACHED_SUCCESS
, rc
);
1934 rc
= memcached_server_push(memc
, servers
);
1935 test_compare(MEMCACHED_SUCCESS
, rc
);
1937 memcached_server_list_free(servers
);
1939 return TEST_SUCCESS
;
1942 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1944 memcached_return_t rc
;
1945 const char *key
= "not_found";
1946 size_t key_len
= strlen(key
);
1948 test_compare(MEMCACHED_SUCCESS
,
1949 memcached_mget(memc
, &key
, &key_len
, 1));
1951 memcached_result_st
*result
= NULL
;
1952 result
= memcached_fetch_result(memc
, result
, &rc
);
1954 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1956 memcached_result_free(result
);
1958 return TEST_SUCCESS
;
1961 static memcached_return_t
clone_test_callback(memcached_st
*parent
, memcached_st
*memc_clone
)
1963 (void)parent
;(void)memc_clone
;
1964 return MEMCACHED_SUCCESS
;
1967 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
)
1970 return MEMCACHED_SUCCESS
;
1973 static test_return_t
callback_test(memcached_st
*memc
)
1975 /* Test User Data */
1979 memcached_return_t rc
;
1981 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1982 test_compare(MEMCACHED_SUCCESS
, rc
);
1983 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1984 test_true(*test_ptr
== x
);
1987 /* Test Clone Callback */
1989 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1990 void *clone_cb_ptr
= *(void **)&clone_cb
;
1991 void *temp_function
= NULL
;
1992 memcached_return_t rc
;
1994 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1996 test_compare(MEMCACHED_SUCCESS
, rc
);
1997 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1998 test_true(temp_function
== clone_cb_ptr
);
2001 /* Test Cleanup Callback */
2003 memcached_cleanup_fn cleanup_cb
=
2004 (memcached_cleanup_fn
)cleanup_test_callback
;
2005 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2006 void *temp_function
= NULL
;
2007 memcached_return_t rc
;
2009 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2011 test_compare(MEMCACHED_SUCCESS
, rc
);
2012 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2013 test_true(temp_function
== cleanup_cb_ptr
);
2016 return TEST_SUCCESS
;
2019 /* We don't test the behavior itself, we test the switches */
2020 static test_return_t
behavior_test(memcached_st
*memc
)
2025 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2026 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2027 test_true(value
== 1);
2029 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2030 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2031 test_true(value
== 1);
2033 set
= MEMCACHED_HASH_MD5
;
2034 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2035 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2036 test_true(value
== MEMCACHED_HASH_MD5
);
2040 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2041 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2042 test_true(value
== 0);
2044 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2045 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2046 test_true(value
== 0);
2048 set
= MEMCACHED_HASH_DEFAULT
;
2049 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2050 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2051 test_true(value
== MEMCACHED_HASH_DEFAULT
);
2053 set
= MEMCACHED_HASH_CRC
;
2054 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2055 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2056 test_true(value
== MEMCACHED_HASH_CRC
);
2058 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2059 test_true(value
> 0);
2061 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2062 test_true(value
> 0);
2064 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2065 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
2066 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2068 return TEST_SUCCESS
;
2071 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2073 memcached_return_t rc
;
2076 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
2077 test_true(rc
== MEMCACHED_DEPRECATED
);
2079 // Platform dependent
2081 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2085 return TEST_SUCCESS
;
2089 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2091 memcached_return_t rc
;
2095 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, set
);
2096 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2098 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2100 if (rc
== MEMCACHED_SUCCESS
)
2102 test_true((bool)value
== set
);
2106 test_false((bool)value
== set
);
2109 return TEST_SUCCESS
;
2113 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2115 memcached_return_t rc
;
2119 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, set
);
2120 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2122 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2124 if (rc
== MEMCACHED_SUCCESS
)
2126 test_true((bool)value
== set
);
2130 test_false((bool)value
== set
);
2133 return TEST_SUCCESS
;
2136 static test_return_t
fetch_all_results(memcached_st
*memc
, size_t &keys_returned
, const memcached_return_t expect
)
2138 memcached_return_t rc
;
2139 char return_key
[MEMCACHED_MAX_KEY
];
2140 size_t return_key_length
;
2142 size_t return_value_length
;
2146 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2147 &return_value_length
, &flags
, &rc
)))
2149 test_true(return_value
);
2150 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2155 if (memcached_success(expect
) and memcached_success(rc
))
2157 return TEST_SUCCESS
;
2159 else if (expect
== rc
)
2161 return TEST_SUCCESS
;
2163 fprintf(stderr
, "\n%s:%u %s(#%lu)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), (unsigned long)(keys_returned
));
2165 return TEST_FAILURE
;
2168 /* Test case provided by Cal Haldenbrand */
2169 #define HALDENBRAND_KEY_COUNT 3000 // * 1024576
2170 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2171 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2173 /* We just keep looking at the same values over and over */
2176 unsigned int setter
= 1;
2177 test_compare(MEMCACHED_SUCCESS
,
2178 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2179 test_compare(MEMCACHED_SUCCESS
,
2180 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2184 unsigned long long total
= 0;
2185 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2187 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2188 char randomstuff
[6 * 1024];
2189 memset(randomstuff
, 0, 6 * 1024);
2190 test_true(size
< 6 * 1024); /* Being safe here */
2192 for (uint32_t j
= 0 ; j
< size
;j
++)
2194 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2199 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2200 memcached_return_t rc
;
2201 test_compare_got(MEMCACHED_SUCCESS
,
2202 rc
= memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
),
2203 memcached_strerror(NULL
, rc
));
2205 test_true(total
> HALDENBRAND_KEY_COUNT
);
2207 return TEST_SUCCESS
;
2210 /* Test case provided by Cal Haldenbrand */
2211 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2213 unsigned int setter
= 1;
2215 test_compare(MEMCACHED_SUCCESS
,
2216 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2218 test_compare(MEMCACHED_SUCCESS
,
2219 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2222 setter
= 20 * 1024576;
2223 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2224 setter
= 20 * 1024576;
2225 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2226 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2227 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2229 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2232 size_t total_value_length
= 0;
2233 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2238 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2239 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2241 memcached_return_t rc
;
2242 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2243 if (memcached_failed(rc
))
2245 if (rc
== MEMCACHED_NOTFOUND
)
2256 test_compare(HALDENBRAND_FLAG_KEY
, flags
);
2258 total_value_length
+= val_len
;
2263 return TEST_SUCCESS
;
2266 /* Do a large mget() over all the keys we think exist */
2267 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2269 unsigned int setter
= 1;
2270 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2271 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2273 setter
= 20 * 1024576;
2274 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2275 setter
= 20 * 1024576;
2276 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2277 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2278 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2281 size_t key_lengths
[HALDENBRAND_KEY_COUNT
];
2282 char **keys
= static_cast<char **>(calloc(HALDENBRAND_KEY_COUNT
, sizeof(char *)));
2284 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2286 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2287 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2288 keys
[x
]= strdup(key
);
2290 key_lengths
[x
]= key_length
;
2291 test_compare(size_t(key_length
), strlen(keys
[x
]));
2294 test_compare(MEMCACHED_SUCCESS
,
2295 memcached_mget(memc
, (const char **)keys
, key_lengths
, HALDENBRAND_KEY_COUNT
));
2298 size_t keys_returned
;
2299 test_compare_got(TEST_SUCCESS
, foo
= fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
), test_strerror(foo
));
2300 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2302 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2308 return TEST_SUCCESS
;
2311 /* Make sure we behave properly if server list has no values */
2312 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2314 const char *keys
[]= {"fudge", "son", "food"};
2315 size_t key_length
[]= {5, 3, 4};
2317 /* Here we free everything before running a bunch of mget tests */
2318 memcached_servers_reset(memc
);
2321 /* We need to empty the server before continueing test */
2322 test_compare(MEMCACHED_NO_SERVERS
,
2323 memcached_flush(memc
, 0));
2325 test_compare(MEMCACHED_NO_SERVERS
,
2326 memcached_mget(memc
, keys
, key_length
, 3));
2328 size_t keys_returned
;
2329 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2330 test_compare(0, keys_returned
);
2332 for (uint32_t x
= 0; x
< 3; x
++)
2334 test_compare(MEMCACHED_NO_SERVERS
,
2335 memcached_set(memc
, keys
[x
], key_length
[x
],
2336 keys
[x
], key_length
[x
],
2337 (time_t)50, (uint32_t)9));
2340 test_compare(MEMCACHED_NO_SERVERS
,
2341 memcached_mget(memc
, keys
, key_length
, 3));
2345 char return_key
[MEMCACHED_MAX_KEY
];
2346 memcached_return_t rc
;
2347 size_t return_key_length
;
2348 size_t return_value_length
;
2351 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2352 &return_value_length
, &flags
, &rc
)))
2354 test_true(return_value
);
2355 test_compare(MEMCACHED_SUCCESS
, rc
);
2356 test_true(return_key_length
== return_value_length
);
2357 test_memcmp(return_value
, return_key
, return_value_length
);
2363 return TEST_SUCCESS
;
2366 #define VALUE_SIZE_BUG5 1048064
2367 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2369 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2370 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2372 size_t value_length
;
2374 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2376 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2378 insert_data
[x
]= (signed char)rand();
2381 test_compare(MEMCACHED_SUCCESS
,
2382 memcached_flush(memc
, 0));
2384 memcached_return_t rc
;
2385 value
= memcached_get(memc
, keys
[0], key_length
[0],
2386 &value_length
, &flags
, &rc
);
2388 test_compare(MEMCACHED_SUCCESS
,
2389 memcached_mget(memc
, keys
, key_length
, 4));
2392 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2393 test_compare(0, count
);
2395 for (uint32_t x
= 0; x
< 4; x
++)
2397 test_compare(MEMCACHED_SUCCESS
,
2398 memcached_set(memc
, keys
[x
], key_length
[x
],
2399 insert_data
, VALUE_SIZE_BUG5
,
2400 (time_t)0, (uint32_t)0));
2403 for (uint32_t x
= 0; x
< 10; x
++)
2405 value
= memcached_get(memc
, keys
[0], key_length
[0],
2406 &value_length
, &flags
, &rc
);
2407 test_compare(rc
, MEMCACHED_SUCCESS
);
2411 test_compare(MEMCACHED_SUCCESS
,
2412 memcached_mget(memc
, keys
, key_length
, 4));
2414 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2415 test_compare(4, count
);
2417 delete [] insert_data
;
2419 return TEST_SUCCESS
;
2422 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2424 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2425 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2426 char return_key
[MEMCACHED_MAX_KEY
];
2427 size_t return_key_length
;
2429 size_t value_length
;
2431 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2433 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2435 insert_data
[x
]= (signed char)rand();
2438 test_compare(MEMCACHED_SUCCESS
,
2439 memcached_flush(memc
, 0));
2441 memcached_return_t rc
;
2442 value
= memcached_get(memc
, keys
[0], key_length
[0],
2443 &value_length
, &flags
, &rc
);
2445 test_compare(MEMCACHED_NOTFOUND
, rc
);
2447 test_compare(MEMCACHED_SUCCESS
,
2448 memcached_mget(memc
, keys
, key_length
, 4));
2451 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2452 &value_length
, &flags
, &rc
)))
2456 test_compare(0, count
);
2457 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2459 for (uint32_t x
= 0; x
< 4; x
++)
2461 test_compare(MEMCACHED_SUCCESS
,
2462 memcached_set(memc
, keys
[x
], key_length
[x
],
2463 insert_data
, VALUE_SIZE_BUG5
,
2464 (time_t)0, (uint32_t)0));
2467 for (uint32_t x
= 0; x
< 2; x
++)
2469 value
= memcached_get(memc
, keys
[0], key_length
[0],
2470 &value_length
, &flags
, &rc
);
2474 test_compare(MEMCACHED_SUCCESS
,
2475 memcached_mget(memc
, keys
, key_length
, 4));
2477 /* We test for purge of partial complete fetches */
2478 for (count
= 3; count
; count
--)
2480 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2481 &value_length
, &flags
, &rc
);
2482 test_compare(MEMCACHED_SUCCESS
, rc
);
2483 test_memcmp(value
, insert_data
, value_length
);
2484 test_true(value_length
);
2488 delete [] insert_data
;
2490 return TEST_SUCCESS
;
2493 static test_return_t
user_supplied_bug8(memcached_st
*)
2495 memcached_return_t rc
;
2497 memcached_st
*memc_clone
;
2499 memcached_server_st
*servers
;
2500 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";
2502 servers
= memcached_servers_parse(server_list
);
2505 mine
= memcached_create(NULL
);
2506 rc
= memcached_server_push(mine
, servers
);
2507 test_compare(MEMCACHED_SUCCESS
, rc
);
2508 memcached_server_list_free(servers
);
2511 memc_clone
= memcached_clone(NULL
, mine
);
2513 memcached_quit(mine
);
2514 memcached_quit(memc_clone
);
2517 memcached_free(mine
);
2518 memcached_free(memc_clone
);
2520 return TEST_SUCCESS
;
2523 /* Test flag store/retrieve */
2524 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2526 const char *keys
= "036790384900";
2527 size_t key_length
= strlen(keys
);
2528 char return_key
[MEMCACHED_MAX_KEY
];
2529 size_t return_key_length
;
2531 size_t value_length
;
2533 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2535 for (unsigned int x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2536 insert_data
[x
]= (signed char)rand();
2538 memcached_flush(memc
, 0);
2541 memcached_return_t rc
= memcached_set(memc
, keys
, key_length
,
2542 insert_data
, VALUE_SIZE_BUG5
,
2544 test_compare(MEMCACHED_SUCCESS
, rc
);
2547 value
= memcached_get(memc
, keys
, key_length
,
2548 &value_length
, &flags
, &rc
);
2549 test_true(flags
== 245);
2553 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2556 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2557 &value_length
, &flags
, &rc
);
2558 test_compare(245, flags
);
2561 delete [] insert_data
;
2564 return TEST_SUCCESS
;
2567 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2569 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2570 size_t key_length
[3];
2574 char return_key
[MEMCACHED_MAX_KEY
];
2575 size_t return_key_length
;
2577 size_t return_value_length
;
2580 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2581 key_length
[1]= strlen("fudge&*@#");
2582 key_length
[2]= strlen("for^#@&$not");
2585 for (unsigned int x
= 0; x
< 3; x
++)
2587 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2588 keys
[x
], key_length
[x
],
2589 (time_t)50, (uint32_t)9);
2590 test_compare(MEMCACHED_SUCCESS
, rc
);
2593 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2594 test_compare(MEMCACHED_SUCCESS
, rc
);
2596 /* We need to empty the server before continueing test */
2597 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2598 &return_value_length
, &flags
, &rc
)) != NULL
)
2600 test_true(return_value
);
2604 test_compare(3, count
);
2606 return TEST_SUCCESS
;
2609 /* We are testing with aggressive timeout to get failures */
2610 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2612 const char *key
= "foo";
2613 size_t value_length
= 512;
2615 unsigned int set
= 1;
2616 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2618 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2619 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2621 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, (uint64_t)timeout
);
2623 char *value
= (char*)malloc(value_length
* sizeof(char));
2625 for (unsigned int x
= 0; x
< value_length
; x
++)
2627 value
[x
]= (char) (x
% 127);
2630 for (unsigned int x
= 1; x
<= 100000; ++x
)
2632 memcached_return_t rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2634 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
,
2635 memcached_strerror(NULL
, rc
));
2637 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2644 memcached_free(mclone
);
2646 return TEST_SUCCESS
;
2650 We are looking failures in the async protocol
2652 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2654 const char *key
= "foo";
2655 size_t value_length
= 512;
2657 unsigned int set
= 1;
2658 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2660 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2661 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2662 int32_t timeout
= -1;
2663 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, (size_t)timeout
);
2665 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2667 test_true(timeout
== -1);
2669 char *value
= (char*)malloc(value_length
* sizeof(char));
2671 for (unsigned int x
= 0; x
< value_length
; x
++)
2673 value
[x
]= (char) (x
% 127);
2676 for (unsigned int x
= 1; x
<= 100000; ++x
)
2678 memcached_return_t rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2683 memcached_free(mclone
);
2685 return TEST_SUCCESS
;
2689 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2691 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2693 memcached_return_t rc
;
2695 size_t value_length
;
2697 uint64_t number_value
;
2699 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2700 &value_length
, &flags
, &rc
);
2701 test_true(value
== NULL
);
2702 test_compare(MEMCACHED_NOTFOUND
, rc
);
2704 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2707 test_true(value
== NULL
);
2708 /* The binary protocol will set the key if it doesn't exist */
2709 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2711 test_compare(MEMCACHED_SUCCESS
, rc
);
2715 test_compare(MEMCACHED_NOTFOUND
, rc
);
2718 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2720 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2721 &value_length
, &flags
, &rc
);
2723 test_compare(MEMCACHED_SUCCESS
, rc
);
2726 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2728 test_true(number_value
== 2);
2729 test_compare(MEMCACHED_SUCCESS
, rc
);
2731 return TEST_SUCCESS
;
2735 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2736 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2738 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2740 char key
[] = "key34567890";
2741 memcached_return_t rc
;
2742 size_t overflowSize
;
2744 char commandFirst
[]= "set key34567890 0 0 ";
2745 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2746 size_t commandLength
;
2749 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2751 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2753 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2755 char *overflow
= new (std::nothrow
) char[testSize
];
2756 test_true(overflow
);
2758 memset(overflow
, 'x', testSize
);
2759 rc
= memcached_set(memc
, key
, strlen(key
),
2760 overflow
, testSize
, 0, 0);
2761 test_compare(MEMCACHED_SUCCESS
, rc
);
2765 return TEST_SUCCESS
;
2770 Test values of many different sizes
2771 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2772 set key34567890 0 0 8169 \r\n
2773 is sent followed by buffer of size 8169, followed by 8169
2775 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2778 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2779 memcached_return_t rc
;
2780 const char *key
= "foo";
2782 size_t value_length
= 18000;
2784 size_t string_length
;
2787 size_t current_length
;
2789 value
= (char*)malloc(value_length
);
2792 for (x
= 0; x
< value_length
; x
++)
2793 value
[x
] = (char) (x
% 127);
2795 for (current_length
= 0; current_length
< value_length
; current_length
++)
2797 rc
= memcached_set(memc
, key
, strlen(key
),
2798 value
, current_length
,
2799 (time_t)0, (uint32_t)0);
2800 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2802 string
= memcached_get(memc
, key
, strlen(key
),
2803 &string_length
, &flags
, &rc
);
2805 test_compare(MEMCACHED_SUCCESS
, rc
);
2806 test_true(string_length
== current_length
);
2807 test_memcmp(string
, value
, string_length
);
2814 return TEST_SUCCESS
;
2818 Look for zero length value problems
2820 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2823 memcached_return_t rc
;
2824 const char *key
= "mykey";
2828 for (x
= 0; x
< 2; x
++)
2830 rc
= memcached_set(memc
, key
, strlen(key
),
2832 (time_t)0, (uint32_t)0);
2834 test_compare(MEMCACHED_SUCCESS
, rc
);
2836 char *value
= memcached_get(memc
, key
, strlen(key
),
2837 &length
, &flags
, &rc
);
2839 test_compare(MEMCACHED_SUCCESS
, rc
);
2844 value
= memcached_get(memc
, key
, strlen(key
),
2845 &length
, &flags
, &rc
);
2847 test_compare(MEMCACHED_SUCCESS
, rc
);
2848 test_true(value
== NULL
);
2849 test_true(length
== 0);
2850 test_true(flags
== 0);
2853 return TEST_SUCCESS
;
2856 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2857 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2859 memcached_return_t rc
;
2860 const char *key
= "mykey";
2865 rc
= memcached_set(memc
, key
, strlen(key
),
2867 (time_t)0, UINT32_MAX
);
2869 test_compare(MEMCACHED_SUCCESS
, rc
);
2871 value
= memcached_get(memc
, key
, strlen(key
),
2872 &length
, &flags
, &rc
);
2874 test_compare(MEMCACHED_SUCCESS
, rc
);
2875 test_true(value
== NULL
);
2876 test_true(length
== 0);
2877 test_true(flags
== UINT32_MAX
);
2879 return TEST_SUCCESS
;
2882 #if !defined(__sun) && !defined(__OpenBSD__)
2883 /* Check the validity of chinese key*/
2884 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2886 memcached_return_t rc
;
2887 const char *key
= "豆瓣";
2888 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2893 rc
= memcached_set(memc
, key
, strlen(key
),
2894 value
, strlen(value
),
2897 test_compare(MEMCACHED_SUCCESS
, rc
);
2899 value2
= memcached_get(memc
, key
, strlen(key
),
2900 &length
, &flags
, &rc
);
2902 test_true(length
==strlen(value
));
2903 test_compare(MEMCACHED_SUCCESS
, rc
);
2904 test_memcmp(value
, value2
, length
);
2907 return TEST_SUCCESS
;
2915 static test_return_t
user_supplied_bug19(memcached_st
*not_used
)
2918 const memcached_server_st
*server
;
2919 memcached_return_t res
;
2923 memc
= memcached_create(NULL
);
2924 memcached_server_add_with_weight(memc
, "localhost", 11311, 100);
2925 memcached_server_add_with_weight(memc
, "localhost", 11312, 100);
2927 server
= memcached_server_by_key(memc
, "a", 1, &res
);
2929 memcached_free(memc
);
2931 return TEST_SUCCESS
;
2934 /* CAS test from Andei */
2935 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2937 memcached_return_t status
;
2938 memcached_result_st
*result
, result_obj
;
2939 const char *key
= "abc";
2940 size_t key_len
= strlen("abc");
2941 const char *value
= "foobar";
2942 size_t value_len
= strlen(value
);
2944 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2946 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2947 test_true(status
== MEMCACHED_SUCCESS
);
2949 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2950 test_true(status
== MEMCACHED_SUCCESS
);
2952 result
= memcached_result_create(memc
, &result_obj
);
2955 memcached_result_create(memc
, &result_obj
);
2956 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2959 test_true(status
== MEMCACHED_SUCCESS
);
2961 memcached_result_free(result
);
2963 return TEST_SUCCESS
;
2966 #include "ketama_test_cases.h"
2967 static test_return_t
user_supplied_bug18(memcached_st
*trash
)
2969 memcached_return_t rc
;
2976 memc
= memcached_create(NULL
);
2979 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
2980 test_compare(MEMCACHED_SUCCESS
, rc
);
2982 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
2983 test_true(value
== 1);
2985 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
2986 test_compare(MEMCACHED_SUCCESS
, rc
);
2988 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
2989 test_true(value
== MEMCACHED_HASH_MD5
);
2991 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");
2992 memcached_server_push(memc
, server_pool
);
2994 /* verify that the server list was parsed okay. */
2995 test_true(memcached_server_count(memc
) == 8);
2996 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
2997 test_true(server_pool
[0].port
== 11211);
2998 test_true(server_pool
[0].weight
== 600);
2999 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
3000 test_true(server_pool
[2].port
== 11211);
3001 test_true(server_pool
[2].weight
== 200);
3002 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
3003 test_true(server_pool
[7].port
== 11211);
3004 test_true(server_pool
[7].weight
== 100);
3006 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
3007 * us test the boundary wraparound.
3009 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
3011 /* verify the standard ketama set. */
3012 for (x
= 0; x
< 99; x
++)
3014 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3016 memcached_server_instance_st instance
=
3017 memcached_server_instance_by_position(memc
, server_idx
);
3019 const char *hostname
= memcached_server_name(instance
);
3020 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
3023 memcached_server_list_free(server_pool
);
3024 memcached_free(memc
);
3026 return TEST_SUCCESS
;
3029 /* Large mget() of missing keys with binary proto
3031 * If many binary quiet commands (such as getq's in an mget) fill the output
3032 * buffer and the server chooses not to respond, memcached_flush hangs. See
3033 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
3036 /* sighandler_t function that always asserts false */
3037 static void fail(int)
3043 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
3048 return TEST_SKIPPED
;
3050 void (*oldalarm
)(int);
3052 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3053 test_true(memc_clone
);
3055 /* only binproto uses getq for mget */
3056 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3058 /* empty the cache to ensure misses (hence non-responses) */
3059 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
3061 size_t* key_lengths
= new (std::nothrow
) size_t[key_count
];
3062 test_true(key_lengths
);
3063 char **keys
= static_cast<char **>(calloc(key_count
, sizeof(char *)));
3065 for (unsigned int x
= 0; x
< key_count
; x
++)
3069 snprintf(buffer
, 30, "%u", x
);
3070 keys
[x
]= strdup(buffer
);
3072 key_lengths
[x
]= strlen(keys
[x
]);
3075 oldalarm
= signal(SIGALRM
, fail
);
3078 test_compare_got(MEMCACHED_SUCCESS
,
3079 memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
), memcached_last_error_message(memc_clone
));
3082 signal(SIGALRM
, oldalarm
);
3084 memcached_return_t rc
;
3086 char return_key
[MEMCACHED_MAX_KEY
];
3087 size_t return_key_length
;
3089 size_t return_value_length
;
3090 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
3091 &return_value_length
, &flags
, &rc
)))
3093 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
3095 test_compare(MEMCACHED_NOTFOUND
, rc
);
3096 test_compare(0, return_value_length
);
3097 test_compare(0, return_key_length
);
3098 test_false(return_key
[0]);
3099 test_false(return_value
);
3101 for (unsigned int x
= 0; x
< key_count
; x
++)
3106 delete [] key_lengths
;
3108 memcached_free(memc_clone
);
3110 return TEST_SUCCESS
;
3114 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3116 test_return_t test_rc
;
3117 test_rc
= pre_binary(memc
);
3119 if (test_rc
!= TEST_SUCCESS
)
3122 /* should work as of r580 */
3123 test_compare(TEST_SUCCESS
,
3124 _user_supplied_bug21(memc
, 10));
3126 /* should fail as of r580 */
3127 test_compare(TEST_SUCCESS
,
3128 _user_supplied_bug21(memc
, 1000));
3130 return TEST_SUCCESS
;
3133 static test_return_t
auto_eject_hosts(memcached_st
*trash
)
3136 memcached_server_instance_st instance
;
3138 memcached_return_t rc
;
3139 memcached_st
*memc
= memcached_create(NULL
);
3142 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3143 test_compare(MEMCACHED_SUCCESS
, rc
);
3145 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3146 test_true(value
== 1);
3148 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3149 test_compare(MEMCACHED_SUCCESS
, rc
);
3151 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3152 test_true(value
== MEMCACHED_HASH_MD5
);
3154 /* server should be removed when in delay */
3155 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
, 1);
3156 test_compare(MEMCACHED_SUCCESS
, rc
);
3158 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS
);
3159 test_true(value
== 1);
3161 memcached_server_st
*server_pool
;
3162 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");
3163 memcached_server_push(memc
, server_pool
);
3165 /* verify that the server list was parsed okay. */
3166 test_true(memcached_server_count(memc
) == 8);
3167 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
3168 test_true(server_pool
[0].port
== 11211);
3169 test_true(server_pool
[0].weight
== 600);
3170 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
3171 test_true(server_pool
[2].port
== 11211);
3172 test_true(server_pool
[2].weight
== 200);
3173 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
3174 test_true(server_pool
[7].port
== 11211);
3175 test_true(server_pool
[7].weight
== 100);
3177 instance
= memcached_server_instance_by_position(memc
, 2);
3178 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) + 15;
3179 memc
->ketama
.next_distribution_rebuild
= time(NULL
) - 1;
3182 This would not work if there were only two hosts.
3184 for (size_t x
= 0; x
< 99; x
++)
3186 memcached_autoeject(memc
);
3187 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3188 test_true(server_idx
!= 2);
3191 /* and re-added when it's back. */
3192 ((memcached_server_write_instance_st
)instance
)->next_retry
= time(NULL
) - 1;
3193 memc
->ketama
.next_distribution_rebuild
= time(NULL
) - 1;
3194 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
,
3195 memc
->distribution
);
3196 for (size_t x
= 0; x
< 99; x
++)
3198 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
3199 // We re-use instance from above.
3201 memcached_server_instance_by_position(memc
, server_idx
);
3202 const char *hostname
= memcached_server_name(instance
);
3203 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
3206 memcached_server_list_free(server_pool
);
3207 memcached_free(memc
);
3209 return TEST_SUCCESS
;
3212 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
3216 memcached_return_t rc
;
3217 memcached_st
*memc
= memcached_create(NULL
);
3221 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3222 test_compare(MEMCACHED_SUCCESS
, rc
);
3224 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3225 test_true(value
== 1);
3227 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3228 test_compare(MEMCACHED_SUCCESS
, rc
);
3230 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3231 test_true(value
== MEMCACHED_HASH_MD5
);
3234 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3236 memcached_server_st
*server_pool
;
3237 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");
3238 memcached_server_push(memc
, server_pool
);
3240 // @todo this needs to be refactored to actually test something.
3243 if ((fp
= fopen("ketama_keys.txt", "w")))
3247 printf("cannot write to file ketama_keys.txt");
3248 return TEST_FAILURE
;
3251 for (int x
= 0; x
< 10000; x
++)
3254 snprintf(key
, sizeof(key
), "%d", x
);
3256 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3257 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3258 in_port_t port
= memc
->hosts
[server_idx
].port
;
3259 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3260 memcached_server_instance_st instance
=
3261 memcached_server_instance_by_position(memc
, host_index
);
3265 memcached_server_list_free(server_pool
);
3266 memcached_free(memc
);
3268 return TEST_SUCCESS
;
3272 static test_return_t
result_static(memcached_st
*memc
)
3274 memcached_result_st result
;
3275 memcached_result_st
*result_ptr
;
3277 result_ptr
= memcached_result_create(memc
, &result
);
3278 test_true(result
.options
.is_allocated
== false);
3279 test_true(memcached_is_initialized(&result
) == true);
3280 test_true(result_ptr
);
3281 test_true(result_ptr
== &result
);
3283 memcached_result_free(&result
);
3285 test_true(result
.options
.is_allocated
== false);
3286 test_true(memcached_is_initialized(&result
) == false);
3288 return TEST_SUCCESS
;
3291 static test_return_t
result_alloc(memcached_st
*memc
)
3293 memcached_result_st
*result_ptr
;
3295 result_ptr
= memcached_result_create(memc
, NULL
);
3296 test_true(result_ptr
);
3297 test_true(result_ptr
->options
.is_allocated
== true);
3298 test_true(memcached_is_initialized(result_ptr
) == true);
3299 memcached_result_free(result_ptr
);
3301 return TEST_SUCCESS
;
3304 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3307 pairs_free(global_pairs
);
3309 return TEST_SUCCESS
;
3312 static test_return_t
generate_pairs(memcached_st
*memc
)
3315 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3316 global_count
= GLOBAL_COUNT
;
3318 for (size_t x
= 0; x
< global_count
; x
++)
3320 global_keys
[x
]= global_pairs
[x
].key
;
3321 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3324 return TEST_SUCCESS
;
3327 static test_return_t
generate_large_pairs(memcached_st
*)
3329 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3330 global_count
= GLOBAL2_COUNT
;
3332 for (size_t x
= 0; x
< global_count
; x
++)
3334 global_keys
[x
]= global_pairs
[x
].key
;
3335 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3338 return TEST_SUCCESS
;
3341 static test_return_t
generate_data(memcached_st
*memc
)
3343 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3345 test_true(check_execute
== global_count
);
3347 return TEST_SUCCESS
;
3350 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3352 uint32_t host_index
= 0;
3353 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3355 test_true(check_execute
== global_count
);
3357 // @todo hosts used size stats
3358 memcached_return_t rc
;
3359 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3362 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3364 /* This test was changes so that "make test" would work properlly */
3366 memcached_server_instance_st instance
=
3367 memcached_server_instance_by_position(memc
, host_index
);
3369 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3371 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3374 memcached_stat_free(NULL
, stat_p
);
3376 return TEST_SUCCESS
;
3378 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3383 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3384 generate_data(memc
);
3386 return TEST_SUCCESS
;
3389 static test_return_t
get_read_count(memcached_st
*memc
)
3391 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3392 test_true(memc_clone
);
3394 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3398 size_t return_value_length
;
3402 for (size_t x
= count
= 0; x
< global_count
; x
++)
3404 memcached_return_t rc
;
3405 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3406 &return_value_length
, &flags
, &rc
);
3407 if (rc
== MEMCACHED_SUCCESS
)
3416 memcached_free(memc_clone
);
3418 return TEST_SUCCESS
;
3421 static test_return_t
get_read(memcached_st
*memc
)
3423 for (size_t x
= 0; x
< global_count
; x
++)
3425 size_t return_value_length
;
3427 memcached_return_t rc
;
3428 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3429 &return_value_length
, &flags
, &rc
);
3431 test_true(return_value);
3432 test_compare(MEMCACHED_SUCCESS, rc);
3434 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3438 return TEST_SUCCESS
;
3441 static test_return_t
mget_read(memcached_st
*memc
)
3444 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3446 memcached_return_t rc
;
3447 test_compare_got(MEMCACHED_SUCCESS
,
3448 rc
= memcached_mget(memc
, global_keys
, global_keys_length
, global_count
),
3449 memcached_strerror(NULL
, rc
));
3451 // Go fetch the keys and test to see if all of them were returned
3453 size_t keys_returned
;
3454 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3455 test_true(keys_returned
> 0);
3457 snprintf(buffer
, sizeof(buffer
), "%lu", (unsigned long)keys_returned
);
3458 test_compare_got(global_count
, keys_returned
, buffer
);
3461 return TEST_SUCCESS
;
3464 static test_return_t
mget_read_result(memcached_st
*memc
)
3467 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3469 test_compare(MEMCACHED_SUCCESS
,
3470 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3472 /* Turn this into a help function */
3474 memcached_result_st results_obj
;
3475 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3477 memcached_return_t rc
;
3478 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3481 test_compare(MEMCACHED_SUCCESS
, rc
);
3483 test_compare(MEMCACHED_END
, rc
);
3485 memcached_result_free(&results_obj
);
3488 return TEST_SUCCESS
;
3491 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3494 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3496 test_compare(MEMCACHED_SUCCESS
,
3497 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3499 memcached_result_st
*results
= NULL
;
3500 memcached_return_t rc
;
3501 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3504 test_compare(MEMCACHED_SUCCESS
, rc
);
3506 test_compare(MEMCACHED_END
, rc
);
3508 memcached_result_free(results
);
3511 return TEST_SUCCESS
;
3514 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3517 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3519 test_compare(MEMCACHED_SUCCESS
,
3520 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3522 // We will scan for just one key
3524 memcached_result_st results_obj
;
3525 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3527 memcached_return_t rc
;
3528 results
= memcached_fetch_result(memc
, results
, &rc
);
3530 test_compare(MEMCACHED_SUCCESS
, rc
);
3532 memcached_result_free(&results_obj
);
3535 // We already have a read happening, lets start up another one.
3536 test_compare(MEMCACHED_SUCCESS
,
3537 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3539 memcached_result_st results_obj
;
3540 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3542 memcached_return_t rc
;
3543 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3546 test_compare(MEMCACHED_SUCCESS
, rc
);
3548 test_compare(MEMCACHED_END
, rc
);
3550 memcached_result_free(&results_obj
);
3553 return TEST_SUCCESS
;
3556 static test_return_t
mget_read_function(memcached_st
*memc
)
3558 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3560 test_compare(MEMCACHED_SUCCESS
,
3561 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3563 memcached_execute_fn callbacks
[]= { &callback_counter
};
3565 test_compare(MEMCACHED_SUCCESS
,
3566 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3568 return TEST_SUCCESS
;
3571 static test_return_t
delete_generate(memcached_st
*memc
)
3573 for (size_t x
= 0; x
< global_count
; x
++)
3575 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3578 return TEST_SUCCESS
;
3581 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3584 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3586 for (size_t x
= 0; x
< global_count
; x
++)
3588 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3591 return TEST_SUCCESS
;
3594 static test_return_t
add_host_test1(memcached_st
*memc
)
3596 memcached_return_t rc
;
3597 char servername
[]= "0.example.com";
3599 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3601 test_compare(1, memcached_server_list_count(servers
));
3603 for (size_t x
= 2; x
< 20; x
++)
3605 char buffer
[SMALL_STRING_LEN
];
3607 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3608 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3610 test_compare(MEMCACHED_SUCCESS
, rc
);
3611 test_compare(x
, memcached_server_list_count(servers
));
3614 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3615 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3617 memcached_server_list_free(servers
);
3619 return TEST_SUCCESS
;
3622 static test_return_t
pre_nonblock(memcached_st
*memc
)
3624 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3626 return TEST_SUCCESS
;
3629 static test_return_t
pre_cork(memcached_st
*memc
)
3632 return TEST_SKIPPED
;
3635 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3636 return TEST_SUCCESS
;
3638 return TEST_SKIPPED
;
3641 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3644 return TEST_SKIPPED
;
3646 test_return_t test_rc
;
3647 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3650 return pre_nonblock(memc
);
3653 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3655 memcached_return_t rc
= MEMCACHED_FAILURE
;
3656 memcached_st
*memc_clone
;
3658 memc_clone
= memcached_clone(NULL
, memc
);
3659 test_true(memc_clone
);
3660 // The memcached_version needs to be done on a clone, because the server
3661 // will not toggle protocol on an connection.
3662 memcached_version(memc_clone
);
3664 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3666 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3667 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3668 test_compare(MEMCACHED_SUCCESS
, rc
);
3669 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3673 return TEST_SKIPPED
;
3676 memcached_free(memc_clone
);
3678 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3681 static test_return_t
pre_murmur(memcached_st
*memc
)
3683 #ifdef HAVE_MURMUR_HASH
3684 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3685 return TEST_SUCCESS
;
3688 return TEST_SKIPPED
;
3692 static test_return_t
pre_jenkins(memcached_st
*memc
)
3694 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3696 return TEST_SUCCESS
;
3700 static test_return_t
pre_md5(memcached_st
*memc
)
3702 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3704 return TEST_SUCCESS
;
3707 static test_return_t
pre_crc(memcached_st
*memc
)
3709 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3711 return TEST_SUCCESS
;
3714 static test_return_t
pre_hsieh(memcached_st
*memc
)
3716 #ifdef HAVE_HSIEH_HASH
3717 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3718 return TEST_SUCCESS
;
3721 return TEST_SKIPPED
;
3725 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3727 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3729 return TEST_SUCCESS
;
3732 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3734 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3736 return TEST_SUCCESS
;
3739 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3741 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3743 return TEST_SUCCESS
;
3746 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3748 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3750 return TEST_SUCCESS
;
3753 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3755 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3756 test_compare(MEMCACHED_SUCCESS
, rc
);
3758 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3759 test_true(value
== 1);
3761 return TEST_SUCCESS
;
3764 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3766 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3767 test_compare(MEMCACHED_SUCCESS
, rc
);
3769 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3770 test_true(value
== 1);
3772 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3773 test_compare(MEMCACHED_SUCCESS
, rc
);
3775 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3776 test_true(value
== MEMCACHED_HASH_MD5
);
3778 return TEST_SUCCESS
;
3782 @note This should be testing to see if the server really supports the binary protocol.
3784 static test_return_t
pre_binary(memcached_st
*memc
)
3786 memcached_return_t rc
= MEMCACHED_FAILURE
;
3788 if (libmemcached_util_version_check(memc
, 1, 4, 4))
3790 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3791 test_compare(MEMCACHED_SUCCESS
, rc
);
3792 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3795 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3798 static test_return_t
pre_sasl(memcached_st
*memc
)
3800 memcached_return_t rc
= MEMCACHED_FAILURE
;
3802 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
3803 const char *server
= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
3804 const char *user
= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
3805 const char *pass
= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
3807 if (server
and user
and pass
)
3809 memcached_server_st
*servers
= memcached_servers_parse(server
);
3811 memcached_servers_reset(memc
);
3812 test_true(memcached_server_push(memc
, servers
) == MEMCACHED_SUCCESS
);
3813 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3814 rc
= memcached_set_sasl_auth_data(memc
, user
, pass
);
3815 test_compare(MEMCACHED_SUCCESS
, rc
);
3821 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3824 static test_return_t
pre_replication(memcached_st
*memc
)
3826 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3829 * Make sure that we store the item on all servers
3830 * (master + replicas == number of servers)
3832 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
,
3833 memcached_server_count(memc
) - 1);
3834 test_compare(MEMCACHED_SUCCESS
, rc
);
3835 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
) == memcached_server_count(memc
) - 1);
3837 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3841 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3843 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3845 return pre_nonblock(memc
);
3849 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3853 #ifdef HARD_MALLOC_TESTS
3854 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3862 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3866 #ifdef HARD_MALLOC_TESTS
3867 void *ret
= malloc(size
+ 8);
3870 ret
= (void*)((caddr_t
)ret
+ 8);
3873 void *ret
= malloc(size
);
3878 memset(ret
, 0xff, size
);
3885 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3887 #ifdef HARD_MALLOC_TESTS
3888 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3889 void *nmem
= realloc(real_ptr
, size
+ 8);
3894 ret
= (void*)((caddr_t
)nmem
+ 8);
3900 return realloc(mem
, size
);
3905 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3907 #ifdef HARD_MALLOC_TESTS
3908 void *mem
= my_malloc(ptr
, nelem
* size
);
3911 memset(mem
, 0, nelem
* size
);
3917 return calloc(nelem
, size
);
3921 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3923 memcached_return_t rc
;
3924 const char *key
= "mine";
3927 /* Make sure be default none exists */
3928 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3929 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3931 /* Test a clean set */
3932 test_compare(MEMCACHED_SUCCESS
,
3933 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3935 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3937 test_memcmp(value
, key
, 4);
3938 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3940 /* Test that we can turn it off */
3941 test_compare(MEMCACHED_SUCCESS
,
3942 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3944 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3946 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3948 /* Now setup for main test */
3949 test_compare(MEMCACHED_SUCCESS
,
3950 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3952 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3954 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3955 test_memcmp(value
, key
, 4);
3957 /* Set to Zero, and then Set to something too large */
3960 memset(long_key
, 0, 255);
3962 test_compare(MEMCACHED_SUCCESS
,
3963 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3965 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3967 test_true(rc
== MEMCACHED_FAILURE
);
3968 test_true(value
== NULL
);
3970 /* Test a long key for failure */
3971 /* TODO, extend test to determine based on setting, what result should be */
3972 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3973 test_compare(MEMCACHED_SUCCESS
,
3974 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3976 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3977 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3978 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3979 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3981 /* Test for a bad prefix, but with a short key */
3982 test_compare_got(MEMCACHED_SUCCESS
,
3983 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1),
3984 memcached_strerror(NULL
, rc
));
3986 if (not memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
3988 strncpy(long_key
, "dog cat", sizeof(long_key
));
3989 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
3990 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3994 return TEST_SUCCESS
;
3997 static test_return_t
set_namespace(memcached_st
*memc
)
3999 memcached_return_t rc
;
4000 const char *key
= "mine";
4003 /* Make sure be default none exists */
4004 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
4005 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
4007 /* Test a clean set */
4008 test_compare(MEMCACHED_SUCCESS
,
4009 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
4011 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
4013 test_memcmp(value
, key
, 4);
4014 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
4016 return TEST_SUCCESS
;
4019 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
4021 test_return_if(pre_binary(memc
));
4022 test_return_if(set_namespace(memc
));
4024 return TEST_SUCCESS
;
4027 #ifdef MEMCACHED_ENABLE_DEPRECATED
4028 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
4030 void *test_ptr
= NULL
;
4033 memcached_malloc_fn malloc_cb
=
4034 (memcached_malloc_fn
)my_malloc
;
4035 cb_ptr
= *(void **)&malloc_cb
;
4036 memcached_return_t rc
;
4038 test_compare(MEMCACHED_SUCCESS
,
4039 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
4040 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
4041 test_compare(MEMCACHED_SUCCESS
, rc
);
4042 test_true(test_ptr
== cb_ptr
);
4046 memcached_realloc_fn realloc_cb
=
4047 (memcached_realloc_fn
)my_realloc
;
4048 cb_ptr
= *(void **)&realloc_cb
;
4049 memcached_return_t rc
;
4051 test_compare(MEMCACHED_SUCCESS
,
4052 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
4053 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
4054 test_compare(MEMCACHED_SUCCESS
, rc
);
4055 test_true(test_ptr
== cb_ptr
);
4059 memcached_free_fn free_cb
=
4060 (memcached_free_fn
)my_free
;
4061 cb_ptr
= *(void **)&free_cb
;
4062 memcached_return_t rc
;
4064 test_compare(MEMCACHED_SUCCESS
,
4065 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
4066 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
4067 test_compare(MEMCACHED_SUCCESS
, rc
);
4068 test_true(test_ptr
== cb_ptr
);
4071 return TEST_SUCCESS
;
4076 static test_return_t
set_memory_alloc(memcached_st
*memc
)
4078 test_compare(MEMCACHED_FAILURE
,
4079 memcached_set_memory_allocators(memc
, NULL
, my_free
,
4080 my_realloc
, my_calloc
, NULL
));
4082 test_compare(MEMCACHED_SUCCESS
,
4083 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
4084 my_realloc
, my_calloc
, NULL
));
4086 memcached_malloc_fn mem_malloc
;
4087 memcached_free_fn mem_free
;
4088 memcached_realloc_fn mem_realloc
;
4089 memcached_calloc_fn mem_calloc
;
4090 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
4091 &mem_realloc
, &mem_calloc
);
4093 test_true(mem_malloc
== my_malloc
);
4094 test_true(mem_realloc
== my_realloc
);
4095 test_true(mem_calloc
== my_calloc
);
4096 test_true(mem_free
== my_free
);
4098 return TEST_SUCCESS
;
4101 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
4104 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4105 memcached_hash_t hash
;
4106 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4107 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
4110 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4111 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4113 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4115 if (hash
!= MEMCACHED_HASH_CRC
)
4116 return TEST_SKIPPED
;
4118 return TEST_SUCCESS
;
4121 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
4124 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
4125 memcached_hash_t hash
;
4126 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
4127 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
4130 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
4131 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
4133 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
4135 if (hash
!= MEMCACHED_HASH_HSIEH
)
4136 return TEST_SKIPPED
;
4139 return TEST_SUCCESS
;
4142 static test_return_t
enable_cas(memcached_st
*memc
)
4144 unsigned int set
= 1;
4146 if (libmemcached_util_version_check(memc
, 1, 2, 4))
4148 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
4150 return TEST_SUCCESS
;
4153 return TEST_SKIPPED
;
4156 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
4158 memcached_version(memc
);
4160 memcached_server_instance_st instance
=
4161 memcached_server_instance_by_position(memc
, 0);
4163 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
4164 || instance
->minor_version
> 2)
4166 return TEST_SUCCESS
;
4169 return TEST_SKIPPED
;
4172 static test_return_t
pre_unix_socket(memcached_st
*memc
)
4174 memcached_return_t rc
;
4177 memcached_servers_reset(memc
);
4179 if (stat("/tmp/memcached.socket", &buf
))
4180 return TEST_SKIPPED
;
4182 rc
= memcached_server_add_unix_socket_with_weight(memc
, "/tmp/memcached.socket", 0);
4184 return ( rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_FAILURE
);
4187 static test_return_t
pre_nodelay(memcached_st
*memc
)
4189 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
4190 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
4192 return TEST_SUCCESS
;
4195 static test_return_t
pre_settimer(memcached_st
*memc
)
4197 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4198 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4200 return TEST_SUCCESS
;
4203 static test_return_t
poll_timeout(memcached_st
*memc
)
4205 size_t timeout
= 100; // Not using, just checking that it sets
4207 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4209 timeout
= (size_t)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
4211 test_compare(100, timeout
);
4213 return TEST_SUCCESS
;
4216 static test_return_t
noreply_test(memcached_st
*memc
)
4218 memcached_return_t ret
;
4219 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
4220 test_true(ret
== MEMCACHED_SUCCESS
);
4221 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4222 test_true(ret
== MEMCACHED_SUCCESS
);
4223 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
4224 test_true(ret
== MEMCACHED_SUCCESS
);
4225 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
4226 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
4227 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
4229 for (int count
=0; count
< 5; ++count
)
4231 for (size_t x
= 0; x
< 100; ++x
)
4234 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4235 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4237 size_t len
= (size_t)check_length
;
4242 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4245 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4248 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4251 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4254 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4260 test_true(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
4264 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4265 ** API and is _ONLY_ done this way to verify that the library works the
4266 ** way it is supposed to do!!!!
4269 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4271 memcached_server_instance_st instance
=
4272 memcached_server_instance_by_position(memc
, x
);
4273 no_msg
+=(int)(instance
->cursor_active
);
4276 test_true(no_msg
== 0);
4277 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4280 ** Now validate that all items was set properly!
4282 for (size_t x
= 0; x
< 100; ++x
)
4286 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4288 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4290 size_t len
= (size_t)check_length
;
4293 char* value
=memcached_get(memc
, key
, strlen(key
),
4294 &length
, &flags
, &ret
);
4295 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4298 case 0: /* FALLTHROUGH */
4299 case 1: /* FALLTHROUGH */
4301 test_true(strncmp(value
, key
, len
) == 0);
4302 test_true(len
== length
);
4305 test_true(length
== len
* 2);
4308 test_true(length
== len
* 3);
4318 /* Try setting an illegal cas value (should not return an error to
4319 * the caller (because we don't expect a return message from the server)
4321 const char* keys
[]= {"0"};
4322 size_t lengths
[]= {1};
4325 memcached_result_st results_obj
;
4326 memcached_result_st
*results
;
4327 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4328 test_true(ret
== MEMCACHED_SUCCESS
);
4330 results
= memcached_result_create(memc
, &results_obj
);
4332 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4334 test_true(ret
== MEMCACHED_SUCCESS
);
4335 uint64_t cas
= memcached_result_cas(results
);
4336 memcached_result_free(&results_obj
);
4338 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4339 test_true(ret
== MEMCACHED_SUCCESS
);
4342 * The item will have a new cas value, so try to set it again with the old
4343 * value. This should fail!
4345 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4346 test_true(ret
== MEMCACHED_SUCCESS
);
4347 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4348 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4349 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4352 return TEST_SUCCESS
;
4355 static test_return_t
analyzer_test(memcached_st
*memc
)
4357 memcached_return_t rc
;
4358 memcached_stat_st
*memc_stat
;
4359 memcached_analysis_st
*report
;
4361 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4362 test_compare(MEMCACHED_SUCCESS
, rc
);
4363 test_true(memc_stat
);
4365 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4366 test_compare(MEMCACHED_SUCCESS
, rc
);
4370 memcached_stat_free(NULL
, memc_stat
);
4372 return TEST_SUCCESS
;
4375 /* Count the objects */
4376 static memcached_return_t
callback_dump_counter(const memcached_st
*ptr
,
4381 (void)ptr
; (void)key
; (void)key_length
;
4382 size_t *counter
= (size_t *)context
;
4384 *counter
= *counter
+ 1;
4386 return MEMCACHED_SUCCESS
;
4389 static test_return_t
dump_test(memcached_st
*memc
)
4392 memcached_dump_fn callbacks
[1];
4394 callbacks
[0]= &callback_dump_counter
;
4396 /* No support for Binary protocol yet */
4397 test_skip(false, memc
->flags
.binary_protocol
);
4399 test_compare(TEST_SUCCESS
, set_test3(memc
));
4401 test_compare(MEMCACHED_SUCCESS
,
4402 memcached_dump(memc
, callbacks
, (void *)&counter
, 1));
4404 /* We may have more then 32 if our previous flush has not completed */
4405 test_true(counter
>= 32);
4407 return TEST_SUCCESS
;
4410 #ifdef HAVE_LIBMEMCACHEDUTIL
4412 struct test_pool_context_st
{
4413 memcached_pool_st
* pool
;
4417 static void* connection_release(void *arg
)
4419 test_pool_context_st
*resource
= static_cast<test_pool_context_st
*>(arg
);
4422 // Release all of the memc we are holding
4423 assert(memcached_success(memcached_pool_push(resource
->pool
, resource
->mmc
)));
4427 #define POOL_SIZE 10
4428 static test_return_t
connection_pool_test(memcached_st
*memc
)
4430 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4431 test_true(pool
!= NULL
);
4432 memcached_st
*mmc
[POOL_SIZE
];
4433 memcached_return_t rc
;
4435 // Fill up our array that we will store the memc that are in the pool
4436 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4438 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4439 test_true(mmc
[x
] != NULL
);
4440 test_compare(MEMCACHED_SUCCESS
, rc
);
4443 // All memc should be gone
4444 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4445 test_compare(MEMCACHED_SUCCESS
, rc
);
4448 test_pool_context_st item
= { pool
, mmc
[9] };
4450 pthread_create(&tid
, NULL
, connection_release
, &item
);
4451 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4452 test_compare(MEMCACHED_SUCCESS
, rc
);
4453 pthread_join(tid
, NULL
);
4455 const char *key
= "key";
4456 size_t keylen
= strlen(key
);
4458 // verify that I can do ops with all connections
4459 test_compare(MEMCACHED_SUCCESS
,
4460 memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0));
4462 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4464 uint64_t number_value
;
4465 test_compare(MEMCACHED_SUCCESS
,
4466 memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
));
4467 test_compare(number_value
, (x
+1));
4471 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4473 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[x
]));
4477 /* verify that I can set behaviors on the pool when I don't have all
4478 * of the connections in the pool. It should however be enabled
4479 * when I push the item into the pool
4481 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4484 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4485 test_compare(MEMCACHED_SUCCESS
, rc
);
4487 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4490 test_compare(9999, memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4491 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[1]));
4492 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4494 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4495 test_compare(9999, memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4496 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4498 test_true(memcached_pool_destroy(pool
) == memc
);
4500 return TEST_SUCCESS
;
4503 static test_return_t
util_version_test(memcached_st
*memc
)
4505 bool if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4506 test_true(if_successful
);
4508 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4510 // We expect failure
4513 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4514 fprintf(stderr
, "\nDumping Server Information\n\n");
4515 memcached_server_fn callbacks
[1];
4517 callbacks
[0]= dump_server_information
;
4518 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4519 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4521 test_true(if_successful
== false);
4523 memcached_server_instance_st instance
=
4524 memcached_server_instance_by_position(memc
, 0);
4526 memcached_version(memc
);
4528 // We only use one binary when we test, so this should be just fine.
4529 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4530 test_true(if_successful
== true);
4532 if (instance
->micro_version
> 0)
4533 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4534 else if (instance
->minor_version
> 0)
4535 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4536 else if (instance
->major_version
> 0)
4537 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4539 test_true(if_successful
== true);
4541 if (instance
->micro_version
> 0)
4542 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4543 else if (instance
->minor_version
> 0)
4544 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4545 else if (instance
->major_version
> 0)
4546 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4548 test_true(if_successful
== false);
4550 return TEST_SUCCESS
;
4553 static test_return_t
ping_test(memcached_st
*memc
)
4555 memcached_return_t rc
;
4556 memcached_server_instance_st instance
=
4557 memcached_server_instance_by_position(memc
, 0);
4559 // Test both the version that returns a code, and the one that does not.
4560 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4561 memcached_server_port(instance
), NULL
));
4563 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4564 memcached_server_port(instance
), &rc
));
4566 test_compare(MEMCACHED_SUCCESS
, rc
);
4568 return TEST_SUCCESS
;
4574 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4578 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4579 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4580 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4581 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4582 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4583 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4584 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4585 #ifdef HAVE_HSIEH_HASH
4586 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4588 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4589 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4590 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4592 return TEST_SUCCESS
;
4596 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4598 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4599 #ifdef HAVE_HSIEH_HASH
4600 expected_rc
= MEMCACHED_SUCCESS
;
4602 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4603 (uint64_t)MEMCACHED_HASH_HSIEH
);
4604 test_true(rc
== expected_rc
);
4606 return TEST_SUCCESS
;
4609 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4611 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4612 #ifdef HAVE_MURMUR_HASH
4613 expected_rc
= MEMCACHED_SUCCESS
;
4615 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4616 (uint64_t)MEMCACHED_HASH_MURMUR
);
4617 test_true(rc
== expected_rc
);
4619 return TEST_SUCCESS
;
4622 static test_return_t
one_at_a_time_run (memcached_st
*memc
)
4628 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4632 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
);
4633 test_true(one_at_a_time_values
[x
] == hash_val
);
4636 return TEST_SUCCESS
;
4639 static test_return_t
md5_run (memcached_st
*memc
)
4645 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4649 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4650 test_true(md5_values
[x
] == hash_val
);
4653 return TEST_SUCCESS
;
4656 static test_return_t
crc_run (memcached_st
*memc
)
4662 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4666 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4667 test_true(crc_values
[x
] == hash_val
);
4670 return TEST_SUCCESS
;
4673 static test_return_t
fnv1_64_run (memcached_st
*memc
)
4679 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4683 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4684 test_true(fnv1_64_values
[x
] == hash_val
);
4687 return TEST_SUCCESS
;
4690 static test_return_t
fnv1a_64_run (memcached_st
*memc
)
4696 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4700 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4701 test_true(fnv1a_64_values
[x
] == hash_val
);
4704 return TEST_SUCCESS
;
4707 static test_return_t
fnv1_32_run (memcached_st
*memc
)
4713 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4717 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4718 test_true(fnv1_32_values
[x
] == hash_val
);
4721 return TEST_SUCCESS
;
4724 static test_return_t
fnv1a_32_run (memcached_st
*memc
)
4730 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4734 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4735 test_true(fnv1a_32_values
[x
] == hash_val
);
4738 return TEST_SUCCESS
;
4741 static test_return_t
hsieh_run (memcached_st
*memc
)
4747 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4751 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4752 test_true(hsieh_values
[x
] == hash_val
);
4755 return TEST_SUCCESS
;
4758 static test_return_t
murmur_run (memcached_st
*memc
)
4760 #ifdef WORDS_BIGENDIAN
4761 (void)murmur_values
;
4762 return TEST_SKIPPED
;
4768 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4772 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
4773 test_true(murmur_values
[x
] == hash_val
);
4776 return TEST_SUCCESS
;
4780 static test_return_t
jenkins_run (memcached_st
*memc
)
4786 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4790 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4791 test_true(jenkins_values
[x
] == hash_val
);
4794 return TEST_SUCCESS
;
4797 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *context
)
4800 return libhashkit_md5(string
, string_length
);
4803 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *context
)
4806 return libhashkit_crc32(string
, string_length
);
4809 static test_return_t
memcached_get_hashkit_test (memcached_st
*memc
)
4813 const hashkit_st
*kit
;
4815 hashkit_return_t hash_rc
;
4817 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};
4818 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};
4820 kit
= memcached_get_hashkit(memc
);
4822 hashkit_clone(&new_kit
, kit
);
4823 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
);
4824 test_true(hash_rc
== HASHKIT_SUCCESS
);
4826 memcached_set_hashkit(memc
, &new_kit
);
4829 Verify Setting the hash.
4831 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4835 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4836 test_true(md5_values
[x
] == hash_val
);
4841 Now check memcached_st.
4843 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4847 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4848 test_true(md5_hosts
[x
] == hash_val
);
4851 hash_rc
= hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
);
4852 test_true(hash_rc
== HASHKIT_SUCCESS
);
4854 memcached_set_hashkit(memc
, &new_kit
);
4857 Verify Setting the hash.
4859 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4863 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4864 test_true(crc_values
[x
] == hash_val
);
4867 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4871 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4872 test_true(crc_hosts
[x
] == hash_val
);
4875 return TEST_SUCCESS
;
4879 Test case adapted from John Gorman <johngorman2@gmail.com>
4881 We are testing the error condition when we connect to a server via memcached_get()
4882 but find that the server is not available.
4884 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*memc
)
4887 memcached_st
*tl_memc_h
;
4889 const char *key
= "MemcachedLives";
4892 memcached_return rc
;
4896 tl_memc_h
= memcached_create(NULL
);
4897 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4899 memcached_server_push(tl_memc_h
, servers
);
4900 memcached_server_list_free(servers
);
4902 // See if memcached is reachable.
4903 value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4906 test_compare(0, len
);
4907 test_true(memcached_failed(rc
));
4909 memcached_free(tl_memc_h
);
4911 return TEST_SUCCESS
;
4915 We connect to a server which exists, but search for a key that does not exist.
4917 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4919 const char *key
= "MemcachedKeyNotEXIST";
4922 memcached_return rc
;
4925 // See if memcached is reachable.
4926 value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4929 test_compare(0, len
);
4930 test_compare(MEMCACHED_NOTFOUND
, rc
);
4932 return TEST_SUCCESS
;
4936 Test case adapted from John Gorman <johngorman2@gmail.com>
4938 We are testing the error condition when we connect to a server via memcached_get_by_key()
4939 but find that the server is not available.
4941 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4944 memcached_st
*tl_memc_h
;
4945 memcached_server_st
*servers
;
4947 const char *key
= "MemcachedLives";
4950 memcached_return rc
;
4954 tl_memc_h
= memcached_create(NULL
);
4955 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4956 memcached_server_push(tl_memc_h
, servers
);
4957 memcached_server_list_free(servers
);
4959 // See if memcached is reachable.
4960 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4963 test_compare(0, len
);
4964 test_true(memcached_failed(rc
));
4966 memcached_free(tl_memc_h
);
4968 return TEST_SUCCESS
;
4972 We connect to a server which exists, but search for a key that does not exist.
4974 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4976 const char *key
= "MemcachedKeyNotEXIST";
4979 memcached_return rc
;
4982 // See if memcached is reachable.
4983 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4986 test_compare(0, len
);
4987 test_compare(MEMCACHED_NOTFOUND
, rc
);
4989 return TEST_SUCCESS
;
4993 static test_return_t
ketama_compatibility_libmemcached(memcached_st
*)
4995 memcached_st
*memc
= memcached_create(NULL
);
4998 test_compare(MEMCACHED_SUCCESS
,
4999 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1));
5002 test_compare(1, value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
5004 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
));
5005 test_compare(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA
, memcached_behavior_get_distribution(memc
));
5008 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");
5009 memcached_server_push(memc
, server_pool
);
5011 /* verify that the server list was parsed okay. */
5012 test_compare(8, memcached_server_count(memc
));
5013 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5014 test_compare(11211, server_pool
[0].port
);
5015 test_compare(600, server_pool
[0].weight
);
5016 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5017 test_compare(11211, server_pool
[2].port
);
5018 test_compare(200, server_pool
[2].weight
);
5019 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5020 test_compare(11211, server_pool
[7].port
);
5021 test_compare(100, server_pool
[7].weight
);
5023 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5024 * us test the boundary wraparound.
5026 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
5028 /* verify the standard ketama set. */
5029 for (uint32_t x
= 0; x
< 99; x
++)
5031 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases
[x
].key
, strlen(ketama_test_cases
[x
].key
));
5032 memcached_server_instance_st instance
=
5033 memcached_server_instance_by_position(memc
, server_idx
);
5034 const char *hostname
= memcached_server_name(instance
);
5036 test_strcmp(hostname
, ketama_test_cases
[x
].server
);
5039 memcached_server_list_free(server_pool
);
5040 memcached_free(memc
);
5042 return TEST_SUCCESS
;
5045 static test_return_t
ketama_compatibility_spymemcached(memcached_st
*)
5049 memcached_st
*memc
= memcached_create(NULL
);
5052 test_compare(MEMCACHED_SUCCESS
,
5053 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1));
5055 test_compare(1, value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
5057 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
));
5058 test_compare(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
, memcached_behavior_get_distribution(memc
));
5060 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");
5061 test_true(server_pool
);
5062 memcached_server_push(memc
, server_pool
);
5064 /* verify that the server list was parsed okay. */
5065 test_compare(8, memcached_server_count(memc
));
5066 test_strcmp(server_pool
[0].hostname
, "10.0.1.1");
5067 test_compare(11211, server_pool
[0].port
);
5068 test_compare(600, server_pool
[0].weight
);
5069 test_strcmp(server_pool
[2].hostname
, "10.0.1.3");
5070 test_compare(11211, server_pool
[2].port
);
5071 test_compare(200, server_pool
[2].weight
);
5072 test_strcmp(server_pool
[7].hostname
, "10.0.1.8");
5073 test_compare(11211, server_pool
[7].port
);
5074 test_compare(100, server_pool
[7].weight
);
5076 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5077 * us test the boundary wraparound.
5079 test_true(memcached_generate_hash(memc
, (char *)"VDEAAAAA", 8) == memc
->ketama
.continuum
[0].index
);
5081 /* verify the standard ketama set. */
5082 for (uint32_t x
= 0; x
< 99; x
++)
5084 uint32_t server_idx
= memcached_generate_hash(memc
, ketama_test_cases_spy
[x
].key
, strlen(ketama_test_cases_spy
[x
].key
));
5086 memcached_server_instance_st instance
=
5087 memcached_server_instance_by_position(memc
, server_idx
);
5089 const char *hostname
= memcached_server_name(instance
);
5091 test_strcmp(hostname
, ketama_test_cases_spy
[x
].server
);
5094 memcached_server_list_free(server_pool
);
5095 memcached_free(memc
);
5097 return TEST_SUCCESS
;
5100 static test_return_t
regression_bug_434484(memcached_st
*memc
)
5102 test_return_t test_rc
;
5103 test_rc
= pre_binary(memc
);
5105 if (test_rc
!= TEST_SUCCESS
)
5108 const char *key
= "regression_bug_434484";
5109 size_t keylen
= strlen(key
);
5111 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
5112 test_compare(MEMCACHED_NOTSTORED
, ret
);
5114 size_t size
= 2048 * 1024;
5115 char *data
= (char*)calloc(1, size
);
5117 test_compare(MEMCACHED_E2BIG
,
5118 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
5121 return TEST_SUCCESS
;
5124 static test_return_t
regression_bug_434843(memcached_st
*memc
)
5126 test_return_t test_rc
;
5127 test_rc
= pre_binary(memc
);
5129 if (test_rc
!= TEST_SUCCESS
)
5132 memcached_return_t rc
;
5134 memcached_execute_fn callbacks
[]= { &callback_counter
};
5137 * I only want to hit only _one_ server so I know the number of requests I'm
5138 * sending in the pipleine to the server. Let's try to do a multiget of
5139 * 1024 (that should satisfy most users don't you think?). Future versions
5140 * will include a mget_execute function call if you need a higher number.
5142 uint32_t number_of_hosts
= memcached_server_count(memc
);
5143 memc
->number_of_hosts
= 1;
5144 const size_t max_keys
= 1024;
5145 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
5146 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5148 for (size_t x
= 0; x
< max_keys
; ++x
)
5152 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5158 * Run two times.. the first time we should have 100% cache miss,
5159 * and the second time we should have 100% cache hits
5161 for (size_t y
= 0; y
< 2; y
++)
5163 test_compare(MEMCACHED_SUCCESS
,
5164 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
5166 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
5167 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5171 /* The first iteration should give me a 100% cache miss. verify that*/
5172 char blob
[1024]= { 0 };
5174 test_false(counter
);
5176 for (size_t x
= 0; x
< max_keys
; ++x
)
5178 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
5179 blob
, sizeof(blob
), 0, 0);
5180 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5185 /* Verify that we received all of the key/value pairs */
5186 test_compare(counter
, max_keys
);
5190 /* Release allocated resources */
5191 for (size_t x
= 0; x
< max_keys
; ++x
)
5198 memc
->number_of_hosts
= number_of_hosts
;
5200 return TEST_SUCCESS
;
5203 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5205 memcached_return_t rc
;
5206 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5207 test_compare(MEMCACHED_SUCCESS
, rc
);
5209 return regression_bug_434843(memc
);
5212 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5214 memcached_return_t rc
;
5215 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5216 test_compare(MEMCACHED_SUCCESS
, rc
);
5218 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5219 test_compare(MEMCACHED_SUCCESS
, rc
);
5220 test_true(bytes_str
);
5221 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
5223 test_compare(MEMCACHED_SUCCESS
, rc
);
5224 test_true(bytes_read_str
);
5226 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
5227 "bytes_written", &rc
);
5228 test_compare(MEMCACHED_SUCCESS
, rc
);
5229 test_true(bytes_written_str
);
5231 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
5232 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
5233 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
5235 test_true(bytes
!= bytes_read
);
5236 test_true(bytes
!= bytes_written
);
5238 /* Release allocated resources */
5240 free(bytes_read_str
);
5241 free(bytes_written_str
);
5242 memcached_stat_free(NULL
, memc_stat
);
5244 return TEST_SUCCESS
;
5248 * The test case isn't obvious so I should probably document why
5249 * it works the way it does. Bug 442914 was caused by a bug
5250 * in the logic in memcached_purge (it did not handle the case
5251 * where the number of bytes sent was equal to the watermark).
5252 * In this test case, create messages so that we hit that case
5253 * and then disable noreply mode and issue a new command to
5254 * verify that it isn't stuck. If we change the format for the
5255 * delete command or the watermarks, we need to update this
5258 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5260 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5261 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5263 uint32_t number_of_hosts
= memcached_server_count(memc
);
5264 memc
->number_of_hosts
= 1;
5269 for (uint32_t x
= 0; x
< 250; ++x
)
5271 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5272 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
5273 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5276 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5279 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
5280 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5282 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5283 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
5285 memc
->number_of_hosts
= number_of_hosts
;
5287 return TEST_SUCCESS
;
5290 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5292 memcached_server_instance_st instance_one
;
5293 memcached_server_instance_st instance_two
;
5295 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
5296 return TEST_SKIPPED
;
5298 test_compare(MEMCACHED_SUCCESS
,
5299 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
5301 const size_t max_keys
= 100;
5302 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
5303 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5305 for (size_t x
= 0; x
< max_keys
; ++x
)
5309 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5312 test_compare(MEMCACHED_SUCCESS
,
5313 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
5317 ** We are using the quiet commands to store the replicas, so we need
5318 ** to ensure that all of them are processed before we can continue.
5319 ** In the test we go directly from storing the object to trying to
5320 ** receive the object from all of the different servers, so we
5321 ** could end up in a race condition (the memcached server hasn't yet
5322 ** processed the quiet command from the replication set when it process
5323 ** the request from the other client (created by the clone)). As a
5324 ** workaround for that we call memcached_quit to send the quit command
5325 ** to the server and wait for the response ;-) If you use the test code
5326 ** as an example for your own code, please note that you shouldn't need
5329 memcached_quit(memc
);
5331 /* Verify that all messages are stored, and we didn't stuff too much
5334 test_compare(MEMCACHED_SUCCESS
,
5335 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5338 memcached_execute_fn callbacks
[]= { &callback_counter
};
5339 memcached_return_t rc
;
5340 test_compare_got(MEMCACHED_SUCCESS
,
5341 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1),
5342 memcached_strerror(NULL
, rc
));
5344 /* Verify that we received all of the key/value pairs */
5345 test_compare(counter
, max_keys
);
5347 memcached_quit(memc
);
5349 * Don't do the following in your code. I am abusing the internal details
5350 * within the library, and this is not a supported interface.
5351 * This is to verify correct behavior in the library. Fake that two servers
5354 instance_one
= memcached_server_instance_by_position(memc
, 0);
5355 instance_two
= memcached_server_instance_by_position(memc
, 2);
5356 in_port_t port0
= instance_one
->port
;
5357 in_port_t port2
= instance_two
->port
;
5359 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5360 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5362 test_compare(MEMCACHED_SUCCESS
,
5363 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5366 test_compare(MEMCACHED_SUCCESS
,
5367 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5368 test_compare(counter
, (unsigned int)max_keys
);
5370 /* restore the memc handle */
5371 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5372 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5374 memcached_quit(memc
);
5376 /* Remove half of the objects */
5377 for (size_t x
= 0; x
< max_keys
; ++x
)
5381 test_compare(MEMCACHED_SUCCESS
,
5382 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
5386 memcached_quit(memc
);
5387 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5388 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5390 /* now retry the command, this time we should have cache misses */
5391 test_compare(MEMCACHED_SUCCESS
,
5392 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5395 test_compare_got(MEMCACHED_SUCCESS
,
5396 rc
= memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1),
5397 memcached_strerror(NULL
, rc
));
5398 test_compare(counter
, (unsigned int)(max_keys
>> 1));
5400 /* Release allocated resources */
5401 for (size_t x
= 0; x
< max_keys
; ++x
)
5408 /* restore the memc handle */
5409 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5410 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5412 return TEST_SUCCESS
;
5415 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5417 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5418 test_true(memc_clone
);
5419 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5421 memcached_server_instance_st instance
=
5422 memcached_server_instance_by_position(memc_clone
, 0);
5424 if (instance
->major_version
> 1 ||
5425 (instance
->major_version
== 1 &&
5426 instance
->minor_version
> 2))
5428 /* Binary protocol doesn't support deferred delete */
5429 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5430 test_true(bin_clone
);
5431 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5432 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
5433 memcached_free(bin_clone
);
5435 memcached_quit(memc_clone
);
5437 /* If we know the server version, deferred delete should fail
5438 * with invalid arguments */
5439 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
5441 /* If we don't know the server version, we should get a protocol error */
5442 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5444 /* but there is a bug in some of the memcached servers (1.4) that treats
5445 * the counter as noreply so it doesn't send the proper error message
5447 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5449 /* And buffered mode should be disabled and we should get protocol error */
5450 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5451 rc
= memcached_delete(memc
, "foo", 3, 1);
5452 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5454 /* Same goes for noreply... */
5455 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5456 rc
= memcached_delete(memc
, "foo", 3, 1);
5457 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5459 /* but a normal request should go through (and be buffered) */
5460 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
5461 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
5463 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
5464 /* unbuffered noreply should be success */
5465 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
5466 /* unbuffered with reply should be not found... */
5467 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5468 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
5471 memcached_free(memc_clone
);
5472 return TEST_SUCCESS
;
5476 /* Test memcached_server_get_last_disconnect
5477 * For a working server set, shall be NULL
5478 * For a set of non existing server, shall not be NULL
5480 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5482 memcached_return_t rc
;
5483 memcached_server_instance_st disconnected_server
;
5485 /* With the working set of server */
5486 const char *key
= "marmotte";
5487 const char *value
= "milka";
5489 memcached_reset_last_disconnected_server(memc
);
5490 test_false(memc
->last_disconnected_server
);
5491 rc
= memcached_set(memc
, key
, strlen(key
),
5492 value
, strlen(value
),
5493 (time_t)0, (uint32_t)0);
5494 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5496 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5497 test_false(disconnected_server
);
5499 /* With a non existing server */
5501 memcached_server_st
*servers
;
5503 const char *server_list
= "localhost:9";
5505 servers
= memcached_servers_parse(server_list
);
5507 mine
= memcached_create(NULL
);
5508 rc
= memcached_server_push(mine
, servers
);
5509 test_compare(MEMCACHED_SUCCESS
, rc
);
5510 memcached_server_list_free(servers
);
5513 rc
= memcached_set(mine
, key
, strlen(key
),
5514 value
, strlen(value
),
5515 (time_t)0, (uint32_t)0);
5516 test_true(memcached_failed(rc
));
5518 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5519 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5520 test_compare(9, memcached_server_port(disconnected_server
));
5521 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5523 memcached_quit(mine
);
5524 memcached_free(mine
);
5526 return TEST_SUCCESS
;
5529 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5531 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5532 char buffer
[BUFSIZ
];
5534 memcached_return_t rc
;
5535 test_compare_got(MEMCACHED_SUCCESS
,
5536 rc
= libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)),
5537 memcached_strerror(NULL
, rc
));
5539 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5542 // We will just use the error strings as our keys
5543 uint32_t counter
= 100;
5546 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5548 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5549 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5550 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, ret
, memcached_last_error_message(memc
));
5552 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5553 test_true(disconnected_server
);
5554 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5555 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5559 memcached_reset_last_disconnected_server(memc
);
5564 memcached_free(memc
);
5566 return TEST_SUCCESS
;
5569 static test_return_t
test_verbosity(memcached_st
*memc
)
5571 memcached_verbosity(memc
, 3);
5573 return TEST_SUCCESS
;
5576 static test_return_t
test_server_failure(memcached_st
*memc
)
5578 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
5580 memcached_st
*local_memc
= memcached_create(NULL
);
5582 memcached_server_add(local_memc
, memcached_server_name(instance
), memcached_server_port(instance
));
5583 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 2);
5585 uint32_t server_count
= memcached_server_count(local_memc
);
5586 test_compare(1, server_count
);
5588 // Disable the server
5589 instance
= memcached_server_instance_by_position(local_memc
, 0);
5590 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 2;
5592 memcached_return_t rc
;
5593 test_compare_got(MEMCACHED_SERVER_MARKED_DEAD
,
5594 rc
= memcached_set(local_memc
, "foo", strlen("foo"), NULL
, 0, (time_t)0, (uint32_t)0),
5595 memcached_last_error_message(local_memc
));
5597 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5598 test_compare_got(MEMCACHED_SUCCESS
,
5599 rc
= memcached_set(local_memc
, "foo", strlen("foo"), NULL
, 0, (time_t)0, (uint32_t)0),
5600 memcached_strerror(NULL
, rc
));
5602 memcached_last_error_message(local_memc
));
5606 memcached_free(local_memc
);
5608 return TEST_SUCCESS
;
5611 static test_return_t
test_cull_servers(memcached_st
*memc
)
5613 uint32_t count
= memcached_server_count(memc
);
5615 // Do not do this in your code, it is not supported.
5616 memc
->servers
[1].options
.is_dead
= true;
5617 memc
->state
.is_time_for_rebuild
= true;
5619 uint32_t new_count
= memcached_server_count(memc
);
5620 test_compare(count
, new_count
);
5623 test_true(count
== new_count
+ 1 );
5626 return TEST_SUCCESS
;
5630 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5631 const char *key
, size_t key_length
,
5632 const char *value
, size_t value_length
,
5642 return MEMCACHED_SUCCESS
;
5645 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5647 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5648 test_compare(MEMCACHED_SUCCESS
, rc
);
5650 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5651 test_compare(MEMCACHED_SUCCESS
, rc
);
5653 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5654 test_compare(MEMCACHED_SUCCESS
, rc
);
5656 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5657 test_compare(MEMCACHED_SUCCESS
, rc
);
5659 return TEST_SUCCESS
;
5663 * This test ensures that the failure counter isn't incremented during
5664 * normal termination of the memcached instance.
5666 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5668 memcached_return_t rc
;
5669 memcached_server_instance_st instance
;
5671 /* Set value to force connection to the server */
5672 const char *key
= "marmotte";
5673 const char *value
= "milka";
5676 * Please note that I'm abusing the internal structures in libmemcached
5677 * in a non-portable way and you shouldn't be doing this. I'm only
5678 * doing this in order to verify that the library works the way it should
5680 uint32_t number_of_hosts
= memcached_server_count(memc
);
5681 memc
->number_of_hosts
= 1;
5683 /* Ensure that we are connected to the server by setting a value */
5684 rc
= memcached_set(memc
, key
, strlen(key
),
5685 value
, strlen(value
),
5686 (time_t)0, (uint32_t)0);
5687 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5690 instance
= memcached_server_instance_by_position(memc
, 0);
5691 /* The test is to see that the memcached_quit doesn't increase the
5692 * the server failure conter, so let's ensure that it is zero
5693 * before sending quit
5695 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5697 memcached_quit(memc
);
5699 /* Verify that it memcached_quit didn't increment the failure counter
5700 * Please note that this isn't bullet proof, because an error could
5703 test_compare(0, instance
->server_failure_counter
);
5705 /* restore the instance */
5706 memc
->number_of_hosts
= number_of_hosts
;
5708 return TEST_SUCCESS
;
5712 * This tests ensures expected disconnections (for some behavior changes
5713 * for instance) do not wrongly increase failure counter
5715 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5717 memcached_return rc
;
5719 memcached_st
*memc_clone
;
5720 memc_clone
= memcached_clone(NULL
, memc
);
5721 test_true(memc_clone
);
5723 /* Set value to force connection to the server */
5724 const char *key
= "marmotte";
5725 const char *value
= "milka";
5726 char *string
= NULL
;
5727 size_t string_length
;
5730 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5731 value
, strlen(value
),
5732 (time_t)0, (uint32_t)0);
5733 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5736 /* put failure limit to 1 */
5737 test_compare(MEMCACHED_SUCCESS
,
5738 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1));
5740 /* Put a retry timeout to effectively activate failure_limit effect */
5741 test_compare(MEMCACHED_SUCCESS
,
5742 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
5744 /* change behavior that triggers memcached_quit()*/
5745 test_compare(MEMCACHED_SUCCESS
,
5746 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5749 /* Check if we still are connected */
5750 string
= memcached_get(memc_clone
, key
, strlen(key
),
5751 &string_length
, &flags
, &rc
);
5753 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5756 memcached_free(memc_clone
);
5758 return TEST_SUCCESS
;
5765 * Test that ensures mget_execute does not end into recursive calls that finally fails
5767 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5769 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5770 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5771 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5772 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5773 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5776 return TEST_SKIPPED
; // My MAC can't handle this test
5780 * I only want to hit _one_ server so I know the number of requests I'm
5781 * sending in the pipeline.
5783 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5784 memc
->number_of_hosts
= 1;
5785 size_t max_keys
= 20480;
5788 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5789 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5791 /* First add all of the items.. */
5792 char blob
[1024]= { 0 };
5793 for (size_t x
= 0; x
< max_keys
; ++x
)
5796 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5799 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5800 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5805 /* Try to get all of them with a large multiget */
5807 memcached_execute_function callbacks
[]= { &callback_counter
};
5808 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5809 (size_t)max_keys
, callbacks
, &counter
, 1);
5810 test_compare(MEMCACHED_SUCCESS
, rc
);
5812 char* the_value
= NULL
;
5813 char the_key
[MEMCACHED_MAX_KEY
];
5814 size_t the_key_length
;
5815 size_t the_value_length
;
5819 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5821 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5827 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5830 test_compare(MEMCACHED_END
, rc
);
5832 /* Verify that we got all of the items */
5833 test_compare(counter
, max_keys
);
5836 /* Release all allocated resources */
5837 for (size_t x
= 0; x
< max_keys
; ++x
)
5844 memc
->number_of_hosts
= number_of_hosts
;
5846 return TEST_SUCCESS
;
5849 static test_return_t
regression_bug_583031(memcached_st
*)
5851 memcached_st
*memc
= memcached_create(NULL
);
5853 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5855 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5856 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5857 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5858 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5859 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5860 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5862 memcached_return_t rc
;
5866 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5868 test_compare(0, length
);
5870 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_strerror(memc
, rc
));
5872 memcached_free(memc
);
5874 return TEST_SUCCESS
;
5877 static test_return_t
regression_bug_581030(memcached_st
*)
5880 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5881 test_false(local_stat
);
5883 memcached_stat_free(NULL
, NULL
);
5886 return TEST_SUCCESS
;
5889 #define regression_bug_655423_COUNT 6000
5890 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5892 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5893 memc
= NULL
; // Just to make sure it is not used
5898 return TEST_SKIPPED
;
5901 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5902 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5903 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5904 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5906 memset(payload
, int('x'), sizeof(payload
));
5908 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5910 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5911 snprintf(key
, sizeof(key
), "%u", x
);
5913 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5916 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5918 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5919 snprintf(key
, sizeof(key
), "%u", x
);
5921 size_t value_length
;
5922 memcached_return_t rc
;
5923 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5925 if (rc
== MEMCACHED_NOTFOUND
)
5928 test_compare(0, value_length
);
5932 test_compare(MEMCACHED_SUCCESS
, rc
);
5934 test_compare(100, value_length
);
5938 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5939 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5940 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5942 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5943 snprintf(key
, sizeof(key
), "%u", x
);
5945 keys
[x
]= strdup(key
);
5947 key_length
[x
]= strlen(key
);
5948 test_true(key_length
[x
]);
5951 memcached_return_t rc
;
5952 test_compare_got(MEMCACHED_SUCCESS
,
5953 rc
= memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
),
5954 memcached_strerror(NULL
, rc
));
5957 memcached_result_st
*result
= NULL
;
5958 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5960 test_compare(100, memcached_result_length(result
));
5964 test_true(count
> 100); // If we don't get back atleast this, something is up
5966 /* Release all allocated resources */
5967 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5975 memcached_free(clone
);
5977 return TEST_SUCCESS
;
5981 * Test that ensures that buffered set to not trigger problems during io_flush
5983 #define regression_bug_490520_COUNT 200480
5984 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5986 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5987 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5988 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5989 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5990 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5992 memc
->number_of_hosts
= 1;
5994 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5995 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5997 /* First add all of the items.. */
5998 char blob
[3333] = {0};
5999 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
6002 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
6006 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
6007 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
6010 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
6017 return TEST_SUCCESS
;
6020 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
6022 fprintf(stderr
, "Iteration #%u: ", it
);
6024 if(error
== MEMCACHED_ERRNO
)
6026 fprintf(stderr
, "system error %d from %s: %s\n",
6027 errno
, what
, strerror(errno
));
6031 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
6032 memcached_strerror(mc
, error
));
6036 #define TEST_CONSTANT_CREATION 200
6038 static test_return_t
regression_bug_(memcached_st
*memc
)
6040 const char *remote_server
;
6043 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
6045 return TEST_SKIPPED
;
6048 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
6050 memcached_st
* mc
= memcached_create(NULL
);
6051 memcached_return rc
;
6053 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
6054 if (rc
!= MEMCACHED_SUCCESS
)
6056 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6059 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
6060 if (rc
!= MEMCACHED_SUCCESS
)
6062 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
6065 rc
= memcached_server_add(mc
, remote_server
, 0);
6066 if (rc
!= MEMCACHED_SUCCESS
)
6068 memcached_die(mc
, rc
, "memcached_server_add", x
);
6071 const char *set_key
= "akey";
6072 const size_t set_key_len
= strlen(set_key
);
6073 const char *set_value
= "a value";
6074 const size_t set_value_len
= strlen(set_value
);
6076 if (rc
== MEMCACHED_SUCCESS
)
6080 size_t get_value_len
;
6082 uint32_t get_value_flags
;
6084 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
6085 &get_value_flags
, &rc
);
6086 if (rc
!= MEMCACHED_SUCCESS
)
6088 memcached_die(mc
, rc
, "memcached_get", x
);
6094 (get_value_len
!= set_value_len
6095 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
6097 fprintf(stderr
, "Values don't match?\n");
6098 rc
= MEMCACHED_FAILURE
;
6104 rc
= memcached_set(mc
,
6105 set_key
, set_key_len
,
6106 set_value
, set_value_len
,
6110 if (rc
!= MEMCACHED_SUCCESS
)
6112 memcached_die(mc
, rc
, "memcached_set", x
);
6119 if (rc
!= MEMCACHED_SUCCESS
)
6125 return TEST_SUCCESS
;
6129 * Test that the sasl authentication works. We cannot use the default
6130 * pool of servers, because that would require that all servers we want
6131 * to test supports SASL authentication, and that they use the default
6134 static test_return_t
sasl_auth_test(memcached_st
*memc
)
6136 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
6137 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0));
6138 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
6139 test_compare(MEMCACHED_SUCCESS
, memcached_destroy_sasl_auth_data(memc
));
6140 test_compare(MEMCACHED_FAILURE
, memcached_destroy_sasl_auth_data(memc
));
6141 test_compare(MEMCACHED_FAILURE
, memcached_destroy_sasl_auth_data(NULL
));
6142 memcached_quit(memc
);
6144 test_compare(MEMCACHED_SUCCESS
,
6145 memcached_set_sasl_auth_data(memc
,
6146 getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
6147 getenv("LIBMEMCACHED_TEST_SASL_SERVER")));
6149 test_compare(MEMCACHED_AUTH_FAILURE
,
6150 memcached_set(memc
, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0));
6151 test_compare(MEMCACHED_SUCCESS
, memcached_destroy_sasl_auth_data(memc
));
6153 memcached_quit(memc
);
6154 return TEST_SUCCESS
;
6157 return TEST_FAILURE
;
6161 /* Clean the server before beginning testing */
6163 {"util_version", 1, (test_callback_fn
*)util_version_test
},
6164 {"flush", 0, (test_callback_fn
*)flush_test
},
6165 {"init", 0, (test_callback_fn
*)init_test
},
6166 {"allocation", 0, (test_callback_fn
*)allocation_test
},
6167 {"server_list_null_test", 0, (test_callback_fn
*)server_list_null_test
},
6168 {"server_unsort", 0, (test_callback_fn
*)server_unsort_test
},
6169 {"server_sort", 0, (test_callback_fn
*)server_sort_test
},
6170 {"server_sort2", 0, (test_callback_fn
*)server_sort2_test
},
6171 {"memcached_server_remove", 0, (test_callback_fn
*)memcached_server_remove_test
},
6172 {"clone_test", 0, (test_callback_fn
*)clone_test
},
6173 {"connection_test", 0, (test_callback_fn
*)connection_test
},
6174 {"callback_test", 0, (test_callback_fn
*)callback_test
},
6175 {"userdata_test", 0, (test_callback_fn
*)userdata_test
},
6176 {"error", 0, (test_callback_fn
*)error_test
},
6177 {"set", 0, (test_callback_fn
*)set_test
},
6178 {"set2", 0, (test_callback_fn
*)set_test2
},
6179 {"set3", 0, (test_callback_fn
*)set_test3
},
6180 {"dump", 1, (test_callback_fn
*)dump_test
},
6181 {"add", 1, (test_callback_fn
*)add_test
},
6182 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", 1, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
6183 {"replace", 1, (test_callback_fn
*)replace_test
},
6184 {"delete", 1, (test_callback_fn
*)delete_test
},
6185 {"get", 1, (test_callback_fn
*)get_test
},
6186 {"get2", 0, (test_callback_fn
*)get_test2
},
6187 {"get3", 0, (test_callback_fn
*)get_test3
},
6188 {"get4", 0, (test_callback_fn
*)get_test4
},
6189 {"partial mget", 0, (test_callback_fn
*)get_test5
},
6190 {"stats_servername", 0, (test_callback_fn
*)stats_servername_test
},
6191 {"increment", 0, (test_callback_fn
*)increment_test
},
6192 {"increment_with_initial", 1, (test_callback_fn
*)increment_with_initial_test
},
6193 {"decrement", 0, (test_callback_fn
*)decrement_test
},
6194 {"decrement_with_initial", 1, (test_callback_fn
*)decrement_with_initial_test
},
6195 {"increment_by_key", 0, (test_callback_fn
*)increment_by_key_test
},
6196 {"increment_with_initial_by_key", 1, (test_callback_fn
*)increment_with_initial_by_key_test
},
6197 {"decrement_by_key", 0, (test_callback_fn
*)decrement_by_key_test
},
6198 {"decrement_with_initial_by_key", 1, (test_callback_fn
*)decrement_with_initial_by_key_test
},
6199 {"quit", 0, (test_callback_fn
*)quit_test
},
6200 {"mget", 1, (test_callback_fn
*)mget_test
},
6201 {"mget_result", 1, (test_callback_fn
*)mget_result_test
},
6202 {"mget_result_alloc", 1, (test_callback_fn
*)mget_result_alloc_test
},
6203 {"mget_result_function", 1, (test_callback_fn
*)mget_result_function
},
6204 {"mget_execute", 1, (test_callback_fn
*)mget_execute
},
6205 {"mget_end", 0, (test_callback_fn
*)mget_end
},
6206 {"get_stats", 0, (test_callback_fn
*)get_stats
},
6207 {"add_host_test", 0, (test_callback_fn
*)add_host_test
},
6208 {"add_host_test_1", 0, (test_callback_fn
*)add_host_test1
},
6209 {"get_stats_keys", 0, (test_callback_fn
*)get_stats_keys
},
6210 {"version_string_test", 0, (test_callback_fn
*)version_string_test
},
6211 {"bad_key", 1, (test_callback_fn
*)bad_key_test
},
6212 {"memcached_server_cursor", 1, (test_callback_fn
*)memcached_server_cursor_test
},
6213 {"read_through", 1, (test_callback_fn
*)read_through
},
6214 {"delete_through", 1, (test_callback_fn
*)delete_through
},
6215 {"noreply", 1, (test_callback_fn
*)noreply_test
},
6216 {"analyzer", 1, (test_callback_fn
*)analyzer_test
},
6217 {"connectionpool", 1, (test_callback_fn
*)connection_pool_test
},
6218 {"memcached_pool_test", 1, (test_callback_fn
*)memcached_pool_test
},
6219 {"ping", 1, (test_callback_fn
*)ping_test
},
6220 {"test_get_last_disconnect", 1, (test_callback_fn
*)test_get_last_disconnect
},
6221 {"verbosity", 1, (test_callback_fn
*)test_verbosity
},
6222 {"test_server_failure", 1, (test_callback_fn
*)test_server_failure
},
6223 {"cull_servers", 1, (test_callback_fn
*)test_cull_servers
},
6224 {"memcached_stat_execute", 1, (test_callback_fn
*)memcached_stat_execute_test
},
6228 test_st behavior_tests
[] ={
6229 {"libmemcached_string_behavior()", 0, (test_callback_fn
*)libmemcached_string_behavior_test
},
6230 {"libmemcached_string_distribution()", 0, (test_callback_fn
*)libmemcached_string_distribution_test
},
6231 {"behavior_test", 0, (test_callback_fn
*)behavior_test
},
6232 {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
6233 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
6234 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
6238 test_st basic_tests
[] ={
6239 {"init", 1, (test_callback_fn
*)basic_init_test
},
6240 {"clone", 1, (test_callback_fn
*)basic_clone_test
},
6241 {"reset", 1, (test_callback_fn
*)basic_reset_stack_test
},
6242 {"reset heap", 1, (test_callback_fn
*)basic_reset_heap_test
},
6243 {"reset stack clone", 1, (test_callback_fn
*)basic_reset_stack_clone_test
},
6244 {"reset heap clone", 1, (test_callback_fn
*)basic_reset_heap_clone_test
},
6248 test_st regression_binary_vs_block
[] ={
6249 {"block add", 1, (test_callback_fn
*)block_add_regression
},
6250 {"binary add", 1, (test_callback_fn
*)binary_add_regression
},
6254 test_st async_tests
[] ={
6255 {"add", 1, (test_callback_fn
*)add_wrapper
},
6259 test_st string_tests
[] ={
6260 {"string static with null", 0, (test_callback_fn
*)string_static_null
},
6261 {"string alloc with null", 0, (test_callback_fn
*)string_alloc_null
},
6262 {"string alloc with 1K", 0, (test_callback_fn
*)string_alloc_with_size
},
6263 {"string alloc with malloc failure", 0, (test_callback_fn
*)string_alloc_with_size_toobig
},
6264 {"string append", 0, (test_callback_fn
*)string_alloc_append
},
6265 {"string append failure (too big)", 0, (test_callback_fn
*)string_alloc_append_toobig
},
6266 {"string_alloc_append_multiple", 0, (test_callback_fn
*)string_alloc_append_multiple
},
6267 {0, 0, (test_callback_fn
*)0}
6270 test_st memcached_server_get_last_disconnect_tests
[] ={
6271 {"memcached_server_get_last_disconnect()", 0, (test_callback_fn
*)test_multiple_get_last_disconnect
},
6272 {0, 0, (test_callback_fn
*)0}
6276 test_st result_tests
[] ={
6277 {"result static", 0, (test_callback_fn
*)result_static
},
6278 {"result alloc", 0, (test_callback_fn
*)result_alloc
},
6279 {0, 0, (test_callback_fn
*)0}
6282 test_st version_1_2_3
[] ={
6283 {"append", 0, (test_callback_fn
*)append_test
},
6284 {"prepend", 0, (test_callback_fn
*)prepend_test
},
6285 {"cas", 0, (test_callback_fn
*)cas_test
},
6286 {"cas2", 0, (test_callback_fn
*)cas2_test
},
6287 {"append_binary", 0, (test_callback_fn
*)append_binary_test
},
6288 {0, 0, (test_callback_fn
*)0}
6291 test_st haldenbrand_tests
[] ={
6292 {"memcached_set", 0, (test_callback_fn
*)user_supplied_bug1
},
6293 {"memcached_get()", 0, (test_callback_fn
*)user_supplied_bug2
},
6294 {"memcached_mget()", 0, (test_callback_fn
*)user_supplied_bug3
},
6295 {0, 0, (test_callback_fn
*)0}
6298 test_st user_tests
[] ={
6299 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
6300 {"user_supplied_bug5", 1, (test_callback_fn
*)user_supplied_bug5
},
6301 {"user_supplied_bug6", 1, (test_callback_fn
*)user_supplied_bug6
},
6302 {"user_supplied_bug7", 1, (test_callback_fn
*)user_supplied_bug7
},
6303 {"user_supplied_bug8", 1, (test_callback_fn
*)user_supplied_bug8
},
6304 {"user_supplied_bug9", 1, (test_callback_fn
*)user_supplied_bug9
},
6305 {"user_supplied_bug10", 1, (test_callback_fn
*)user_supplied_bug10
},
6306 {"user_supplied_bug11", 1, (test_callback_fn
*)user_supplied_bug11
},
6307 {"user_supplied_bug12", 1, (test_callback_fn
*)user_supplied_bug12
},
6308 {"user_supplied_bug13", 1, (test_callback_fn
*)user_supplied_bug13
},
6309 {"user_supplied_bug14", 1, (test_callback_fn
*)user_supplied_bug14
},
6310 {"user_supplied_bug15", 1, (test_callback_fn
*)user_supplied_bug15
},
6311 {"user_supplied_bug16", 1, (test_callback_fn
*)user_supplied_bug16
},
6312 #if !defined(__sun) && !defined(__OpenBSD__)
6314 ** It seems to be something weird with the character sets..
6315 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6316 ** guess I need to find out how this is supposed to work.. Perhaps I need
6317 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6318 ** so just disable the code for now...).
6320 {"user_supplied_bug17", 1, (test_callback_fn
*)user_supplied_bug17
},
6322 {"user_supplied_bug18", 1, (test_callback_fn
*)user_supplied_bug18
},
6323 {"user_supplied_bug19", 1, (test_callback_fn
*)user_supplied_bug19
},
6324 {"user_supplied_bug20", 1, (test_callback_fn
*)user_supplied_bug20
},
6325 {"user_supplied_bug21", 1, (test_callback_fn
*)user_supplied_bug21
},
6326 {"wrong_failure_counter_test", 1, (test_callback_fn
*)wrong_failure_counter_test
},
6327 {"wrong_failure_counter_two_test", 1, (test_callback_fn
*)wrong_failure_counter_two_test
},
6328 {0, 0, (test_callback_fn
*)0}
6331 test_st replication_tests
[]= {
6332 {"set", 1, (test_callback_fn
*)replication_set_test
},
6333 {"get", 0, (test_callback_fn
*)replication_get_test
},
6334 {"mget", 0, (test_callback_fn
*)replication_mget_test
},
6335 {"delete", 0, (test_callback_fn
*)replication_delete_test
},
6336 {"rand_mget", 0, (test_callback_fn
*)replication_randomize_mget_test
},
6337 {"fail", 0, (test_callback_fn
*)replication_randomize_mget_fail_test
},
6338 {0, 0, (test_callback_fn
*)0}
6342 * The following test suite is used to verify that we don't introduce
6343 * regression bugs. If you want more information about the bug / test,
6344 * you should look in the bug report at
6345 * http://bugs.launchpad.net/libmemcached
6347 test_st regression_tests
[]= {
6348 {"lp:434484", 1, (test_callback_fn
*)regression_bug_434484
},
6349 {"lp:434843", 1, (test_callback_fn
*)regression_bug_434843
},
6350 {"lp:434843-buffered", 1, (test_callback_fn
*)regression_bug_434843_buffered
},
6351 {"lp:421108", 1, (test_callback_fn
*)regression_bug_421108
},
6352 {"lp:442914", 1, (test_callback_fn
*)regression_bug_442914
},
6353 {"lp:447342", 1, (test_callback_fn
*)regression_bug_447342
},
6354 {"lp:463297", 1, (test_callback_fn
*)regression_bug_463297
},
6355 {"lp:490486", 1, (test_callback_fn
*)regression_bug_490486
},
6356 {"lp:583031", 1, (test_callback_fn
*)regression_bug_583031
},
6357 {"lp:?", 1, (test_callback_fn
*)regression_bug_
},
6358 {"lp:728286", 1, (test_callback_fn
*)regression_bug_728286
},
6359 {"lp:581030", 1, (test_callback_fn
*)regression_bug_581030
},
6360 {"lp:71231153 connect()", 1, (test_callback_fn
*)regression_bug_71231153_connect
},
6361 {"lp:71231153 poll()", 1, (test_callback_fn
*)regression_bug_71231153_poll
},
6362 {"lp:655423", 1, (test_callback_fn
*)regression_bug_655423
},
6363 {"lp:490520", 1, (test_callback_fn
*)regression_bug_490520
},
6364 {0, 0, (test_callback_fn
*)0}
6367 test_st sasl_auth_tests
[]= {
6368 {"sasl_auth", 1, (test_callback_fn
*)sasl_auth_test
},
6369 {0, 0, (test_callback_fn
*)0}
6372 test_st ketama_compatibility
[]= {
6373 {"libmemcached", 1, (test_callback_fn
*)ketama_compatibility_libmemcached
},
6374 {"spymemcached", 1, (test_callback_fn
*)ketama_compatibility_spymemcached
},
6375 {0, 0, (test_callback_fn
*)0}
6378 test_st generate_tests
[] ={
6379 {"generate_pairs", 1, (test_callback_fn
*)generate_pairs
},
6380 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6381 {"get_read", 0, (test_callback_fn
*)get_read
},
6382 {"delete_generate", 0, (test_callback_fn
*)delete_generate
},
6383 {"generate_buffer_data", 1, (test_callback_fn
*)generate_buffer_data
},
6384 {"delete_buffer", 0, (test_callback_fn
*)delete_buffer_generate
},
6385 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6386 {"mget_read", 0, (test_callback_fn
*)mget_read
},
6387 {"mget_read_result", 0, (test_callback_fn
*)mget_read_result
},
6388 {"memcached_fetch_result() use internal result", 0, (test_callback_fn
*)mget_read_internal_result
},
6389 {"memcached_fetch_result() partial read", 0, (test_callback_fn
*)mget_read_partial_result
},
6390 {"mget_read_function", 0, (test_callback_fn
*)mget_read_function
},
6391 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6392 {"generate_large_pairs", 1, (test_callback_fn
*)generate_large_pairs
},
6393 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6394 {"generate_buffer_data", 1, (test_callback_fn
*)generate_buffer_data
},
6395 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6396 {0, 0, (test_callback_fn
*)0}
6399 test_st consistent_tests
[] ={
6400 {"generate_pairs", 1, (test_callback_fn
*)generate_pairs
},
6401 {"generate_data", 1, (test_callback_fn
*)generate_data
},
6402 {"get_read", 0, (test_callback_fn
*)get_read_count
},
6403 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6404 {0, 0, (test_callback_fn
*)0}
6407 test_st consistent_weighted_tests
[] ={
6408 {"generate_pairs", 1, (test_callback_fn
*)generate_pairs
},
6409 {"generate_data", 1, (test_callback_fn
*)generate_data_with_stats
},
6410 {"get_read", 0, (test_callback_fn
*)get_read_count
},
6411 {"cleanup", 1, (test_callback_fn
*)cleanup_pairs
},
6412 {0, 0, (test_callback_fn
*)0}
6415 test_st hsieh_availability
[] ={
6416 {"hsieh_avaibility_test", 0, (test_callback_fn
*)hsieh_avaibility_test
},
6417 {0, 0, (test_callback_fn
*)0}
6420 test_st murmur_availability
[] ={
6421 {"murmur_avaibility_test", 0, (test_callback_fn
*)murmur_avaibility_test
},
6422 {0, 0, (test_callback_fn
*)0}
6426 test_st hash_sanity
[] ={
6427 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
6428 {0, 0, (test_callback_fn
*)0}
6432 test_st ketama_auto_eject_hosts
[] ={
6433 {"auto_eject_hosts", 1, (test_callback_fn
*)auto_eject_hosts
},
6434 {"output_ketama_weighted_keys", 1, (test_callback_fn
*)output_ketama_weighted_keys
},
6435 {0, 0, (test_callback_fn
*)0}
6438 test_st hash_tests
[] ={
6439 {"one_at_a_time_run", 0, (test_callback_fn
*)one_at_a_time_run
},
6440 {"md5", 0, (test_callback_fn
*)md5_run
},
6441 {"crc", 0, (test_callback_fn
*)crc_run
},
6442 {"fnv1_64", 0, (test_callback_fn
*)fnv1_64_run
},
6443 {"fnv1a_64", 0, (test_callback_fn
*)fnv1a_64_run
},
6444 {"fnv1_32", 0, (test_callback_fn
*)fnv1_32_run
},
6445 {"fnv1a_32", 0, (test_callback_fn
*)fnv1a_32_run
},
6446 {"hsieh", 0, (test_callback_fn
*)hsieh_run
},
6447 {"murmur", 0, (test_callback_fn
*)murmur_run
},
6448 {"jenkis", 0, (test_callback_fn
*)jenkins_run
},
6449 {"memcached_get_hashkit", 0, (test_callback_fn
*)memcached_get_hashkit_test
},
6450 {0, 0, (test_callback_fn
*)0}
6453 test_st error_conditions
[] ={
6454 {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
6455 {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
6456 {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
6457 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6458 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6459 {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
6460 {0, 0, (test_callback_fn
*)0}
6464 test_st parser_tests
[] ={
6465 {"behavior", 0, (test_callback_fn
*)behavior_parser_test
},
6466 {"boolean_options", 0, (test_callback_fn
*)parser_boolean_options_test
},
6467 {"configure_file", 0, (test_callback_fn
*)memcached_create_with_options_with_filename
},
6468 {"distribtions", 0, (test_callback_fn
*)parser_distribution_test
},
6469 {"hash", 0, (test_callback_fn
*)parser_hash_test
},
6470 {"libmemcached_check_configuration", 0, (test_callback_fn
*)libmemcached_check_configuration_test
},
6471 {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
6472 {"number_options", 0, (test_callback_fn
*)parser_number_options_test
},
6473 {"randomly generated options", 0, (test_callback_fn
*)random_statement_build_test
},
6474 {"prefix_key", 0, (test_callback_fn
*)parser_key_prefix_test
},
6475 {"server", 0, (test_callback_fn
*)server_test
},
6476 {"bad server strings", 0, (test_callback_fn
*)servers_bad_test
},
6477 {"server with weights", 0, (test_callback_fn
*)server_with_weight_test
},
6478 {"parsing servername, port, and weight", 0, (test_callback_fn
*)test_hostname_port_weight
},
6479 {0, 0, (test_callback_fn
*)0}
6482 test_st virtual_bucket_tests
[] ={
6483 {"basic", 0, (test_callback_fn
*)virtual_back_map
},
6484 {0, 0, (test_callback_fn
*)0}
6487 test_st namespace_tests
[] ={
6488 {"basic tests", 0, (test_callback_fn
*)selection_of_namespace_tests
},
6489 {"increment", 0, (test_callback_fn
*)memcached_increment_namespace
},
6490 {0, 0, (test_callback_fn
*)0}
6493 collection_st collection
[] ={
6495 {"hash_sanity", 0, 0, hash_sanity
},
6497 {"basic", 0, 0, basic_tests
},
6498 {"hsieh_availability", 0, 0, hsieh_availability
},
6499 {"murmur_availability", 0, 0, murmur_availability
},
6500 {"block", 0, 0, tests
},
6501 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
6502 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
6503 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6504 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
6505 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
6506 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
6507 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
6508 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
6509 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
6510 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
6511 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
6512 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
6513 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
6514 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6515 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
6516 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6517 {"poll_timeout", (test_callback_fn
*)poll_timeout
, 0, tests
},
6518 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
6519 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
6520 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
6521 #ifdef MEMCACHED_ENABLE_DEPRECATED
6522 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
6524 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
6525 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
6526 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
6527 {"specific namespace", 0, 0, namespace_tests
},
6528 {"sasl_auth", (test_callback_fn
*)pre_sasl
, 0, sasl_auth_tests
},
6529 {"sasl", (test_callback_fn
*)pre_sasl
, 0, tests
},
6530 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
6531 {"string", 0, 0, string_tests
},
6532 {"result", 0, 0, result_tests
},
6533 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
6534 {"async_binary", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
6535 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
6536 {"user", 0, 0, user_tests
},
6537 {"generate", 0, 0, generate_tests
},
6538 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
6539 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
6540 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
6541 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
6542 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
6543 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
6544 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
6546 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
6547 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
6548 {"consistent_not", 0, 0, consistent_tests
},
6549 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
6550 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6551 {"ketama_compat", 0, 0, ketama_compatibility
},
6552 {"test_hashes", 0, 0, hash_tests
},
6553 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6554 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6555 {"regression", 0, 0, regression_tests
},
6556 {"behaviors", 0, 0, behavior_tests
},
6557 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6558 {"error_conditions", 0, 0, error_conditions
},
6559 {"parser", 0, 0, parser_tests
},
6560 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6561 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6565 #include "tests/libmemcached_world.h"
6567 void get_world(Framework
*world
)
6569 world
->collections
= collection
;
6571 world
->_create
= (test_callback_create_fn
*)world_create
;
6572 world
->_destroy
= (test_callback_fn
*)world_destroy
;
6574 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6575 world
->item
._flush
= (test_callback_fn
*)world_flush
;
6576 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6577 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6578 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6580 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6581 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6583 world
->runner
= &defualt_libmemcached_runner
;