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 test_skip(true, libmemcached_util_version_check(memc
, 1, 4, 4));
110 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
115 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
118 * I only want to hit _one_ server so I know the number of requests I'm
119 * sending in the pipeline.
121 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
123 char server_string
[1024];
124 int server_string_length
;
127 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
128 memcached_server_name(instance
), int(memcached_server_port(instance
)),
133 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
134 memcached_server_name(instance
), int(memcached_server_port(instance
)));
137 if (server_string_length
<= 0)
143 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, buffer
, sizeof(buffer
))))
145 Error
<< "Failed to parse " << server_string_length
;
149 return memcached(server_string
, server_string_length
);
153 static test_return_t
init_test(memcached_st
*not_used
)
158 (void)memcached_create(&memc
);
159 memcached_free(&memc
);
164 #define TEST_PORT_COUNT 7
165 in_port_t test_ports
[TEST_PORT_COUNT
];
167 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
168 const memcached_server_st
*server
,
172 size_t bigger
= *((size_t *)(context
));
174 assert(bigger
<= memcached_server_port(server
));
175 *((size_t *)(context
))= memcached_server_port(server
);
177 return MEMCACHED_SUCCESS
;
180 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
181 const memcached_server_st
*instance
,
185 FILE *stream
= (FILE *)context
;
188 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
189 memcached_server_name(instance
),
190 memcached_server_port(instance
),
191 instance
->major_version
,
192 instance
->minor_version
,
193 instance
->micro_version
);
195 return MEMCACHED_SUCCESS
;
198 static test_return_t
server_sort_test(memcached_st
*ptr
)
200 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
202 memcached_return_t rc
;
203 memcached_server_fn callbacks
[1];
204 memcached_st
*local_memc
;
207 local_memc
= memcached_create(NULL
);
208 test_true(local_memc
);
209 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
211 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
213 test_ports
[x
]= (in_port_t
)random() % 64000;
214 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
215 test_compare(memcached_server_count(local_memc
), x
+1);
217 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
219 test_compare(MEMCACHED_SUCCESS
, rc
);
222 callbacks
[0]= server_display_function
;
223 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
226 memcached_free(local_memc
);
231 static test_return_t
server_sort2_test(memcached_st
*ptr
)
233 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
234 memcached_server_fn callbacks
[1];
235 memcached_st
*local_memc
;
236 memcached_server_instance_st instance
;
239 local_memc
= memcached_create(NULL
);
240 test_true(local_memc
);
241 test_compare(MEMCACHED_SUCCESS
,
242 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
244 test_compare(MEMCACHED_SUCCESS
,
245 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
246 instance
= memcached_server_instance_by_position(local_memc
, 0);
247 test_compare(in_port_t(43043), memcached_server_port(instance
));
249 test_compare(MEMCACHED_SUCCESS
,
250 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
252 instance
= memcached_server_instance_by_position(local_memc
, 0);
253 test_compare(in_port_t(43042), memcached_server_port(instance
));
255 instance
= memcached_server_instance_by_position(local_memc
, 1);
256 test_compare(in_port_t(43043), memcached_server_port(instance
));
258 callbacks
[0]= server_display_function
;
259 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
262 memcached_free(local_memc
);
267 static test_return_t
memcached_server_remove_test(memcached_st
*)
269 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";
272 test_compare(MEMCACHED_SUCCESS
,
273 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
274 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
277 memcached_server_fn callbacks
[1];
278 callbacks
[0]= server_print_callback
;
279 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
281 memcached_free(memc
);
286 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
287 const memcached_server_st
*server
,
291 uint32_t x
= *((uint32_t *)(context
));
293 if (! (test_ports
[x
] == server
->port
))
295 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
296 return MEMCACHED_FAILURE
;
299 *((uint32_t *)(context
))= ++x
;
301 return MEMCACHED_SUCCESS
;
304 static test_return_t
server_unsort_test(memcached_st
*ptr
)
306 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
307 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
308 memcached_server_fn callbacks
[1];
309 memcached_st
*local_memc
;
312 local_memc
= memcached_create(NULL
);
313 test_true(local_memc
);
315 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
317 test_ports
[x
]= (in_port_t
)(random() % 64000);
318 test_compare(MEMCACHED_SUCCESS
,
319 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
320 test_compare(memcached_server_count(local_memc
), x
+1);
322 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
326 callbacks
[0]= server_display_unsort_function
;
327 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
329 /* Now we sort old data! */
330 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
331 callbacks
[0]= server_display_function
;
332 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
335 memcached_free(local_memc
);
340 static test_return_t
allocation_test(memcached_st
*not_used
)
344 memc
= memcached_create(NULL
);
346 memcached_free(memc
);
351 static test_return_t
clone_test(memcached_st
*memc
)
355 memcached_st
*memc_clone
;
356 memc_clone
= memcached_clone(NULL
, NULL
);
357 test_true(memc_clone
);
358 memcached_free(memc_clone
);
361 /* Can we init from null? */
363 memcached_st
*memc_clone
;
364 memc_clone
= memcached_clone(NULL
, memc
);
365 test_true(memc_clone
);
368 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
369 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
370 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
371 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
374 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
375 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
376 test_true(memc_clone
->distribution
== memc
->distribution
);
377 { // Test all of the flags
378 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
379 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
380 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
381 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
382 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
383 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
384 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
385 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
386 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
387 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
388 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
389 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
390 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
392 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
393 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
394 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
395 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
396 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
397 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
398 test_true(memc_clone
->on_clone
== memc
->on_clone
);
399 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
400 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
401 test_true(memc_clone
->recv_size
== memc
->recv_size
);
402 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
403 test_true(memc_clone
->send_size
== memc
->send_size
);
404 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
405 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
406 test_true(memc_clone
->user_data
== memc
->user_data
);
408 memcached_free(memc_clone
);
411 /* Can we init from struct? */
413 memcached_st declared_clone
;
414 memcached_st
*memc_clone
;
415 memset(&declared_clone
, 0 , sizeof(memcached_st
));
416 memc_clone
= memcached_clone(&declared_clone
, NULL
);
417 test_true(memc_clone
);
418 memcached_free(memc_clone
);
421 /* Can we init from struct? */
423 memcached_st declared_clone
;
424 memcached_st
*memc_clone
;
425 memset(&declared_clone
, 0 , sizeof(memcached_st
));
426 memc_clone
= memcached_clone(&declared_clone
, memc
);
427 test_true(memc_clone
);
428 memcached_free(memc_clone
);
434 static test_return_t
userdata_test(memcached_st
*memc
)
437 test_false(memcached_set_user_data(memc
, foo
));
438 test_true(memcached_get_user_data(memc
) == foo
);
439 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
444 static test_return_t
connection_test(memcached_st
*memc
)
446 test_compare(MEMCACHED_SUCCESS
,
447 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
452 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
454 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
456 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
458 test_compare(36, int(MEMCACHED_BEHAVIOR_MAX
));
463 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
465 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
467 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
469 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
474 static test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
476 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
477 982370485U, 1263635348U, 4242906218U, 3829656100U,
478 1891735253U, 334139633U, 2257084983U, 3088286104U,
479 13199785U, 2542027183U, 1097051614U, 199566778U,
480 2748246961U, 2465192557U, 1664094137U, 2405439045U,
481 1842224848U, 692413798U, 3479807801U, 919913813U,
482 4269430871U, 610793021U, 527273862U, 1437122909U,
483 2300930706U, 2943759320U, 674306647U, 2400528935U,
484 54481931U, 4186304426U, 1741088401U, 2979625118U,
485 4159057246U, 3425930182U, 2593724503U, 1868899624U,
486 1769812374U, 2302537950U, 1110330676U, 3365377466U,
487 1336171666U, 3021258493U, 2334992265U, 3861994737U,
488 3582734124, 3365377466U };
490 // You have updated the memcache_error messages but not updated docs/tests.
491 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
494 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
495 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
496 MEMCACHED_HASH_JENKINS
);
497 if (values
[rc
] != hash_val
)
499 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
500 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
502 test_compare(values
[rc
], hash_val
);
504 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
509 static test_return_t
set_test(memcached_st
*memc
)
511 memcached_return_t rc
= memcached_set(memc
,
512 test_literal_param("foo"),
513 test_literal_param("when we sanitize"),
514 time_t(0), (uint32_t)0);
515 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
520 static test_return_t
append_test(memcached_st
*memc
)
522 memcached_return_t rc
;
523 const char *key
= "fig";
524 const char *in_value
= "we";
525 char *out_value
= NULL
;
529 rc
= memcached_flush(memc
, 0);
530 test_compare(MEMCACHED_SUCCESS
, rc
);
532 rc
= memcached_set(memc
, key
, strlen(key
),
533 in_value
, strlen(in_value
),
534 (time_t)0, (uint32_t)0);
535 test_compare(MEMCACHED_SUCCESS
, rc
);
537 rc
= memcached_append(memc
, key
, strlen(key
),
538 " the", strlen(" the"),
539 (time_t)0, (uint32_t)0);
540 test_compare(MEMCACHED_SUCCESS
, rc
);
542 rc
= memcached_append(memc
, key
, strlen(key
),
543 " people", strlen(" people"),
544 (time_t)0, (uint32_t)0);
545 test_compare(MEMCACHED_SUCCESS
, rc
);
547 out_value
= memcached_get(memc
, key
, strlen(key
),
548 &value_length
, &flags
, &rc
);
549 test_memcmp(out_value
, "we the people", strlen("we the people"));
550 test_compare(strlen("we the people"), value_length
);
551 test_compare(MEMCACHED_SUCCESS
, rc
);
557 static test_return_t
append_binary_test(memcached_st
*memc
)
559 memcached_return_t rc
;
560 const char *key
= "numbers";
561 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
567 rc
= memcached_flush(memc
, 0);
568 test_compare(MEMCACHED_SUCCESS
, rc
);
570 rc
= memcached_set(memc
,
573 (time_t)0, (uint32_t)0);
574 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
576 for (x
= 0; store_list
[x
] ; x
++)
578 rc
= memcached_append(memc
,
580 (char *)&store_list
[x
], sizeof(uint32_t),
581 (time_t)0, (uint32_t)0);
582 test_compare(MEMCACHED_SUCCESS
, rc
);
585 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
586 &value_length
, &flags
, &rc
);
587 test_compare(value_length
, sizeof(uint32_t) * x
);
588 test_compare(MEMCACHED_SUCCESS
, rc
);
590 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
592 test_compare(*ptr
, store_list
[x
- counter
]);
600 static test_return_t
cas2_test(memcached_st
*memc
)
602 memcached_return_t rc
;
603 const char *keys
[]= {"fudge", "son", "food"};
604 size_t key_length
[]= {5, 3, 4};
605 const char *value
= "we the people";
606 size_t value_length
= strlen("we the people");
607 memcached_result_st results_obj
;
608 memcached_result_st
*results
;
611 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
613 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
615 for (uint32_t x
= 0; x
< 3; x
++)
617 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
618 keys
[x
], key_length
[x
],
619 (time_t)50, (uint32_t)9);
620 test_compare(MEMCACHED_SUCCESS
, rc
);
623 test_compare(MEMCACHED_SUCCESS
,
624 memcached_mget(memc
, keys
, key_length
, 3));
626 results
= memcached_result_create(memc
, &results_obj
);
629 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
631 test_true(results
->item_cas
);
632 test_compare(MEMCACHED_SUCCESS
, rc
);
633 test_true(memcached_result_cas(results
));
635 test_memcmp(value
, "we the people", strlen("we the people"));
636 test_compare(strlen("we the people"), value_length
);
637 test_compare(MEMCACHED_SUCCESS
, rc
);
639 memcached_result_free(&results_obj
);
644 static test_return_t
cas_test(memcached_st
*memc
)
646 memcached_return_t rc
;
647 const char *key
= "fun";
648 size_t key_length
= strlen(key
);
649 const char *value
= "we the people";
650 const char* keys
[2] = { key
, NULL
};
651 size_t keylengths
[2] = { strlen(key
), 0 };
652 size_t value_length
= strlen(value
);
653 const char *value2
= "change the value";
654 size_t value2_length
= strlen(value2
);
656 memcached_result_st results_obj
;
657 memcached_result_st
*results
;
660 rc
= memcached_flush(memc
, 0);
661 test_compare(MEMCACHED_SUCCESS
, rc
);
663 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
665 rc
= memcached_set(memc
, key
, strlen(key
),
666 value
, strlen(value
),
667 (time_t)0, (uint32_t)0);
668 test_compare(MEMCACHED_SUCCESS
, rc
);
670 test_compare(MEMCACHED_SUCCESS
,
671 memcached_mget(memc
, keys
, keylengths
, 1));
673 results
= memcached_result_create(memc
, &results_obj
);
676 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
678 test_compare(MEMCACHED_SUCCESS
, rc
);
679 test_true(memcached_result_cas(results
));
680 test_memcmp(value
, memcached_result_value(results
), value_length
);
681 test_compare(strlen(memcached_result_value(results
)), value_length
);
682 test_compare(MEMCACHED_SUCCESS
, rc
);
683 uint64_t cas
= memcached_result_cas(results
);
686 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
687 test_true(rc
== MEMCACHED_END
);
688 test_true(results
== NULL
);
691 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
692 test_compare(MEMCACHED_SUCCESS
, rc
);
695 * The item will have a new cas value, so try to set it again with the old
696 * value. This should fail!
698 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
699 test_compare(MEMCACHED_DATA_EXISTS
, rc
);
701 memcached_result_free(&results_obj
);
706 static test_return_t
prepend_test(memcached_st
*memc
)
708 memcached_return_t rc
;
709 const char *key
= "fig";
710 const char *value
= "people";
711 char *out_value
= NULL
;
715 rc
= memcached_flush(memc
, 0);
716 test_compare(MEMCACHED_SUCCESS
, rc
);
718 rc
= memcached_set(memc
, key
, strlen(key
),
719 value
, strlen(value
),
720 (time_t)0, (uint32_t)0);
721 test_compare(MEMCACHED_SUCCESS
, rc
);
723 rc
= memcached_prepend(memc
, key
, strlen(key
),
724 "the ", strlen("the "),
725 (time_t)0, (uint32_t)0);
726 test_compare(MEMCACHED_SUCCESS
, rc
);
728 rc
= memcached_prepend(memc
, key
, strlen(key
),
729 "we ", strlen("we "),
730 (time_t)0, (uint32_t)0);
731 test_compare(MEMCACHED_SUCCESS
, rc
);
733 out_value
= memcached_get(memc
, key
, strlen(key
),
734 &value_length
, &flags
, &rc
);
735 test_memcmp(out_value
, "we the people", strlen("we the people"));
736 test_compare(strlen("we the people"), value_length
);
737 test_compare(MEMCACHED_SUCCESS
, rc
);
744 Set the value, then quit to make sure it is flushed.
745 Come back in and test that add fails.
747 static test_return_t
add_test(memcached_st
*memc
)
749 memcached_return_t rc
;
750 const char *key
= "foo";
751 const char *value
= "when we sanitize";
752 unsigned long long setting_value
;
754 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
756 rc
= memcached_set(memc
, key
, strlen(key
),
757 value
, strlen(value
),
758 (time_t)0, (uint32_t)0);
759 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
760 memcached_quit(memc
);
761 rc
= memcached_add(memc
, key
, strlen(key
),
762 value
, strlen(value
),
763 (time_t)0, (uint32_t)0);
765 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
768 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
772 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
779 ** There was a problem of leaking filedescriptors in the initial release
780 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
781 ** systems it seems that the kernel is slow on reclaiming the resources
782 ** because the connects starts to time out (the test doesn't do much
783 ** anyway, so just loop 10 iterations)
785 static test_return_t
add_wrapper(memcached_st
*memc
)
787 unsigned int max
= 10000;
795 for (uint32_t x
= 0; x
< max
; x
++)
801 static test_return_t
replace_test(memcached_st
*memc
)
803 memcached_return_t rc
;
804 const char *key
= "foo";
805 const char *value
= "when we sanitize";
806 const char *original
= "first we insert some data";
808 rc
= memcached_set(memc
, key
, strlen(key
),
809 original
, strlen(original
),
810 (time_t)0, (uint32_t)0);
811 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
813 test_compare(MEMCACHED_SUCCESS
,
814 memcached_replace(memc
, key
, strlen(key
),
815 value
, strlen(value
),
816 (time_t)0, (uint32_t)0));
821 static test_return_t
delete_test(memcached_st
*memc
)
823 memcached_return_t rc
;
824 const char *key
= "foo";
825 const char *value
= "when we sanitize";
827 rc
= memcached_set(memc
, key
, strlen(key
),
828 value
, strlen(value
),
829 (time_t)0, (uint32_t)0);
830 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
832 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
833 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
838 static test_return_t
flush_test(memcached_st
*memc
)
840 uint64_t query_id
= memcached_query_id(memc
);
841 test_compare(MEMCACHED_SUCCESS
,
842 memcached_flush(memc
, 0));
843 test_compare(query_id
+1, memcached_query_id(memc
));
848 static memcached_return_t
server_function(const memcached_st
*ptr
,
849 const memcached_server_st
*server
,
852 (void)ptr
; (void)server
; (void)context
;
855 return MEMCACHED_SUCCESS
;
858 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
861 strncpy(context
, "foo bad", sizeof(context
));
862 memcached_server_fn callbacks
[1];
864 callbacks
[0]= server_function
;
865 memcached_server_cursor(memc
, callbacks
, context
, 1);
869 static test_return_t
bad_key_test(memcached_st
*memc
)
871 memcached_return_t rc
;
872 const char *key
= "foo bad";
874 memcached_st
*memc_clone
;
876 uint64_t query_id
= memcached_query_id(memc
);
878 // Just skip if we are in binary mode.
879 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
881 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
883 memc_clone
= memcached_clone(NULL
, memc
);
884 test_true(memc_clone
);
886 query_id
= memcached_query_id(memc_clone
);
887 test_compare(MEMCACHED_SUCCESS
,
888 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
889 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
891 /* All keys are valid in the binary protocol (except for length) */
892 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
894 uint64_t before_query_id
= memcached_query_id(memc_clone
);
896 size_t string_length
;
897 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
898 &string_length
, &flags
, &rc
);
899 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
900 test_zero(string_length
);
903 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
905 query_id
= memcached_query_id(memc_clone
);
906 test_compare(MEMCACHED_SUCCESS
,
907 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
908 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
910 size_t string_length
;
911 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
912 &string_length
, &flags
, &rc
);
913 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
914 test_zero(string_length
);
918 /* Test multi key for bad keys */
919 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
920 size_t key_lengths
[] = { 7, 7, 7 };
921 query_id
= memcached_query_id(memc_clone
);
922 test_compare(MEMCACHED_SUCCESS
,
923 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
924 test_compare(query_id
, memcached_query_id(memc_clone
));
926 query_id
= memcached_query_id(memc_clone
);
927 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
928 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
929 test_compare(query_id
+1, memcached_query_id(memc_clone
));
931 query_id
= memcached_query_id(memc_clone
);
932 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
933 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
934 test_compare(query_id
+1, memcached_query_id(memc_clone
));
936 /* The following test should be moved to the end of this function when the
937 memcached server is updated to allow max size length of the keys in the
940 test_compare(MEMCACHED_SUCCESS
,
941 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
943 std::vector
<char> longkey
;
944 longkey
.reserve(MEMCACHED_MAX_KEY
);
945 longkey
.insert(longkey
.end(), MEMCACHED_MAX_KEY
, 'a');
946 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
948 size_t string_length
;
950 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
951 test_compare(MEMCACHED_NOTFOUND
, rc
);
952 test_zero(string_length
);
954 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
955 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
956 test_zero(string_length
);
960 /* Make sure zero length keys are marked as bad */
962 test_compare(MEMCACHED_SUCCESS
,
963 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
964 size_t string_length
;
965 char *string
= memcached_get(memc_clone
, key
, 0,
966 &string_length
, &flags
, &rc
);
967 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
968 test_zero(string_length
);
972 memcached_free(memc_clone
);
977 #define READ_THROUGH_VALUE "set for me"
978 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
981 memcached_result_st
*result
)
983 (void)memc
;(void)key
;(void)key_length
;
984 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
987 #ifndef __INTEL_COMPILER
988 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
991 static test_return_t
read_through(memcached_st
*memc
)
993 memcached_return_t rc
;
994 const char *key
= "foo";
996 size_t string_length
;
998 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1000 string
= memcached_get(memc
, key
, strlen(key
),
1001 &string_length
, &flags
, &rc
);
1003 test_compare(MEMCACHED_NOTFOUND
, rc
);
1004 test_false(string_length
);
1007 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
);
1008 test_compare(MEMCACHED_SUCCESS
, rc
);
1010 string
= memcached_get(memc
, key
, strlen(key
),
1011 &string_length
, &flags
, &rc
);
1013 test_compare(MEMCACHED_SUCCESS
, rc
);
1014 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1015 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1016 test_strcmp(READ_THROUGH_VALUE
, string
);
1019 string
= memcached_get(memc
, key
, strlen(key
),
1020 &string_length
, &flags
, &rc
);
1022 test_compare(MEMCACHED_SUCCESS
, rc
);
1024 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1025 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1026 test_strcmp(READ_THROUGH_VALUE
, string
);
1029 return TEST_SUCCESS
;
1032 static test_return_t
get_test(memcached_st
*memc
)
1034 memcached_return_t rc
;
1035 const char *key
= "foo";
1037 size_t string_length
;
1040 uint64_t query_id
= memcached_query_id(memc
);
1041 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
1042 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
1043 test_compare(query_id
+1, memcached_query_id(memc
));
1045 string
= memcached_get(memc
, key
, strlen(key
),
1046 &string_length
, &flags
, &rc
);
1048 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1049 test_false(string_length
);
1052 return TEST_SUCCESS
;
1055 static test_return_t
get_test2(memcached_st
*memc
)
1057 const char *key
= "foo";
1058 const char *value
= "when we sanitize";
1060 uint64_t query_id
= memcached_query_id(memc
);
1061 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1062 value
, strlen(value
),
1063 (time_t)0, (uint32_t)0);
1064 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1065 test_compare(query_id
+1, memcached_query_id(memc
));
1067 query_id
= memcached_query_id(memc
);
1068 test_true(query_id
);
1071 size_t string_length
;
1072 char *string
= memcached_get(memc
, key
, strlen(key
),
1073 &string_length
, &flags
, &rc
);
1074 test_compare(query_id
+1, memcached_query_id(memc
));
1076 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1077 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1079 test_compare(strlen(value
), string_length
);
1080 test_memcmp(string
, value
, string_length
);
1084 return TEST_SUCCESS
;
1087 static test_return_t
set_test2(memcached_st
*memc
)
1089 for (uint32_t x
= 0; x
< 10; x
++)
1091 memcached_return_t rc
= memcached_set(memc
,
1092 test_literal_param("foo"),
1093 test_literal_param("train in the brain"),
1094 time_t(0), uint32_t(0));
1095 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1098 return TEST_SUCCESS
;
1101 static test_return_t
set_test3(memcached_st
*memc
)
1103 size_t value_length
= 8191;
1105 std::vector
<char> value
;
1106 value
.reserve(value_length
);
1107 for (uint32_t x
= 0; x
< value_length
; x
++)
1109 value
.push_back(char(x
% 127));
1112 /* The dump test relies on there being at least 32 items in memcached */
1113 for (uint32_t x
= 0; x
< 32; x
++)
1117 snprintf(key
, sizeof(key
), "foo%u", x
);
1119 uint64_t query_id
= memcached_query_id(memc
);
1120 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1121 &value
[0], value
.size(),
1122 (time_t)0, (uint32_t)0);
1123 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1124 test_compare(query_id
+1, memcached_query_id(memc
));
1127 return TEST_SUCCESS
;
1130 static test_return_t
get_test3(memcached_st
*memc
)
1132 const char *key
= "foo";
1133 size_t value_length
= 8191;
1135 std::vector
<char> value
;
1136 value
.reserve(value_length
);
1137 for (uint32_t x
= 0; x
< value_length
; x
++)
1139 value
.push_back(char(x
% 127));
1142 memcached_return_t rc
;
1143 rc
= memcached_set(memc
, key
, strlen(key
),
1144 &value
[0], value
.size(),
1145 (time_t)0, (uint32_t)0);
1146 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1148 size_t string_length
;
1150 char *string
= memcached_get(memc
, key
, strlen(key
),
1151 &string_length
, &flags
, &rc
);
1153 test_compare(MEMCACHED_SUCCESS
, rc
);
1155 test_compare(string_length
, value_length
);
1156 test_memcmp(string
, &value
[0], string_length
);
1160 return TEST_SUCCESS
;
1163 static test_return_t
get_test4(memcached_st
*memc
)
1165 const char *key
= "foo";
1166 size_t value_length
= 8191;
1168 std::vector
<char> value
;
1169 value
.reserve(value_length
);
1170 for (uint32_t x
= 0; x
< value_length
; x
++)
1172 value
.push_back(char(x
% 127));
1175 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1176 &value
[0], value
.size(),
1177 (time_t)0, (uint32_t)0);
1178 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1180 for (uint32_t x
= 0; x
< 10; x
++)
1183 size_t string_length
;
1184 char *string
= memcached_get(memc
, key
, strlen(key
),
1185 &string_length
, &flags
, &rc
);
1187 test_compare(MEMCACHED_SUCCESS
, rc
);
1189 test_compare(string_length
, value_length
);
1190 test_memcmp(string
, &value
[0], string_length
);
1194 return TEST_SUCCESS
;
1198 * This test verifies that memcached_read_one_response doesn't try to
1199 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1200 * responses before you execute a storage command.
1202 static test_return_t
get_test5(memcached_st
*memc
)
1205 ** Request the same key twice, to ensure that we hash to the same server
1206 ** (so that we have multiple response values queued up) ;-)
1208 const char *keys
[]= { "key", "key" };
1209 size_t lengths
[]= { 3, 3 };
1213 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1214 keys
[0], lengths
[0], 0, 0);
1215 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1217 memcached_result_st results_obj
;
1218 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1221 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1224 memcached_result_free(&results_obj
);
1226 /* Don't read out the second result, but issue a set instead.. */
1227 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1229 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1230 &rlen
, &flags
, &rc
);
1232 test_compare(MEMCACHED_NOTFOUND
, rc
);
1233 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1235 test_compare(MEMCACHED_SUCCESS
, rc
);
1238 return TEST_SUCCESS
;
1241 static test_return_t
mget_end(memcached_st
*memc
)
1243 const char *keys
[]= { "foo", "foo2" };
1244 size_t lengths
[]= { 3, 4 };
1245 const char *values
[]= { "fjord", "41" };
1247 memcached_return_t rc
;
1250 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1252 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[x
], lengths
[x
], values
[x
], strlen(values
[x
]), (time_t)0, (uint32_t)0));
1256 size_t string_length
;
1259 // retrieve both via mget
1260 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1262 char key
[MEMCACHED_MAX_KEY
];
1265 // this should get both
1266 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1268 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1270 test_compare(MEMCACHED_SUCCESS
, rc
);
1272 if (key_length
== 4)
1277 test_compare(string_length
, strlen(values
[val
]));
1278 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1282 // this should indicate end
1283 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1284 test_compare(MEMCACHED_END
, rc
);
1288 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1289 test_compare(MEMCACHED_SUCCESS
, rc
);
1291 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1292 test_compare(key_length
, lengths
[0]);
1293 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1294 test_compare(string_length
, strlen(values
[0]));
1295 test_true(strncmp(values
[0], string
, string_length
) == 0);
1296 test_compare(MEMCACHED_SUCCESS
, rc
);
1299 // this should indicate end
1300 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1301 test_compare(MEMCACHED_END
, rc
);
1304 return TEST_SUCCESS
;
1307 /* Do not copy the style of this code, I just access hosts to testthis function */
1308 static test_return_t
stats_servername_test(memcached_st
*memc
)
1310 memcached_stat_st memc_stat
;
1311 memcached_server_instance_st instance
=
1312 memcached_server_instance_by_position(memc
, 0);
1314 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1316 return TEST_SKIPPED
;
1319 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1320 memcached_server_name(instance
),
1321 memcached_server_port(instance
)));
1323 return TEST_SUCCESS
;
1326 static test_return_t
increment_test(memcached_st
*memc
)
1328 uint64_t new_number
;
1330 test_compare(MEMCACHED_SUCCESS
,
1332 test_literal_param("number"),
1333 test_literal_param("0"),
1334 (time_t)0, (uint32_t)0));
1336 test_compare(MEMCACHED_SUCCESS
,
1337 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1338 test_compare(uint64_t(1), new_number
);
1340 test_compare(MEMCACHED_SUCCESS
,
1341 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1342 test_compare(uint64_t(2), new_number
);
1344 return TEST_SUCCESS
;
1347 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1349 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1351 uint64_t new_number
;
1352 uint64_t initial
= 0;
1354 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1356 test_compare(MEMCACHED_SUCCESS
,
1357 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1358 test_compare(new_number
, initial
);
1360 test_compare(MEMCACHED_SUCCESS
,
1361 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1362 test_compare(new_number
, (initial
+1));
1364 return TEST_SUCCESS
;
1367 static test_return_t
decrement_test(memcached_st
*memc
)
1369 uint64_t new_number
;
1370 memcached_return_t rc
;
1371 const char *value
= "3";
1373 rc
= memcached_set(memc
,
1374 test_literal_param("number"),
1375 value
, strlen(value
),
1376 (time_t)0, (uint32_t)0);
1377 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1379 test_compare(MEMCACHED_SUCCESS
,
1380 memcached_decrement(memc
,
1381 test_literal_param("number"),
1383 test_compare(uint64_t(2), new_number
);
1385 test_compare(MEMCACHED_SUCCESS
,
1386 memcached_decrement(memc
,
1387 test_literal_param("number"),
1389 test_compare(uint64_t(1), new_number
);
1391 return TEST_SUCCESS
;
1394 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1396 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1398 uint64_t new_number
;
1399 uint64_t initial
= 3;
1401 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1403 test_compare(MEMCACHED_SUCCESS
,
1404 memcached_decrement_with_initial(memc
,
1405 test_literal_param("number"),
1406 1, initial
, 0, &new_number
));
1407 test_compare(new_number
, initial
);
1409 test_compare(MEMCACHED_SUCCESS
,
1410 memcached_decrement_with_initial(memc
,
1411 test_literal_param("number"),
1412 1, initial
, 0, &new_number
));
1413 test_compare(new_number
, (initial
- 1));
1415 return TEST_SUCCESS
;
1418 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1420 uint64_t new_number
;
1421 memcached_return_t rc
;
1422 const char *master_key
= "foo";
1423 const char *key
= "number";
1424 const char *value
= "0";
1426 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1428 value
, strlen(value
),
1429 (time_t)0, (uint32_t)0);
1430 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1432 test_compare(MEMCACHED_SUCCESS
,
1433 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1434 test_compare(uint64_t(1), new_number
);
1436 test_compare(MEMCACHED_SUCCESS
,
1437 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1438 test_compare(uint64_t(2), new_number
);
1440 return TEST_SUCCESS
;
1443 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1445 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1447 uint64_t new_number
;
1448 memcached_return_t rc
;
1449 const char *master_key
= "foo";
1450 const char *key
= "number";
1451 uint64_t initial
= 0;
1453 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1455 1, initial
, 0, &new_number
);
1456 test_compare(MEMCACHED_SUCCESS
, rc
);
1457 test_compare(new_number
, initial
);
1459 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1461 1, initial
, 0, &new_number
);
1462 test_compare(MEMCACHED_SUCCESS
, rc
);
1463 test_compare(new_number
, (initial
+1));
1465 return TEST_SUCCESS
;
1468 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1470 uint64_t new_number
;
1471 memcached_return_t rc
;
1472 const char *value
= "3";
1474 rc
= memcached_set_by_key(memc
,
1475 test_literal_param("foo"),
1476 test_literal_param("number"),
1477 value
, strlen(value
),
1478 (time_t)0, (uint32_t)0);
1479 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1481 test_compare(MEMCACHED_SUCCESS
,
1482 memcached_decrement_by_key(memc
,
1483 test_literal_param("foo"),
1484 test_literal_param("number"),
1486 test_compare(uint64_t(2), new_number
);
1488 test_compare(MEMCACHED_SUCCESS
,
1489 memcached_decrement_by_key(memc
,
1490 test_literal_param("foo"),
1491 test_literal_param("number"),
1493 test_compare(uint64_t(1), new_number
);
1495 return TEST_SUCCESS
;
1498 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1500 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1502 uint64_t new_number
;
1503 uint64_t initial
= 3;
1505 test_compare(MEMCACHED_SUCCESS
,
1506 memcached_decrement_with_initial_by_key(memc
,
1507 test_literal_param("foo"),
1508 test_literal_param("number"),
1509 1, initial
, 0, &new_number
));
1510 test_compare(new_number
, initial
);
1512 test_compare(MEMCACHED_SUCCESS
,
1513 memcached_decrement_with_initial_by_key(memc
,
1514 test_literal_param("foo"),
1515 test_literal_param("number"),
1516 1, initial
, 0, &new_number
));
1517 test_compare(new_number
, (initial
- 1));
1519 return TEST_SUCCESS
;
1521 static test_return_t
binary_increment_with_prefix_test(memcached_st
*orig_memc
)
1523 memcached_st
*memc
= memcached_clone(NULL
, orig_memc
);
1525 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1527 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1529 memcached_return_t rc
;
1530 rc
= memcached_set(memc
,
1531 test_literal_param("number"),
1532 test_literal_param("0"),
1533 (time_t)0, (uint32_t)0);
1534 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1536 uint64_t new_number
;
1537 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1538 test_literal_param("number"),
1540 test_compare(uint64_t(1), new_number
);
1542 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1543 test_literal_param("number"),
1545 test_compare(uint64_t(2), new_number
);
1546 memcached_free(memc
);
1548 return TEST_SUCCESS
;
1551 static test_return_t
quit_test(memcached_st
*memc
)
1553 memcached_return_t rc
;
1554 const char *key
= "fudge";
1555 const char *value
= "sanford and sun";
1557 rc
= memcached_set(memc
, key
, strlen(key
),
1558 value
, strlen(value
),
1559 (time_t)10, (uint32_t)3);
1560 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1561 memcached_quit(memc
);
1563 rc
= memcached_set(memc
, key
, strlen(key
),
1564 value
, strlen(value
),
1565 (time_t)50, (uint32_t)9);
1566 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1568 return TEST_SUCCESS
;
1571 static test_return_t
mget_result_test(memcached_st
*memc
)
1573 const char *keys
[]= {"fudge", "son", "food"};
1574 size_t key_length
[]= {5, 3, 4};
1576 memcached_result_st results_obj
;
1577 memcached_result_st
*results
;
1579 results
= memcached_result_create(memc
, &results_obj
);
1581 test_true(&results_obj
== results
);
1583 /* We need to empty the server before continueing test */
1584 test_compare(MEMCACHED_SUCCESS
,
1585 memcached_flush(memc
, 0));
1587 test_compare(MEMCACHED_SUCCESS
,
1588 memcached_mget(memc
, keys
, key_length
, 3));
1590 memcached_return_t rc
;
1591 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1596 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1597 test_false(results
);
1598 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1600 for (uint32_t x
= 0; x
< 3; x
++)
1602 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1603 keys
[x
], key_length
[x
],
1604 (time_t)50, (uint32_t)9);
1605 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1608 test_compare(MEMCACHED_SUCCESS
,
1609 memcached_mget(memc
, keys
, key_length
, 3));
1611 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1614 test_true(&results_obj
== results
);
1615 test_compare(MEMCACHED_SUCCESS
, rc
);
1616 test_memcmp(memcached_result_key_value(results
),
1617 memcached_result_value(results
),
1618 memcached_result_length(results
));
1619 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1622 memcached_result_free(&results_obj
);
1624 return TEST_SUCCESS
;
1627 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1629 const char *keys
[]= {"fudge", "son", "food"};
1630 size_t key_length
[]= {5, 3, 4};
1632 memcached_result_st
*results
;
1634 /* We need to empty the server before continueing test */
1635 test_compare(MEMCACHED_SUCCESS
,
1636 memcached_flush(memc
, 0));
1638 test_compare(MEMCACHED_SUCCESS
,
1639 memcached_mget(memc
, keys
, key_length
, 3));
1641 memcached_return_t rc
;
1642 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1646 test_false(results
);
1647 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1649 for (uint32_t x
= 0; x
< 3; x
++)
1651 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1652 keys
[x
], key_length
[x
],
1653 (time_t)50, (uint32_t)9);
1654 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1657 test_compare(MEMCACHED_SUCCESS
,
1658 memcached_mget(memc
, keys
, key_length
, 3));
1661 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1664 test_compare(MEMCACHED_SUCCESS
, rc
);
1665 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1666 test_memcmp(memcached_result_key_value(results
),
1667 memcached_result_value(results
),
1668 memcached_result_length(results
));
1669 memcached_result_free(results
);
1673 return TEST_SUCCESS
;
1676 /* Count the results */
1677 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1679 size_t *counter
= (size_t *)context
;
1681 *counter
= *counter
+ 1;
1683 return MEMCACHED_SUCCESS
;
1686 static test_return_t
mget_result_function(memcached_st
*memc
)
1688 const char *keys
[]= {"fudge", "son", "food"};
1689 size_t key_length
[]= {5, 3, 4};
1691 memcached_execute_fn callbacks
[1];
1693 /* We need to empty the server before continueing test */
1694 test_compare(MEMCACHED_SUCCESS
,
1695 memcached_flush(memc
, 0));
1696 for (uint32_t x
= 0; x
< 3; x
++)
1698 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1699 keys
[x
], key_length
[x
],
1700 (time_t)50, (uint32_t)9);
1701 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1704 test_compare(MEMCACHED_SUCCESS
,
1705 memcached_mget(memc
, keys
, key_length
, 3));
1707 callbacks
[0]= &callback_counter
;
1710 test_compare(MEMCACHED_SUCCESS
,
1711 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1713 test_compare(size_t(3), counter
);
1715 return TEST_SUCCESS
;
1718 static test_return_t
mget_test(memcached_st
*memc
)
1720 const char *keys
[]= {"fudge", "son", "food"};
1721 size_t key_length
[]= {5, 3, 4};
1723 char return_key
[MEMCACHED_MAX_KEY
];
1724 size_t return_key_length
;
1726 size_t return_value_length
;
1728 /* We need to empty the server before continueing test */
1729 test_compare(MEMCACHED_SUCCESS
,
1730 memcached_flush(memc
, 0));
1732 test_compare(MEMCACHED_SUCCESS
,
1733 memcached_mget(memc
, keys
, key_length
, 3));
1736 memcached_return_t rc
;
1737 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1738 &return_value_length
, &flags
, &rc
)))
1740 test_true(return_value
);
1742 test_false(return_value
);
1743 test_zero(return_value_length
);
1744 test_compare(MEMCACHED_NOTFOUND
, rc
);
1746 for (uint32_t x
= 0; x
< 3; x
++)
1748 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1749 keys
[x
], key_length
[x
],
1750 (time_t)50, (uint32_t)9);
1751 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1753 test_compare(MEMCACHED_SUCCESS
,
1754 memcached_mget(memc
, keys
, key_length
, 3));
1757 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1758 &return_value_length
, &flags
, &rc
)))
1760 test_true(return_value
);
1761 test_compare(MEMCACHED_SUCCESS
, rc
);
1762 if (not memc
->_namespace
)
1764 test_compare(return_key_length
, return_value_length
);
1765 test_memcmp(return_value
, return_key
, return_value_length
);
1771 return TEST_SUCCESS
;
1774 static test_return_t
mget_execute(memcached_st
*original_memc
)
1776 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1778 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1781 size_t max_keys
= 20480;
1784 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1785 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1787 /* First add all of the items.. */
1788 char blob
[1024] = {0};
1790 for (size_t x
= 0; x
< max_keys
; ++x
)
1794 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1796 test_true(keys
[x
] != NULL
);
1797 uint64_t query_id
= memcached_query_id(memc
);
1798 memcached_return_t rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1799 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1800 test_compare(query_id
+1, memcached_query_id(memc
));
1803 /* Try to get all of them with a large multiget */
1805 memcached_execute_fn callbacks
[]= { &callback_counter
};
1806 test_compare(MEMCACHED_SUCCESS
,
1807 memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1808 max_keys
, callbacks
, &counter
, 1));
1811 uint64_t query_id
= memcached_query_id(memc
);
1812 test_compare(MEMCACHED_SUCCESS
,
1813 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1814 test_compare(query_id
, memcached_query_id(memc
));
1816 /* Verify that we got all of the items */
1817 test_true(counter
== max_keys
);
1820 /* Release all allocated resources */
1821 for (size_t x
= 0; x
< max_keys
; ++x
)
1828 memcached_free(memc
);
1830 return TEST_SUCCESS
;
1833 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1835 static test_return_t
key_setup(memcached_st
*memc
)
1837 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1839 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1841 return TEST_SUCCESS
;
1844 static test_return_t
key_teardown(memcached_st
*memc
)
1847 pairs_free(global_pairs
);
1849 return TEST_SUCCESS
;
1852 static test_return_t
block_add_regression(memcached_st
*memc
)
1854 /* First add all of the items.. */
1855 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1857 char blob
[1024] = {0};
1859 memcached_return_t rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1860 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
, memcached_strerror(NULL
, rc
));
1863 return TEST_SUCCESS
;
1866 static test_return_t
binary_add_regression(memcached_st
*memc
)
1868 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1869 test_return_t rc
= block_add_regression(memc
);
1874 static test_return_t
get_stats_keys(memcached_st
*memc
)
1878 memcached_stat_st memc_stat
;
1879 memcached_return_t rc
;
1881 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1882 test_compare(MEMCACHED_SUCCESS
, rc
);
1883 for (ptr
= stat_list
; *ptr
; ptr
++)
1888 return TEST_SUCCESS
;
1891 static test_return_t
version_string_test(memcached_st
*)
1893 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1895 return TEST_SUCCESS
;
1898 static test_return_t
get_stats(memcached_st
*memc
)
1900 memcached_return_t rc
;
1902 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1903 test_compare(MEMCACHED_SUCCESS
, rc
);
1904 test_true(memc_stat
);
1906 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1908 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1909 test_compare(MEMCACHED_SUCCESS
, rc
);
1910 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1915 memcached_stat_free(NULL
, memc_stat
);
1917 return TEST_SUCCESS
;
1920 static test_return_t
add_host_test(memcached_st
*memc
)
1922 char servername
[]= "0.example.com";
1924 memcached_return_t rc
;
1925 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1926 test_compare(1U, memcached_server_list_count(servers
));
1928 for (unsigned int x
= 2; x
< 20; x
++)
1930 char buffer
[SMALL_STRING_LEN
];
1932 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1933 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1935 test_compare(MEMCACHED_SUCCESS
, rc
);
1936 test_compare(x
, memcached_server_list_count(servers
));
1939 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1940 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1942 memcached_server_list_free(servers
);
1944 return TEST_SUCCESS
;
1947 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1949 memcached_return_t rc
;
1951 const char *key
= "not_found";
1952 size_t key_length
= test_literal_param_size("not_found");
1954 test_compare(MEMCACHED_SUCCESS
,
1955 memcached_mget(memc
, &key
, &key_length
, 1));
1957 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1959 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1961 memcached_result_free(result
);
1963 return TEST_SUCCESS
;
1966 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1968 return MEMCACHED_SUCCESS
;
1971 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1973 return MEMCACHED_SUCCESS
;
1976 static test_return_t
callback_test(memcached_st
*memc
)
1978 /* Test User Data */
1982 memcached_return_t rc
;
1984 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1985 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1986 test_true(*test_ptr
== x
);
1989 /* Test Clone Callback */
1991 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1992 void *clone_cb_ptr
= *(void **)&clone_cb
;
1993 void *temp_function
= NULL
;
1995 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
1996 memcached_return_t rc
;
1997 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1998 test_true(temp_function
== clone_cb_ptr
);
1999 test_compare(MEMCACHED_SUCCESS
, rc
);
2002 /* Test Cleanup Callback */
2004 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2005 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2006 void *temp_function
= NULL
;
2007 memcached_return_t rc
;
2009 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2010 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2011 test_true(temp_function
== cleanup_cb_ptr
);
2014 return TEST_SUCCESS
;
2017 /* We don't test the behavior itself, we test the switches */
2018 static test_return_t
behavior_test(memcached_st
*memc
)
2020 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2021 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2023 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2024 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2026 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2027 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2029 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2030 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2032 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2033 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2035 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2036 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2038 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2039 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2041 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2043 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2045 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2046 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2047 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2049 return TEST_SUCCESS
;
2052 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2054 test_compare(MEMCACHED_DEPRECATED
,
2055 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2057 // Platform dependent
2059 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2063 return TEST_SUCCESS
;
2067 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2069 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2070 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2072 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2074 if (memcached_success(rc
))
2083 return TEST_SUCCESS
;
2087 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2089 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2090 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2092 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2094 if (memcached_success(rc
))
2103 return TEST_SUCCESS
;
2106 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, const memcached_return_t expect
)
2108 memcached_return_t rc
;
2109 char return_key
[MEMCACHED_MAX_KEY
];
2110 size_t return_key_length
;
2112 size_t return_value_length
;
2116 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2117 &return_value_length
, &flags
, &rc
)))
2119 test_true(return_value
);
2120 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2125 if (memcached_success(expect
) and memcached_success(rc
))
2127 return TEST_SUCCESS
;
2129 else if (expect
== rc
)
2131 return TEST_SUCCESS
;
2133 fprintf(stderr
, "\n%s:%u %s(#%u)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), keys_returned
);
2135 return TEST_FAILURE
;
2138 /* Test case provided by Cal Haldenbrand */
2139 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2140 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2141 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2143 /* We just keep looking at the same values over and over */
2146 test_compare(MEMCACHED_SUCCESS
,
2147 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2148 test_compare(MEMCACHED_SUCCESS
,
2149 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2153 unsigned long long total
= 0;
2154 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2156 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2157 char randomstuff
[6 * 1024];
2158 memset(randomstuff
, 0, 6 * 1024);
2159 test_true(size
< 6 * 1024); /* Being safe here */
2161 for (uint32_t j
= 0 ; j
< size
;j
++)
2163 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2168 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2169 test_compare(MEMCACHED_SUCCESS
,
2170 memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
));
2172 test_true(total
> HALDENBRAND_KEY_COUNT
);
2174 return TEST_SUCCESS
;
2177 /* Test case provided by Cal Haldenbrand */
2178 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2180 test_compare(MEMCACHED_SUCCESS
,
2181 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2183 test_compare(MEMCACHED_SUCCESS
,
2184 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2187 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576));
2188 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576));
2189 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2190 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2192 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2195 size_t total_value_length
= 0;
2196 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2201 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2202 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2204 memcached_return_t rc
;
2205 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2206 if (memcached_failed(rc
))
2208 if (rc
== MEMCACHED_NOTFOUND
)
2219 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2221 total_value_length
+= val_len
;
2226 return TEST_SUCCESS
;
2229 /* Do a large mget() over all the keys we think exist */
2230 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2232 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
2233 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
2236 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576);
2237 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576);
2238 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2239 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2242 std::vector
<size_t> key_lengths
;
2243 key_lengths
.resize(HALDENBRAND_KEY_COUNT
);
2244 char **keys
= static_cast<char **>(calloc(key_lengths
.size(), sizeof(char *)));
2246 for (uint32_t x
= 0; x
< key_lengths
.size(); x
++)
2248 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2249 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2250 test_true(key_length
);
2251 keys
[x
]= strdup(key
);
2253 key_lengths
[x
]= key_length
;
2254 test_compare(size_t(key_length
), strlen(keys
[x
]));
2257 test_compare(MEMCACHED_SUCCESS
,
2258 memcached_mget(memc
, (const char **)keys
, &key_lengths
[0], key_lengths
.size()));
2260 unsigned int keys_returned
;
2261 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
2262 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2264 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2270 return TEST_SUCCESS
;
2273 /* Make sure we behave properly if server list has no values */
2274 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2276 const char *keys
[]= {"fudge", "son", "food"};
2277 size_t key_length
[]= {5, 3, 4};
2279 /* Here we free everything before running a bunch of mget tests */
2280 memcached_servers_reset(memc
);
2283 /* We need to empty the server before continueing test */
2284 test_compare(MEMCACHED_NO_SERVERS
,
2285 memcached_flush(memc
, 0));
2287 test_compare(MEMCACHED_NO_SERVERS
,
2288 memcached_mget(memc
, keys
, key_length
, 3));
2290 unsigned int keys_returned
;
2291 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2292 test_zero(keys_returned
);
2294 for (uint32_t x
= 0; x
< 3; x
++)
2296 test_compare(MEMCACHED_NO_SERVERS
,
2297 memcached_set(memc
, keys
[x
], key_length
[x
],
2298 keys
[x
], key_length
[x
],
2299 (time_t)50, (uint32_t)9));
2302 test_compare(MEMCACHED_NO_SERVERS
,
2303 memcached_mget(memc
, keys
, key_length
, 3));
2307 char return_key
[MEMCACHED_MAX_KEY
];
2308 memcached_return_t rc
;
2309 size_t return_key_length
;
2310 size_t return_value_length
;
2313 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2314 &return_value_length
, &flags
, &rc
)))
2316 test_true(return_value
);
2317 test_compare(MEMCACHED_SUCCESS
, rc
);
2318 test_true(return_key_length
== return_value_length
);
2319 test_memcmp(return_value
, return_key
, return_value_length
);
2325 return TEST_SUCCESS
;
2328 #define VALUE_SIZE_BUG5 1048064
2329 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2331 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2332 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2334 size_t value_length
;
2336 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2338 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2340 insert_data
[x
]= (signed char)rand();
2343 test_compare(MEMCACHED_SUCCESS
,
2344 memcached_flush(memc
, 0));
2346 memcached_return_t rc
;
2347 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2348 test_compare(MEMCACHED_SUCCESS
,
2349 memcached_mget(memc
, keys
, key_length
, 4));
2352 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2355 for (uint32_t x
= 0; x
< 4; x
++)
2357 test_compare(MEMCACHED_SUCCESS
,
2358 memcached_set(memc
, keys
[x
], key_length
[x
],
2359 insert_data
, VALUE_SIZE_BUG5
,
2360 (time_t)0, (uint32_t)0));
2363 for (uint32_t x
= 0; x
< 10; x
++)
2365 value
= memcached_get(memc
, keys
[0], key_length
[0],
2366 &value_length
, &flags
, &rc
);
2367 test_compare(rc
, MEMCACHED_SUCCESS
);
2371 test_compare(MEMCACHED_SUCCESS
,
2372 memcached_mget(memc
, keys
, key_length
, 4));
2374 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2375 test_compare(4U, count
);
2377 delete [] insert_data
;
2379 return TEST_SUCCESS
;
2382 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2384 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2385 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2386 char return_key
[MEMCACHED_MAX_KEY
];
2387 size_t return_key_length
;
2389 size_t value_length
;
2391 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2393 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2395 insert_data
[x
]= (signed char)rand();
2398 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2400 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2402 // We will now confirm that memcached_mget() returns success, but we will
2403 // then check to make sure that no actual keys are returned.
2404 test_compare(MEMCACHED_SUCCESS
,
2405 memcached_mget(memc
, keys
, key_length
, 4));
2407 memcached_return_t rc
;
2409 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2410 &value_length
, &flags
, &rc
)))
2415 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2417 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2419 test_compare(MEMCACHED_SUCCESS
,
2420 memcached_set(memc
, keys
[x
], key_length
[x
],
2421 insert_data
, VALUE_SIZE_BUG5
,
2422 (time_t)0, (uint32_t)0));
2424 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2426 for (uint32_t x
= 0; x
< 2; x
++)
2428 value
= memcached_get(memc
, keys
[0], key_length
[0],
2429 &value_length
, &flags
, &rc
);
2433 test_compare(MEMCACHED_SUCCESS
,
2434 memcached_mget(memc
, keys
, key_length
, 4));
2435 /* We test for purge of partial complete fetches */
2436 for (count
= 3; count
; count
--)
2438 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2439 &value_length
, &flags
, &rc
);
2440 test_compare(MEMCACHED_SUCCESS
, rc
);
2441 test_memcmp(value
, insert_data
, value_length
);
2442 test_true(value_length
);
2446 delete [] insert_data
;
2448 return TEST_SUCCESS
;
2451 static test_return_t
user_supplied_bug8(memcached_st
*)
2453 memcached_return_t rc
;
2455 memcached_st
*memc_clone
;
2457 memcached_server_st
*servers
;
2458 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";
2460 servers
= memcached_servers_parse(server_list
);
2463 mine
= memcached_create(NULL
);
2464 rc
= memcached_server_push(mine
, servers
);
2465 test_compare(MEMCACHED_SUCCESS
, rc
);
2466 memcached_server_list_free(servers
);
2469 memc_clone
= memcached_clone(NULL
, mine
);
2471 memcached_quit(mine
);
2472 memcached_quit(memc_clone
);
2475 memcached_free(mine
);
2476 memcached_free(memc_clone
);
2478 return TEST_SUCCESS
;
2481 /* Test flag store/retrieve */
2482 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2484 const char *keys
= "036790384900";
2485 size_t key_length
= strlen(keys
);
2486 char return_key
[MEMCACHED_MAX_KEY
];
2487 size_t return_key_length
;
2489 size_t value_length
;
2491 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2493 for (unsigned int x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2495 insert_data
[x
]= (signed char)rand();
2498 memcached_flush(memc
, 0);
2501 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2502 insert_data
, VALUE_SIZE_BUG5
,
2505 memcached_return_t rc
;
2507 value
= memcached_get(memc
, keys
, key_length
,
2508 &value_length
, &flags
, &rc
);
2509 test_compare(245U, flags
);
2513 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2516 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2517 &value_length
, &flags
, &rc
);
2518 test_compare(uint32_t(245), flags
);
2521 delete [] insert_data
;
2524 return TEST_SUCCESS
;
2527 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2529 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2530 size_t key_length
[3];
2534 char return_key
[MEMCACHED_MAX_KEY
];
2535 size_t return_key_length
;
2537 size_t return_value_length
;
2540 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2541 key_length
[1]= strlen("fudge&*@#");
2542 key_length
[2]= strlen("for^#@&$not");
2545 for (unsigned int x
= 0; x
< 3; x
++)
2547 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2548 keys
[x
], key_length
[x
],
2549 (time_t)50, (uint32_t)9);
2550 test_compare(MEMCACHED_SUCCESS
, rc
);
2553 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2554 test_compare(MEMCACHED_SUCCESS
, rc
);
2556 /* We need to empty the server before continueing test */
2557 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2558 &return_value_length
, &flags
, &rc
)) != NULL
)
2560 test_true(return_value
);
2564 test_compare(3U, count
);
2566 return TEST_SUCCESS
;
2569 /* We are testing with aggressive timeout to get failures */
2570 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2572 size_t value_length
= 512;
2573 unsigned int set
= 1;
2574 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2576 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2577 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2578 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2580 std::vector
<char> value
;
2581 value
.reserve(value_length
);
2582 for (uint32_t x
= 0; x
< value_length
; x
++)
2584 value
.push_back(char(x
% 127));
2587 for (unsigned int x
= 1; x
<= 100000; ++x
)
2589 memcached_return_t rc
= memcached_set(mclone
,
2590 test_literal_param("foo"),
2591 &value
[0], value
.size(),
2594 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2595 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2596 memcached_strerror(NULL
, rc
));
2598 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2604 memcached_free(mclone
);
2606 return TEST_SUCCESS
;
2610 We are looking failures in the async protocol
2612 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2614 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2616 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2617 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2618 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2620 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2623 std::vector
<char> value
;
2625 for (unsigned int x
= 0; x
< 512; x
++)
2627 value
.push_back(char(x
% 127));
2630 for (unsigned int x
= 1; x
<= 100000; ++x
)
2632 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2636 memcached_free(mclone
);
2638 return TEST_SUCCESS
;
2642 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2644 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2646 memcached_return_t rc
;
2648 size_t value_length
;
2650 uint64_t number_value
;
2652 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2653 &value_length
, &flags
, &rc
);
2655 test_compare(MEMCACHED_NOTFOUND
, rc
);
2657 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2660 /* The binary protocol will set the key if it doesn't exist */
2661 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2663 test_compare(MEMCACHED_SUCCESS
, rc
);
2667 test_compare(MEMCACHED_NOTFOUND
, rc
);
2670 test_compare(MEMCACHED_SUCCESS
,
2671 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2673 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2677 test_compare(MEMCACHED_SUCCESS
,
2678 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2679 test_compare(2UL, number_value
);
2681 return TEST_SUCCESS
;
2685 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2686 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2688 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2690 char key
[] = "key34567890";
2691 memcached_return_t rc
;
2692 size_t overflowSize
;
2694 char commandFirst
[]= "set key34567890 0 0 ";
2695 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2696 size_t commandLength
;
2699 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2701 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2703 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2705 char *overflow
= new (std::nothrow
) char[testSize
];
2706 test_true(overflow
);
2708 memset(overflow
, 'x', testSize
);
2709 rc
= memcached_set(memc
, key
, strlen(key
),
2710 overflow
, testSize
, 0, 0);
2711 test_compare(MEMCACHED_SUCCESS
, rc
);
2715 return TEST_SUCCESS
;
2720 Test values of many different sizes
2721 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2722 set key34567890 0 0 8169 \r\n
2723 is sent followed by buffer of size 8169, followed by 8169
2725 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2727 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2729 std::vector
<char> value
;
2730 value
.reserve(18000);
2731 for (size_t x
= 0; x
< 18000; x
++)
2733 value
.push_back((char) (x
% 127));
2736 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2738 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2739 &value
[0], current_length
,
2740 (time_t)0, (uint32_t)0);
2741 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2743 size_t string_length
;
2745 char *string
= memcached_get(memc
, test_literal_param("foo"),
2746 &string_length
, &flags
, &rc
);
2748 test_compare(MEMCACHED_SUCCESS
, rc
);
2749 test_compare(string_length
, current_length
);
2750 test_memcmp(string
, &value
[0], string_length
);
2755 return TEST_SUCCESS
;
2759 Look for zero length value problems
2761 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2763 for (uint32_t x
= 0; x
< 2; x
++)
2765 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2767 (time_t)0, (uint32_t)0);
2769 test_compare(MEMCACHED_SUCCESS
, rc
);
2773 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2774 &length
, &flags
, &rc
);
2776 test_compare(MEMCACHED_SUCCESS
, rc
);
2781 value
= memcached_get(memc
, test_literal_param("mykey"),
2782 &length
, &flags
, &rc
);
2784 test_compare(MEMCACHED_SUCCESS
, rc
);
2785 test_true(value
== NULL
);
2790 return TEST_SUCCESS
;
2793 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2794 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2796 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2798 (time_t)0, UINT32_MAX
);
2800 test_compare(MEMCACHED_SUCCESS
, rc
);
2804 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2805 &length
, &flags
, &rc
);
2807 test_compare(MEMCACHED_SUCCESS
, rc
);
2808 test_true(value
== NULL
);
2810 test_compare(flags
, UINT32_MAX
);
2812 return TEST_SUCCESS
;
2815 #if !defined(__sun) && !defined(__OpenBSD__)
2816 /* Check the validity of chinese key*/
2817 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2819 const char *key
= "豆瓣";
2820 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2821 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2822 value
, strlen(value
),
2825 test_compare(MEMCACHED_SUCCESS
, rc
);
2829 char *value2
= memcached_get(memc
, key
, strlen(key
),
2830 &length
, &flags
, &rc
);
2832 test_true(length
==strlen(value
));
2833 test_compare(MEMCACHED_SUCCESS
, rc
);
2834 test_memcmp(value
, value2
, length
);
2837 return TEST_SUCCESS
;
2845 static test_return_t
user_supplied_bug19(memcached_st
*)
2847 memcached_return_t res
;
2849 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2851 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2854 memcached_free(memc
);
2856 return TEST_SUCCESS
;
2859 /* CAS test from Andei */
2860 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2862 const char *key
= "abc";
2863 size_t key_len
= strlen("abc");
2865 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2867 test_compare(MEMCACHED_SUCCESS
,
2869 test_literal_param("abc"),
2870 test_literal_param("foobar"),
2871 (time_t)0, (uint32_t)0));
2873 test_compare(MEMCACHED_SUCCESS
,
2874 memcached_mget(memc
, &key
, &key_len
, 1));
2876 memcached_result_st result_obj
;
2877 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2880 memcached_result_create(memc
, &result_obj
);
2881 memcached_return_t status
;
2882 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2885 test_compare(MEMCACHED_SUCCESS
, status
);
2887 memcached_result_free(result
);
2889 return TEST_SUCCESS
;
2892 /* Large mget() of missing keys with binary proto
2894 * If many binary quiet commands (such as getq's in an mget) fill the output
2895 * buffer and the server chooses not to respond, memcached_flush hangs. See
2896 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2899 /* sighandler_t function that always asserts false */
2900 static void fail(int)
2906 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2911 return TEST_SKIPPED
;
2913 void (*oldalarm
)(int);
2915 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2916 test_true(memc_clone
);
2918 /* only binproto uses getq for mget */
2919 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2921 /* empty the cache to ensure misses (hence non-responses) */
2922 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2924 std::vector
<size_t> key_lengths
;
2925 key_lengths
.resize(key_count
);
2926 char **keys
= static_cast<char **>(calloc(key_lengths
.size(), sizeof(char *)));
2928 for (unsigned int x
= 0; x
< key_lengths
.size(); x
++)
2932 snprintf(buffer
, 30, "%u", x
);
2933 keys
[x
]= strdup(buffer
);
2935 key_lengths
[x
]= strlen(keys
[x
]);
2938 oldalarm
= signal(SIGALRM
, fail
);
2941 test_compare_got(MEMCACHED_SUCCESS
,
2942 memcached_mget(memc_clone
, (const char **)keys
, &key_lengths
[0], key_count
), memcached_last_error_message(memc_clone
));
2945 signal(SIGALRM
, oldalarm
);
2947 memcached_return_t rc
;
2949 char return_key
[MEMCACHED_MAX_KEY
];
2950 size_t return_key_length
;
2952 size_t return_value_length
;
2953 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2954 &return_value_length
, &flags
, &rc
)))
2956 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2958 test_compare(MEMCACHED_NOTFOUND
, rc
);
2959 test_zero(return_value_length
);
2960 test_zero(return_key_length
);
2961 test_false(return_key
[0]);
2962 test_false(return_value
);
2964 for (unsigned int x
= 0; x
< key_count
; x
++)
2970 memcached_free(memc_clone
);
2972 return TEST_SUCCESS
;
2976 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
2978 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2980 /* should work as of r580 */
2981 test_compare(TEST_SUCCESS
,
2982 _user_supplied_bug21(memc
, 10));
2984 /* should fail as of r580 */
2985 test_compare(TEST_SUCCESS
,
2986 _user_supplied_bug21(memc
, 1000));
2988 return TEST_SUCCESS
;
2991 static test_return_t
output_ketama_weighted_keys(memcached_st
*)
2993 memcached_st
*memc
= memcached_create(NULL
);
2997 test_compare(MEMCACHED_SUCCESS
,
2998 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
3000 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3001 test_compare(value
, uint64_t(1));
3003 test_compare(MEMCACHED_SUCCESS
,
3004 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3006 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3007 test_true(value
== MEMCACHED_HASH_MD5
);
3010 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3012 memcached_server_st
*server_pool
;
3013 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");
3014 memcached_server_push(memc
, server_pool
);
3016 // @todo this needs to be refactored to actually test something.
3019 if ((fp
= fopen("ketama_keys.txt", "w")))
3023 printf("cannot write to file ketama_keys.txt");
3024 return TEST_FAILURE
;
3027 for (int x
= 0; x
< 10000; x
++)
3030 snprintf(key
, sizeof(key
), "%d", x
);
3032 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3033 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3034 in_port_t port
= memc
->hosts
[server_idx
].port
;
3035 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3036 memcached_server_instance_st instance
=
3037 memcached_server_instance_by_position(memc
, host_index
);
3041 memcached_server_list_free(server_pool
);
3042 memcached_free(memc
);
3044 return TEST_SUCCESS
;
3048 static test_return_t
result_static(memcached_st
*memc
)
3050 memcached_result_st result
;
3051 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3052 test_false(result
.options
.is_allocated
);
3053 test_true(memcached_is_initialized(&result
));
3054 test_true(result_ptr
);
3055 test_true(result_ptr
== &result
);
3057 memcached_result_free(&result
);
3059 test_false(result
.options
.is_allocated
);
3060 test_false(memcached_is_initialized(&result
));
3062 return TEST_SUCCESS
;
3065 static test_return_t
result_alloc(memcached_st
*memc
)
3067 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3068 test_true(result_ptr
);
3069 test_true(result_ptr
->options
.is_allocated
);
3070 test_true(memcached_is_initialized(result_ptr
));
3071 memcached_result_free(result_ptr
);
3073 return TEST_SUCCESS
;
3076 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3079 pairs_free(global_pairs
);
3081 return TEST_SUCCESS
;
3084 static test_return_t
generate_pairs(memcached_st
*)
3086 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3087 global_count
= GLOBAL_COUNT
;
3089 for (size_t x
= 0; x
< global_count
; x
++)
3091 global_keys
[x
]= global_pairs
[x
].key
;
3092 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3095 return TEST_SUCCESS
;
3098 static test_return_t
generate_large_pairs(memcached_st
*)
3100 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3101 global_count
= GLOBAL2_COUNT
;
3103 for (size_t x
= 0; x
< global_count
; x
++)
3105 global_keys
[x
]= global_pairs
[x
].key
;
3106 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3109 return TEST_SUCCESS
;
3112 static test_return_t
generate_data(memcached_st
*memc
)
3114 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3116 test_compare(check_execute
, global_count
);
3118 return TEST_SUCCESS
;
3121 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3123 uint32_t host_index
= 0;
3124 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3126 test_true(check_execute
== global_count
);
3128 // @todo hosts used size stats
3129 memcached_return_t rc
;
3130 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3133 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3135 /* This test was changes so that "make test" would work properlly */
3138 memcached_server_instance_st instance
=
3139 memcached_server_instance_by_position(memc
, host_index
);
3141 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3143 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3146 memcached_stat_free(NULL
, stat_p
);
3148 return TEST_SUCCESS
;
3150 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3152 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3153 generate_data(memc
);
3155 return TEST_SUCCESS
;
3158 static test_return_t
get_read_count(memcached_st
*memc
)
3160 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3161 test_true(memc_clone
);
3163 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3167 size_t return_value_length
;
3171 for (size_t x
= count
= 0; x
< global_count
; x
++)
3173 memcached_return_t rc
;
3174 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3175 &return_value_length
, &flags
, &rc
);
3176 if (rc
== MEMCACHED_SUCCESS
)
3187 memcached_free(memc_clone
);
3189 return TEST_SUCCESS
;
3192 static test_return_t
get_read(memcached_st
*memc
)
3194 for (size_t x
= 0; x
< global_count
; x
++)
3196 size_t return_value_length
;
3198 memcached_return_t rc
;
3199 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3200 &return_value_length
, &flags
, &rc
);
3202 test_true(return_value);
3203 test_compare(MEMCACHED_SUCCESS, rc);
3205 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3211 return TEST_SUCCESS
;
3214 static test_return_t
mget_read(memcached_st
*memc
)
3217 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3219 test_compare(MEMCACHED_SUCCESS
,
3220 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3222 // Go fetch the keys and test to see if all of them were returned
3224 unsigned int keys_returned
;
3225 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3226 test_true(keys_returned
> 0);
3227 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3230 return TEST_SUCCESS
;
3233 static test_return_t
mget_read_result(memcached_st
*memc
)
3236 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3238 test_compare(MEMCACHED_SUCCESS
,
3239 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3241 /* Turn this into a help function */
3243 memcached_result_st results_obj
;
3244 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3247 memcached_return_t rc
;
3248 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3250 if (rc
== MEMCACHED_IN_PROGRESS
)
3256 test_compare(MEMCACHED_SUCCESS
, rc
);
3258 test_compare(MEMCACHED_END
, rc
);
3260 memcached_result_free(&results_obj
);
3263 return TEST_SUCCESS
;
3266 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3269 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3271 test_compare(MEMCACHED_SUCCESS
,
3272 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3274 memcached_result_st
*results
= NULL
;
3275 memcached_return_t rc
;
3276 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3279 test_compare(MEMCACHED_SUCCESS
, rc
);
3281 test_compare(MEMCACHED_END
, rc
);
3283 memcached_result_free(results
);
3286 return TEST_SUCCESS
;
3289 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3292 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3294 test_compare(MEMCACHED_SUCCESS
,
3295 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3297 // We will scan for just one key
3299 memcached_result_st results_obj
;
3300 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3302 memcached_return_t rc
;
3303 results
= memcached_fetch_result(memc
, results
, &rc
);
3305 test_compare(MEMCACHED_SUCCESS
, rc
);
3307 memcached_result_free(&results_obj
);
3310 // We already have a read happening, lets start up another one.
3311 test_compare(MEMCACHED_SUCCESS
,
3312 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3314 memcached_result_st results_obj
;
3315 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3317 test_false(memcached_is_allocated(results
));
3319 memcached_return_t rc
;
3320 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3323 test_compare(MEMCACHED_SUCCESS
, rc
);
3325 test_compare(MEMCACHED_END
, rc
);
3327 memcached_result_free(&results_obj
);
3330 return TEST_SUCCESS
;
3333 static test_return_t
mget_read_function(memcached_st
*memc
)
3335 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3337 test_compare(MEMCACHED_SUCCESS
,
3338 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3340 memcached_execute_fn callbacks
[]= { &callback_counter
};
3342 test_compare(MEMCACHED_SUCCESS
,
3343 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3345 return TEST_SUCCESS
;
3348 static test_return_t
delete_generate(memcached_st
*memc
)
3350 for (size_t x
= 0; x
< global_count
; x
++)
3352 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3355 return TEST_SUCCESS
;
3358 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3360 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3362 for (size_t x
= 0; x
< global_count
; x
++)
3364 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3367 return TEST_SUCCESS
;
3370 static test_return_t
add_host_test1(memcached_st
*memc
)
3372 memcached_return_t rc
;
3373 char servername
[]= "0.example.com";
3375 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3377 test_compare(1U, memcached_server_list_count(servers
));
3379 for (uint32_t x
= 2; x
< 20; x
++)
3381 char buffer
[SMALL_STRING_LEN
];
3383 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3384 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3386 test_compare(MEMCACHED_SUCCESS
, rc
);
3387 test_compare(x
, memcached_server_list_count(servers
));
3390 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3391 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3393 memcached_server_list_free(servers
);
3395 return TEST_SUCCESS
;
3398 static test_return_t
pre_nonblock(memcached_st
*memc
)
3400 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3402 return TEST_SUCCESS
;
3405 static test_return_t
pre_cork(memcached_st
*memc
)
3408 return TEST_SKIPPED
;
3411 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3412 return TEST_SUCCESS
;
3414 return TEST_SKIPPED
;
3417 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3420 return TEST_SKIPPED
;
3422 test_return_t test_rc
;
3423 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3426 return pre_nonblock(memc
);
3429 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3431 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3432 test_true(memc_clone
);
3434 // The memcached_version needs to be done on a clone, because the server
3435 // will not toggle protocol on an connection.
3436 memcached_version(memc_clone
);
3438 memcached_return_t rc
= MEMCACHED_FAILURE
;
3439 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3441 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3442 test_compare(MEMCACHED_SUCCESS
,
3443 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3444 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3448 memcached_free(memc_clone
);
3449 return TEST_SKIPPED
;
3452 memcached_free(memc_clone
);
3454 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3457 static test_return_t
pre_murmur(memcached_st
*memc
)
3459 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3460 return TEST_SUCCESS
;
3463 static test_return_t
pre_jenkins(memcached_st
*memc
)
3465 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3467 return TEST_SUCCESS
;
3471 static test_return_t
pre_md5(memcached_st
*memc
)
3473 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3475 return TEST_SUCCESS
;
3478 static test_return_t
pre_crc(memcached_st
*memc
)
3480 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3482 return TEST_SUCCESS
;
3485 static test_return_t
pre_hsieh(memcached_st
*memc
)
3487 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
));
3488 return TEST_SUCCESS
;
3491 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3493 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3495 return TEST_SUCCESS
;
3498 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3500 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
));
3502 return TEST_SUCCESS
;
3505 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3507 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3509 return TEST_SUCCESS
;
3512 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3514 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3516 return TEST_SUCCESS
;
3519 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3521 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3522 test_compare(MEMCACHED_SUCCESS
, rc
);
3524 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3525 test_compare(value
, uint64_t(1));
3527 return TEST_SUCCESS
;
3530 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3532 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3533 test_compare(MEMCACHED_SUCCESS
, rc
);
3535 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3536 test_compare(value
, uint64_t(1));
3538 test_compare(MEMCACHED_SUCCESS
,
3539 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3541 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3542 test_compare(MEMCACHED_HASH_MD5
, memcached_hash_t(value
));
3544 return TEST_SUCCESS
;
3547 static test_return_t
pre_replication(memcached_st
*memc
)
3549 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3552 * Make sure that we store the item on all servers
3553 * (master + replicas == number of servers)
3555 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3556 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3558 return TEST_SUCCESS
;
3562 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3564 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3566 return pre_nonblock(memc
);
3570 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3574 #ifdef HARD_MALLOC_TESTS
3575 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3583 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3587 #ifdef HARD_MALLOC_TESTS
3588 void *ret
= malloc(size
+ 8);
3591 ret
= (void*)((caddr_t
)ret
+ 8);
3594 void *ret
= malloc(size
);
3599 memset(ret
, 0xff, size
);
3606 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3608 #ifdef HARD_MALLOC_TESTS
3609 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3610 void *nmem
= realloc(real_ptr
, size
+ 8);
3615 ret
= (void*)((caddr_t
)nmem
+ 8);
3621 return realloc(mem
, size
);
3626 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3628 #ifdef HARD_MALLOC_TESTS
3629 void *mem
= my_malloc(ptr
, nelem
* size
);
3632 memset(mem
, 0, nelem
* size
);
3638 return calloc(nelem
, size
);
3642 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3644 memcached_return_t rc
;
3645 const char *key
= "mine";
3648 /* Make sure be default none exists */
3649 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3651 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3653 /* Test a clean set */
3654 test_compare(MEMCACHED_SUCCESS
,
3655 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3657 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3659 test_memcmp(value
, key
, 4);
3660 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3662 /* Test that we can turn it off */
3663 test_compare(MEMCACHED_SUCCESS
,
3664 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3666 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3668 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3670 /* Now setup for main test */
3671 test_compare(MEMCACHED_SUCCESS
,
3672 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3674 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3676 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3677 test_memcmp(value
, key
, 4);
3679 /* Set to Zero, and then Set to something too large */
3682 memset(long_key
, 0, 255);
3684 test_compare(MEMCACHED_SUCCESS
,
3685 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3687 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3689 test_compare(MEMCACHED_SUCCESS
, rc
);
3691 /* Test a long key for failure */
3692 /* TODO, extend test to determine based on setting, what result should be */
3693 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3694 test_compare(MEMCACHED_SUCCESS
,
3695 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3697 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3698 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3699 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3700 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3702 /* Test for a bad prefix, but with a short key */
3703 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3704 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3706 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3707 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3710 return TEST_SUCCESS
;
3713 static test_return_t
set_namespace(memcached_st
*memc
)
3715 memcached_return_t rc
;
3716 const char *key
= "mine";
3719 // Make sure we default to a null namespace
3720 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3722 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3724 /* Test a clean set */
3725 test_compare(MEMCACHED_SUCCESS
,
3726 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3728 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3730 test_memcmp(value
, key
, 4);
3731 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3733 return TEST_SUCCESS
;
3736 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3738 test_return_if(pre_binary(memc
));
3739 test_return_if(set_namespace(memc
));
3741 return TEST_SUCCESS
;
3744 #ifdef MEMCACHED_ENABLE_DEPRECATED
3745 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3747 void *test_ptr
= NULL
;
3750 memcached_malloc_fn malloc_cb
=
3751 (memcached_malloc_fn
)my_malloc
;
3752 cb_ptr
= *(void **)&malloc_cb
;
3753 memcached_return_t rc
;
3755 test_compare(MEMCACHED_SUCCESS
,
3756 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3757 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3758 test_compare(MEMCACHED_SUCCESS
, rc
);
3759 test_true(test_ptr
== cb_ptr
);
3763 memcached_realloc_fn realloc_cb
=
3764 (memcached_realloc_fn
)my_realloc
;
3765 cb_ptr
= *(void **)&realloc_cb
;
3766 memcached_return_t rc
;
3768 test_compare(MEMCACHED_SUCCESS
,
3769 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3770 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3771 test_compare(MEMCACHED_SUCCESS
, rc
);
3772 test_true(test_ptr
== cb_ptr
);
3776 memcached_free_fn free_cb
=
3777 (memcached_free_fn
)my_free
;
3778 cb_ptr
= *(void **)&free_cb
;
3779 memcached_return_t rc
;
3781 test_compare(MEMCACHED_SUCCESS
,
3782 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3783 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3784 test_compare(MEMCACHED_SUCCESS
, rc
);
3785 test_true(test_ptr
== cb_ptr
);
3788 return TEST_SUCCESS
;
3793 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3795 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3796 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3797 my_realloc
, my_calloc
, NULL
));
3799 test_compare(MEMCACHED_SUCCESS
,
3800 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3801 my_realloc
, my_calloc
, NULL
));
3803 memcached_malloc_fn mem_malloc
;
3804 memcached_free_fn mem_free
;
3805 memcached_realloc_fn mem_realloc
;
3806 memcached_calloc_fn mem_calloc
;
3807 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3808 &mem_realloc
, &mem_calloc
);
3810 test_true(mem_malloc
== my_malloc
);
3811 test_true(mem_realloc
== my_realloc
);
3812 test_true(mem_calloc
== my_calloc
);
3813 test_true(mem_free
== my_free
);
3815 return TEST_SUCCESS
;
3818 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3821 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3822 memcached_hash_t hash
;
3823 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3824 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3827 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3828 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3830 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3832 if (hash
!= MEMCACHED_HASH_CRC
)
3833 return TEST_SKIPPED
;
3835 return TEST_SUCCESS
;
3838 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3841 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3842 memcached_hash_t hash
;
3843 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3844 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3849 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3850 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3852 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3854 if (hash
!= MEMCACHED_HASH_HSIEH
)
3855 return TEST_SKIPPED
;
3858 return TEST_SUCCESS
;
3861 static test_return_t
enable_cas(memcached_st
*memc
)
3863 unsigned int set
= 1;
3865 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3867 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3869 return TEST_SUCCESS
;
3872 return TEST_SKIPPED
;
3875 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3877 memcached_version(memc
);
3879 memcached_server_instance_st instance
=
3880 memcached_server_instance_by_position(memc
, 0);
3882 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3883 or instance
->minor_version
> 2)
3885 return TEST_SUCCESS
;
3888 return TEST_SKIPPED
;
3891 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3895 memcached_servers_reset(memc
);
3896 const char *socket_file
= default_socket();
3898 test_skip(0, stat(socket_file
, &buf
));
3900 test_compare(MEMCACHED_SUCCESS
,
3901 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
3903 return TEST_SUCCESS
;
3906 static test_return_t
pre_nodelay(memcached_st
*memc
)
3908 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3909 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3911 return TEST_SUCCESS
;
3914 static test_return_t
pre_settimer(memcached_st
*memc
)
3916 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3917 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3919 return TEST_SUCCESS
;
3922 static test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3924 const uint64_t timeout
= 100; // Not using, just checking that it sets
3926 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3928 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3930 return TEST_SUCCESS
;
3933 static test_return_t
noreply_test(memcached_st
*memc
)
3935 test_compare(MEMCACHED_SUCCESS
,
3936 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
3937 test_compare(MEMCACHED_SUCCESS
,
3938 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1));
3939 test_compare(MEMCACHED_SUCCESS
,
3940 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
3941 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3942 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3943 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3945 memcached_return_t ret
;
3946 for (int count
= 0; count
< 5; ++count
)
3948 for (size_t x
= 0; x
< 100; ++x
)
3951 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3952 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3954 size_t len
= (size_t)check_length
;
3959 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3962 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3965 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3968 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3971 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3977 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, ret
));
3981 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3982 ** API and is _ONLY_ done this way to verify that the library works the
3983 ** way it is supposed to do!!!!
3986 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3988 memcached_server_instance_st instance
=
3989 memcached_server_instance_by_position(memc
, x
);
3990 no_msg
+=(int)(instance
->cursor_active
);
3993 test_true(no_msg
== 0);
3994 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
3997 ** Now validate that all items was set properly!
3999 for (size_t x
= 0; x
< 100; ++x
)
4003 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4005 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4007 size_t len
= (size_t)check_length
;
4010 char* value
=memcached_get(memc
, key
, strlen(key
),
4011 &length
, &flags
, &ret
);
4012 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
4015 case 0: /* FALLTHROUGH */
4016 case 1: /* FALLTHROUGH */
4018 test_true(strncmp(value
, key
, len
) == 0);
4019 test_true(len
== length
);
4022 test_true(length
== len
* 2);
4025 test_true(length
== len
* 3);
4035 /* Try setting an illegal cas value (should not return an error to
4036 * the caller (because we don't expect a return message from the server)
4038 const char* keys
[]= {"0"};
4039 size_t lengths
[]= {1};
4042 memcached_result_st results_obj
;
4043 memcached_result_st
*results
;
4044 test_compare(MEMCACHED_SUCCESS
,
4045 memcached_mget(memc
, keys
, lengths
, 1));
4047 results
= memcached_result_create(memc
, &results_obj
);
4049 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4051 test_compare(MEMCACHED_SUCCESS
, ret
);
4052 uint64_t cas
= memcached_result_cas(results
);
4053 memcached_result_free(&results_obj
);
4055 test_compare(MEMCACHED_SUCCESS
,
4056 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4059 * The item will have a new cas value, so try to set it again with the old
4060 * value. This should fail!
4062 test_compare(MEMCACHED_SUCCESS
,
4063 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4064 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4065 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4066 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4069 return TEST_SUCCESS
;
4072 static test_return_t
analyzer_test(memcached_st
*memc
)
4074 memcached_return_t rc
;
4075 memcached_analysis_st
*report
;
4077 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4078 test_compare(MEMCACHED_SUCCESS
, rc
);
4079 test_true(memc_stat
);
4081 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4082 test_compare(MEMCACHED_SUCCESS
, rc
);
4086 memcached_stat_free(NULL
, memc_stat
);
4088 return TEST_SUCCESS
;
4091 /* Count the objects */
4093 static test_return_t
dump_test(memcached_st
*memc
)
4095 /* No support for Binary protocol yet */
4096 test_skip(false, memc
->flags
.binary_protocol
);
4098 test_compare(TEST_SUCCESS
, set_test3(memc
));
4100 // confirm_key_count() call dump
4101 size_t counter
= confirm_key_count(memc
);
4103 /* We may have more then 32 if our previous flush has not completed */
4104 test_true(counter
>= 32);
4106 return TEST_SUCCESS
;
4109 static test_return_t
util_version_test(memcached_st
*memc
)
4111 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
4112 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
4114 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4116 // We expect failure
4119 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4120 fprintf(stderr
, "\nDumping Server Information\n\n");
4121 memcached_server_fn callbacks
[1];
4123 callbacks
[0]= dump_server_information
;
4124 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4125 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4127 test_true(if_successful
== false);
4129 memcached_server_instance_st instance
=
4130 memcached_server_instance_by_position(memc
, 0);
4132 memcached_version(memc
);
4134 // We only use one binary when we test, so this should be just fine.
4135 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4136 test_true(if_successful
== true);
4138 if (instance
->micro_version
> 0)
4140 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4142 else if (instance
->minor_version
> 0)
4144 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4146 else if (instance
->major_version
> 0)
4148 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4151 test_true(if_successful
== true);
4153 if (instance
->micro_version
> 0)
4155 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4157 else if (instance
->minor_version
> 0)
4159 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4161 else if (instance
->major_version
> 0)
4163 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4166 test_true(if_successful
== false);
4168 return TEST_SUCCESS
;
4171 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4173 memcached_return_t rc
;
4174 memcached_server_instance_st instance
=
4175 memcached_server_instance_by_position(memc
, 0);
4177 // Test both the version that returns a code, and the one that does not.
4178 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4179 memcached_server_port(instance
) -1, NULL
) == -1);
4181 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4182 memcached_server_port(instance
) -1, &rc
) == -1);
4183 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4185 return TEST_SUCCESS
;
4189 static test_return_t
getpid_test(memcached_st
*memc
)
4191 memcached_return_t rc
;
4192 memcached_server_instance_st instance
=
4193 memcached_server_instance_by_position(memc
, 0);
4195 // Test both the version that returns a code, and the one that does not.
4196 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4197 memcached_server_port(instance
), NULL
) > -1);
4199 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4200 memcached_server_port(instance
), &rc
) > -1);
4201 test_compare(MEMCACHED_SUCCESS
, rc
);
4203 return TEST_SUCCESS
;
4206 static test_return_t
ping_test(memcached_st
*memc
)
4208 memcached_return_t rc
;
4209 memcached_server_instance_st instance
=
4210 memcached_server_instance_by_position(memc
, 0);
4212 // Test both the version that returns a code, and the one that does not.
4213 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4214 memcached_server_port(instance
), NULL
));
4216 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4217 memcached_server_port(instance
), &rc
));
4219 test_compare(MEMCACHED_SUCCESS
, rc
);
4221 return TEST_SUCCESS
;
4226 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4230 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4231 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4232 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4233 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4234 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4235 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4236 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4237 #ifdef HAVE_HSIEH_HASH
4238 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4240 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4241 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4242 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4244 return TEST_SUCCESS
;
4248 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4250 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4252 test_compare(MEMCACHED_SUCCESS
,
4253 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4254 (uint64_t)MEMCACHED_HASH_HSIEH
));
4256 return TEST_SUCCESS
;
4259 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4261 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4263 test_compare(MEMCACHED_SUCCESS
,
4264 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
4266 return TEST_SUCCESS
;
4269 static test_return_t
one_at_a_time_run (memcached_st
*)
4274 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4276 test_compare(one_at_a_time_values
[x
],
4277 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
4280 return TEST_SUCCESS
;
4283 static test_return_t
md5_run (memcached_st
*)
4288 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4290 test_compare(md5_values
[x
],
4291 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
4294 return TEST_SUCCESS
;
4297 static test_return_t
crc_run (memcached_st
*)
4302 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4304 test_compare(crc_values
[x
],
4305 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
4308 return TEST_SUCCESS
;
4311 static test_return_t
fnv1_64_run (memcached_st
*)
4313 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
4318 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4320 test_compare(fnv1_64_values
[x
],
4321 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
4324 return TEST_SUCCESS
;
4327 static test_return_t
fnv1a_64_run (memcached_st
*)
4329 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
4334 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4336 test_compare(fnv1a_64_values
[x
],
4337 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
4340 return TEST_SUCCESS
;
4343 static test_return_t
fnv1_32_run (memcached_st
*)
4348 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4350 test_compare(fnv1_32_values
[x
],
4351 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
4354 return TEST_SUCCESS
;
4357 static test_return_t
fnv1a_32_run (memcached_st
*)
4362 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4364 test_compare(fnv1a_32_values
[x
],
4365 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
4368 return TEST_SUCCESS
;
4371 static test_return_t
hsieh_run (memcached_st
*)
4373 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4378 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4380 test_compare(hsieh_values
[x
],
4381 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
4384 return TEST_SUCCESS
;
4387 static test_return_t
murmur_run (memcached_st
*)
4389 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4391 #ifdef WORDS_BIGENDIAN
4392 (void)murmur_values
;
4393 return TEST_SKIPPED
;
4398 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4400 test_compare(murmur_values
[x
],
4401 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
4404 return TEST_SUCCESS
;
4408 static test_return_t
jenkins_run (memcached_st
*)
4413 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4415 test_compare(jenkins_values
[x
],
4416 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
4419 return TEST_SUCCESS
;
4422 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
4424 return libhashkit_md5(string
, string_length
);
4427 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
4429 return libhashkit_crc32(string
, string_length
);
4432 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4438 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
4440 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};
4441 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};
4443 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4445 hashkit_clone(&new_kit
, kit
);
4446 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4448 memcached_set_hashkit(memc
, &new_kit
);
4451 Verify Setting the hash.
4453 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4457 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4458 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4463 Now check memcached_st.
4465 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4469 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4470 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4473 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4475 memcached_set_hashkit(memc
, &new_kit
);
4478 Verify Setting the hash.
4480 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4484 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4485 test_true(crc_values
[x
] == hash_val
);
4488 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4492 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4493 test_compare(crc_hosts
[x
], hash_val
);
4496 memcached_free(memc
);
4498 return TEST_SUCCESS
;
4502 Test case adapted from John Gorman <johngorman2@gmail.com>
4504 We are testing the error condition when we connect to a server via memcached_get()
4505 but find that the server is not available.
4507 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4509 const char *key
= "MemcachedLives";
4512 memcached_return rc
;
4515 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4517 // See if memcached is reachable.
4518 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4522 test_true(memcached_failed(rc
));
4524 memcached_free(tl_memc_h
);
4526 return TEST_SUCCESS
;
4530 We connect to a server which exists, but search for a key that does not exist.
4532 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4534 const char *key
= "MemcachedKeyNotEXIST";
4537 memcached_return rc
;
4539 // See if memcached is reachable.
4540 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4544 test_compare(MEMCACHED_NOTFOUND
, rc
);
4546 return TEST_SUCCESS
;
4550 Test case adapted from John Gorman <johngorman2@gmail.com>
4552 We are testing the error condition when we connect to a server via memcached_get_by_key()
4553 but find that the server is not available.
4555 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4558 memcached_st
*tl_memc_h
;
4559 memcached_server_st
*servers
;
4561 const char *key
= "MemcachedLives";
4564 memcached_return rc
;
4568 tl_memc_h
= memcached_create(NULL
);
4569 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4570 memcached_server_push(tl_memc_h
, servers
);
4571 memcached_server_list_free(servers
);
4573 // See if memcached is reachable.
4574 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4578 test_true(memcached_failed(rc
));
4580 memcached_free(tl_memc_h
);
4582 return TEST_SUCCESS
;
4586 We connect to a server which exists, but search for a key that does not exist.
4588 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4590 const char *key
= "MemcachedKeyNotEXIST";
4593 memcached_return rc
;
4596 // See if memcached is reachable.
4597 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4601 test_compare(MEMCACHED_NOTFOUND
, rc
);
4603 return TEST_SUCCESS
;
4606 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4608 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4610 const char *key
= "regression_bug_434484";
4611 size_t keylen
= strlen(key
);
4613 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4614 test_compare(MEMCACHED_NOTSTORED
, ret
);
4616 size_t size
= 2048 * 1024;
4617 char *data
= (char*)calloc(1, size
);
4619 test_compare(MEMCACHED_E2BIG
,
4620 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4623 return TEST_SUCCESS
;
4626 static test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4628 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4630 memcached_return_t rc
;
4632 memcached_execute_fn callbacks
[]= { &callback_counter
};
4635 * I only want to hit only _one_ server so I know the number of requests I'm
4636 * sending in the pipleine to the server. Let's try to do a multiget of
4637 * 1024 (that should satisfy most users don't you think?). Future versions
4638 * will include a mget_execute function call if you need a higher number.
4640 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4642 const size_t max_keys
= 1024;
4643 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4644 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4646 for (size_t x
= 0; x
< max_keys
; ++x
)
4650 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4656 * Run two times.. the first time we should have 100% cache miss,
4657 * and the second time we should have 100% cache hits
4659 for (size_t y
= 0; y
< 2; y
++)
4661 test_compare(MEMCACHED_SUCCESS
,
4662 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4664 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4665 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4669 /* The first iteration should give me a 100% cache miss. verify that*/
4670 char blob
[1024]= { 0 };
4672 test_false(counter
);
4674 for (size_t x
= 0; x
< max_keys
; ++x
)
4676 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4677 blob
, sizeof(blob
), 0, 0);
4678 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4683 /* Verify that we received all of the key/value pairs */
4684 test_compare(counter
, max_keys
);
4688 /* Release allocated resources */
4689 for (size_t x
= 0; x
< max_keys
; ++x
)
4696 memcached_free(memc
);
4698 return TEST_SUCCESS
;
4701 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4703 memcached_return_t rc
;
4704 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4705 test_compare(MEMCACHED_SUCCESS
, rc
);
4707 return regression_bug_434843(memc
);
4710 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4712 memcached_return_t rc
;
4713 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4714 test_compare(MEMCACHED_SUCCESS
, rc
);
4716 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4717 test_compare(MEMCACHED_SUCCESS
, rc
);
4718 test_true(bytes_str
);
4719 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4721 test_compare(MEMCACHED_SUCCESS
, rc
);
4722 test_true(bytes_read_str
);
4724 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4725 "bytes_written", &rc
);
4726 test_compare(MEMCACHED_SUCCESS
, rc
);
4727 test_true(bytes_written_str
);
4729 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4730 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4731 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4733 test_true(bytes
!= bytes_read
);
4734 test_true(bytes
!= bytes_written
);
4736 /* Release allocated resources */
4738 free(bytes_read_str
);
4739 free(bytes_written_str
);
4740 memcached_stat_free(NULL
, memc_stat
);
4742 return TEST_SUCCESS
;
4746 * The test case isn't obvious so I should probably document why
4747 * it works the way it does. Bug 442914 was caused by a bug
4748 * in the logic in memcached_purge (it did not handle the case
4749 * where the number of bytes sent was equal to the watermark).
4750 * In this test case, create messages so that we hit that case
4751 * and then disable noreply mode and issue a new command to
4752 * verify that it isn't stuck. If we change the format for the
4753 * delete command or the watermarks, we need to update this
4756 static test_return_t
regression_bug_442914(memcached_st
*memc
)
4758 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4759 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4761 uint32_t number_of_hosts
= memcached_server_count(memc
);
4762 memc
->number_of_hosts
= 1;
4767 for (uint32_t x
= 0; x
< 250; ++x
)
4769 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4770 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4771 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4774 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
4777 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4778 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4780 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4781 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
4783 memc
->number_of_hosts
= number_of_hosts
;
4785 return TEST_SUCCESS
;
4788 static test_return_t
regression_bug_447342(memcached_st
*memc
)
4790 memcached_server_instance_st instance_one
;
4791 memcached_server_instance_st instance_two
;
4793 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4794 return TEST_SKIPPED
;
4796 test_compare(MEMCACHED_SUCCESS
,
4797 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4799 const unsigned int max_keys
= 100;
4800 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4801 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4803 for (unsigned int x
= 0; x
< max_keys
; ++x
)
4807 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4810 test_compare(MEMCACHED_SUCCESS
,
4811 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
4815 ** We are using the quiet commands to store the replicas, so we need
4816 ** to ensure that all of them are processed before we can continue.
4817 ** In the test we go directly from storing the object to trying to
4818 ** receive the object from all of the different servers, so we
4819 ** could end up in a race condition (the memcached server hasn't yet
4820 ** processed the quiet command from the replication set when it process
4821 ** the request from the other client (created by the clone)). As a
4822 ** workaround for that we call memcached_quit to send the quit command
4823 ** to the server and wait for the response ;-) If you use the test code
4824 ** as an example for your own code, please note that you shouldn't need
4827 memcached_quit(memc
);
4829 /* Verify that all messages are stored, and we didn't stuff too much
4832 test_compare(MEMCACHED_SUCCESS
,
4833 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4835 unsigned int counter
= 0;
4836 memcached_execute_fn callbacks
[]= { &callback_counter
};
4837 test_compare(MEMCACHED_SUCCESS
,
4838 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4840 /* Verify that we received all of the key/value pairs */
4841 test_compare(counter
, max_keys
);
4843 memcached_quit(memc
);
4845 * Don't do the following in your code. I am abusing the internal details
4846 * within the library, and this is not a supported interface.
4847 * This is to verify correct behavior in the library. Fake that two servers
4850 instance_one
= memcached_server_instance_by_position(memc
, 0);
4851 instance_two
= memcached_server_instance_by_position(memc
, 2);
4852 in_port_t port0
= instance_one
->port
;
4853 in_port_t port2
= instance_two
->port
;
4855 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4856 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4858 test_compare(MEMCACHED_SUCCESS
,
4859 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4862 test_compare(MEMCACHED_SUCCESS
,
4863 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4864 test_compare(counter
, (unsigned int)max_keys
);
4866 /* restore the memc handle */
4867 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4868 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4870 memcached_quit(memc
);
4872 /* Remove half of the objects */
4873 for (size_t x
= 0; x
< max_keys
; ++x
)
4877 test_compare(MEMCACHED_SUCCESS
,
4878 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
4882 memcached_quit(memc
);
4883 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4884 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4886 /* now retry the command, this time we should have cache misses */
4887 test_compare(MEMCACHED_SUCCESS
,
4888 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4891 test_compare(MEMCACHED_SUCCESS
,
4892 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4893 test_compare(counter
, (unsigned int)(max_keys
>> 1));
4895 /* Release allocated resources */
4896 for (size_t x
= 0; x
< max_keys
; ++x
)
4903 /* restore the memc handle */
4904 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4905 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4907 return TEST_SUCCESS
;
4910 static test_return_t
regression_bug_463297(memcached_st
*memc
)
4912 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4913 test_true(memc_clone
);
4914 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4916 memcached_server_instance_st instance
=
4917 memcached_server_instance_by_position(memc_clone
, 0);
4919 if (instance
->major_version
> 1 ||
4920 (instance
->major_version
== 1 &&
4921 instance
->minor_version
> 2))
4923 /* Binary protocol doesn't support deferred delete */
4924 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4925 test_true(bin_clone
);
4926 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4927 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4928 memcached_free(bin_clone
);
4930 memcached_quit(memc_clone
);
4932 /* If we know the server version, deferred delete should fail
4933 * with invalid arguments */
4934 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4936 /* If we don't know the server version, we should get a protocol error */
4937 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4939 /* but there is a bug in some of the memcached servers (1.4) that treats
4940 * the counter as noreply so it doesn't send the proper error message
4942 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4944 /* And buffered mode should be disabled and we should get protocol error */
4945 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4946 rc
= memcached_delete(memc
, "foo", 3, 1);
4947 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4949 /* Same goes for noreply... */
4950 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4951 rc
= memcached_delete(memc
, "foo", 3, 1);
4952 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4954 /* but a normal request should go through (and be buffered) */
4955 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4956 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4958 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4959 /* unbuffered noreply should be success */
4960 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4961 /* unbuffered with reply should be not found... */
4962 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4963 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4966 memcached_free(memc_clone
);
4967 return TEST_SUCCESS
;
4971 /* Test memcached_server_get_last_disconnect
4972 * For a working server set, shall be NULL
4973 * For a set of non existing server, shall not be NULL
4975 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4977 memcached_return_t rc
;
4978 memcached_server_instance_st disconnected_server
;
4980 /* With the working set of server */
4981 const char *key
= "marmotte";
4982 const char *value
= "milka";
4984 memcached_reset_last_disconnected_server(memc
);
4985 test_false(memc
->last_disconnected_server
);
4986 rc
= memcached_set(memc
, key
, strlen(key
),
4987 value
, strlen(value
),
4988 (time_t)0, (uint32_t)0);
4989 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4991 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4992 test_false(disconnected_server
);
4994 /* With a non existing server */
4996 memcached_server_st
*servers
;
4998 const char *server_list
= "localhost:9";
5000 servers
= memcached_servers_parse(server_list
);
5002 mine
= memcached_create(NULL
);
5003 rc
= memcached_server_push(mine
, servers
);
5004 test_compare(MEMCACHED_SUCCESS
, rc
);
5005 memcached_server_list_free(servers
);
5008 rc
= memcached_set(mine
, key
, strlen(key
),
5009 value
, strlen(value
),
5010 (time_t)0, (uint32_t)0);
5011 test_true(memcached_failed(rc
));
5013 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5014 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5015 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5016 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5018 memcached_quit(mine
);
5019 memcached_free(mine
);
5021 return TEST_SUCCESS
;
5024 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5026 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5027 char buffer
[BUFSIZ
];
5029 test_compare(MEMCACHED_SUCCESS
,
5030 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5032 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5035 // We will just use the error strings as our keys
5036 uint32_t counter
= 100;
5039 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5041 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5042 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5043 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
5045 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5046 test_true(disconnected_server
);
5047 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5048 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5052 memcached_reset_last_disconnected_server(memc
);
5057 memcached_free(memc
);
5059 return TEST_SUCCESS
;
5062 static test_return_t
test_verbosity(memcached_st
*memc
)
5064 memcached_verbosity(memc
, 3);
5066 return TEST_SUCCESS
;
5070 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5071 const char *key
, size_t key_length
,
5072 const char *value
, size_t value_length
,
5082 return MEMCACHED_SUCCESS
;
5085 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5087 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5088 test_compare(MEMCACHED_SUCCESS
, rc
);
5090 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5091 test_compare(MEMCACHED_SUCCESS
, rc
);
5093 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5094 test_compare(MEMCACHED_SUCCESS
, rc
);
5096 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5097 test_compare(MEMCACHED_SUCCESS
, rc
);
5099 return TEST_SUCCESS
;
5103 * This test ensures that the failure counter isn't incremented during
5104 * normal termination of the memcached instance.
5106 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5108 memcached_return_t rc
;
5109 memcached_server_instance_st instance
;
5111 /* Set value to force connection to the server */
5112 const char *key
= "marmotte";
5113 const char *value
= "milka";
5116 * Please note that I'm abusing the internal structures in libmemcached
5117 * in a non-portable way and you shouldn't be doing this. I'm only
5118 * doing this in order to verify that the library works the way it should
5120 uint32_t number_of_hosts
= memcached_server_count(memc
);
5121 memc
->number_of_hosts
= 1;
5123 /* Ensure that we are connected to the server by setting a value */
5124 rc
= memcached_set(memc
, key
, strlen(key
),
5125 value
, strlen(value
),
5126 (time_t)0, (uint32_t)0);
5127 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5130 instance
= memcached_server_instance_by_position(memc
, 0);
5131 /* The test is to see that the memcached_quit doesn't increase the
5132 * the server failure conter, so let's ensure that it is zero
5133 * before sending quit
5135 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5137 memcached_quit(memc
);
5139 /* Verify that it memcached_quit didn't increment the failure counter
5140 * Please note that this isn't bullet proof, because an error could
5143 test_zero(instance
->server_failure_counter
);
5145 /* restore the instance */
5146 memc
->number_of_hosts
= number_of_hosts
;
5148 return TEST_SUCCESS
;
5152 * This tests ensures expected disconnections (for some behavior changes
5153 * for instance) do not wrongly increase failure counter
5155 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5157 memcached_return rc
;
5159 memcached_st
*memc_clone
;
5160 memc_clone
= memcached_clone(NULL
, memc
);
5161 test_true(memc_clone
);
5163 /* Set value to force connection to the server */
5164 const char *key
= "marmotte";
5165 const char *value
= "milka";
5166 char *string
= NULL
;
5167 size_t string_length
;
5170 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5171 value
, strlen(value
),
5172 (time_t)0, (uint32_t)0);
5173 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5176 /* put failure limit to 1 */
5177 test_compare(MEMCACHED_SUCCESS
,
5178 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1));
5180 /* Put a retry timeout to effectively activate failure_limit effect */
5181 test_compare(MEMCACHED_SUCCESS
,
5182 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
5184 /* change behavior that triggers memcached_quit()*/
5185 test_compare(MEMCACHED_SUCCESS
,
5186 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5189 /* Check if we still are connected */
5190 string
= memcached_get(memc_clone
, key
, strlen(key
),
5191 &string_length
, &flags
, &rc
);
5193 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5196 memcached_free(memc_clone
);
5198 return TEST_SUCCESS
;
5205 * Test that ensures mget_execute does not end into recursive calls that finally fails
5207 static test_return_t
regression_bug_490486(memcached_st
*original_memc
)
5211 return TEST_SKIPPED
; // My MAC can't handle this test
5214 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
5217 * I only want to hit _one_ server so I know the number of requests I'm
5218 * sending in the pipeline.
5220 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
5223 size_t max_keys
= 20480;
5225 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5226 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5228 /* First add all of the items.. */
5229 char blob
[1024]= { 0 };
5230 for (size_t x
= 0; x
< max_keys
; ++x
)
5233 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5236 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5237 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5242 /* Try to get all of them with a large multiget */
5244 memcached_execute_function callbacks
[]= { &callback_counter
};
5245 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5246 (size_t)max_keys
, callbacks
, &counter
, 1);
5247 test_compare(MEMCACHED_SUCCESS
, rc
);
5249 char* the_value
= NULL
;
5250 char the_key
[MEMCACHED_MAX_KEY
];
5251 size_t the_key_length
;
5252 size_t the_value_length
;
5256 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5258 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5264 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5267 test_compare(MEMCACHED_END
, rc
);
5269 /* Verify that we got all of the items */
5270 test_compare(counter
, max_keys
);
5273 /* Release all allocated resources */
5274 for (size_t x
= 0; x
< max_keys
; ++x
)
5281 memcached_free(memc
);
5283 return TEST_SUCCESS
;
5286 static test_return_t
regression_bug_583031(memcached_st
*)
5288 memcached_st
*memc
= memcached_create(NULL
);
5290 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5292 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5293 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5294 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5295 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5296 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5297 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5299 memcached_return_t rc
;
5303 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5307 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5309 memcached_free(memc
);
5311 return TEST_SUCCESS
;
5314 static test_return_t
regression_bug_581030(memcached_st
*)
5317 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5318 test_false(local_stat
);
5320 memcached_stat_free(NULL
, NULL
);
5323 return TEST_SUCCESS
;
5326 #define regression_bug_655423_COUNT 6000
5327 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5329 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5330 memc
= NULL
; // Just to make sure it is not used
5335 return TEST_SKIPPED
;
5338 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5339 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5340 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5341 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5343 memset(payload
, int('x'), sizeof(payload
));
5345 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5347 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5348 snprintf(key
, sizeof(key
), "%u", x
);
5350 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5353 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5355 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5356 snprintf(key
, sizeof(key
), "%u", x
);
5358 size_t value_length
;
5359 memcached_return_t rc
;
5360 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5362 if (rc
== MEMCACHED_NOTFOUND
)
5365 test_zero(value_length
);
5369 test_compare(MEMCACHED_SUCCESS
, rc
);
5371 test_compare(100LLU, value_length
);
5375 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5376 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5377 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5379 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5380 snprintf(key
, sizeof(key
), "%u", x
);
5382 keys
[x
]= strdup(key
);
5384 key_length
[x
]= strlen(key
);
5385 test_true(key_length
[x
]);
5388 test_compare(MEMCACHED_SUCCESS
,
5389 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5392 memcached_result_st
*result
= NULL
;
5393 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5395 test_compare(size_t(100), memcached_result_length(result
));
5399 test_true(count
> 100); // If we don't get back atleast this, something is up
5401 /* Release all allocated resources */
5402 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5410 memcached_free(clone
);
5412 return TEST_SUCCESS
;
5416 * Test that ensures that buffered set to not trigger problems during io_flush
5418 #define regression_bug_490520_COUNT 200480
5419 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5421 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5422 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5423 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5424 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5425 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5427 memc
->number_of_hosts
= 1;
5429 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5430 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5432 /* First add all of the items.. */
5433 char blob
[3333] = {0};
5434 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5437 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5441 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5442 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5445 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5452 return TEST_SUCCESS
;
5456 static test_return_t
regression_bug_854604(memcached_st
*)
5460 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
5462 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
5464 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
5465 test_compare(buffer
[0], 0);
5467 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
5468 test_true(strlen(buffer
));
5470 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
5471 test_true(strlen(buffer
));
5473 return TEST_SUCCESS
;
5476 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5478 fprintf(stderr
, "Iteration #%u: ", it
);
5480 if (error
== MEMCACHED_ERRNO
)
5482 fprintf(stderr
, "system error %d from %s: %s\n",
5483 errno
, what
, strerror(errno
));
5487 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5488 memcached_strerror(mc
, error
));
5492 #define TEST_CONSTANT_CREATION 200
5494 static test_return_t
regression_bug_(memcached_st
*memc
)
5496 const char *remote_server
;
5499 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5501 return TEST_SKIPPED
;
5504 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5506 memcached_st
* mc
= memcached_create(NULL
);
5507 memcached_return rc
;
5509 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5510 if (rc
!= MEMCACHED_SUCCESS
)
5512 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5515 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5516 if (rc
!= MEMCACHED_SUCCESS
)
5518 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5521 rc
= memcached_server_add(mc
, remote_server
, 0);
5522 if (rc
!= MEMCACHED_SUCCESS
)
5524 memcached_die(mc
, rc
, "memcached_server_add", x
);
5527 const char *set_key
= "akey";
5528 const size_t set_key_len
= strlen(set_key
);
5529 const char *set_value
= "a value";
5530 const size_t set_value_len
= strlen(set_value
);
5532 if (rc
== MEMCACHED_SUCCESS
)
5536 size_t get_value_len
;
5538 uint32_t get_value_flags
;
5540 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5541 &get_value_flags
, &rc
);
5542 if (rc
!= MEMCACHED_SUCCESS
)
5544 memcached_die(mc
, rc
, "memcached_get", x
);
5550 (get_value_len
!= set_value_len
5551 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5553 fprintf(stderr
, "Values don't match?\n");
5554 rc
= MEMCACHED_FAILURE
;
5560 rc
= memcached_set(mc
,
5561 set_key
, set_key_len
,
5562 set_value
, set_value_len
,
5566 if (rc
!= MEMCACHED_SUCCESS
)
5568 memcached_die(mc
, rc
, "memcached_set", x
);
5575 if (rc
!= MEMCACHED_SUCCESS
)
5581 return TEST_SUCCESS
;
5584 /* Clean the server before beginning testing */
5586 {"util_version", true, (test_callback_fn
*)util_version_test
},
5587 {"flush", false, (test_callback_fn
*)flush_test
},
5588 {"init", false, (test_callback_fn
*)init_test
},
5589 {"allocation", false, (test_callback_fn
*)allocation_test
},
5590 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5591 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5592 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5593 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5594 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5595 {"clone_test", false, (test_callback_fn
*)clone_test
},
5596 {"connection_test", false, (test_callback_fn
*)connection_test
},
5597 {"callback_test", false, (test_callback_fn
*)callback_test
},
5598 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5599 {"set", false, (test_callback_fn
*)set_test
},
5600 {"set2", false, (test_callback_fn
*)set_test2
},
5601 {"set3", false, (test_callback_fn
*)set_test3
},
5602 {"dump", true, (test_callback_fn
*)dump_test
},
5603 {"add", true, (test_callback_fn
*)add_test
},
5604 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5605 {"replace", true, (test_callback_fn
*)replace_test
},
5606 {"delete", true, (test_callback_fn
*)delete_test
},
5607 {"get", true, (test_callback_fn
*)get_test
},
5608 {"get2", false, (test_callback_fn
*)get_test2
},
5609 {"get3", false, (test_callback_fn
*)get_test3
},
5610 {"get4", false, (test_callback_fn
*)get_test4
},
5611 {"partial mget", false, (test_callback_fn
*)get_test5
},
5612 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5613 {"increment", false, (test_callback_fn
*)increment_test
},
5614 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5615 {"decrement", false, (test_callback_fn
*)decrement_test
},
5616 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5617 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5618 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5619 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5620 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5621 {"binary_increment_with_prefix", 1, (test_callback_fn
*)binary_increment_with_prefix_test
},
5622 {"quit", false, (test_callback_fn
*)quit_test
},
5623 {"mget", true, (test_callback_fn
*)mget_test
},
5624 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5625 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5626 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5627 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5628 {"mget_end", false, (test_callback_fn
*)mget_end
},
5629 {"get_stats", false, (test_callback_fn
*)get_stats
},
5630 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5631 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5632 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5633 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
5634 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5635 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5636 {"read_through", true, (test_callback_fn
*)read_through
},
5637 {"delete_through", true, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER
},
5638 {"noreply", true, (test_callback_fn
*)noreply_test
},
5639 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5640 {"memcached_pool_st", true, (test_callback_fn
*)connection_pool_test
},
5641 {"memcached_pool_st #2", true, (test_callback_fn
*)connection_pool2_test
},
5643 {"memcached_pool_st #3", true, (test_callback_fn
*)connection_pool3_test
},
5645 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
5646 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
5647 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
5648 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
5649 {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_NOTFOUND
},
5650 {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_SUCCESS
},
5651 {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_by_key_NOTFOUND
},
5652 {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_by_key_SUCCESS
},
5653 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5654 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5658 test_st touch_tests
[] ={
5659 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5660 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5664 test_st behavior_tests
[] ={
5665 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5666 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5667 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5668 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5669 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5670 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5671 {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test
},
5672 {"MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY", false, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY
},
5676 test_st libmemcachedutil_tests
[] ={
5677 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5678 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5679 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5683 test_st basic_tests
[] ={
5684 {"init", true, (test_callback_fn
*)basic_init_test
},
5685 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5686 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5687 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5688 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5689 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5690 {"memcached_return_t", false, (test_callback_fn
*)memcached_return_t_TEST
},
5694 test_st regression_binary_vs_block
[] ={
5695 {"block add", true, (test_callback_fn
*)block_add_regression
},
5696 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
5700 test_st async_tests
[] ={
5701 {"add", true, (test_callback_fn
*)add_wrapper
},
5705 test_st memcached_server_get_last_disconnect_tests
[] ={
5706 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
5707 {0, 0, (test_callback_fn
*)0}
5711 test_st result_tests
[] ={
5712 {"result static", false, (test_callback_fn
*)result_static
},
5713 {"result alloc", false, (test_callback_fn
*)result_alloc
},
5714 {0, 0, (test_callback_fn
*)0}
5717 test_st version_1_2_3
[] ={
5718 {"append", false, (test_callback_fn
*)append_test
},
5719 {"prepend", false, (test_callback_fn
*)prepend_test
},
5720 {"cas", false, (test_callback_fn
*)cas_test
},
5721 {"cas2", false, (test_callback_fn
*)cas2_test
},
5722 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
5723 {0, 0, (test_callback_fn
*)0}
5726 test_st haldenbrand_tests
[] ={
5727 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
5728 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
5729 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
5730 {0, 0, (test_callback_fn
*)0}
5733 test_st user_tests
[] ={
5734 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
5735 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
5736 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
5737 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
5738 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
5739 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
5740 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
5741 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
5742 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
5743 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
5744 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
5745 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
5746 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
5747 #if !defined(__sun) && !defined(__OpenBSD__)
5749 ** It seems to be something weird with the character sets..
5750 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5751 ** guess I need to find out how this is supposed to work.. Perhaps I need
5752 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5753 ** so just disable the code for now...).
5755 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
5757 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
5758 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
5759 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
5760 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
5761 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
5762 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
5763 {0, 0, (test_callback_fn
*)0}
5766 test_st replication_tests
[]= {
5767 {"set", true, (test_callback_fn
*)replication_set_test
},
5768 {"get", false, (test_callback_fn
*)replication_get_test
},
5769 {"mget", false, (test_callback_fn
*)replication_mget_test
},
5770 {"delete", true, (test_callback_fn
*)replication_delete_test
},
5771 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
5772 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
5773 {0, 0, (test_callback_fn
*)0}
5777 * The following test suite is used to verify that we don't introduce
5778 * regression bugs. If you want more information about the bug / test,
5779 * you should look in the bug report at
5780 * http://bugs.launchpad.net/libmemcached
5782 test_st regression_tests
[]= {
5783 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
5784 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
5785 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
5786 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
5787 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
5788 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
5789 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
5790 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
5791 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
5792 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
5793 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
5794 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
5795 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
5796 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
5797 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
5798 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
5799 {"lp:854604", true, (test_callback_fn
*)regression_bug_854604
},
5800 {0, false, (test_callback_fn
*)0}
5803 test_st ketama_compatibility
[]= {
5804 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
5805 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
5806 {0, 0, (test_callback_fn
*)0}
5809 test_st generate_tests
[] ={
5810 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5811 {"generate_data", true, (test_callback_fn
*)generate_data
},
5812 {"get_read", false, (test_callback_fn
*)get_read
},
5813 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
5814 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5815 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
5816 {"generate_data", true, (test_callback_fn
*)generate_data
},
5817 {"mget_read", false, (test_callback_fn
*)mget_read
},
5818 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
5819 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
5820 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
5821 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
5822 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5823 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
5824 {"generate_data", true, (test_callback_fn
*)generate_data
},
5825 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5826 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5827 {0, 0, (test_callback_fn
*)0}
5830 test_st consistent_tests
[] ={
5831 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5832 {"generate_data", true, (test_callback_fn
*)generate_data
},
5833 {"get_read", 0, (test_callback_fn
*)get_read_count
},
5834 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5835 {0, 0, (test_callback_fn
*)0}
5838 test_st consistent_weighted_tests
[] ={
5839 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5840 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
5841 {"get_read", false, (test_callback_fn
*)get_read_count
},
5842 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5843 {0, 0, (test_callback_fn
*)0}
5846 test_st hsieh_availability
[] ={
5847 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
5848 {0, 0, (test_callback_fn
*)0}
5851 test_st murmur_availability
[] ={
5852 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
5853 {0, 0, (test_callback_fn
*)0}
5857 test_st hash_sanity
[] ={
5858 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
5859 {0, 0, (test_callback_fn
*)0}
5863 test_st ketama_auto_eject_hosts
[] ={
5864 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
5865 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
5866 {0, 0, (test_callback_fn
*)0}
5869 test_st hash_tests
[] ={
5870 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
5871 {"md5", false, (test_callback_fn
*)md5_run
},
5872 {"crc", false, (test_callback_fn
*)crc_run
},
5873 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
5874 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
5875 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
5876 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
5877 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
5878 {"murmur", false, (test_callback_fn
*)murmur_run
},
5879 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
5880 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
5881 {0, 0, (test_callback_fn
*)0}
5884 test_st error_conditions
[] ={
5885 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
5886 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
5887 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
5888 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5889 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5890 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
5891 {0, 0, (test_callback_fn
*)0}
5894 test_st parser_tests
[] ={
5895 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
5896 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
5897 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
5898 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
5899 {"hash", false, (test_callback_fn
*)parser_hash_test
},
5900 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
5901 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
5902 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
5903 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
5904 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
5905 {"server", false, (test_callback_fn
*)server_test
},
5906 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
5907 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
5908 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
5909 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
5910 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
5911 {0, 0, (test_callback_fn
*)0}
5914 test_st virtual_bucket_tests
[] ={
5915 {"basic", false, (test_callback_fn
*)virtual_back_map
},
5916 {0, 0, (test_callback_fn
*)0}
5919 test_st memcached_server_add_tests
[] ={
5920 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
5921 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
5922 {0, 0, (test_callback_fn
*)0}
5925 test_st namespace_tests
[] ={
5926 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
5927 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
5928 {0, 0, (test_callback_fn
*)0}
5931 collection_st collection
[] ={
5933 {"hash_sanity", 0, 0, hash_sanity
},
5935 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
5936 {"basic", 0, 0, basic_tests
},
5937 {"hsieh_availability", 0, 0, hsieh_availability
},
5938 {"murmur_availability", 0, 0, murmur_availability
},
5939 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
5940 {"block", 0, 0, tests
},
5941 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
5942 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
5943 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5944 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
5945 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
5946 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
5947 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
5948 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
5949 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
5950 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
5951 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
5952 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
5953 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
5954 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
5955 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
5956 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5957 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
5958 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
5959 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
5960 #ifdef MEMCACHED_ENABLE_DEPRECATED
5961 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
5963 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
5964 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
5965 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
5966 {"specific namespace", 0, 0, namespace_tests
},
5967 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
5968 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
5969 {"result", 0, 0, result_tests
},
5970 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
5971 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
5972 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
5973 {"user written tests", 0, 0, user_tests
},
5974 {"generate", 0, 0, generate_tests
},
5975 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
5976 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
5977 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
5978 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
5979 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
5980 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
5981 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
5983 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
5984 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
5985 {"consistent_not", 0, 0, consistent_tests
},
5986 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
5987 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
5988 {"ketama_compat", 0, 0, ketama_compatibility
},
5989 {"test_hashes", 0, 0, hash_tests
},
5990 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
5991 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
5992 {"regression", 0, 0, regression_tests
},
5993 {"behaviors", 0, 0, behavior_tests
},
5994 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
5995 {"error_conditions", 0, 0, error_conditions
},
5996 {"parser", 0, 0, parser_tests
},
5997 {"virtual buckets", 0, 0, virtual_bucket_tests
},
5998 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
5999 {"touch", 0, 0, touch_tests
},
6003 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
6005 #include "tests/libmemcached_world.h"
6007 void get_world(Framework
*world
)
6009 world
->collections
= collection
;
6011 world
->_create
= (test_callback_create_fn
*)world_create
;
6012 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6014 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6015 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6016 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6017 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6018 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6020 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6021 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6023 world
->set_runner(&defualt_libmemcached_runner
);
6025 world
->set_socket();