1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 #include <libtest/test.hpp>
45 #include <libmemcached-1.0/memcached.h>
46 #include <libmemcached/is.h>
47 #include <libmemcached/server_instance.h>
49 #include <libhashkit-1.0/hashkit.h>
55 #include <semaphore.h>
59 #include <sys/types.h>
64 #include <libtest/server.h>
66 #include "clients/generator.h"
67 #include "clients/execute.h"
69 #define SMALL_STRING_LEN 1024
71 #include <libtest/test.hpp>
73 #include "tests/basic.h"
74 #include "tests/debug.h"
75 #include "tests/deprecated.h"
76 #include "tests/error_conditions.h"
77 #include "tests/exist.h"
78 #include "tests/ketama.h"
79 #include "tests/namespace.h"
80 #include "tests/parser.h"
81 #include "tests/touch.h"
82 #include "tests/callbacks.h"
83 #include "tests/pool.h"
84 #include "tests/print.h"
85 #include "tests/replication.h"
86 #include "tests/server_add.h"
87 #include "tests/virtual_buckets.h"
89 using namespace libtest
;
91 #include <libmemcached/util.h>
93 #include "hash_results.h"
95 #define GLOBAL_COUNT 10000
96 #define GLOBAL2_COUNT 100
97 #define SERVERS_TO_CREATE 5
98 static uint32_t global_count
;
100 static pairs_st
*global_pairs
;
101 static const char *global_keys
[GLOBAL_COUNT
];
102 static size_t global_keys_length
[GLOBAL_COUNT
];
105 @note This should be testing to see if the server really supports the binary protocol.
107 static test_return_t
pre_binary(memcached_st
*memc
)
109 memcached_return_t rc
= MEMCACHED_FAILURE
;
111 if (libmemcached_util_version_check(memc
, 1, 4, 4))
113 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
114 test_compare(MEMCACHED_SUCCESS
, rc
);
115 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
118 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
122 static test_return_t
init_test(memcached_st
*not_used
)
127 (void)memcached_create(&memc
);
128 memcached_free(&memc
);
133 #define TEST_PORT_COUNT 7
134 in_port_t test_ports
[TEST_PORT_COUNT
];
136 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
137 const memcached_server_st
*server
,
141 size_t bigger
= *((size_t *)(context
));
143 assert(bigger
<= memcached_server_port(server
));
144 *((size_t *)(context
))= memcached_server_port(server
);
146 return MEMCACHED_SUCCESS
;
149 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
150 const memcached_server_st
*instance
,
154 FILE *stream
= (FILE *)context
;
157 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
158 memcached_server_name(instance
),
159 memcached_server_port(instance
),
160 instance
->major_version
,
161 instance
->minor_version
,
162 instance
->micro_version
);
164 return MEMCACHED_SUCCESS
;
167 static test_return_t
server_sort_test(memcached_st
*ptr
)
169 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
171 memcached_return_t rc
;
172 memcached_server_fn callbacks
[1];
173 memcached_st
*local_memc
;
176 local_memc
= memcached_create(NULL
);
177 test_true(local_memc
);
178 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
180 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
182 test_ports
[x
]= (in_port_t
)random() % 64000;
183 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
184 test_compare(memcached_server_count(local_memc
), x
+1);
186 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
188 test_compare(MEMCACHED_SUCCESS
, rc
);
191 callbacks
[0]= server_display_function
;
192 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
195 memcached_free(local_memc
);
200 static test_return_t
server_sort2_test(memcached_st
*ptr
)
202 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
203 memcached_server_fn callbacks
[1];
204 memcached_st
*local_memc
;
205 memcached_server_instance_st instance
;
208 local_memc
= memcached_create(NULL
);
209 test_true(local_memc
);
210 test_compare(MEMCACHED_SUCCESS
,
211 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
213 test_compare(MEMCACHED_SUCCESS
,
214 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
215 instance
= memcached_server_instance_by_position(local_memc
, 0);
216 test_compare(in_port_t(43043), memcached_server_port(instance
));
218 test_compare(MEMCACHED_SUCCESS
,
219 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
221 instance
= memcached_server_instance_by_position(local_memc
, 0);
222 test_compare(in_port_t(43042), memcached_server_port(instance
));
224 instance
= memcached_server_instance_by_position(local_memc
, 1);
225 test_compare(in_port_t(43043), memcached_server_port(instance
));
227 callbacks
[0]= server_display_function
;
228 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
231 memcached_free(local_memc
);
236 static test_return_t
memcached_server_remove_test(memcached_st
*)
238 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";
241 test_compare(MEMCACHED_SUCCESS
,
242 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
243 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
246 memcached_server_fn callbacks
[1];
247 callbacks
[0]= server_print_callback
;
248 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
250 memcached_free(memc
);
255 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
256 const memcached_server_st
*server
,
260 uint32_t x
= *((uint32_t *)(context
));
262 if (! (test_ports
[x
] == server
->port
))
264 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
265 return MEMCACHED_FAILURE
;
268 *((uint32_t *)(context
))= ++x
;
270 return MEMCACHED_SUCCESS
;
273 static test_return_t
server_unsort_test(memcached_st
*ptr
)
275 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
276 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
277 memcached_server_fn callbacks
[1];
278 memcached_st
*local_memc
;
281 local_memc
= memcached_create(NULL
);
282 test_true(local_memc
);
284 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
286 test_ports
[x
]= (in_port_t
)(random() % 64000);
287 test_compare(MEMCACHED_SUCCESS
,
288 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
289 test_compare(memcached_server_count(local_memc
), x
+1);
291 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
295 callbacks
[0]= server_display_unsort_function
;
296 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
298 /* Now we sort old data! */
299 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
300 callbacks
[0]= server_display_function
;
301 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
304 memcached_free(local_memc
);
309 static test_return_t
allocation_test(memcached_st
*not_used
)
313 memc
= memcached_create(NULL
);
315 memcached_free(memc
);
320 static test_return_t
clone_test(memcached_st
*memc
)
324 memcached_st
*memc_clone
;
325 memc_clone
= memcached_clone(NULL
, NULL
);
326 test_true(memc_clone
);
327 memcached_free(memc_clone
);
330 /* Can we init from null? */
332 memcached_st
*memc_clone
;
333 memc_clone
= memcached_clone(NULL
, memc
);
334 test_true(memc_clone
);
337 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
338 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
339 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
340 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
343 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
344 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
345 test_true(memc_clone
->distribution
== memc
->distribution
);
346 { // Test all of the flags
347 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
348 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
349 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
350 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
351 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
352 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
353 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
354 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
355 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
356 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
357 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
358 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
359 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
361 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
362 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
363 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
364 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
365 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
366 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
367 test_true(memc_clone
->on_clone
== memc
->on_clone
);
368 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
369 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
370 test_true(memc_clone
->recv_size
== memc
->recv_size
);
371 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
372 test_true(memc_clone
->send_size
== memc
->send_size
);
373 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
374 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
375 test_true(memc_clone
->user_data
== memc
->user_data
);
377 memcached_free(memc_clone
);
380 /* Can we init from struct? */
382 memcached_st declared_clone
;
383 memcached_st
*memc_clone
;
384 memset(&declared_clone
, 0 , sizeof(memcached_st
));
385 memc_clone
= memcached_clone(&declared_clone
, NULL
);
386 test_true(memc_clone
);
387 memcached_free(memc_clone
);
390 /* Can we init from struct? */
392 memcached_st declared_clone
;
393 memcached_st
*memc_clone
;
394 memset(&declared_clone
, 0 , sizeof(memcached_st
));
395 memc_clone
= memcached_clone(&declared_clone
, memc
);
396 test_true(memc_clone
);
397 memcached_free(memc_clone
);
403 static test_return_t
userdata_test(memcached_st
*memc
)
406 test_false(memcached_set_user_data(memc
, foo
));
407 test_true(memcached_get_user_data(memc
) == foo
);
408 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
413 static test_return_t
connection_test(memcached_st
*memc
)
415 test_compare(MEMCACHED_SUCCESS
,
416 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
421 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
423 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
425 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
427 test_compare(36, int(MEMCACHED_BEHAVIOR_MAX
));
432 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
434 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
436 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
438 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
443 static test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
445 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
446 982370485U, 1263635348U, 4242906218U, 3829656100U,
447 1891735253U, 334139633U, 2257084983U, 3088286104U,
448 13199785U, 2542027183U, 1097051614U, 199566778U,
449 2748246961U, 2465192557U, 1664094137U, 2405439045U,
450 1842224848U, 692413798U, 3479807801U, 919913813U,
451 4269430871U, 610793021U, 527273862U, 1437122909U,
452 2300930706U, 2943759320U, 674306647U, 2400528935U,
453 54481931U, 4186304426U, 1741088401U, 2979625118U,
454 4159057246U, 3425930182U, 2593724503U, 1868899624U,
455 1769812374U, 2302537950U, 1110330676U, 3365377466U,
456 1336171666U, 3021258493U, 2334992265U, 3861994737U,
459 // You have updated the memcache_error messages but not updated docs/tests.
460 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
463 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
464 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
465 MEMCACHED_HASH_JENKINS
);
466 if (values
[rc
] != hash_val
)
468 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
469 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
471 test_compare(values
[rc
], hash_val
);
473 test_compare(48, int(MEMCACHED_MAXIMUM_RETURN
));
478 static test_return_t
set_test(memcached_st
*memc
)
480 memcached_return_t rc
= memcached_set(memc
,
481 test_literal_param("foo"),
482 test_literal_param("when we sanitize"),
483 time_t(0), (uint32_t)0);
484 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
489 static test_return_t
append_test(memcached_st
*memc
)
491 memcached_return_t rc
;
492 const char *key
= "fig";
493 const char *in_value
= "we";
494 char *out_value
= NULL
;
498 rc
= memcached_flush(memc
, 0);
499 test_compare(MEMCACHED_SUCCESS
, rc
);
501 rc
= memcached_set(memc
, key
, strlen(key
),
502 in_value
, strlen(in_value
),
503 (time_t)0, (uint32_t)0);
504 test_compare(MEMCACHED_SUCCESS
, rc
);
506 rc
= memcached_append(memc
, key
, strlen(key
),
507 " the", strlen(" the"),
508 (time_t)0, (uint32_t)0);
509 test_compare(MEMCACHED_SUCCESS
, rc
);
511 rc
= memcached_append(memc
, key
, strlen(key
),
512 " people", strlen(" people"),
513 (time_t)0, (uint32_t)0);
514 test_compare(MEMCACHED_SUCCESS
, rc
);
516 out_value
= memcached_get(memc
, key
, strlen(key
),
517 &value_length
, &flags
, &rc
);
518 test_memcmp(out_value
, "we the people", strlen("we the people"));
519 test_compare(strlen("we the people"), value_length
);
520 test_compare(MEMCACHED_SUCCESS
, rc
);
526 static test_return_t
append_binary_test(memcached_st
*memc
)
528 memcached_return_t rc
;
529 const char *key
= "numbers";
530 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
536 rc
= memcached_flush(memc
, 0);
537 test_compare(MEMCACHED_SUCCESS
, rc
);
539 rc
= memcached_set(memc
,
542 (time_t)0, (uint32_t)0);
543 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
545 for (x
= 0; store_list
[x
] ; x
++)
547 rc
= memcached_append(memc
,
549 (char *)&store_list
[x
], sizeof(uint32_t),
550 (time_t)0, (uint32_t)0);
551 test_compare(MEMCACHED_SUCCESS
, rc
);
554 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
555 &value_length
, &flags
, &rc
);
556 test_compare(value_length
, sizeof(uint32_t) * x
);
557 test_compare(MEMCACHED_SUCCESS
, rc
);
559 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
561 test_compare(*ptr
, store_list
[x
- counter
]);
569 static test_return_t
cas2_test(memcached_st
*memc
)
571 memcached_return_t rc
;
572 const char *keys
[]= {"fudge", "son", "food"};
573 size_t key_length
[]= {5, 3, 4};
574 const char *value
= "we the people";
575 size_t value_length
= strlen("we the people");
576 memcached_result_st results_obj
;
577 memcached_result_st
*results
;
580 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
582 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
584 for (uint32_t x
= 0; x
< 3; x
++)
586 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
587 keys
[x
], key_length
[x
],
588 (time_t)50, (uint32_t)9);
589 test_compare(MEMCACHED_SUCCESS
, rc
);
592 test_compare(MEMCACHED_SUCCESS
,
593 memcached_mget(memc
, keys
, key_length
, 3));
595 results
= memcached_result_create(memc
, &results_obj
);
598 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
600 test_true(results
->item_cas
);
601 test_compare(MEMCACHED_SUCCESS
, rc
);
602 test_true(memcached_result_cas(results
));
604 test_memcmp(value
, "we the people", strlen("we the people"));
605 test_compare(strlen("we the people"), value_length
);
606 test_compare(MEMCACHED_SUCCESS
, rc
);
608 memcached_result_free(&results_obj
);
613 static test_return_t
cas_test(memcached_st
*memc
)
615 memcached_return_t rc
;
616 const char *key
= "fun";
617 size_t key_length
= strlen(key
);
618 const char *value
= "we the people";
619 const char* keys
[2] = { key
, NULL
};
620 size_t keylengths
[2] = { strlen(key
), 0 };
621 size_t value_length
= strlen(value
);
622 const char *value2
= "change the value";
623 size_t value2_length
= strlen(value2
);
625 memcached_result_st results_obj
;
626 memcached_result_st
*results
;
629 rc
= memcached_flush(memc
, 0);
630 test_compare(MEMCACHED_SUCCESS
, rc
);
632 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
634 rc
= memcached_set(memc
, key
, strlen(key
),
635 value
, strlen(value
),
636 (time_t)0, (uint32_t)0);
637 test_compare(MEMCACHED_SUCCESS
, rc
);
639 test_compare(MEMCACHED_SUCCESS
,
640 memcached_mget(memc
, keys
, keylengths
, 1));
642 results
= memcached_result_create(memc
, &results_obj
);
645 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
647 test_compare(MEMCACHED_SUCCESS
, rc
);
648 test_true(memcached_result_cas(results
));
649 test_memcmp(value
, memcached_result_value(results
), value_length
);
650 test_compare(strlen(memcached_result_value(results
)), value_length
);
651 test_compare(MEMCACHED_SUCCESS
, rc
);
652 uint64_t cas
= memcached_result_cas(results
);
655 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
656 test_true(rc
== MEMCACHED_END
);
657 test_true(results
== NULL
);
660 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
661 test_compare(MEMCACHED_SUCCESS
, rc
);
664 * The item will have a new cas value, so try to set it again with the old
665 * value. This should fail!
667 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
668 test_compare(MEMCACHED_DATA_EXISTS
, rc
);
670 memcached_result_free(&results_obj
);
675 static test_return_t
prepend_test(memcached_st
*memc
)
677 memcached_return_t rc
;
678 const char *key
= "fig";
679 const char *value
= "people";
680 char *out_value
= NULL
;
684 rc
= memcached_flush(memc
, 0);
685 test_compare(MEMCACHED_SUCCESS
, rc
);
687 rc
= memcached_set(memc
, key
, strlen(key
),
688 value
, strlen(value
),
689 (time_t)0, (uint32_t)0);
690 test_compare(MEMCACHED_SUCCESS
, rc
);
692 rc
= memcached_prepend(memc
, key
, strlen(key
),
693 "the ", strlen("the "),
694 (time_t)0, (uint32_t)0);
695 test_compare(MEMCACHED_SUCCESS
, rc
);
697 rc
= memcached_prepend(memc
, key
, strlen(key
),
698 "we ", strlen("we "),
699 (time_t)0, (uint32_t)0);
700 test_compare(MEMCACHED_SUCCESS
, rc
);
702 out_value
= memcached_get(memc
, key
, strlen(key
),
703 &value_length
, &flags
, &rc
);
704 test_memcmp(out_value
, "we the people", strlen("we the people"));
705 test_compare(strlen("we the people"), value_length
);
706 test_compare(MEMCACHED_SUCCESS
, rc
);
713 Set the value, then quit to make sure it is flushed.
714 Come back in and test that add fails.
716 static test_return_t
add_test(memcached_st
*memc
)
718 memcached_return_t rc
;
719 const char *key
= "foo";
720 const char *value
= "when we sanitize";
721 unsigned long long setting_value
;
723 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
725 rc
= memcached_set(memc
, key
, strlen(key
),
726 value
, strlen(value
),
727 (time_t)0, (uint32_t)0);
728 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
729 memcached_quit(memc
);
730 rc
= memcached_add(memc
, key
, strlen(key
),
731 value
, strlen(value
),
732 (time_t)0, (uint32_t)0);
734 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
737 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
741 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
748 ** There was a problem of leaking filedescriptors in the initial release
749 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
750 ** systems it seems that the kernel is slow on reclaiming the resources
751 ** because the connects starts to time out (the test doesn't do much
752 ** anyway, so just loop 10 iterations)
754 static test_return_t
add_wrapper(memcached_st
*memc
)
756 unsigned int max
= 10000;
764 for (uint32_t x
= 0; x
< max
; x
++)
770 static test_return_t
replace_test(memcached_st
*memc
)
772 memcached_return_t rc
;
773 const char *key
= "foo";
774 const char *value
= "when we sanitize";
775 const char *original
= "first we insert some data";
777 rc
= memcached_set(memc
, key
, strlen(key
),
778 original
, strlen(original
),
779 (time_t)0, (uint32_t)0);
780 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
782 test_compare(MEMCACHED_SUCCESS
,
783 memcached_replace(memc
, key
, strlen(key
),
784 value
, strlen(value
),
785 (time_t)0, (uint32_t)0));
790 static test_return_t
delete_test(memcached_st
*memc
)
792 memcached_return_t rc
;
793 const char *key
= "foo";
794 const char *value
= "when we sanitize";
796 rc
= memcached_set(memc
, key
, strlen(key
),
797 value
, strlen(value
),
798 (time_t)0, (uint32_t)0);
799 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
801 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
802 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
807 static test_return_t
flush_test(memcached_st
*memc
)
809 uint64_t query_id
= memcached_query_id(memc
);
810 test_compare(MEMCACHED_SUCCESS
,
811 memcached_flush(memc
, 0));
812 test_compare(query_id
+1, memcached_query_id(memc
));
817 static memcached_return_t
server_function(const memcached_st
*ptr
,
818 const memcached_server_st
*server
,
821 (void)ptr
; (void)server
; (void)context
;
824 return MEMCACHED_SUCCESS
;
827 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
830 strncpy(context
, "foo bad", sizeof(context
));
831 memcached_server_fn callbacks
[1];
833 callbacks
[0]= server_function
;
834 memcached_server_cursor(memc
, callbacks
, context
, 1);
838 static test_return_t
bad_key_test(memcached_st
*memc
)
840 memcached_return_t rc
;
841 const char *key
= "foo bad";
843 memcached_st
*memc_clone
;
845 uint64_t query_id
= memcached_query_id(memc
);
847 // Just skip if we are in binary mode.
848 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
850 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
852 memc_clone
= memcached_clone(NULL
, memc
);
853 test_true(memc_clone
);
855 query_id
= memcached_query_id(memc_clone
);
856 test_compare(MEMCACHED_SUCCESS
,
857 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
858 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
860 /* All keys are valid in the binary protocol (except for length) */
861 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
863 uint64_t before_query_id
= memcached_query_id(memc_clone
);
865 size_t string_length
;
866 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
867 &string_length
, &flags
, &rc
);
868 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
869 test_zero(string_length
);
872 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
874 query_id
= memcached_query_id(memc_clone
);
875 test_compare(MEMCACHED_SUCCESS
,
876 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
877 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
879 size_t string_length
;
880 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
881 &string_length
, &flags
, &rc
);
882 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
883 test_zero(string_length
);
887 /* Test multi key for bad keys */
888 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
889 size_t key_lengths
[] = { 7, 7, 7 };
890 query_id
= memcached_query_id(memc_clone
);
891 test_compare(MEMCACHED_SUCCESS
,
892 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
893 test_compare(query_id
, memcached_query_id(memc_clone
));
895 query_id
= memcached_query_id(memc_clone
);
896 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
897 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
898 test_compare(query_id
+1, memcached_query_id(memc_clone
));
900 query_id
= memcached_query_id(memc_clone
);
901 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
902 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
903 test_compare(query_id
+1, memcached_query_id(memc_clone
));
905 /* The following test should be moved to the end of this function when the
906 memcached server is updated to allow max size length of the keys in the
909 test_compare(MEMCACHED_SUCCESS
,
910 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
912 std::vector
<char> longkey
;
913 longkey
.reserve(MEMCACHED_MAX_KEY
);
914 longkey
.insert(longkey
.end(), MEMCACHED_MAX_KEY
, 'a');
915 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
917 size_t string_length
;
919 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
920 test_compare(MEMCACHED_NOTFOUND
, rc
);
921 test_zero(string_length
);
923 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
924 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
925 test_zero(string_length
);
929 /* Make sure zero length keys are marked as bad */
931 test_compare(MEMCACHED_SUCCESS
,
932 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
933 size_t string_length
;
934 char *string
= memcached_get(memc_clone
, key
, 0,
935 &string_length
, &flags
, &rc
);
936 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
937 test_zero(string_length
);
941 memcached_free(memc_clone
);
946 #define READ_THROUGH_VALUE "set for me"
947 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
950 memcached_result_st
*result
)
952 (void)memc
;(void)key
;(void)key_length
;
953 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
956 #ifndef __INTEL_COMPILER
957 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
960 static test_return_t
read_through(memcached_st
*memc
)
962 memcached_return_t rc
;
963 const char *key
= "foo";
965 size_t string_length
;
967 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
969 string
= memcached_get(memc
, key
, strlen(key
),
970 &string_length
, &flags
, &rc
);
972 test_compare(MEMCACHED_NOTFOUND
, rc
);
973 test_false(string_length
);
976 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
);
977 test_compare(MEMCACHED_SUCCESS
, rc
);
979 string
= memcached_get(memc
, key
, strlen(key
),
980 &string_length
, &flags
, &rc
);
982 test_compare(MEMCACHED_SUCCESS
, rc
);
983 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
984 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
985 test_strcmp(READ_THROUGH_VALUE
, string
);
988 string
= memcached_get(memc
, key
, strlen(key
),
989 &string_length
, &flags
, &rc
);
991 test_compare(MEMCACHED_SUCCESS
, rc
);
993 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
994 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
995 test_strcmp(READ_THROUGH_VALUE
, string
);
1001 static test_return_t
get_test(memcached_st
*memc
)
1003 memcached_return_t rc
;
1004 const char *key
= "foo";
1006 size_t string_length
;
1009 uint64_t query_id
= memcached_query_id(memc
);
1010 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
1011 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
1012 test_compare(query_id
+1, memcached_query_id(memc
));
1014 string
= memcached_get(memc
, key
, strlen(key
),
1015 &string_length
, &flags
, &rc
);
1017 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1018 test_false(string_length
);
1021 return TEST_SUCCESS
;
1024 static test_return_t
get_test2(memcached_st
*memc
)
1026 const char *key
= "foo";
1027 const char *value
= "when we sanitize";
1029 uint64_t query_id
= memcached_query_id(memc
);
1030 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1031 value
, strlen(value
),
1032 (time_t)0, (uint32_t)0);
1033 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1034 test_compare(query_id
+1, memcached_query_id(memc
));
1036 query_id
= memcached_query_id(memc
);
1037 test_true(query_id
);
1040 size_t string_length
;
1041 char *string
= memcached_get(memc
, key
, strlen(key
),
1042 &string_length
, &flags
, &rc
);
1043 test_compare(query_id
+1, memcached_query_id(memc
));
1045 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1046 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1048 test_compare(strlen(value
), string_length
);
1049 test_memcmp(string
, value
, string_length
);
1053 return TEST_SUCCESS
;
1056 static test_return_t
set_test2(memcached_st
*memc
)
1058 for (uint32_t x
= 0; x
< 10; x
++)
1060 memcached_return_t rc
= memcached_set(memc
,
1061 test_literal_param("foo"),
1062 test_literal_param("train in the brain"),
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 std::vector
<char> value
;
1075 value
.reserve(value_length
);
1076 for (uint32_t x
= 0; x
< value_length
; x
++)
1078 value
.push_back(char(x
% 127));
1081 /* The dump test relies on there being at least 32 items in memcached */
1082 for (uint32_t x
= 0; x
< 32; x
++)
1086 snprintf(key
, sizeof(key
), "foo%u", x
);
1088 uint64_t query_id
= memcached_query_id(memc
);
1089 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1090 &value
[0], value
.size(),
1091 (time_t)0, (uint32_t)0);
1092 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1093 test_compare(query_id
+1, memcached_query_id(memc
));
1096 return TEST_SUCCESS
;
1099 static test_return_t
get_test3(memcached_st
*memc
)
1101 const char *key
= "foo";
1102 size_t value_length
= 8191;
1104 std::vector
<char> value
;
1105 value
.reserve(value_length
);
1106 for (uint32_t x
= 0; x
< value_length
; x
++)
1108 value
.push_back(char(x
% 127));
1111 memcached_return_t rc
;
1112 rc
= memcached_set(memc
, key
, strlen(key
),
1113 &value
[0], value
.size(),
1114 (time_t)0, (uint32_t)0);
1115 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1117 size_t string_length
;
1119 char *string
= memcached_get(memc
, key
, strlen(key
),
1120 &string_length
, &flags
, &rc
);
1122 test_compare(MEMCACHED_SUCCESS
, rc
);
1124 test_compare(string_length
, value_length
);
1125 test_memcmp(string
, &value
[0], string_length
);
1129 return TEST_SUCCESS
;
1132 static test_return_t
get_test4(memcached_st
*memc
)
1134 const char *key
= "foo";
1135 size_t value_length
= 8191;
1137 std::vector
<char> value
;
1138 value
.reserve(value_length
);
1139 for (uint32_t x
= 0; x
< value_length
; x
++)
1141 value
.push_back(char(x
% 127));
1144 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1145 &value
[0], value
.size(),
1146 (time_t)0, (uint32_t)0);
1147 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1149 for (uint32_t x
= 0; x
< 10; x
++)
1152 size_t string_length
;
1153 char *string
= memcached_get(memc
, key
, strlen(key
),
1154 &string_length
, &flags
, &rc
);
1156 test_compare(MEMCACHED_SUCCESS
, rc
);
1158 test_compare(string_length
, value_length
);
1159 test_memcmp(string
, &value
[0], string_length
);
1163 return TEST_SUCCESS
;
1167 * This test verifies that memcached_read_one_response doesn't try to
1168 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1169 * responses before you execute a storage command.
1171 static test_return_t
get_test5(memcached_st
*memc
)
1174 ** Request the same key twice, to ensure that we hash to the same server
1175 ** (so that we have multiple response values queued up) ;-)
1177 const char *keys
[]= { "key", "key" };
1178 size_t lengths
[]= { 3, 3 };
1182 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1183 keys
[0], lengths
[0], 0, 0);
1184 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1186 memcached_result_st results_obj
;
1187 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1190 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1193 memcached_result_free(&results_obj
);
1195 /* Don't read out the second result, but issue a set instead.. */
1196 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1198 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1199 &rlen
, &flags
, &rc
);
1201 test_compare(MEMCACHED_NOTFOUND
, rc
);
1202 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1204 test_compare(MEMCACHED_SUCCESS
, rc
);
1207 return TEST_SUCCESS
;
1210 static test_return_t
mget_end(memcached_st
*memc
)
1212 const char *keys
[]= { "foo", "foo2" };
1213 size_t lengths
[]= { 3, 4 };
1214 const char *values
[]= { "fjord", "41" };
1216 memcached_return_t rc
;
1219 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1221 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[x
], lengths
[x
], values
[x
], strlen(values
[x
]), (time_t)0, (uint32_t)0));
1225 size_t string_length
;
1228 // retrieve both via mget
1229 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1231 char key
[MEMCACHED_MAX_KEY
];
1234 // this should get both
1235 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1237 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1239 test_compare(MEMCACHED_SUCCESS
, rc
);
1241 if (key_length
== 4)
1246 test_compare(string_length
, strlen(values
[val
]));
1247 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1251 // this should indicate end
1252 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1253 test_compare(MEMCACHED_END
, rc
);
1257 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1258 test_compare(MEMCACHED_SUCCESS
, rc
);
1260 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1261 test_compare(key_length
, lengths
[0]);
1262 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1263 test_compare(string_length
, strlen(values
[0]));
1264 test_true(strncmp(values
[0], string
, string_length
) == 0);
1265 test_compare(MEMCACHED_SUCCESS
, rc
);
1268 // this should indicate end
1269 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1270 test_compare(MEMCACHED_END
, rc
);
1273 return TEST_SUCCESS
;
1276 /* Do not copy the style of this code, I just access hosts to testthis function */
1277 static test_return_t
stats_servername_test(memcached_st
*memc
)
1279 memcached_stat_st memc_stat
;
1280 memcached_server_instance_st instance
=
1281 memcached_server_instance_by_position(memc
, 0);
1283 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1285 return TEST_SKIPPED
;
1288 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1289 memcached_server_name(instance
),
1290 memcached_server_port(instance
)));
1292 return TEST_SUCCESS
;
1295 static test_return_t
increment_test(memcached_st
*memc
)
1297 uint64_t new_number
;
1299 test_compare(MEMCACHED_SUCCESS
,
1301 test_literal_param("number"),
1302 test_literal_param("0"),
1303 (time_t)0, (uint32_t)0));
1305 test_compare(MEMCACHED_SUCCESS
,
1306 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1307 test_compare(uint64_t(1), new_number
);
1309 test_compare(MEMCACHED_SUCCESS
,
1310 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1311 test_compare(uint64_t(2), new_number
);
1313 return TEST_SUCCESS
;
1316 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1318 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1320 uint64_t new_number
;
1321 uint64_t initial
= 0;
1323 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1325 test_compare(MEMCACHED_SUCCESS
,
1326 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1327 test_compare(new_number
, initial
);
1329 test_compare(MEMCACHED_SUCCESS
,
1330 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1331 test_compare(new_number
, (initial
+1));
1333 return TEST_SUCCESS
;
1336 static test_return_t
decrement_test(memcached_st
*memc
)
1338 uint64_t new_number
;
1339 memcached_return_t rc
;
1340 const char *value
= "3";
1342 rc
= memcached_set(memc
,
1343 test_literal_param("number"),
1344 value
, strlen(value
),
1345 (time_t)0, (uint32_t)0);
1346 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1348 test_compare(MEMCACHED_SUCCESS
,
1349 memcached_decrement(memc
,
1350 test_literal_param("number"),
1352 test_compare(uint64_t(2), new_number
);
1354 test_compare(MEMCACHED_SUCCESS
,
1355 memcached_decrement(memc
,
1356 test_literal_param("number"),
1358 test_compare(uint64_t(1), new_number
);
1360 return TEST_SUCCESS
;
1363 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1365 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1367 uint64_t new_number
;
1368 uint64_t initial
= 3;
1370 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1372 test_compare(MEMCACHED_SUCCESS
,
1373 memcached_decrement_with_initial(memc
,
1374 test_literal_param("number"),
1375 1, initial
, 0, &new_number
));
1376 test_compare(new_number
, initial
);
1378 test_compare(MEMCACHED_SUCCESS
,
1379 memcached_decrement_with_initial(memc
,
1380 test_literal_param("number"),
1381 1, initial
, 0, &new_number
));
1382 test_compare(new_number
, (initial
- 1));
1384 return TEST_SUCCESS
;
1387 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1389 uint64_t new_number
;
1390 memcached_return_t rc
;
1391 const char *master_key
= "foo";
1392 const char *key
= "number";
1393 const char *value
= "0";
1395 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1397 value
, strlen(value
),
1398 (time_t)0, (uint32_t)0);
1399 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1401 test_compare(MEMCACHED_SUCCESS
,
1402 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1403 test_compare(uint64_t(1), new_number
);
1405 test_compare(MEMCACHED_SUCCESS
,
1406 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1407 test_compare(uint64_t(2), new_number
);
1409 return TEST_SUCCESS
;
1412 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1414 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1416 uint64_t new_number
;
1417 memcached_return_t rc
;
1418 const char *master_key
= "foo";
1419 const char *key
= "number";
1420 uint64_t initial
= 0;
1422 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1424 1, initial
, 0, &new_number
);
1425 test_compare(MEMCACHED_SUCCESS
, rc
);
1426 test_compare(new_number
, initial
);
1428 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1430 1, initial
, 0, &new_number
);
1431 test_compare(MEMCACHED_SUCCESS
, rc
);
1432 test_compare(new_number
, (initial
+1));
1434 return TEST_SUCCESS
;
1437 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1439 uint64_t new_number
;
1440 memcached_return_t rc
;
1441 const char *value
= "3";
1443 rc
= memcached_set_by_key(memc
,
1444 test_literal_param("foo"),
1445 test_literal_param("number"),
1446 value
, strlen(value
),
1447 (time_t)0, (uint32_t)0);
1448 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1450 test_compare(MEMCACHED_SUCCESS
,
1451 memcached_decrement_by_key(memc
,
1452 test_literal_param("foo"),
1453 test_literal_param("number"),
1455 test_compare(uint64_t(2), new_number
);
1457 test_compare(MEMCACHED_SUCCESS
,
1458 memcached_decrement_by_key(memc
,
1459 test_literal_param("foo"),
1460 test_literal_param("number"),
1462 test_compare(uint64_t(1), new_number
);
1464 return TEST_SUCCESS
;
1467 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1469 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1471 uint64_t new_number
;
1472 uint64_t initial
= 3;
1474 test_compare(MEMCACHED_SUCCESS
,
1475 memcached_decrement_with_initial_by_key(memc
,
1476 test_literal_param("foo"),
1477 test_literal_param("number"),
1478 1, initial
, 0, &new_number
));
1479 test_compare(new_number
, initial
);
1481 test_compare(MEMCACHED_SUCCESS
,
1482 memcached_decrement_with_initial_by_key(memc
,
1483 test_literal_param("foo"),
1484 test_literal_param("number"),
1485 1, initial
, 0, &new_number
));
1486 test_compare(new_number
, (initial
- 1));
1488 return TEST_SUCCESS
;
1490 static test_return_t
binary_increment_with_prefix_test(memcached_st
*orig_memc
)
1492 memcached_st
*memc
= memcached_clone(NULL
, orig_memc
);
1494 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1496 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1498 memcached_return_t rc
;
1499 rc
= memcached_set(memc
,
1500 test_literal_param("number"),
1501 test_literal_param("0"),
1502 (time_t)0, (uint32_t)0);
1503 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1505 uint64_t new_number
;
1506 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1507 test_literal_param("number"),
1509 test_compare(uint64_t(1), new_number
);
1511 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1512 test_literal_param("number"),
1514 test_compare(uint64_t(2), new_number
);
1515 memcached_free(memc
);
1517 return TEST_SUCCESS
;
1520 static test_return_t
quit_test(memcached_st
*memc
)
1522 memcached_return_t rc
;
1523 const char *key
= "fudge";
1524 const char *value
= "sanford and sun";
1526 rc
= memcached_set(memc
, key
, strlen(key
),
1527 value
, strlen(value
),
1528 (time_t)10, (uint32_t)3);
1529 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1530 memcached_quit(memc
);
1532 rc
= memcached_set(memc
, key
, strlen(key
),
1533 value
, strlen(value
),
1534 (time_t)50, (uint32_t)9);
1535 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1537 return TEST_SUCCESS
;
1540 static test_return_t
mget_result_test(memcached_st
*memc
)
1542 const char *keys
[]= {"fudge", "son", "food"};
1543 size_t key_length
[]= {5, 3, 4};
1545 memcached_result_st results_obj
;
1546 memcached_result_st
*results
;
1548 results
= memcached_result_create(memc
, &results_obj
);
1550 test_true(&results_obj
== results
);
1552 /* We need to empty the server before continueing test */
1553 test_compare(MEMCACHED_SUCCESS
,
1554 memcached_flush(memc
, 0));
1556 test_compare(MEMCACHED_SUCCESS
,
1557 memcached_mget(memc
, keys
, key_length
, 3));
1559 memcached_return_t rc
;
1560 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1565 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1566 test_false(results
);
1567 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1569 for (uint32_t x
= 0; x
< 3; x
++)
1571 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1572 keys
[x
], key_length
[x
],
1573 (time_t)50, (uint32_t)9);
1574 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1577 test_compare(MEMCACHED_SUCCESS
,
1578 memcached_mget(memc
, keys
, key_length
, 3));
1580 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1583 test_true(&results_obj
== results
);
1584 test_compare(MEMCACHED_SUCCESS
, rc
);
1585 test_memcmp(memcached_result_key_value(results
),
1586 memcached_result_value(results
),
1587 memcached_result_length(results
));
1588 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1591 memcached_result_free(&results_obj
);
1593 return TEST_SUCCESS
;
1596 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1598 const char *keys
[]= {"fudge", "son", "food"};
1599 size_t key_length
[]= {5, 3, 4};
1601 memcached_result_st
*results
;
1603 /* We need to empty the server before continueing test */
1604 test_compare(MEMCACHED_SUCCESS
,
1605 memcached_flush(memc
, 0));
1607 test_compare(MEMCACHED_SUCCESS
,
1608 memcached_mget(memc
, keys
, key_length
, 3));
1610 memcached_return_t rc
;
1611 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1615 test_false(results
);
1616 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1618 for (uint32_t x
= 0; x
< 3; x
++)
1620 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1621 keys
[x
], key_length
[x
],
1622 (time_t)50, (uint32_t)9);
1623 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1626 test_compare(MEMCACHED_SUCCESS
,
1627 memcached_mget(memc
, keys
, key_length
, 3));
1630 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1633 test_compare(MEMCACHED_SUCCESS
, rc
);
1634 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1635 test_memcmp(memcached_result_key_value(results
),
1636 memcached_result_value(results
),
1637 memcached_result_length(results
));
1638 memcached_result_free(results
);
1642 return TEST_SUCCESS
;
1645 /* Count the results */
1646 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1648 size_t *counter
= (size_t *)context
;
1650 *counter
= *counter
+ 1;
1652 return MEMCACHED_SUCCESS
;
1655 static test_return_t
mget_result_function(memcached_st
*memc
)
1657 const char *keys
[]= {"fudge", "son", "food"};
1658 size_t key_length
[]= {5, 3, 4};
1660 memcached_execute_fn callbacks
[1];
1662 /* We need to empty the server before continueing test */
1663 test_compare(MEMCACHED_SUCCESS
,
1664 memcached_flush(memc
, 0));
1665 for (uint32_t x
= 0; x
< 3; x
++)
1667 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1668 keys
[x
], key_length
[x
],
1669 (time_t)50, (uint32_t)9);
1670 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1673 test_compare(MEMCACHED_SUCCESS
,
1674 memcached_mget(memc
, keys
, key_length
, 3));
1676 callbacks
[0]= &callback_counter
;
1679 test_compare(MEMCACHED_SUCCESS
,
1680 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1682 test_compare(size_t(3), counter
);
1684 return TEST_SUCCESS
;
1687 static test_return_t
mget_test(memcached_st
*memc
)
1689 const char *keys
[]= {"fudge", "son", "food"};
1690 size_t key_length
[]= {5, 3, 4};
1692 char return_key
[MEMCACHED_MAX_KEY
];
1693 size_t return_key_length
;
1695 size_t return_value_length
;
1697 /* We need to empty the server before continueing test */
1698 test_compare(MEMCACHED_SUCCESS
,
1699 memcached_flush(memc
, 0));
1701 test_compare(MEMCACHED_SUCCESS
,
1702 memcached_mget(memc
, keys
, key_length
, 3));
1705 memcached_return_t rc
;
1706 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1707 &return_value_length
, &flags
, &rc
)))
1709 test_true(return_value
);
1711 test_false(return_value
);
1712 test_zero(return_value_length
);
1713 test_compare(MEMCACHED_NOTFOUND
, rc
);
1715 for (uint32_t x
= 0; x
< 3; x
++)
1717 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1718 keys
[x
], key_length
[x
],
1719 (time_t)50, (uint32_t)9);
1720 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1722 test_compare(MEMCACHED_SUCCESS
,
1723 memcached_mget(memc
, keys
, key_length
, 3));
1726 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1727 &return_value_length
, &flags
, &rc
)))
1729 test_true(return_value
);
1730 test_compare(MEMCACHED_SUCCESS
, rc
);
1731 if (not memc
->_namespace
)
1733 test_compare(return_key_length
, return_value_length
);
1734 test_memcmp(return_value
, return_key
, return_value_length
);
1740 return TEST_SUCCESS
;
1743 static test_return_t
mget_execute(memcached_st
*memc
)
1747 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1751 * I only want to hit _one_ server so I know the number of requests I'm
1752 * sending in the pipeline.
1754 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1755 memc
->number_of_hosts
= 1;
1757 size_t max_keys
= 20480;
1760 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1761 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1763 /* First add all of the items.. */
1764 char blob
[1024] = {0};
1765 memcached_return_t rc
;
1767 for (size_t x
= 0; x
< max_keys
; ++x
)
1771 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1773 test_true(keys
[x
] != NULL
);
1774 uint64_t query_id
= memcached_query_id(memc
);
1775 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1776 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1777 test_compare(query_id
+1, memcached_query_id(memc
));
1780 /* Try to get all of them with a large multiget */
1782 memcached_execute_fn callbacks
[]= { &callback_counter
};
1783 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1784 max_keys
, callbacks
, &counter
, 1);
1786 if (memcached_success(rc
))
1789 uint64_t query_id
= memcached_query_id(memc
);
1790 test_compare(MEMCACHED_SUCCESS
,
1791 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1792 test_compare(query_id
, memcached_query_id(memc
));
1794 /* Verify that we got all of the items */
1795 test_true(counter
== max_keys
);
1797 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1799 test_true(counter
== 0);
1803 test_fail("note: this test functions differently when in binary mode");
1806 /* Release all allocated resources */
1807 for (size_t x
= 0; x
< max_keys
; ++x
)
1814 memc
->number_of_hosts
= number_of_hosts
;
1815 return TEST_SUCCESS
;
1818 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1820 static test_return_t
key_setup(memcached_st
*memc
)
1822 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1824 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1826 return TEST_SUCCESS
;
1829 static test_return_t
key_teardown(memcached_st
*memc
)
1832 pairs_free(global_pairs
);
1834 return TEST_SUCCESS
;
1837 static test_return_t
block_add_regression(memcached_st
*memc
)
1839 /* First add all of the items.. */
1840 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1842 memcached_return_t rc
;
1843 char blob
[1024] = {0};
1845 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1846 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1849 return TEST_SUCCESS
;
1852 static test_return_t
binary_add_regression(memcached_st
*memc
)
1854 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1855 test_return_t rc
= block_add_regression(memc
);
1856 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1860 static test_return_t
get_stats_keys(memcached_st
*memc
)
1864 memcached_stat_st memc_stat
;
1865 memcached_return_t rc
;
1867 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1868 test_compare(MEMCACHED_SUCCESS
, rc
);
1869 for (ptr
= stat_list
; *ptr
; ptr
++)
1874 return TEST_SUCCESS
;
1877 static test_return_t
version_string_test(memcached_st
*memc
)
1879 const char *version_string
;
1882 version_string
= memcached_lib_version();
1884 test_strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
);
1886 return TEST_SUCCESS
;
1889 static test_return_t
get_stats(memcached_st
*memc
)
1891 memcached_return_t rc
;
1893 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1894 test_compare(MEMCACHED_SUCCESS
, rc
);
1895 test_true(memc_stat
);
1897 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1899 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1900 test_compare(MEMCACHED_SUCCESS
, rc
);
1901 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1906 memcached_stat_free(NULL
, memc_stat
);
1908 return TEST_SUCCESS
;
1911 static test_return_t
add_host_test(memcached_st
*memc
)
1914 memcached_server_st
*servers
;
1915 memcached_return_t rc
;
1916 char servername
[]= "0.example.com";
1918 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1920 test_true(1 == memcached_server_list_count(servers
));
1922 for (x
= 2; x
< 20; x
++)
1924 char buffer
[SMALL_STRING_LEN
];
1926 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1927 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1929 test_compare(MEMCACHED_SUCCESS
, rc
);
1930 test_true(x
== memcached_server_list_count(servers
));
1933 rc
= memcached_server_push(memc
, servers
);
1934 test_compare(MEMCACHED_SUCCESS
, rc
);
1935 rc
= memcached_server_push(memc
, servers
);
1936 test_compare(MEMCACHED_SUCCESS
, rc
);
1938 memcached_server_list_free(servers
);
1940 return TEST_SUCCESS
;
1943 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1945 memcached_return_t rc
;
1946 const char *key
= "not_found";
1947 size_t key_len
= strlen(key
);
1949 test_compare(MEMCACHED_SUCCESS
,
1950 memcached_mget(memc
, &key
, &key_len
, 1));
1952 memcached_result_st
*result
= NULL
;
1953 result
= memcached_fetch_result(memc
, result
, &rc
);
1955 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1957 memcached_result_free(result
);
1959 return TEST_SUCCESS
;
1962 static memcached_return_t
clone_test_callback(memcached_st
*parent
, memcached_st
*memc_clone
)
1964 (void)parent
;(void)memc_clone
;
1965 return MEMCACHED_SUCCESS
;
1968 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
)
1971 return MEMCACHED_SUCCESS
;
1974 static test_return_t
callback_test(memcached_st
*memc
)
1976 /* Test User Data */
1980 memcached_return_t rc
;
1982 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1983 test_compare(MEMCACHED_SUCCESS
, rc
);
1984 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1985 test_true(*test_ptr
== x
);
1988 /* Test Clone Callback */
1990 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1991 void *clone_cb_ptr
= *(void **)&clone_cb
;
1992 void *temp_function
= NULL
;
1993 memcached_return_t rc
;
1995 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
1997 test_compare(MEMCACHED_SUCCESS
, rc
);
1998 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1999 test_true(temp_function
== clone_cb_ptr
);
2002 /* Test Cleanup Callback */
2004 memcached_cleanup_fn cleanup_cb
=
2005 (memcached_cleanup_fn
)cleanup_test_callback
;
2006 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2007 void *temp_function
= NULL
;
2008 memcached_return_t rc
;
2010 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2012 test_compare(MEMCACHED_SUCCESS
, rc
);
2013 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2014 test_true(temp_function
== cleanup_cb_ptr
);
2017 return TEST_SUCCESS
;
2020 /* We don't test the behavior itself, we test the switches */
2021 static test_return_t
behavior_test(memcached_st
*memc
)
2026 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2027 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2028 test_true(value
== 1);
2030 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2031 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2032 test_true(value
== 1);
2034 set
= MEMCACHED_HASH_MD5
;
2035 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2036 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2037 test_true(value
== MEMCACHED_HASH_MD5
);
2041 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2042 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2043 test_true(value
== 0);
2045 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2046 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2047 test_true(value
== 0);
2049 set
= MEMCACHED_HASH_DEFAULT
;
2050 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2051 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2052 test_true(value
== MEMCACHED_HASH_DEFAULT
);
2054 set
= MEMCACHED_HASH_CRC
;
2055 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2056 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2057 test_true(value
== MEMCACHED_HASH_CRC
);
2059 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2060 test_true(value
> 0);
2062 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2063 test_true(value
> 0);
2065 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2066 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
2067 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2069 return TEST_SUCCESS
;
2072 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2074 memcached_return_t rc
;
2077 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
2078 test_true(rc
== MEMCACHED_DEPRECATED
);
2080 // Platform dependent
2082 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2086 return TEST_SUCCESS
;
2090 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2092 memcached_return_t rc
;
2096 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, set
);
2097 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2099 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2101 if (rc
== MEMCACHED_SUCCESS
)
2103 test_true((bool)value
== set
);
2107 test_false((bool)value
== set
);
2110 return TEST_SUCCESS
;
2114 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2116 memcached_return_t rc
;
2120 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, set
);
2121 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2123 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2125 if (rc
== MEMCACHED_SUCCESS
)
2127 test_true((bool)value
== set
);
2131 test_false((bool)value
== set
);
2134 return TEST_SUCCESS
;
2137 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, const memcached_return_t expect
)
2139 memcached_return_t rc
;
2140 char return_key
[MEMCACHED_MAX_KEY
];
2141 size_t return_key_length
;
2143 size_t return_value_length
;
2147 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2148 &return_value_length
, &flags
, &rc
)))
2150 test_true(return_value
);
2151 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2156 if (memcached_success(expect
) and memcached_success(rc
))
2158 return TEST_SUCCESS
;
2160 else if (expect
== rc
)
2162 return TEST_SUCCESS
;
2164 fprintf(stderr
, "\n%s:%u %s(#%u)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), keys_returned
);
2166 return TEST_FAILURE
;
2169 /* Test case provided by Cal Haldenbrand */
2170 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2171 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2172 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2174 /* We just keep looking at the same values over and over */
2177 unsigned int setter
= 1;
2178 test_compare(MEMCACHED_SUCCESS
,
2179 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2180 test_compare(MEMCACHED_SUCCESS
,
2181 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2185 unsigned long long total
= 0;
2186 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2188 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2189 char randomstuff
[6 * 1024];
2190 memset(randomstuff
, 0, 6 * 1024);
2191 test_true(size
< 6 * 1024); /* Being safe here */
2193 for (uint32_t j
= 0 ; j
< size
;j
++)
2195 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2200 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2201 test_compare(MEMCACHED_SUCCESS
,
2202 memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
));
2204 test_true(total
> HALDENBRAND_KEY_COUNT
);
2206 return TEST_SUCCESS
;
2209 /* Test case provided by Cal Haldenbrand */
2210 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2212 unsigned int setter
= 1;
2214 test_compare(MEMCACHED_SUCCESS
,
2215 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2217 test_compare(MEMCACHED_SUCCESS
,
2218 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2221 setter
= 20 * 1024576;
2222 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2223 setter
= 20 * 1024576;
2224 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2225 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2226 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2228 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2231 size_t total_value_length
= 0;
2232 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2237 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2238 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2240 memcached_return_t rc
;
2241 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2242 if (memcached_failed(rc
))
2244 if (rc
== MEMCACHED_NOTFOUND
)
2255 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2257 total_value_length
+= val_len
;
2262 return TEST_SUCCESS
;
2265 /* Do a large mget() over all the keys we think exist */
2266 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2268 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
2269 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
2272 setter
= 20 * 1024576;
2273 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2274 setter
= 20 * 1024576;
2275 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2276 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2277 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2280 size_t key_lengths
[HALDENBRAND_KEY_COUNT
];
2281 char **keys
= static_cast<char **>(calloc(HALDENBRAND_KEY_COUNT
, sizeof(char *)));
2283 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2285 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2286 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2287 test_true(key_length
);
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
));
2297 unsigned int keys_returned
;
2298 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
2299 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2301 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2307 return TEST_SUCCESS
;
2310 /* Make sure we behave properly if server list has no values */
2311 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2313 const char *keys
[]= {"fudge", "son", "food"};
2314 size_t key_length
[]= {5, 3, 4};
2316 /* Here we free everything before running a bunch of mget tests */
2317 memcached_servers_reset(memc
);
2320 /* We need to empty the server before continueing test */
2321 test_compare(MEMCACHED_NO_SERVERS
,
2322 memcached_flush(memc
, 0));
2324 test_compare(MEMCACHED_NO_SERVERS
,
2325 memcached_mget(memc
, keys
, key_length
, 3));
2327 unsigned int keys_returned
;
2328 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2329 test_zero(keys_returned
);
2331 for (uint32_t x
= 0; x
< 3; x
++)
2333 test_compare(MEMCACHED_NO_SERVERS
,
2334 memcached_set(memc
, keys
[x
], key_length
[x
],
2335 keys
[x
], key_length
[x
],
2336 (time_t)50, (uint32_t)9));
2339 test_compare(MEMCACHED_NO_SERVERS
,
2340 memcached_mget(memc
, keys
, key_length
, 3));
2344 char return_key
[MEMCACHED_MAX_KEY
];
2345 memcached_return_t rc
;
2346 size_t return_key_length
;
2347 size_t return_value_length
;
2350 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2351 &return_value_length
, &flags
, &rc
)))
2353 test_true(return_value
);
2354 test_compare(MEMCACHED_SUCCESS
, rc
);
2355 test_true(return_key_length
== return_value_length
);
2356 test_memcmp(return_value
, return_key
, return_value_length
);
2362 return TEST_SUCCESS
;
2365 #define VALUE_SIZE_BUG5 1048064
2366 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2368 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2369 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2371 size_t value_length
;
2373 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2375 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2377 insert_data
[x
]= (signed char)rand();
2380 test_compare(MEMCACHED_SUCCESS
,
2381 memcached_flush(memc
, 0));
2383 memcached_return_t rc
;
2384 value
= memcached_get(memc
, keys
[0], key_length
[0],
2385 &value_length
, &flags
, &rc
);
2387 test_compare(MEMCACHED_SUCCESS
,
2388 memcached_mget(memc
, keys
, key_length
, 4));
2391 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2394 for (uint32_t x
= 0; x
< 4; x
++)
2396 test_compare(MEMCACHED_SUCCESS
,
2397 memcached_set(memc
, keys
[x
], key_length
[x
],
2398 insert_data
, VALUE_SIZE_BUG5
,
2399 (time_t)0, (uint32_t)0));
2402 for (uint32_t x
= 0; x
< 10; x
++)
2404 value
= memcached_get(memc
, keys
[0], key_length
[0],
2405 &value_length
, &flags
, &rc
);
2406 test_compare(rc
, MEMCACHED_SUCCESS
);
2410 test_compare(MEMCACHED_SUCCESS
,
2411 memcached_mget(memc
, keys
, key_length
, 4));
2413 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2414 test_compare(4U, count
);
2416 delete [] insert_data
;
2418 return TEST_SUCCESS
;
2421 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2423 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2424 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2425 char return_key
[MEMCACHED_MAX_KEY
];
2426 size_t return_key_length
;
2428 size_t value_length
;
2430 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2432 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2434 insert_data
[x
]= (signed char)rand();
2437 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2439 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2441 // We will now confirm that memcached_mget() returns success, but we will
2442 // then check to make sure that no actual keys are returned.
2443 test_compare(MEMCACHED_SUCCESS
,
2444 memcached_mget(memc
, keys
, key_length
, 4));
2446 memcached_return_t rc
;
2448 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2449 &value_length
, &flags
, &rc
)))
2454 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2456 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2458 test_compare(MEMCACHED_SUCCESS
,
2459 memcached_set(memc
, keys
[x
], key_length
[x
],
2460 insert_data
, VALUE_SIZE_BUG5
,
2461 (time_t)0, (uint32_t)0));
2463 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2465 for (uint32_t x
= 0; x
< 2; x
++)
2467 value
= memcached_get(memc
, keys
[0], key_length
[0],
2468 &value_length
, &flags
, &rc
);
2472 test_compare(MEMCACHED_SUCCESS
,
2473 memcached_mget(memc
, keys
, key_length
, 4));
2474 /* We test for purge of partial complete fetches */
2475 for (count
= 3; count
; count
--)
2477 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2478 &value_length
, &flags
, &rc
);
2479 test_compare(MEMCACHED_SUCCESS
, rc
);
2480 test_memcmp(value
, insert_data
, value_length
);
2481 test_true(value_length
);
2485 delete [] insert_data
;
2487 return TEST_SUCCESS
;
2490 static test_return_t
user_supplied_bug8(memcached_st
*)
2492 memcached_return_t rc
;
2494 memcached_st
*memc_clone
;
2496 memcached_server_st
*servers
;
2497 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";
2499 servers
= memcached_servers_parse(server_list
);
2502 mine
= memcached_create(NULL
);
2503 rc
= memcached_server_push(mine
, servers
);
2504 test_compare(MEMCACHED_SUCCESS
, rc
);
2505 memcached_server_list_free(servers
);
2508 memc_clone
= memcached_clone(NULL
, mine
);
2510 memcached_quit(mine
);
2511 memcached_quit(memc_clone
);
2514 memcached_free(mine
);
2515 memcached_free(memc_clone
);
2517 return TEST_SUCCESS
;
2520 /* Test flag store/retrieve */
2521 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2523 const char *keys
= "036790384900";
2524 size_t key_length
= strlen(keys
);
2525 char return_key
[MEMCACHED_MAX_KEY
];
2526 size_t return_key_length
;
2528 size_t value_length
;
2530 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2532 for (unsigned int x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2533 insert_data
[x
]= (signed char)rand();
2535 memcached_flush(memc
, 0);
2538 memcached_return_t rc
= memcached_set(memc
, keys
, key_length
,
2539 insert_data
, VALUE_SIZE_BUG5
,
2541 test_compare(MEMCACHED_SUCCESS
, rc
);
2544 value
= memcached_get(memc
, keys
, key_length
,
2545 &value_length
, &flags
, &rc
);
2546 test_true(flags
== 245);
2550 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2553 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2554 &value_length
, &flags
, &rc
);
2555 test_compare(uint32_t(245), flags
);
2558 delete [] insert_data
;
2561 return TEST_SUCCESS
;
2564 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2566 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2567 size_t key_length
[3];
2571 char return_key
[MEMCACHED_MAX_KEY
];
2572 size_t return_key_length
;
2574 size_t return_value_length
;
2577 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2578 key_length
[1]= strlen("fudge&*@#");
2579 key_length
[2]= strlen("for^#@&$not");
2582 for (unsigned int x
= 0; x
< 3; x
++)
2584 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2585 keys
[x
], key_length
[x
],
2586 (time_t)50, (uint32_t)9);
2587 test_compare(MEMCACHED_SUCCESS
, rc
);
2590 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2591 test_compare(MEMCACHED_SUCCESS
, rc
);
2593 /* We need to empty the server before continueing test */
2594 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2595 &return_value_length
, &flags
, &rc
)) != NULL
)
2597 test_true(return_value
);
2601 test_compare(3U, count
);
2603 return TEST_SUCCESS
;
2606 /* We are testing with aggressive timeout to get failures */
2607 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2609 size_t value_length
= 512;
2610 unsigned int set
= 1;
2611 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2613 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2614 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2615 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2617 std::vector
<char> value
;
2618 value
.reserve(value_length
);
2619 for (uint32_t x
= 0; x
< value_length
; x
++)
2621 value
.push_back(char(x
% 127));
2624 for (unsigned int x
= 1; x
<= 100000; ++x
)
2626 memcached_return_t rc
= memcached_set(mclone
,
2627 test_literal_param("foo"),
2628 &value
[0], value
.size(),
2631 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2632 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2633 memcached_strerror(NULL
, rc
));
2635 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2641 memcached_free(mclone
);
2643 return TEST_SUCCESS
;
2647 We are looking failures in the async protocol
2649 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2651 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2653 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2654 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2655 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2657 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2660 std::vector
<char> value
;
2662 for (unsigned int x
= 0; x
< 512; x
++)
2664 value
.push_back(char(x
% 127));
2667 for (unsigned int x
= 1; x
<= 100000; ++x
)
2669 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2673 memcached_free(mclone
);
2675 return TEST_SUCCESS
;
2679 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2681 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2683 memcached_return_t rc
;
2685 size_t value_length
;
2687 uint64_t number_value
;
2689 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2690 &value_length
, &flags
, &rc
);
2691 test_true(value
== NULL
);
2692 test_compare(MEMCACHED_NOTFOUND
, rc
);
2694 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2696 test_true(value
== NULL
);
2697 /* The binary protocol will set the key if it doesn't exist */
2698 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2700 test_compare(MEMCACHED_SUCCESS
, rc
);
2704 test_compare(MEMCACHED_NOTFOUND
, rc
);
2707 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2709 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2710 &value_length
, &flags
, &rc
);
2712 test_compare(MEMCACHED_SUCCESS
, rc
);
2715 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2717 test_true(number_value
== 2);
2718 test_compare(MEMCACHED_SUCCESS
, rc
);
2720 return TEST_SUCCESS
;
2724 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2725 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2727 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2729 char key
[] = "key34567890";
2730 memcached_return_t rc
;
2731 size_t overflowSize
;
2733 char commandFirst
[]= "set key34567890 0 0 ";
2734 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2735 size_t commandLength
;
2738 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2740 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2742 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2744 char *overflow
= new (std::nothrow
) char[testSize
];
2745 test_true(overflow
);
2747 memset(overflow
, 'x', testSize
);
2748 rc
= memcached_set(memc
, key
, strlen(key
),
2749 overflow
, testSize
, 0, 0);
2750 test_compare(MEMCACHED_SUCCESS
, rc
);
2754 return TEST_SUCCESS
;
2759 Test values of many different sizes
2760 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2761 set key34567890 0 0 8169 \r\n
2762 is sent followed by buffer of size 8169, followed by 8169
2764 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2766 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2768 std::vector
<char> value
;
2769 value
.reserve(18000);
2770 for (size_t x
= 0; x
< 18000; x
++)
2772 value
.push_back((char) (x
% 127));
2775 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2777 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2778 &value
[0], current_length
,
2779 (time_t)0, (uint32_t)0);
2780 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2782 size_t string_length
;
2784 char *string
= memcached_get(memc
, test_literal_param("foo"),
2785 &string_length
, &flags
, &rc
);
2787 test_compare(MEMCACHED_SUCCESS
, rc
);
2788 test_compare(string_length
, current_length
);
2789 test_memcmp(string
, &value
[0], string_length
);
2794 return TEST_SUCCESS
;
2798 Look for zero length value problems
2800 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2802 for (uint32_t x
= 0; x
< 2; x
++)
2804 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2806 (time_t)0, (uint32_t)0);
2808 test_compare(MEMCACHED_SUCCESS
, rc
);
2812 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2813 &length
, &flags
, &rc
);
2815 test_compare(MEMCACHED_SUCCESS
, rc
);
2820 value
= memcached_get(memc
, test_literal_param("mykey"),
2821 &length
, &flags
, &rc
);
2823 test_compare(MEMCACHED_SUCCESS
, rc
);
2824 test_true(value
== NULL
);
2829 return TEST_SUCCESS
;
2832 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2833 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2835 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2837 (time_t)0, UINT32_MAX
);
2839 test_compare(MEMCACHED_SUCCESS
, rc
);
2843 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2844 &length
, &flags
, &rc
);
2846 test_compare(MEMCACHED_SUCCESS
, rc
);
2847 test_true(value
== NULL
);
2849 test_compare(flags
, UINT32_MAX
);
2851 return TEST_SUCCESS
;
2854 #if !defined(__sun) && !defined(__OpenBSD__)
2855 /* Check the validity of chinese key*/
2856 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2858 const char *key
= "豆瓣";
2859 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2860 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2861 value
, strlen(value
),
2864 test_compare(MEMCACHED_SUCCESS
, rc
);
2868 char *value2
= memcached_get(memc
, key
, strlen(key
),
2869 &length
, &flags
, &rc
);
2871 test_true(length
==strlen(value
));
2872 test_compare(MEMCACHED_SUCCESS
, rc
);
2873 test_memcmp(value
, value2
, length
);
2876 return TEST_SUCCESS
;
2884 static test_return_t
user_supplied_bug19(memcached_st
*)
2886 memcached_return_t res
;
2888 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2890 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2893 memcached_free(memc
);
2895 return TEST_SUCCESS
;
2898 /* CAS test from Andei */
2899 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2901 const char *key
= "abc";
2902 size_t key_len
= strlen("abc");
2904 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2906 test_compare(MEMCACHED_SUCCESS
,
2908 test_literal_param("abc"),
2909 test_literal_param("foobar"),
2910 (time_t)0, (uint32_t)0));
2912 test_compare(MEMCACHED_SUCCESS
,
2913 memcached_mget(memc
, &key
, &key_len
, 1));
2915 memcached_result_st result_obj
;
2916 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2919 memcached_result_create(memc
, &result_obj
);
2920 memcached_return_t status
;
2921 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2924 test_compare(MEMCACHED_SUCCESS
, status
);
2926 memcached_result_free(result
);
2928 return TEST_SUCCESS
;
2931 /* Large mget() of missing keys with binary proto
2933 * If many binary quiet commands (such as getq's in an mget) fill the output
2934 * buffer and the server chooses not to respond, memcached_flush hangs. See
2935 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2938 /* sighandler_t function that always asserts false */
2939 static void fail(int)
2945 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2950 return TEST_SKIPPED
;
2952 void (*oldalarm
)(int);
2954 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2955 test_true(memc_clone
);
2957 /* only binproto uses getq for mget */
2958 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2960 /* empty the cache to ensure misses (hence non-responses) */
2961 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2963 size_t* key_lengths
= new (std::nothrow
) size_t[key_count
];
2964 test_true(key_lengths
);
2965 char **keys
= static_cast<char **>(calloc(key_count
, sizeof(char *)));
2967 for (unsigned int x
= 0; x
< key_count
; x
++)
2971 snprintf(buffer
, 30, "%u", x
);
2972 keys
[x
]= strdup(buffer
);
2974 key_lengths
[x
]= strlen(keys
[x
]);
2977 oldalarm
= signal(SIGALRM
, fail
);
2980 test_compare_got(MEMCACHED_SUCCESS
,
2981 memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
), memcached_last_error_message(memc_clone
));
2984 signal(SIGALRM
, oldalarm
);
2986 memcached_return_t rc
;
2988 char return_key
[MEMCACHED_MAX_KEY
];
2989 size_t return_key_length
;
2991 size_t return_value_length
;
2992 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2993 &return_value_length
, &flags
, &rc
)))
2995 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2997 test_compare(MEMCACHED_NOTFOUND
, rc
);
2998 test_zero(return_value_length
);
2999 test_zero(return_key_length
);
3000 test_false(return_key
[0]);
3001 test_false(return_value
);
3003 for (unsigned int x
= 0; x
< key_count
; x
++)
3008 delete [] key_lengths
;
3010 memcached_free(memc_clone
);
3012 return TEST_SUCCESS
;
3016 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3018 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3020 /* should work as of r580 */
3021 test_compare(TEST_SUCCESS
,
3022 _user_supplied_bug21(memc
, 10));
3024 /* should fail as of r580 */
3025 test_compare(TEST_SUCCESS
,
3026 _user_supplied_bug21(memc
, 1000));
3028 return TEST_SUCCESS
;
3031 static test_return_t
output_ketama_weighted_keys(memcached_st
*)
3033 memcached_st
*memc
= memcached_create(NULL
);
3037 test_compare(MEMCACHED_SUCCESS
,
3038 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
3040 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3041 test_compare(value
, uint64_t(1));
3043 test_compare(MEMCACHED_SUCCESS
,
3044 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3046 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3047 test_true(value
== MEMCACHED_HASH_MD5
);
3050 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3052 memcached_server_st
*server_pool
;
3053 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");
3054 memcached_server_push(memc
, server_pool
);
3056 // @todo this needs to be refactored to actually test something.
3059 if ((fp
= fopen("ketama_keys.txt", "w")))
3063 printf("cannot write to file ketama_keys.txt");
3064 return TEST_FAILURE
;
3067 for (int x
= 0; x
< 10000; x
++)
3070 snprintf(key
, sizeof(key
), "%d", x
);
3072 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3073 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3074 in_port_t port
= memc
->hosts
[server_idx
].port
;
3075 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3076 memcached_server_instance_st instance
=
3077 memcached_server_instance_by_position(memc
, host_index
);
3081 memcached_server_list_free(server_pool
);
3082 memcached_free(memc
);
3084 return TEST_SUCCESS
;
3088 static test_return_t
result_static(memcached_st
*memc
)
3090 memcached_result_st result
;
3091 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3092 test_false(result
.options
.is_allocated
);
3093 test_true(memcached_is_initialized(&result
));
3094 test_true(result_ptr
);
3095 test_true(result_ptr
== &result
);
3097 memcached_result_free(&result
);
3099 test_false(result
.options
.is_allocated
);
3100 test_false(memcached_is_initialized(&result
));
3102 return TEST_SUCCESS
;
3105 static test_return_t
result_alloc(memcached_st
*memc
)
3107 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3108 test_true(result_ptr
);
3109 test_true(result_ptr
->options
.is_allocated
);
3110 test_true(memcached_is_initialized(result_ptr
));
3111 memcached_result_free(result_ptr
);
3113 return TEST_SUCCESS
;
3116 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3119 pairs_free(global_pairs
);
3121 return TEST_SUCCESS
;
3124 static test_return_t
generate_pairs(memcached_st
*)
3126 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3127 global_count
= GLOBAL_COUNT
;
3129 for (size_t x
= 0; x
< global_count
; x
++)
3131 global_keys
[x
]= global_pairs
[x
].key
;
3132 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3135 return TEST_SUCCESS
;
3138 static test_return_t
generate_large_pairs(memcached_st
*)
3140 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3141 global_count
= GLOBAL2_COUNT
;
3143 for (size_t x
= 0; x
< global_count
; x
++)
3145 global_keys
[x
]= global_pairs
[x
].key
;
3146 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3149 return TEST_SUCCESS
;
3152 static test_return_t
generate_data(memcached_st
*memc
)
3154 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3156 test_compare(check_execute
, global_count
);
3158 return TEST_SUCCESS
;
3161 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3163 uint32_t host_index
= 0;
3164 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3166 test_true(check_execute
== global_count
);
3168 // @todo hosts used size stats
3169 memcached_return_t rc
;
3170 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3173 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3175 /* This test was changes so that "make test" would work properlly */
3178 memcached_server_instance_st instance
=
3179 memcached_server_instance_by_position(memc
, host_index
);
3181 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3183 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3186 memcached_stat_free(NULL
, stat_p
);
3188 return TEST_SUCCESS
;
3190 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3192 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3193 generate_data(memc
);
3195 return TEST_SUCCESS
;
3198 static test_return_t
get_read_count(memcached_st
*memc
)
3200 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3201 test_true(memc_clone
);
3203 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3207 size_t return_value_length
;
3211 for (size_t x
= count
= 0; x
< global_count
; x
++)
3213 memcached_return_t rc
;
3214 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3215 &return_value_length
, &flags
, &rc
);
3216 if (rc
== MEMCACHED_SUCCESS
)
3227 memcached_free(memc_clone
);
3229 return TEST_SUCCESS
;
3232 static test_return_t
get_read(memcached_st
*memc
)
3234 for (size_t x
= 0; x
< global_count
; x
++)
3236 size_t return_value_length
;
3238 memcached_return_t rc
;
3239 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3240 &return_value_length
, &flags
, &rc
);
3242 test_true(return_value);
3243 test_compare(MEMCACHED_SUCCESS, rc);
3245 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3251 return TEST_SUCCESS
;
3254 static test_return_t
mget_read(memcached_st
*memc
)
3257 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3259 test_compare(MEMCACHED_SUCCESS
,
3260 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3262 // Go fetch the keys and test to see if all of them were returned
3264 unsigned int keys_returned
;
3265 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3266 test_true(keys_returned
> 0);
3267 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3270 return TEST_SUCCESS
;
3273 static test_return_t
mget_read_result(memcached_st
*memc
)
3276 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3278 test_compare(MEMCACHED_SUCCESS
,
3279 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3281 /* Turn this into a help function */
3283 memcached_result_st results_obj
;
3284 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3287 memcached_return_t rc
;
3288 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3290 if (rc
== MEMCACHED_IN_PROGRESS
)
3296 test_compare(MEMCACHED_SUCCESS
, rc
);
3298 test_compare(MEMCACHED_END
, rc
);
3300 memcached_result_free(&results_obj
);
3303 return TEST_SUCCESS
;
3306 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3309 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3311 test_compare(MEMCACHED_SUCCESS
,
3312 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3314 memcached_result_st
*results
= NULL
;
3315 memcached_return_t rc
;
3316 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3319 test_compare(MEMCACHED_SUCCESS
, rc
);
3321 test_compare(MEMCACHED_END
, rc
);
3323 memcached_result_free(results
);
3326 return TEST_SUCCESS
;
3329 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3332 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3334 test_compare(MEMCACHED_SUCCESS
,
3335 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3337 // We will scan for just one key
3339 memcached_result_st results_obj
;
3340 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3342 memcached_return_t rc
;
3343 results
= memcached_fetch_result(memc
, results
, &rc
);
3345 test_compare(MEMCACHED_SUCCESS
, rc
);
3347 memcached_result_free(&results_obj
);
3350 // We already have a read happening, lets start up another one.
3351 test_compare(MEMCACHED_SUCCESS
,
3352 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3354 memcached_result_st results_obj
;
3355 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3357 test_false(memcached_is_allocated(results
));
3359 memcached_return_t rc
;
3360 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3363 test_compare(MEMCACHED_SUCCESS
, rc
);
3365 test_compare(MEMCACHED_END
, rc
);
3367 memcached_result_free(&results_obj
);
3370 return TEST_SUCCESS
;
3373 static test_return_t
mget_read_function(memcached_st
*memc
)
3375 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3377 test_compare(MEMCACHED_SUCCESS
,
3378 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3380 memcached_execute_fn callbacks
[]= { &callback_counter
};
3382 test_compare(MEMCACHED_SUCCESS
,
3383 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3385 return TEST_SUCCESS
;
3388 static test_return_t
delete_generate(memcached_st
*memc
)
3390 for (size_t x
= 0; x
< global_count
; x
++)
3392 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3395 return TEST_SUCCESS
;
3398 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3400 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3402 for (size_t x
= 0; x
< global_count
; x
++)
3404 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3407 return TEST_SUCCESS
;
3410 static test_return_t
add_host_test1(memcached_st
*memc
)
3412 memcached_return_t rc
;
3413 char servername
[]= "0.example.com";
3415 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3417 test_compare(1U, memcached_server_list_count(servers
));
3419 for (uint32_t x
= 2; x
< 20; x
++)
3421 char buffer
[SMALL_STRING_LEN
];
3423 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3424 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3426 test_compare(MEMCACHED_SUCCESS
, rc
);
3427 test_compare(x
, memcached_server_list_count(servers
));
3430 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3431 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3433 memcached_server_list_free(servers
);
3435 return TEST_SUCCESS
;
3438 static test_return_t
pre_nonblock(memcached_st
*memc
)
3440 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3442 return TEST_SUCCESS
;
3445 static test_return_t
pre_cork(memcached_st
*memc
)
3448 return TEST_SKIPPED
;
3451 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3452 return TEST_SUCCESS
;
3454 return TEST_SKIPPED
;
3457 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3460 return TEST_SKIPPED
;
3462 test_return_t test_rc
;
3463 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3466 return pre_nonblock(memc
);
3469 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3471 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3472 test_true(memc_clone
);
3474 // The memcached_version needs to be done on a clone, because the server
3475 // will not toggle protocol on an connection.
3476 memcached_version(memc_clone
);
3478 memcached_return_t rc
= MEMCACHED_FAILURE
;
3479 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3481 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3482 test_compare(MEMCACHED_SUCCESS
,
3483 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3484 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3488 memcached_free(memc_clone
);
3489 return TEST_SKIPPED
;
3492 memcached_free(memc_clone
);
3494 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3497 static test_return_t
pre_murmur(memcached_st
*memc
)
3499 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3500 return TEST_SUCCESS
;
3503 static test_return_t
pre_jenkins(memcached_st
*memc
)
3505 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3507 return TEST_SUCCESS
;
3511 static test_return_t
pre_md5(memcached_st
*memc
)
3513 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3515 return TEST_SUCCESS
;
3518 static test_return_t
pre_crc(memcached_st
*memc
)
3520 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3522 return TEST_SUCCESS
;
3525 static test_return_t
pre_hsieh(memcached_st
*memc
)
3527 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
));
3528 return TEST_SUCCESS
;
3531 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3533 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3535 return TEST_SUCCESS
;
3538 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3540 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
));
3542 return TEST_SUCCESS
;
3545 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3547 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3549 return TEST_SUCCESS
;
3552 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3554 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3556 return TEST_SUCCESS
;
3559 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3561 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3562 test_compare(MEMCACHED_SUCCESS
, rc
);
3564 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3565 test_compare(value
, uint64_t(1));
3567 return TEST_SUCCESS
;
3570 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3572 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3573 test_compare(MEMCACHED_SUCCESS
, rc
);
3575 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3576 test_compare(value
, uint64_t(1));
3578 test_compare(MEMCACHED_SUCCESS
,
3579 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3581 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3582 test_compare(MEMCACHED_HASH_MD5
, memcached_hash_t(value
));
3584 return TEST_SUCCESS
;
3587 static test_return_t
pre_replication(memcached_st
*memc
)
3589 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3592 * Make sure that we store the item on all servers
3593 * (master + replicas == number of servers)
3595 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3596 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3598 return TEST_SUCCESS
;
3602 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3604 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3606 return pre_nonblock(memc
);
3610 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3614 #ifdef HARD_MALLOC_TESTS
3615 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3623 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3627 #ifdef HARD_MALLOC_TESTS
3628 void *ret
= malloc(size
+ 8);
3631 ret
= (void*)((caddr_t
)ret
+ 8);
3634 void *ret
= malloc(size
);
3639 memset(ret
, 0xff, size
);
3646 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3648 #ifdef HARD_MALLOC_TESTS
3649 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3650 void *nmem
= realloc(real_ptr
, size
+ 8);
3655 ret
= (void*)((caddr_t
)nmem
+ 8);
3661 return realloc(mem
, size
);
3666 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3668 #ifdef HARD_MALLOC_TESTS
3669 void *mem
= my_malloc(ptr
, nelem
* size
);
3672 memset(mem
, 0, nelem
* size
);
3678 return calloc(nelem
, size
);
3682 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3684 memcached_return_t rc
;
3685 const char *key
= "mine";
3688 /* Make sure be default none exists */
3689 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3691 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3693 /* Test a clean set */
3694 test_compare(MEMCACHED_SUCCESS
,
3695 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3697 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3699 test_memcmp(value
, key
, 4);
3700 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3702 /* Test that we can turn it off */
3703 test_compare(MEMCACHED_SUCCESS
,
3704 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3706 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3708 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3710 /* Now setup for main test */
3711 test_compare(MEMCACHED_SUCCESS
,
3712 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3714 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3716 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3717 test_memcmp(value
, key
, 4);
3719 /* Set to Zero, and then Set to something too large */
3722 memset(long_key
, 0, 255);
3724 test_compare(MEMCACHED_SUCCESS
,
3725 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3727 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3729 test_compare(MEMCACHED_SUCCESS
, rc
);
3731 /* Test a long key for failure */
3732 /* TODO, extend test to determine based on setting, what result should be */
3733 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3734 test_compare(MEMCACHED_SUCCESS
,
3735 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3737 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3738 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3739 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3740 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3742 /* Test for a bad prefix, but with a short key */
3743 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3744 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3746 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3747 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3750 return TEST_SUCCESS
;
3753 static test_return_t
set_namespace(memcached_st
*memc
)
3755 memcached_return_t rc
;
3756 const char *key
= "mine";
3759 // Make sure we default to a null namespace
3760 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3762 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3764 /* Test a clean set */
3765 test_compare(MEMCACHED_SUCCESS
,
3766 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3768 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3770 test_memcmp(value
, key
, 4);
3771 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3773 return TEST_SUCCESS
;
3776 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3778 test_return_if(pre_binary(memc
));
3779 test_return_if(set_namespace(memc
));
3781 return TEST_SUCCESS
;
3784 #ifdef MEMCACHED_ENABLE_DEPRECATED
3785 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3787 void *test_ptr
= NULL
;
3790 memcached_malloc_fn malloc_cb
=
3791 (memcached_malloc_fn
)my_malloc
;
3792 cb_ptr
= *(void **)&malloc_cb
;
3793 memcached_return_t rc
;
3795 test_compare(MEMCACHED_SUCCESS
,
3796 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3797 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3798 test_compare(MEMCACHED_SUCCESS
, rc
);
3799 test_true(test_ptr
== cb_ptr
);
3803 memcached_realloc_fn realloc_cb
=
3804 (memcached_realloc_fn
)my_realloc
;
3805 cb_ptr
= *(void **)&realloc_cb
;
3806 memcached_return_t rc
;
3808 test_compare(MEMCACHED_SUCCESS
,
3809 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3810 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3811 test_compare(MEMCACHED_SUCCESS
, rc
);
3812 test_true(test_ptr
== cb_ptr
);
3816 memcached_free_fn free_cb
=
3817 (memcached_free_fn
)my_free
;
3818 cb_ptr
= *(void **)&free_cb
;
3819 memcached_return_t rc
;
3821 test_compare(MEMCACHED_SUCCESS
,
3822 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3823 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3824 test_compare(MEMCACHED_SUCCESS
, rc
);
3825 test_true(test_ptr
== cb_ptr
);
3828 return TEST_SUCCESS
;
3833 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3835 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3836 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3837 my_realloc
, my_calloc
, NULL
));
3839 test_compare(MEMCACHED_SUCCESS
,
3840 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3841 my_realloc
, my_calloc
, NULL
));
3843 memcached_malloc_fn mem_malloc
;
3844 memcached_free_fn mem_free
;
3845 memcached_realloc_fn mem_realloc
;
3846 memcached_calloc_fn mem_calloc
;
3847 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3848 &mem_realloc
, &mem_calloc
);
3850 test_true(mem_malloc
== my_malloc
);
3851 test_true(mem_realloc
== my_realloc
);
3852 test_true(mem_calloc
== my_calloc
);
3853 test_true(mem_free
== my_free
);
3855 return TEST_SUCCESS
;
3858 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3861 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3862 memcached_hash_t hash
;
3863 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3864 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3867 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3868 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3870 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3872 if (hash
!= MEMCACHED_HASH_CRC
)
3873 return TEST_SKIPPED
;
3875 return TEST_SUCCESS
;
3878 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3881 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3882 memcached_hash_t hash
;
3883 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3884 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3889 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3890 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3892 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3894 if (hash
!= MEMCACHED_HASH_HSIEH
)
3895 return TEST_SKIPPED
;
3898 return TEST_SUCCESS
;
3901 static test_return_t
enable_cas(memcached_st
*memc
)
3903 unsigned int set
= 1;
3905 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3907 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3909 return TEST_SUCCESS
;
3912 return TEST_SKIPPED
;
3915 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3917 memcached_version(memc
);
3919 memcached_server_instance_st instance
=
3920 memcached_server_instance_by_position(memc
, 0);
3922 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3923 or instance
->minor_version
> 2)
3925 return TEST_SUCCESS
;
3928 return TEST_SKIPPED
;
3931 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3935 memcached_servers_reset(memc
);
3936 const char *socket_file
= default_socket();
3938 test_skip(0, stat(socket_file
, &buf
));
3940 test_compare(MEMCACHED_SUCCESS
,
3941 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
3943 return TEST_SUCCESS
;
3946 static test_return_t
pre_nodelay(memcached_st
*memc
)
3948 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3949 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3951 return TEST_SUCCESS
;
3954 static test_return_t
pre_settimer(memcached_st
*memc
)
3956 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3957 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3959 return TEST_SUCCESS
;
3962 static test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3964 const uint64_t timeout
= 100; // Not using, just checking that it sets
3966 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3968 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3970 return TEST_SUCCESS
;
3973 static test_return_t
noreply_test(memcached_st
*memc
)
3975 test_compare(MEMCACHED_SUCCESS
,
3976 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
3977 test_compare(MEMCACHED_SUCCESS
,
3978 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1));
3979 test_compare(MEMCACHED_SUCCESS
,
3980 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
3981 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3982 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3983 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3985 memcached_return_t ret
;
3986 for (int count
= 0; count
< 5; ++count
)
3988 for (size_t x
= 0; x
< 100; ++x
)
3991 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3992 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3994 size_t len
= (size_t)check_length
;
3999 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4002 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4005 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4008 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4011 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4017 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, ret
));
4021 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4022 ** API and is _ONLY_ done this way to verify that the library works the
4023 ** way it is supposed to do!!!!
4026 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4028 memcached_server_instance_st instance
=
4029 memcached_server_instance_by_position(memc
, x
);
4030 no_msg
+=(int)(instance
->cursor_active
);
4033 test_true(no_msg
== 0);
4034 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4037 ** Now validate that all items was set properly!
4039 for (size_t x
= 0; x
< 100; ++x
)
4043 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4045 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4047 size_t len
= (size_t)check_length
;
4050 char* value
=memcached_get(memc
, key
, strlen(key
),
4051 &length
, &flags
, &ret
);
4052 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
4055 case 0: /* FALLTHROUGH */
4056 case 1: /* FALLTHROUGH */
4058 test_true(strncmp(value
, key
, len
) == 0);
4059 test_true(len
== length
);
4062 test_true(length
== len
* 2);
4065 test_true(length
== len
* 3);
4075 /* Try setting an illegal cas value (should not return an error to
4076 * the caller (because we don't expect a return message from the server)
4078 const char* keys
[]= {"0"};
4079 size_t lengths
[]= {1};
4082 memcached_result_st results_obj
;
4083 memcached_result_st
*results
;
4084 test_compare(MEMCACHED_SUCCESS
,
4085 memcached_mget(memc
, keys
, lengths
, 1));
4087 results
= memcached_result_create(memc
, &results_obj
);
4089 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4091 test_compare(MEMCACHED_SUCCESS
, ret
);
4092 uint64_t cas
= memcached_result_cas(results
);
4093 memcached_result_free(&results_obj
);
4095 test_compare(MEMCACHED_SUCCESS
,
4096 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4099 * The item will have a new cas value, so try to set it again with the old
4100 * value. This should fail!
4102 test_compare(MEMCACHED_SUCCESS
,
4103 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4104 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4105 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4106 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4109 return TEST_SUCCESS
;
4112 static test_return_t
analyzer_test(memcached_st
*memc
)
4114 memcached_return_t rc
;
4115 memcached_analysis_st
*report
;
4117 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4118 test_compare(MEMCACHED_SUCCESS
, rc
);
4119 test_true(memc_stat
);
4121 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4122 test_compare(MEMCACHED_SUCCESS
, rc
);
4126 memcached_stat_free(NULL
, memc_stat
);
4128 return TEST_SUCCESS
;
4131 /* Count the objects */
4133 static test_return_t
dump_test(memcached_st
*memc
)
4135 /* No support for Binary protocol yet */
4136 test_skip(false, memc
->flags
.binary_protocol
);
4138 test_compare(TEST_SUCCESS
, set_test3(memc
));
4140 // confirm_key_count() call dump
4141 size_t counter
= confirm_key_count(memc
);
4143 /* We may have more then 32 if our previous flush has not completed */
4144 test_true(counter
>= 32);
4146 return TEST_SUCCESS
;
4149 static test_return_t
util_version_test(memcached_st
*memc
)
4151 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
4152 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
4154 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4156 // We expect failure
4159 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4160 fprintf(stderr
, "\nDumping Server Information\n\n");
4161 memcached_server_fn callbacks
[1];
4163 callbacks
[0]= dump_server_information
;
4164 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4165 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4167 test_true(if_successful
== false);
4169 memcached_server_instance_st instance
=
4170 memcached_server_instance_by_position(memc
, 0);
4172 memcached_version(memc
);
4174 // We only use one binary when we test, so this should be just fine.
4175 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4176 test_true(if_successful
== true);
4178 if (instance
->micro_version
> 0)
4180 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4182 else if (instance
->minor_version
> 0)
4184 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4186 else if (instance
->major_version
> 0)
4188 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4191 test_true(if_successful
== true);
4193 if (instance
->micro_version
> 0)
4195 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4197 else if (instance
->minor_version
> 0)
4199 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4201 else if (instance
->major_version
> 0)
4203 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4206 test_true(if_successful
== false);
4208 return TEST_SUCCESS
;
4211 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4213 memcached_return_t rc
;
4214 memcached_server_instance_st instance
=
4215 memcached_server_instance_by_position(memc
, 0);
4217 // Test both the version that returns a code, and the one that does not.
4218 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4219 memcached_server_port(instance
) -1, NULL
) == -1);
4221 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4222 memcached_server_port(instance
) -1, &rc
) == -1);
4223 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4225 return TEST_SUCCESS
;
4229 static test_return_t
getpid_test(memcached_st
*memc
)
4231 memcached_return_t rc
;
4232 memcached_server_instance_st instance
=
4233 memcached_server_instance_by_position(memc
, 0);
4235 // Test both the version that returns a code, and the one that does not.
4236 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4237 memcached_server_port(instance
), NULL
) > -1);
4239 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4240 memcached_server_port(instance
), &rc
) > -1);
4241 test_compare(MEMCACHED_SUCCESS
, rc
);
4243 return TEST_SUCCESS
;
4246 static test_return_t
ping_test(memcached_st
*memc
)
4248 memcached_return_t rc
;
4249 memcached_server_instance_st instance
=
4250 memcached_server_instance_by_position(memc
, 0);
4252 // Test both the version that returns a code, and the one that does not.
4253 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4254 memcached_server_port(instance
), NULL
));
4256 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4257 memcached_server_port(instance
), &rc
));
4259 test_compare(MEMCACHED_SUCCESS
, rc
);
4261 return TEST_SUCCESS
;
4266 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4270 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4271 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4272 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4273 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4274 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4275 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4276 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4277 #ifdef HAVE_HSIEH_HASH
4278 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4280 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4281 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4282 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4284 return TEST_SUCCESS
;
4288 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4290 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4292 test_compare(MEMCACHED_SUCCESS
,
4293 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4294 (uint64_t)MEMCACHED_HASH_HSIEH
));
4296 return TEST_SUCCESS
;
4299 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4301 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4303 test_compare(MEMCACHED_SUCCESS
,
4304 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
4306 return TEST_SUCCESS
;
4309 static test_return_t
one_at_a_time_run (memcached_st
*)
4314 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4316 test_compare(one_at_a_time_values
[x
],
4317 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
4320 return TEST_SUCCESS
;
4323 static test_return_t
md5_run (memcached_st
*)
4328 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4330 test_compare(md5_values
[x
],
4331 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
4334 return TEST_SUCCESS
;
4337 static test_return_t
crc_run (memcached_st
*)
4342 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4344 test_compare(crc_values
[x
],
4345 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
4348 return TEST_SUCCESS
;
4351 static test_return_t
fnv1_64_run (memcached_st
*)
4353 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
4358 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4360 test_compare(fnv1_64_values
[x
],
4361 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
4364 return TEST_SUCCESS
;
4367 static test_return_t
fnv1a_64_run (memcached_st
*)
4369 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
4374 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4376 test_compare(fnv1a_64_values
[x
],
4377 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
4380 return TEST_SUCCESS
;
4383 static test_return_t
fnv1_32_run (memcached_st
*)
4388 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4390 test_compare(fnv1_32_values
[x
],
4391 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
4394 return TEST_SUCCESS
;
4397 static test_return_t
fnv1a_32_run (memcached_st
*)
4402 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4404 test_compare(fnv1a_32_values
[x
],
4405 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
4408 return TEST_SUCCESS
;
4411 static test_return_t
hsieh_run (memcached_st
*)
4413 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4418 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4420 test_compare(hsieh_values
[x
],
4421 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
4424 return TEST_SUCCESS
;
4427 static test_return_t
murmur_run (memcached_st
*)
4429 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4431 #ifdef WORDS_BIGENDIAN
4432 (void)murmur_values
;
4433 return TEST_SKIPPED
;
4438 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4440 test_compare(murmur_values
[x
],
4441 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
4444 return TEST_SUCCESS
;
4448 static test_return_t
jenkins_run (memcached_st
*)
4453 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4455 test_compare(jenkins_values
[x
],
4456 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
4459 return TEST_SUCCESS
;
4462 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
4464 return libhashkit_md5(string
, string_length
);
4467 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
4469 return libhashkit_crc32(string
, string_length
);
4472 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4478 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5"));
4480 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};
4481 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};
4483 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4485 hashkit_clone(&new_kit
, kit
);
4486 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4488 memcached_set_hashkit(memc
, &new_kit
);
4491 Verify Setting the hash.
4493 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4497 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4498 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4503 Now check memcached_st.
4505 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4509 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4510 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4513 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4515 memcached_set_hashkit(memc
, &new_kit
);
4518 Verify Setting the hash.
4520 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4524 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4525 test_true(crc_values
[x
] == hash_val
);
4528 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4532 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4533 test_compare(crc_hosts
[x
], hash_val
);
4536 memcached_free(memc
);
4538 return TEST_SUCCESS
;
4542 Test case adapted from John Gorman <johngorman2@gmail.com>
4544 We are testing the error condition when we connect to a server via memcached_get()
4545 but find that the server is not available.
4547 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4549 const char *key
= "MemcachedLives";
4552 memcached_return rc
;
4555 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4557 // See if memcached is reachable.
4558 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4562 test_true(memcached_failed(rc
));
4564 memcached_free(tl_memc_h
);
4566 return TEST_SUCCESS
;
4570 We connect to a server which exists, but search for a key that does not exist.
4572 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4574 const char *key
= "MemcachedKeyNotEXIST";
4577 memcached_return rc
;
4579 // See if memcached is reachable.
4580 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4584 test_compare(MEMCACHED_NOTFOUND
, rc
);
4586 return TEST_SUCCESS
;
4590 Test case adapted from John Gorman <johngorman2@gmail.com>
4592 We are testing the error condition when we connect to a server via memcached_get_by_key()
4593 but find that the server is not available.
4595 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4598 memcached_st
*tl_memc_h
;
4599 memcached_server_st
*servers
;
4601 const char *key
= "MemcachedLives";
4604 memcached_return rc
;
4608 tl_memc_h
= memcached_create(NULL
);
4609 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4610 memcached_server_push(tl_memc_h
, servers
);
4611 memcached_server_list_free(servers
);
4613 // See if memcached is reachable.
4614 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4618 test_true(memcached_failed(rc
));
4620 memcached_free(tl_memc_h
);
4622 return TEST_SUCCESS
;
4626 We connect to a server which exists, but search for a key that does not exist.
4628 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4630 const char *key
= "MemcachedKeyNotEXIST";
4633 memcached_return rc
;
4636 // See if memcached is reachable.
4637 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4641 test_compare(MEMCACHED_NOTFOUND
, rc
);
4643 return TEST_SUCCESS
;
4646 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4648 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4650 const char *key
= "regression_bug_434484";
4651 size_t keylen
= strlen(key
);
4653 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4654 test_compare(MEMCACHED_NOTSTORED
, ret
);
4656 size_t size
= 2048 * 1024;
4657 char *data
= (char*)calloc(1, size
);
4659 test_compare(MEMCACHED_E2BIG
,
4660 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4663 return TEST_SUCCESS
;
4666 static test_return_t
regression_bug_434843(memcached_st
*memc
)
4668 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4670 memcached_return_t rc
;
4672 memcached_execute_fn callbacks
[]= { &callback_counter
};
4675 * I only want to hit only _one_ server so I know the number of requests I'm
4676 * sending in the pipleine to the server. Let's try to do a multiget of
4677 * 1024 (that should satisfy most users don't you think?). Future versions
4678 * will include a mget_execute function call if you need a higher number.
4680 uint32_t number_of_hosts
= memcached_server_count(memc
);
4681 memc
->number_of_hosts
= 1;
4682 const size_t max_keys
= 1024;
4683 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4684 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4686 for (size_t x
= 0; x
< max_keys
; ++x
)
4690 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4696 * Run two times.. the first time we should have 100% cache miss,
4697 * and the second time we should have 100% cache hits
4699 for (size_t y
= 0; y
< 2; y
++)
4701 test_compare(MEMCACHED_SUCCESS
,
4702 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4704 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4705 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4709 /* The first iteration should give me a 100% cache miss. verify that*/
4710 char blob
[1024]= { 0 };
4712 test_false(counter
);
4714 for (size_t x
= 0; x
< max_keys
; ++x
)
4716 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4717 blob
, sizeof(blob
), 0, 0);
4718 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4723 /* Verify that we received all of the key/value pairs */
4724 test_compare(counter
, max_keys
);
4728 /* Release allocated resources */
4729 for (size_t x
= 0; x
< max_keys
; ++x
)
4736 memc
->number_of_hosts
= number_of_hosts
;
4738 return TEST_SUCCESS
;
4741 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4743 memcached_return_t rc
;
4744 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4745 test_compare(MEMCACHED_SUCCESS
, rc
);
4747 return regression_bug_434843(memc
);
4750 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4752 memcached_return_t rc
;
4753 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4754 test_compare(MEMCACHED_SUCCESS
, rc
);
4756 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4757 test_compare(MEMCACHED_SUCCESS
, rc
);
4758 test_true(bytes_str
);
4759 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4761 test_compare(MEMCACHED_SUCCESS
, rc
);
4762 test_true(bytes_read_str
);
4764 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4765 "bytes_written", &rc
);
4766 test_compare(MEMCACHED_SUCCESS
, rc
);
4767 test_true(bytes_written_str
);
4769 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4770 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4771 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4773 test_true(bytes
!= bytes_read
);
4774 test_true(bytes
!= bytes_written
);
4776 /* Release allocated resources */
4778 free(bytes_read_str
);
4779 free(bytes_written_str
);
4780 memcached_stat_free(NULL
, memc_stat
);
4782 return TEST_SUCCESS
;
4786 * The test case isn't obvious so I should probably document why
4787 * it works the way it does. Bug 442914 was caused by a bug
4788 * in the logic in memcached_purge (it did not handle the case
4789 * where the number of bytes sent was equal to the watermark).
4790 * In this test case, create messages so that we hit that case
4791 * and then disable noreply mode and issue a new command to
4792 * verify that it isn't stuck. If we change the format for the
4793 * delete command or the watermarks, we need to update this
4796 static test_return_t
regression_bug_442914(memcached_st
*memc
)
4798 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4799 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4801 uint32_t number_of_hosts
= memcached_server_count(memc
);
4802 memc
->number_of_hosts
= 1;
4807 for (uint32_t x
= 0; x
< 250; ++x
)
4809 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4810 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4811 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4814 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
4817 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4818 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4820 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4821 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
4823 memc
->number_of_hosts
= number_of_hosts
;
4825 return TEST_SUCCESS
;
4828 static test_return_t
regression_bug_447342(memcached_st
*memc
)
4830 memcached_server_instance_st instance_one
;
4831 memcached_server_instance_st instance_two
;
4833 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4834 return TEST_SKIPPED
;
4836 test_compare(MEMCACHED_SUCCESS
,
4837 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4839 const unsigned int max_keys
= 100;
4840 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4841 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4843 for (unsigned int x
= 0; x
< max_keys
; ++x
)
4847 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4850 test_compare(MEMCACHED_SUCCESS
,
4851 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
4855 ** We are using the quiet commands to store the replicas, so we need
4856 ** to ensure that all of them are processed before we can continue.
4857 ** In the test we go directly from storing the object to trying to
4858 ** receive the object from all of the different servers, so we
4859 ** could end up in a race condition (the memcached server hasn't yet
4860 ** processed the quiet command from the replication set when it process
4861 ** the request from the other client (created by the clone)). As a
4862 ** workaround for that we call memcached_quit to send the quit command
4863 ** to the server and wait for the response ;-) If you use the test code
4864 ** as an example for your own code, please note that you shouldn't need
4867 memcached_quit(memc
);
4869 /* Verify that all messages are stored, and we didn't stuff too much
4872 test_compare(MEMCACHED_SUCCESS
,
4873 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4875 unsigned int counter
= 0;
4876 memcached_execute_fn callbacks
[]= { &callback_counter
};
4877 test_compare(MEMCACHED_SUCCESS
,
4878 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4880 /* Verify that we received all of the key/value pairs */
4881 test_compare(counter
, max_keys
);
4883 memcached_quit(memc
);
4885 * Don't do the following in your code. I am abusing the internal details
4886 * within the library, and this is not a supported interface.
4887 * This is to verify correct behavior in the library. Fake that two servers
4890 instance_one
= memcached_server_instance_by_position(memc
, 0);
4891 instance_two
= memcached_server_instance_by_position(memc
, 2);
4892 in_port_t port0
= instance_one
->port
;
4893 in_port_t port2
= instance_two
->port
;
4895 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4896 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4898 test_compare(MEMCACHED_SUCCESS
,
4899 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4902 test_compare(MEMCACHED_SUCCESS
,
4903 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4904 test_compare(counter
, (unsigned int)max_keys
);
4906 /* restore the memc handle */
4907 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4908 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4910 memcached_quit(memc
);
4912 /* Remove half of the objects */
4913 for (size_t x
= 0; x
< max_keys
; ++x
)
4917 test_compare(MEMCACHED_SUCCESS
,
4918 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
4922 memcached_quit(memc
);
4923 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4924 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4926 /* now retry the command, this time we should have cache misses */
4927 test_compare(MEMCACHED_SUCCESS
,
4928 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4931 test_compare(MEMCACHED_SUCCESS
,
4932 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4933 test_compare(counter
, (unsigned int)(max_keys
>> 1));
4935 /* Release allocated resources */
4936 for (size_t x
= 0; x
< max_keys
; ++x
)
4943 /* restore the memc handle */
4944 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4945 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4947 return TEST_SUCCESS
;
4950 static test_return_t
regression_bug_463297(memcached_st
*memc
)
4952 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4953 test_true(memc_clone
);
4954 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4956 memcached_server_instance_st instance
=
4957 memcached_server_instance_by_position(memc_clone
, 0);
4959 if (instance
->major_version
> 1 ||
4960 (instance
->major_version
== 1 &&
4961 instance
->minor_version
> 2))
4963 /* Binary protocol doesn't support deferred delete */
4964 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4965 test_true(bin_clone
);
4966 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4967 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4968 memcached_free(bin_clone
);
4970 memcached_quit(memc_clone
);
4972 /* If we know the server version, deferred delete should fail
4973 * with invalid arguments */
4974 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4976 /* If we don't know the server version, we should get a protocol error */
4977 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4979 /* but there is a bug in some of the memcached servers (1.4) that treats
4980 * the counter as noreply so it doesn't send the proper error message
4982 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4984 /* And buffered mode should be disabled and we should get protocol error */
4985 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4986 rc
= memcached_delete(memc
, "foo", 3, 1);
4987 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4989 /* Same goes for noreply... */
4990 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4991 rc
= memcached_delete(memc
, "foo", 3, 1);
4992 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4994 /* but a normal request should go through (and be buffered) */
4995 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4996 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4998 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4999 /* unbuffered noreply should be success */
5000 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
5001 /* unbuffered with reply should be not found... */
5002 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5003 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
5006 memcached_free(memc_clone
);
5007 return TEST_SUCCESS
;
5011 /* Test memcached_server_get_last_disconnect
5012 * For a working server set, shall be NULL
5013 * For a set of non existing server, shall not be NULL
5015 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5017 memcached_return_t rc
;
5018 memcached_server_instance_st disconnected_server
;
5020 /* With the working set of server */
5021 const char *key
= "marmotte";
5022 const char *value
= "milka";
5024 memcached_reset_last_disconnected_server(memc
);
5025 test_false(memc
->last_disconnected_server
);
5026 rc
= memcached_set(memc
, key
, strlen(key
),
5027 value
, strlen(value
),
5028 (time_t)0, (uint32_t)0);
5029 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5031 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5032 test_false(disconnected_server
);
5034 /* With a non existing server */
5036 memcached_server_st
*servers
;
5038 const char *server_list
= "localhost:9";
5040 servers
= memcached_servers_parse(server_list
);
5042 mine
= memcached_create(NULL
);
5043 rc
= memcached_server_push(mine
, servers
);
5044 test_compare(MEMCACHED_SUCCESS
, rc
);
5045 memcached_server_list_free(servers
);
5048 rc
= memcached_set(mine
, key
, strlen(key
),
5049 value
, strlen(value
),
5050 (time_t)0, (uint32_t)0);
5051 test_true(memcached_failed(rc
));
5053 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5054 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5055 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5056 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5058 memcached_quit(mine
);
5059 memcached_free(mine
);
5061 return TEST_SUCCESS
;
5064 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5066 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5067 char buffer
[BUFSIZ
];
5069 test_compare(MEMCACHED_SUCCESS
,
5070 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5072 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5075 // We will just use the error strings as our keys
5076 uint32_t counter
= 100;
5079 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5081 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5082 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5083 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
5085 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5086 test_true(disconnected_server
);
5087 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5088 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5092 memcached_reset_last_disconnected_server(memc
);
5097 memcached_free(memc
);
5099 return TEST_SUCCESS
;
5102 static test_return_t
test_verbosity(memcached_st
*memc
)
5104 memcached_verbosity(memc
, 3);
5106 return TEST_SUCCESS
;
5110 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5111 const char *key
, size_t key_length
,
5112 const char *value
, size_t value_length
,
5122 return MEMCACHED_SUCCESS
;
5125 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5127 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5128 test_compare(MEMCACHED_SUCCESS
, rc
);
5130 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5131 test_compare(MEMCACHED_SUCCESS
, rc
);
5133 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5134 test_compare(MEMCACHED_SUCCESS
, rc
);
5136 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5137 test_compare(MEMCACHED_SUCCESS
, rc
);
5139 return TEST_SUCCESS
;
5143 * This test ensures that the failure counter isn't incremented during
5144 * normal termination of the memcached instance.
5146 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5148 memcached_return_t rc
;
5149 memcached_server_instance_st instance
;
5151 /* Set value to force connection to the server */
5152 const char *key
= "marmotte";
5153 const char *value
= "milka";
5156 * Please note that I'm abusing the internal structures in libmemcached
5157 * in a non-portable way and you shouldn't be doing this. I'm only
5158 * doing this in order to verify that the library works the way it should
5160 uint32_t number_of_hosts
= memcached_server_count(memc
);
5161 memc
->number_of_hosts
= 1;
5163 /* Ensure that we are connected to the server by setting a value */
5164 rc
= memcached_set(memc
, key
, strlen(key
),
5165 value
, strlen(value
),
5166 (time_t)0, (uint32_t)0);
5167 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5170 instance
= memcached_server_instance_by_position(memc
, 0);
5171 /* The test is to see that the memcached_quit doesn't increase the
5172 * the server failure conter, so let's ensure that it is zero
5173 * before sending quit
5175 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5177 memcached_quit(memc
);
5179 /* Verify that it memcached_quit didn't increment the failure counter
5180 * Please note that this isn't bullet proof, because an error could
5183 test_zero(instance
->server_failure_counter
);
5185 /* restore the instance */
5186 memc
->number_of_hosts
= number_of_hosts
;
5188 return TEST_SUCCESS
;
5192 * This tests ensures expected disconnections (for some behavior changes
5193 * for instance) do not wrongly increase failure counter
5195 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5197 memcached_return rc
;
5199 memcached_st
*memc_clone
;
5200 memc_clone
= memcached_clone(NULL
, memc
);
5201 test_true(memc_clone
);
5203 /* Set value to force connection to the server */
5204 const char *key
= "marmotte";
5205 const char *value
= "milka";
5206 char *string
= NULL
;
5207 size_t string_length
;
5210 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5211 value
, strlen(value
),
5212 (time_t)0, (uint32_t)0);
5213 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5216 /* put failure limit to 1 */
5217 test_compare(MEMCACHED_SUCCESS
,
5218 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1));
5220 /* Put a retry timeout to effectively activate failure_limit effect */
5221 test_compare(MEMCACHED_SUCCESS
,
5222 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
5224 /* change behavior that triggers memcached_quit()*/
5225 test_compare(MEMCACHED_SUCCESS
,
5226 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5229 /* Check if we still are connected */
5230 string
= memcached_get(memc_clone
, key
, strlen(key
),
5231 &string_length
, &flags
, &rc
);
5233 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5236 memcached_free(memc_clone
);
5238 return TEST_SUCCESS
;
5245 * Test that ensures mget_execute does not end into recursive calls that finally fails
5247 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5249 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5250 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5251 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5252 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5253 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5256 return TEST_SKIPPED
; // My MAC can't handle this test
5260 * I only want to hit _one_ server so I know the number of requests I'm
5261 * sending in the pipeline.
5263 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5264 memc
->number_of_hosts
= 1;
5265 size_t max_keys
= 20480;
5268 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5269 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5271 /* First add all of the items.. */
5272 char blob
[1024]= { 0 };
5273 for (size_t x
= 0; x
< max_keys
; ++x
)
5276 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5279 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5280 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5285 /* Try to get all of them with a large multiget */
5287 memcached_execute_function callbacks
[]= { &callback_counter
};
5288 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5289 (size_t)max_keys
, callbacks
, &counter
, 1);
5290 test_compare(MEMCACHED_SUCCESS
, rc
);
5292 char* the_value
= NULL
;
5293 char the_key
[MEMCACHED_MAX_KEY
];
5294 size_t the_key_length
;
5295 size_t the_value_length
;
5299 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5301 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5307 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5310 test_compare(MEMCACHED_END
, rc
);
5312 /* Verify that we got all of the items */
5313 test_compare(counter
, max_keys
);
5316 /* Release all allocated resources */
5317 for (size_t x
= 0; x
< max_keys
; ++x
)
5324 memc
->number_of_hosts
= number_of_hosts
;
5326 return TEST_SUCCESS
;
5329 static test_return_t
regression_bug_583031(memcached_st
*)
5331 memcached_st
*memc
= memcached_create(NULL
);
5333 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5335 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5336 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5337 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5338 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5339 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5340 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5342 memcached_return_t rc
;
5346 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5350 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5352 memcached_free(memc
);
5354 return TEST_SUCCESS
;
5357 static test_return_t
regression_bug_581030(memcached_st
*)
5360 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5361 test_false(local_stat
);
5363 memcached_stat_free(NULL
, NULL
);
5366 return TEST_SUCCESS
;
5369 #define regression_bug_655423_COUNT 6000
5370 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5372 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5373 memc
= NULL
; // Just to make sure it is not used
5378 return TEST_SKIPPED
;
5381 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5382 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5383 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5384 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5386 memset(payload
, int('x'), sizeof(payload
));
5388 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5390 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5391 snprintf(key
, sizeof(key
), "%u", x
);
5393 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5396 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5398 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5399 snprintf(key
, sizeof(key
), "%u", x
);
5401 size_t value_length
;
5402 memcached_return_t rc
;
5403 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5405 if (rc
== MEMCACHED_NOTFOUND
)
5408 test_zero(value_length
);
5412 test_compare(MEMCACHED_SUCCESS
, rc
);
5414 test_compare(100LLU, value_length
);
5418 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5419 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5420 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5422 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5423 snprintf(key
, sizeof(key
), "%u", x
);
5425 keys
[x
]= strdup(key
);
5427 key_length
[x
]= strlen(key
);
5428 test_true(key_length
[x
]);
5431 test_compare(MEMCACHED_SUCCESS
,
5432 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5435 memcached_result_st
*result
= NULL
;
5436 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5438 test_compare(size_t(100), memcached_result_length(result
));
5442 test_true(count
> 100); // If we don't get back atleast this, something is up
5444 /* Release all allocated resources */
5445 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5453 memcached_free(clone
);
5455 return TEST_SUCCESS
;
5459 * Test that ensures that buffered set to not trigger problems during io_flush
5461 #define regression_bug_490520_COUNT 200480
5462 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5464 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5465 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5466 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5467 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5468 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5470 memc
->number_of_hosts
= 1;
5472 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5473 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5475 /* First add all of the items.. */
5476 char blob
[3333] = {0};
5477 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5480 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5484 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5485 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5488 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5495 return TEST_SUCCESS
;
5499 static test_return_t
regression_bug_854604(memcached_st
*)
5503 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
5505 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
5507 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
5508 test_compare(buffer
[0], 0);
5510 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
5511 test_true(strlen(buffer
));
5513 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
5514 test_true(strlen(buffer
));
5516 return TEST_SUCCESS
;
5519 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5521 fprintf(stderr
, "Iteration #%u: ", it
);
5523 if (error
== MEMCACHED_ERRNO
)
5525 fprintf(stderr
, "system error %d from %s: %s\n",
5526 errno
, what
, strerror(errno
));
5530 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5531 memcached_strerror(mc
, error
));
5535 #define TEST_CONSTANT_CREATION 200
5537 static test_return_t
regression_bug_(memcached_st
*memc
)
5539 const char *remote_server
;
5542 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5544 return TEST_SKIPPED
;
5547 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5549 memcached_st
* mc
= memcached_create(NULL
);
5550 memcached_return rc
;
5552 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5553 if (rc
!= MEMCACHED_SUCCESS
)
5555 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5558 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5559 if (rc
!= MEMCACHED_SUCCESS
)
5561 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5564 rc
= memcached_server_add(mc
, remote_server
, 0);
5565 if (rc
!= MEMCACHED_SUCCESS
)
5567 memcached_die(mc
, rc
, "memcached_server_add", x
);
5570 const char *set_key
= "akey";
5571 const size_t set_key_len
= strlen(set_key
);
5572 const char *set_value
= "a value";
5573 const size_t set_value_len
= strlen(set_value
);
5575 if (rc
== MEMCACHED_SUCCESS
)
5579 size_t get_value_len
;
5581 uint32_t get_value_flags
;
5583 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5584 &get_value_flags
, &rc
);
5585 if (rc
!= MEMCACHED_SUCCESS
)
5587 memcached_die(mc
, rc
, "memcached_get", x
);
5593 (get_value_len
!= set_value_len
5594 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5596 fprintf(stderr
, "Values don't match?\n");
5597 rc
= MEMCACHED_FAILURE
;
5603 rc
= memcached_set(mc
,
5604 set_key
, set_key_len
,
5605 set_value
, set_value_len
,
5609 if (rc
!= MEMCACHED_SUCCESS
)
5611 memcached_die(mc
, rc
, "memcached_set", x
);
5618 if (rc
!= MEMCACHED_SUCCESS
)
5624 return TEST_SUCCESS
;
5627 /* Clean the server before beginning testing */
5629 {"util_version", true, (test_callback_fn
*)util_version_test
},
5630 {"flush", false, (test_callback_fn
*)flush_test
},
5631 {"init", false, (test_callback_fn
*)init_test
},
5632 {"allocation", false, (test_callback_fn
*)allocation_test
},
5633 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5634 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5635 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5636 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5637 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5638 {"clone_test", false, (test_callback_fn
*)clone_test
},
5639 {"connection_test", false, (test_callback_fn
*)connection_test
},
5640 {"callback_test", false, (test_callback_fn
*)callback_test
},
5641 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5642 {"set", false, (test_callback_fn
*)set_test
},
5643 {"set2", false, (test_callback_fn
*)set_test2
},
5644 {"set3", false, (test_callback_fn
*)set_test3
},
5645 {"dump", true, (test_callback_fn
*)dump_test
},
5646 {"add", true, (test_callback_fn
*)add_test
},
5647 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5648 {"replace", true, (test_callback_fn
*)replace_test
},
5649 {"delete", true, (test_callback_fn
*)delete_test
},
5650 {"get", true, (test_callback_fn
*)get_test
},
5651 {"get2", false, (test_callback_fn
*)get_test2
},
5652 {"get3", false, (test_callback_fn
*)get_test3
},
5653 {"get4", false, (test_callback_fn
*)get_test4
},
5654 {"partial mget", false, (test_callback_fn
*)get_test5
},
5655 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5656 {"increment", false, (test_callback_fn
*)increment_test
},
5657 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5658 {"decrement", false, (test_callback_fn
*)decrement_test
},
5659 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5660 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5661 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5662 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5663 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5664 {"binary_increment_with_prefix", 1, (test_callback_fn
*)binary_increment_with_prefix_test
},
5665 {"quit", false, (test_callback_fn
*)quit_test
},
5666 {"mget", true, (test_callback_fn
*)mget_test
},
5667 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5668 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5669 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5670 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5671 {"mget_end", false, (test_callback_fn
*)mget_end
},
5672 {"get_stats", false, (test_callback_fn
*)get_stats
},
5673 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5674 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5675 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5676 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
5677 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5678 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5679 {"read_through", true, (test_callback_fn
*)read_through
},
5680 {"delete_through", true, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER
},
5681 {"noreply", true, (test_callback_fn
*)noreply_test
},
5682 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5683 {"memcached_pool_st", true, (test_callback_fn
*)connection_pool_test
},
5684 {"memcached_pool_st #2", true, (test_callback_fn
*)connection_pool2_test
},
5685 {"memcached_pool_st #3", true, (test_callback_fn
*)connection_pool3_test
},
5686 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
5687 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
5688 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
5689 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
5690 {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_NOTFOUND
},
5691 {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_SUCCESS
},
5692 {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_by_key_NOTFOUND
},
5693 {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_by_key_SUCCESS
},
5694 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5695 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5699 test_st touch_tests
[] ={
5700 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5701 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5705 test_st behavior_tests
[] ={
5706 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5707 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5708 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5709 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5710 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5711 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5712 {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test
},
5713 {"MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY", false, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY
},
5717 test_st libmemcachedutil_tests
[] ={
5718 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5719 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5720 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5724 test_st basic_tests
[] ={
5725 {"init", true, (test_callback_fn
*)basic_init_test
},
5726 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5727 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5728 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5729 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5730 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5731 {"memcached_return_t", false, (test_callback_fn
*)memcached_return_t_TEST
},
5735 test_st regression_binary_vs_block
[] ={
5736 {"block add", true, (test_callback_fn
*)block_add_regression
},
5737 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
5741 test_st async_tests
[] ={
5742 {"add", true, (test_callback_fn
*)add_wrapper
},
5746 test_st memcached_server_get_last_disconnect_tests
[] ={
5747 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
5748 {0, 0, (test_callback_fn
*)0}
5752 test_st result_tests
[] ={
5753 {"result static", false, (test_callback_fn
*)result_static
},
5754 {"result alloc", false, (test_callback_fn
*)result_alloc
},
5755 {0, 0, (test_callback_fn
*)0}
5758 test_st version_1_2_3
[] ={
5759 {"append", false, (test_callback_fn
*)append_test
},
5760 {"prepend", false, (test_callback_fn
*)prepend_test
},
5761 {"cas", false, (test_callback_fn
*)cas_test
},
5762 {"cas2", false, (test_callback_fn
*)cas2_test
},
5763 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
5764 {0, 0, (test_callback_fn
*)0}
5767 test_st haldenbrand_tests
[] ={
5768 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
5769 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
5770 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
5771 {0, 0, (test_callback_fn
*)0}
5774 test_st user_tests
[] ={
5775 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
5776 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
5777 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
5778 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
5779 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
5780 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
5781 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
5782 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
5783 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
5784 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
5785 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
5786 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
5787 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
5788 #if !defined(__sun) && !defined(__OpenBSD__)
5790 ** It seems to be something weird with the character sets..
5791 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5792 ** guess I need to find out how this is supposed to work.. Perhaps I need
5793 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5794 ** so just disable the code for now...).
5796 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
5798 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
5799 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
5800 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
5801 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
5802 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
5803 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
5804 {0, 0, (test_callback_fn
*)0}
5807 test_st replication_tests
[]= {
5808 {"set", true, (test_callback_fn
*)replication_set_test
},
5809 {"get", false, (test_callback_fn
*)replication_get_test
},
5810 {"mget", false, (test_callback_fn
*)replication_mget_test
},
5811 {"delete", true, (test_callback_fn
*)replication_delete_test
},
5812 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
5813 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
5814 {0, 0, (test_callback_fn
*)0}
5818 * The following test suite is used to verify that we don't introduce
5819 * regression bugs. If you want more information about the bug / test,
5820 * you should look in the bug report at
5821 * http://bugs.launchpad.net/libmemcached
5823 test_st regression_tests
[]= {
5824 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
5825 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
5826 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
5827 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
5828 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
5829 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
5830 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
5831 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
5832 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
5833 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
5834 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
5835 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
5836 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
5837 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
5838 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
5839 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
5840 {"lp:854604", true, (test_callback_fn
*)regression_bug_854604
},
5841 {0, false, (test_callback_fn
*)0}
5844 test_st ketama_compatibility
[]= {
5845 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
5846 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
5847 {0, 0, (test_callback_fn
*)0}
5850 test_st generate_tests
[] ={
5851 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5852 {"generate_data", true, (test_callback_fn
*)generate_data
},
5853 {"get_read", false, (test_callback_fn
*)get_read
},
5854 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
5855 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5856 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
5857 {"generate_data", true, (test_callback_fn
*)generate_data
},
5858 {"mget_read", false, (test_callback_fn
*)mget_read
},
5859 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
5860 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
5861 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
5862 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
5863 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5864 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
5865 {"generate_data", true, (test_callback_fn
*)generate_data
},
5866 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5867 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5868 {0, 0, (test_callback_fn
*)0}
5871 test_st consistent_tests
[] ={
5872 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5873 {"generate_data", true, (test_callback_fn
*)generate_data
},
5874 {"get_read", 0, (test_callback_fn
*)get_read_count
},
5875 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5876 {0, 0, (test_callback_fn
*)0}
5879 test_st consistent_weighted_tests
[] ={
5880 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5881 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
5882 {"get_read", false, (test_callback_fn
*)get_read_count
},
5883 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5884 {0, 0, (test_callback_fn
*)0}
5887 test_st hsieh_availability
[] ={
5888 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
5889 {0, 0, (test_callback_fn
*)0}
5892 test_st murmur_availability
[] ={
5893 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
5894 {0, 0, (test_callback_fn
*)0}
5898 test_st hash_sanity
[] ={
5899 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
5900 {0, 0, (test_callback_fn
*)0}
5904 test_st ketama_auto_eject_hosts
[] ={
5905 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
5906 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
5907 {0, 0, (test_callback_fn
*)0}
5910 test_st hash_tests
[] ={
5911 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
5912 {"md5", false, (test_callback_fn
*)md5_run
},
5913 {"crc", false, (test_callback_fn
*)crc_run
},
5914 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
5915 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
5916 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
5917 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
5918 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
5919 {"murmur", false, (test_callback_fn
*)murmur_run
},
5920 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
5921 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
5922 {0, 0, (test_callback_fn
*)0}
5925 test_st error_conditions
[] ={
5926 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
5927 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
5928 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
5929 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5930 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5931 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
5932 {0, 0, (test_callback_fn
*)0}
5935 test_st parser_tests
[] ={
5936 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
5937 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
5938 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
5939 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
5940 {"hash", false, (test_callback_fn
*)parser_hash_test
},
5941 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
5942 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
5943 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
5944 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
5945 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
5946 {"server", false, (test_callback_fn
*)server_test
},
5947 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
5948 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
5949 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
5950 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
5951 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
5952 {0, 0, (test_callback_fn
*)0}
5955 test_st virtual_bucket_tests
[] ={
5956 {"basic", false, (test_callback_fn
*)virtual_back_map
},
5957 {0, 0, (test_callback_fn
*)0}
5960 test_st memcached_server_add_tests
[] ={
5961 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
5962 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
5963 {0, 0, (test_callback_fn
*)0}
5966 test_st namespace_tests
[] ={
5967 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
5968 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
5969 {0, 0, (test_callback_fn
*)0}
5972 collection_st collection
[] ={
5974 {"hash_sanity", 0, 0, hash_sanity
},
5976 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
5977 {"basic", 0, 0, basic_tests
},
5978 {"hsieh_availability", 0, 0, hsieh_availability
},
5979 {"murmur_availability", 0, 0, murmur_availability
},
5980 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
5981 {"block", 0, 0, tests
},
5982 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
5983 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
5984 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5985 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
5986 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
5987 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
5988 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
5989 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
5990 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
5991 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
5992 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
5993 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
5994 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
5995 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
5996 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
5997 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5998 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
5999 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
6000 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
6001 #ifdef MEMCACHED_ENABLE_DEPRECATED
6002 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
6004 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
6005 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
6006 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
6007 {"specific namespace", 0, 0, namespace_tests
},
6008 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
6009 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
6010 {"result", 0, 0, result_tests
},
6011 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
6012 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
6013 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
6014 {"user written tests", 0, 0, user_tests
},
6015 {"generate", 0, 0, generate_tests
},
6016 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
6017 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
6018 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
6019 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
6020 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
6021 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
6022 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
6024 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
6025 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
6026 {"consistent_not", 0, 0, consistent_tests
},
6027 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
6028 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6029 {"ketama_compat", 0, 0, ketama_compatibility
},
6030 {"test_hashes", 0, 0, hash_tests
},
6031 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6032 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6033 {"regression", 0, 0, regression_tests
},
6034 {"behaviors", 0, 0, behavior_tests
},
6035 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6036 {"error_conditions", 0, 0, error_conditions
},
6037 {"parser", 0, 0, parser_tests
},
6038 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6039 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6040 {"touch", 0, 0, touch_tests
},
6044 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
6046 #include "tests/libmemcached_world.h"
6048 void get_world(Framework
*world
)
6050 world
->collections
= collection
;
6052 world
->_create
= (test_callback_create_fn
*)world_create
;
6053 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6055 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6056 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6057 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6058 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6059 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6061 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6062 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6064 world
->set_runner(&defualt_libmemcached_runner
);
6066 world
->set_socket();