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 "tests/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
= GLOBAL2_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 bool return_value_based_on_buffering(memcached_st
*memc
)
117 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
))
119 return MEMCACHED_BUFFERED
;
122 return MEMCACHED_SUCCESS
;
125 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
128 * I only want to hit _one_ server so I know the number of requests I'm
129 * sending in the pipeline.
131 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
133 char server_string
[1024];
134 int server_string_length
;
137 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
138 memcached_server_name(instance
), int(memcached_server_port(instance
)),
143 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
144 memcached_server_name(instance
), int(memcached_server_port(instance
)));
147 if (server_string_length
<= 0)
153 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, buffer
, sizeof(buffer
))))
155 Error
<< "Failed to parse " << server_string_length
;
159 return memcached(server_string
, server_string_length
);
163 static test_return_t
init_test(memcached_st
*not_used
)
168 (void)memcached_create(&memc
);
169 memcached_free(&memc
);
174 #define TEST_PORT_COUNT 7
175 in_port_t test_ports
[TEST_PORT_COUNT
];
177 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
178 const memcached_server_st
*server
,
182 size_t bigger
= *((size_t *)(context
));
184 assert(bigger
<= memcached_server_port(server
));
185 *((size_t *)(context
))= memcached_server_port(server
);
187 return MEMCACHED_SUCCESS
;
190 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
191 const memcached_server_st
*instance
,
195 FILE *stream
= (FILE *)context
;
198 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
199 memcached_server_name(instance
),
200 memcached_server_port(instance
),
201 instance
->major_version
,
202 instance
->minor_version
,
203 instance
->micro_version
);
205 return MEMCACHED_SUCCESS
;
208 static test_return_t
server_sort_test(memcached_st
*ptr
)
210 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
212 memcached_return_t rc
;
213 memcached_server_fn callbacks
[1];
214 memcached_st
*local_memc
;
217 local_memc
= memcached_create(NULL
);
218 test_true(local_memc
);
219 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
221 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
223 test_ports
[x
]= (in_port_t
)random() % 64000;
224 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
225 test_compare(memcached_server_count(local_memc
), x
+1);
227 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
229 test_compare(MEMCACHED_SUCCESS
, rc
);
232 callbacks
[0]= server_display_function
;
233 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
236 memcached_free(local_memc
);
241 static test_return_t
server_sort2_test(memcached_st
*ptr
)
243 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
244 memcached_server_fn callbacks
[1];
245 memcached_st
*local_memc
;
246 memcached_server_instance_st instance
;
249 local_memc
= memcached_create(NULL
);
250 test_true(local_memc
);
251 test_compare(MEMCACHED_SUCCESS
,
252 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
254 test_compare(MEMCACHED_SUCCESS
,
255 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
256 instance
= memcached_server_instance_by_position(local_memc
, 0);
257 test_compare(in_port_t(43043), memcached_server_port(instance
));
259 test_compare(MEMCACHED_SUCCESS
,
260 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
262 instance
= memcached_server_instance_by_position(local_memc
, 0);
263 test_compare(in_port_t(43042), memcached_server_port(instance
));
265 instance
= memcached_server_instance_by_position(local_memc
, 1);
266 test_compare(in_port_t(43043), memcached_server_port(instance
));
268 callbacks
[0]= server_display_function
;
269 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
272 memcached_free(local_memc
);
277 static test_return_t
memcached_server_remove_test(memcached_st
*)
279 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";
282 test_compare(MEMCACHED_SUCCESS
,
283 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
284 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
287 memcached_server_fn callbacks
[1];
288 callbacks
[0]= server_print_callback
;
289 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
291 memcached_free(memc
);
296 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
297 const memcached_server_st
*server
,
301 uint32_t x
= *((uint32_t *)(context
));
303 if (! (test_ports
[x
] == server
->port
))
305 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
306 return MEMCACHED_FAILURE
;
309 *((uint32_t *)(context
))= ++x
;
311 return MEMCACHED_SUCCESS
;
314 static test_return_t
server_unsort_test(memcached_st
*ptr
)
316 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
317 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
318 memcached_server_fn callbacks
[1];
319 memcached_st
*local_memc
;
322 local_memc
= memcached_create(NULL
);
323 test_true(local_memc
);
325 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
327 test_ports
[x
]= (in_port_t
)(random() % 64000);
328 test_compare(MEMCACHED_SUCCESS
,
329 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
330 test_compare(memcached_server_count(local_memc
), x
+1);
332 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
336 callbacks
[0]= server_display_unsort_function
;
337 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
339 /* Now we sort old data! */
340 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
341 callbacks
[0]= server_display_function
;
342 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
345 memcached_free(local_memc
);
350 static test_return_t
allocation_test(memcached_st
*not_used
)
354 memc
= memcached_create(NULL
);
356 memcached_free(memc
);
361 static test_return_t
clone_test(memcached_st
*memc
)
365 memcached_st
*memc_clone
;
366 memc_clone
= memcached_clone(NULL
, NULL
);
367 test_true(memc_clone
);
368 memcached_free(memc_clone
);
371 /* Can we init from null? */
373 memcached_st
*memc_clone
;
374 memc_clone
= memcached_clone(NULL
, memc
);
375 test_true(memc_clone
);
378 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
379 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
380 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
381 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
384 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
385 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
386 test_true(memc_clone
->distribution
== memc
->distribution
);
387 { // Test all of the flags
388 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
389 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
390 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
391 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
392 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
393 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
394 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
395 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
396 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
397 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
398 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
399 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
400 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
402 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
403 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
404 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
405 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
406 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
407 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
408 test_true(memc_clone
->on_clone
== memc
->on_clone
);
409 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
410 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
411 test_true(memc_clone
->recv_size
== memc
->recv_size
);
412 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
413 test_true(memc_clone
->send_size
== memc
->send_size
);
414 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
415 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
416 test_true(memc_clone
->user_data
== memc
->user_data
);
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
, NULL
);
427 test_true(memc_clone
);
428 memcached_free(memc_clone
);
431 /* Can we init from struct? */
433 memcached_st declared_clone
;
434 memcached_st
*memc_clone
;
435 memset(&declared_clone
, 0 , sizeof(memcached_st
));
436 memc_clone
= memcached_clone(&declared_clone
, memc
);
437 test_true(memc_clone
);
438 memcached_free(memc_clone
);
444 static test_return_t
userdata_test(memcached_st
*memc
)
447 test_false(memcached_set_user_data(memc
, foo
));
448 test_true(memcached_get_user_data(memc
) == foo
);
449 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
454 static test_return_t
connection_test(memcached_st
*memc
)
456 test_compare(MEMCACHED_SUCCESS
,
457 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
462 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
464 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
466 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
468 test_compare(36, int(MEMCACHED_BEHAVIOR_MAX
));
473 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
475 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
477 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
479 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
484 static test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
486 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
487 982370485U, 1263635348U, 4242906218U, 3829656100U,
488 1891735253U, 334139633U, 2257084983U, 3088286104U,
489 13199785U, 2542027183U, 1097051614U, 199566778U,
490 2748246961U, 2465192557U, 1664094137U, 2405439045U,
491 1842224848U, 692413798U, 3479807801U, 919913813U,
492 4269430871U, 610793021U, 527273862U, 1437122909U,
493 2300930706U, 2943759320U, 674306647U, 2400528935U,
494 54481931U, 4186304426U, 1741088401U, 2979625118U,
495 4159057246U, 3425930182U, 2593724503U, 1868899624U,
496 1769812374U, 2302537950U, 1110330676U, 3365377466U,
497 1336171666U, 3021258493U, 2334992265U, 3861994737U,
498 3582734124U, 3365377466U };
500 // You have updated the memcache_error messages but not updated docs/tests.
501 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
504 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
505 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
506 MEMCACHED_HASH_JENKINS
);
507 if (values
[rc
] != hash_val
)
509 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
510 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
512 test_compare(values
[rc
], hash_val
);
514 test_compare(49, int(MEMCACHED_MAXIMUM_RETURN
));
519 static test_return_t
set_test(memcached_st
*memc
)
521 memcached_return_t rc
= memcached_set(memc
,
522 test_literal_param("foo"),
523 test_literal_param("when we sanitize"),
524 time_t(0), (uint32_t)0);
525 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
530 static test_return_t
append_test(memcached_st
*memc
)
532 memcached_return_t rc
;
533 const char *key
= "fig";
534 const char *in_value
= "we";
535 char *out_value
= NULL
;
539 rc
= memcached_flush(memc
, 0);
540 test_compare(MEMCACHED_SUCCESS
, rc
);
542 rc
= memcached_set(memc
, key
, strlen(key
),
543 in_value
, strlen(in_value
),
544 (time_t)0, (uint32_t)0);
545 test_compare(MEMCACHED_SUCCESS
, rc
);
547 rc
= memcached_append(memc
, key
, strlen(key
),
548 " the", strlen(" the"),
549 (time_t)0, (uint32_t)0);
550 test_compare(MEMCACHED_SUCCESS
, rc
);
552 rc
= memcached_append(memc
, key
, strlen(key
),
553 " people", strlen(" people"),
554 (time_t)0, (uint32_t)0);
555 test_compare(MEMCACHED_SUCCESS
, rc
);
557 out_value
= memcached_get(memc
, key
, strlen(key
),
558 &value_length
, &flags
, &rc
);
559 test_memcmp(out_value
, "we the people", strlen("we the people"));
560 test_compare(strlen("we the people"), value_length
);
561 test_compare(MEMCACHED_SUCCESS
, rc
);
567 static test_return_t
append_binary_test(memcached_st
*memc
)
569 memcached_return_t rc
;
570 const char *key
= "numbers";
571 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
577 rc
= memcached_flush(memc
, 0);
578 test_compare(MEMCACHED_SUCCESS
, rc
);
580 rc
= memcached_set(memc
,
583 (time_t)0, (uint32_t)0);
584 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
586 for (x
= 0; store_list
[x
] ; x
++)
588 rc
= memcached_append(memc
,
590 (char *)&store_list
[x
], sizeof(uint32_t),
591 (time_t)0, (uint32_t)0);
592 test_compare(MEMCACHED_SUCCESS
, rc
);
595 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
596 &value_length
, &flags
, &rc
);
597 test_compare(value_length
, sizeof(uint32_t) * x
);
598 test_compare(MEMCACHED_SUCCESS
, rc
);
600 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
602 test_compare(*ptr
, store_list
[x
- counter
]);
610 static test_return_t
cas2_test(memcached_st
*memc
)
612 memcached_return_t rc
;
613 const char *keys
[]= {"fudge", "son", "food"};
614 size_t key_length
[]= {5, 3, 4};
615 const char *value
= "we the people";
616 size_t value_length
= strlen("we the people");
617 memcached_result_st results_obj
;
618 memcached_result_st
*results
;
621 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
623 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
625 for (uint32_t x
= 0; x
< 3; x
++)
627 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
628 keys
[x
], key_length
[x
],
629 (time_t)50, (uint32_t)9);
630 test_compare(MEMCACHED_SUCCESS
, rc
);
633 test_compare(MEMCACHED_SUCCESS
,
634 memcached_mget(memc
, keys
, key_length
, 3));
636 results
= memcached_result_create(memc
, &results_obj
);
639 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
641 test_true(results
->item_cas
);
642 test_compare(MEMCACHED_SUCCESS
, rc
);
643 test_true(memcached_result_cas(results
));
645 test_memcmp(value
, "we the people", strlen("we the people"));
646 test_compare(strlen("we the people"), value_length
);
647 test_compare(MEMCACHED_SUCCESS
, rc
);
649 memcached_result_free(&results_obj
);
654 static test_return_t
cas_test(memcached_st
*memc
)
656 const char *key
= "fun";
657 size_t key_length
= strlen(key
);
658 const char *value
= "we the people";
659 const char* keys
[2] = { key
, NULL
};
660 size_t keylengths
[2] = { strlen(key
), 0 };
661 size_t value_length
= strlen(value
);
662 const char *value2
= "change the value";
663 size_t value2_length
= strlen(value2
);
665 memcached_result_st results_obj
;
666 memcached_result_st
*results
;
668 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
670 test_skip(true, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
672 test_compare(MEMCACHED_SUCCESS
,
673 memcached_set(memc
, key
, strlen(key
),
674 value
, strlen(value
),
675 (time_t)0, (uint32_t)0));
677 test_compare(MEMCACHED_SUCCESS
,
678 memcached_mget(memc
, keys
, keylengths
, 1));
680 results
= memcached_result_create(memc
, &results_obj
);
683 memcached_return_t rc
;
684 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
686 test_compare(MEMCACHED_SUCCESS
, rc
);
687 test_true(memcached_result_cas(results
));
688 test_memcmp(value
, memcached_result_value(results
), value_length
);
689 test_compare(strlen(memcached_result_value(results
)), value_length
);
690 test_compare(MEMCACHED_SUCCESS
, rc
);
691 uint64_t cas
= memcached_result_cas(results
);
694 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
695 test_true(rc
== MEMCACHED_END
);
696 test_true(results
== NULL
);
699 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
700 test_compare(MEMCACHED_SUCCESS
, rc
);
703 * The item will have a new cas value, so try to set it again with the old
704 * value. This should fail!
706 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
707 test_compare(MEMCACHED_DATA_EXISTS
, rc
);
709 memcached_result_free(&results_obj
);
714 static test_return_t
prepend_test(memcached_st
*memc
)
716 const char *key
= "fig";
717 const char *value
= "people";
719 test_compare(MEMCACHED_SUCCESS
,
720 memcached_flush(memc
, 0));
722 test_compare(MEMCACHED_SUCCESS
,
723 memcached_set(memc
, key
, strlen(key
),
724 value
, strlen(value
),
725 time_t(0), uint32_t(0)));
727 test_compare(MEMCACHED_SUCCESS
,
728 memcached_prepend(memc
, key
, strlen(key
),
729 "the ", strlen("the "),
730 time_t(0), uint32_t(0)));
732 test_compare(MEMCACHED_SUCCESS
,
733 memcached_prepend(memc
, key
, strlen(key
),
734 "we ", strlen("we "),
735 time_t(0), uint32_t(0)));
739 memcached_return_t rc
;
740 char *out_value
= memcached_get(memc
, key
, strlen(key
),
741 &value_length
, &flags
, &rc
);
742 test_memcmp(out_value
, "we the people", strlen("we the people"));
743 test_compare(strlen("we the people"), value_length
);
744 test_compare(MEMCACHED_SUCCESS
, rc
);
751 Set the value, then quit to make sure it is flushed.
752 Come back in and test that add fails.
754 static test_return_t
add_test(memcached_st
*memc
)
756 memcached_return_t rc
;
757 const char *key
= "foo";
758 const char *value
= "when we sanitize";
759 unsigned long long setting_value
;
761 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
763 rc
= memcached_set(memc
, key
, strlen(key
),
764 value
, strlen(value
),
765 (time_t)0, (uint32_t)0);
766 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
767 memcached_quit(memc
);
768 rc
= memcached_add(memc
, key
, strlen(key
),
769 value
, strlen(value
),
770 (time_t)0, (uint32_t)0);
772 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
775 test_true(rc
== MEMCACHED_NOTSTORED
or rc
== MEMCACHED_STORED
);
779 test_true(rc
== MEMCACHED_NOTSTORED
or rc
== MEMCACHED_DATA_EXISTS
);
786 ** There was a problem of leaking filedescriptors in the initial release
787 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
788 ** systems it seems that the kernel is slow on reclaiming the resources
789 ** because the connects starts to time out (the test doesn't do much
790 ** anyway, so just loop 10 iterations)
792 static test_return_t
add_wrapper(memcached_st
*memc
)
794 unsigned int max
= 10000;
802 for (uint32_t x
= 0; x
< max
; x
++)
808 static test_return_t
replace_test(memcached_st
*memc
)
810 memcached_return_t rc
;
811 const char *key
= "foo";
812 const char *value
= "when we sanitize";
813 const char *original
= "first we insert some data";
815 rc
= memcached_set(memc
, key
, strlen(key
),
816 original
, strlen(original
),
817 (time_t)0, (uint32_t)0);
818 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
820 test_compare(MEMCACHED_SUCCESS
,
821 memcached_replace(memc
, key
, strlen(key
),
822 value
, strlen(value
),
823 (time_t)0, (uint32_t)0));
828 static test_return_t
delete_test(memcached_st
*memc
)
830 test_compare(return_value_based_on_buffering(memc
),
832 test_literal_param(__func__
),
833 test_literal_param("when we sanitize"),
834 time_t(0), uint32_t(0)));
836 memcached_return_t rc
= memcached_delete(memc
,
837 test_literal_param(__func__
),
839 test_compare_hint(MEMCACHED_SUCCESS
,
841 memcached_last_error_message(memc
));
846 static test_return_t
flush_test(memcached_st
*memc
)
848 uint64_t query_id
= memcached_query_id(memc
);
849 test_compare(MEMCACHED_SUCCESS
,
850 memcached_flush(memc
, 0));
851 test_compare(query_id
+1, memcached_query_id(memc
));
856 static memcached_return_t
server_function(const memcached_st
*ptr
,
857 const memcached_server_st
*server
,
860 (void)ptr
; (void)server
; (void)context
;
863 return MEMCACHED_SUCCESS
;
866 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
869 strncpy(context
, "foo bad", sizeof(context
));
870 memcached_server_fn callbacks
[1];
872 callbacks
[0]= server_function
;
873 memcached_server_cursor(memc
, callbacks
, context
, 1);
877 static test_return_t
bad_key_test(memcached_st
*memc
)
879 memcached_return_t rc
;
880 const char *key
= "foo bad";
882 memcached_st
*memc_clone
;
884 uint64_t query_id
= memcached_query_id(memc
);
886 // Just skip if we are in binary mode.
887 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
889 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
891 memc_clone
= memcached_clone(NULL
, memc
);
892 test_true(memc_clone
);
894 query_id
= memcached_query_id(memc_clone
);
895 test_compare(MEMCACHED_SUCCESS
,
896 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
897 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
899 /* All keys are valid in the binary protocol (except for length) */
900 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
902 uint64_t before_query_id
= memcached_query_id(memc_clone
);
904 size_t string_length
;
905 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
906 &string_length
, &flags
, &rc
);
907 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
908 test_zero(string_length
);
911 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
913 query_id
= memcached_query_id(memc_clone
);
914 test_compare(MEMCACHED_SUCCESS
,
915 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
916 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
918 size_t string_length
;
919 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
920 &string_length
, &flags
, &rc
);
921 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
922 test_zero(string_length
);
926 /* Test multi key for bad keys */
927 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
928 size_t key_lengths
[] = { 7, 7, 7 };
929 query_id
= memcached_query_id(memc_clone
);
930 test_compare(MEMCACHED_SUCCESS
,
931 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
932 test_compare(query_id
, memcached_query_id(memc_clone
));
934 query_id
= memcached_query_id(memc_clone
);
935 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
936 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
937 test_compare(query_id
+1, memcached_query_id(memc_clone
));
939 query_id
= memcached_query_id(memc_clone
);
940 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
941 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
942 test_compare(query_id
+1, memcached_query_id(memc_clone
));
944 /* The following test should be moved to the end of this function when the
945 memcached server is updated to allow max size length of the keys in the
948 test_compare(MEMCACHED_SUCCESS
,
949 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
951 std::vector
<char> longkey
;
953 std::vector
<char>::iterator it
= longkey
.begin();
954 longkey
.insert(it
, MEMCACHED_MAX_KEY
, 'a');
957 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
959 size_t string_length
;
961 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
962 test_compare(MEMCACHED_NOTFOUND
, rc
);
963 test_zero(string_length
);
965 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
966 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
967 test_zero(string_length
);
971 /* Make sure zero length keys are marked as bad */
973 test_compare(MEMCACHED_SUCCESS
,
974 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
975 size_t string_length
;
976 char *string
= memcached_get(memc_clone
, key
, 0,
977 &string_length
, &flags
, &rc
);
978 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
979 test_zero(string_length
);
983 memcached_free(memc_clone
);
988 #define READ_THROUGH_VALUE "set for me"
989 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
992 memcached_result_st
*result
)
994 (void)memc
;(void)key
;(void)key_length
;
995 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
998 #ifndef __INTEL_COMPILER
999 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1002 static test_return_t
read_through(memcached_st
*memc
)
1004 memcached_return_t rc
;
1005 const char *key
= "foo";
1007 size_t string_length
;
1009 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1011 string
= memcached_get(memc
, key
, strlen(key
),
1012 &string_length
, &flags
, &rc
);
1014 test_compare(MEMCACHED_NOTFOUND
, rc
);
1015 test_false(string_length
);
1018 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
);
1019 test_compare(MEMCACHED_SUCCESS
, rc
);
1021 string
= memcached_get(memc
, key
, strlen(key
),
1022 &string_length
, &flags
, &rc
);
1024 test_compare(MEMCACHED_SUCCESS
, rc
);
1025 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1026 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1027 test_strcmp(READ_THROUGH_VALUE
, string
);
1030 string
= memcached_get(memc
, key
, strlen(key
),
1031 &string_length
, &flags
, &rc
);
1033 test_compare(MEMCACHED_SUCCESS
, rc
);
1035 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1036 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1037 test_strcmp(READ_THROUGH_VALUE
, string
);
1040 return TEST_SUCCESS
;
1043 static test_return_t
get_test(memcached_st
*memc
)
1045 memcached_return_t rc
;
1046 const char *key
= "foo";
1048 size_t string_length
;
1051 uint64_t query_id
= memcached_query_id(memc
);
1052 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
1053 test_true_got(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
, memcached_last_error_message(memc
));
1054 test_compare(query_id
+1, memcached_query_id(memc
));
1056 string
= memcached_get(memc
, key
, strlen(key
),
1057 &string_length
, &flags
, &rc
);
1059 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1060 test_false(string_length
);
1063 return TEST_SUCCESS
;
1066 static test_return_t
get_test2(memcached_st
*memc
)
1068 const char *key
= "foo";
1069 const char *value
= "when we sanitize";
1071 uint64_t query_id
= memcached_query_id(memc
);
1072 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1073 value
, strlen(value
),
1074 (time_t)0, (uint32_t)0);
1075 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1076 test_compare(query_id
+1, memcached_query_id(memc
));
1078 query_id
= memcached_query_id(memc
);
1079 test_true(query_id
);
1082 size_t string_length
;
1083 char *string
= memcached_get(memc
, key
, strlen(key
),
1084 &string_length
, &flags
, &rc
);
1085 test_compare(query_id
+1, memcached_query_id(memc
));
1087 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1088 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1090 test_compare(strlen(value
), string_length
);
1091 test_memcmp(string
, value
, string_length
);
1095 return TEST_SUCCESS
;
1098 static test_return_t
set_test2(memcached_st
*memc
)
1100 for (uint32_t x
= 0; x
< 10; x
++)
1102 memcached_return_t rc
= memcached_set(memc
,
1103 test_literal_param("foo"),
1104 test_literal_param("train in the brain"),
1105 time_t(0), uint32_t(0));
1106 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1109 return TEST_SUCCESS
;
1112 static test_return_t
set_test3(memcached_st
*memc
)
1114 size_t value_length
= 8191;
1116 std::vector
<char> value
;
1117 value
.reserve(value_length
);
1118 for (uint32_t x
= 0; x
< value_length
; x
++)
1120 value
.push_back(char(x
% 127));
1123 /* The dump test relies on there being at least 32 items in memcached */
1124 for (uint32_t x
= 0; x
< 32; x
++)
1128 snprintf(key
, sizeof(key
), "foo%u", x
);
1130 uint64_t query_id
= memcached_query_id(memc
);
1131 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1132 &value
[0], value
.size(),
1133 (time_t)0, (uint32_t)0);
1134 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1135 test_compare(query_id
+1, memcached_query_id(memc
));
1138 return TEST_SUCCESS
;
1141 static test_return_t
get_test3(memcached_st
*memc
)
1143 const char *key
= "foo";
1144 size_t value_length
= 8191;
1146 std::vector
<char> value
;
1147 value
.reserve(value_length
);
1148 for (uint32_t x
= 0; x
< value_length
; x
++)
1150 value
.push_back(char(x
% 127));
1153 memcached_return_t rc
;
1154 rc
= memcached_set(memc
, key
, strlen(key
),
1155 &value
[0], value
.size(),
1156 (time_t)0, (uint32_t)0);
1157 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1159 size_t string_length
;
1161 char *string
= memcached_get(memc
, key
, strlen(key
),
1162 &string_length
, &flags
, &rc
);
1164 test_compare(MEMCACHED_SUCCESS
, rc
);
1166 test_compare(string_length
, value_length
);
1167 test_memcmp(string
, &value
[0], string_length
);
1171 return TEST_SUCCESS
;
1174 static test_return_t
get_test4(memcached_st
*memc
)
1176 const char *key
= "foo";
1177 size_t value_length
= 8191;
1179 std::vector
<char> value
;
1180 value
.reserve(value_length
);
1181 for (uint32_t x
= 0; x
< value_length
; x
++)
1183 value
.push_back(char(x
% 127));
1186 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1187 &value
[0], value
.size(),
1188 (time_t)0, (uint32_t)0);
1189 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1191 for (uint32_t x
= 0; x
< 10; x
++)
1194 size_t string_length
;
1195 char *string
= memcached_get(memc
, key
, strlen(key
),
1196 &string_length
, &flags
, &rc
);
1198 test_compare(MEMCACHED_SUCCESS
, rc
);
1200 test_compare(string_length
, value_length
);
1201 test_memcmp(string
, &value
[0], string_length
);
1205 return TEST_SUCCESS
;
1209 * This test verifies that memcached_read_one_response doesn't try to
1210 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1211 * responses before you execute a storage command.
1213 static test_return_t
get_test5(memcached_st
*memc
)
1216 ** Request the same key twice, to ensure that we hash to the same server
1217 ** (so that we have multiple response values queued up) ;-)
1219 const char *keys
[]= { "key", "key" };
1220 size_t lengths
[]= { 3, 3 };
1224 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1225 keys
[0], lengths
[0], 0, 0);
1226 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1228 memcached_result_st results_obj
;
1229 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1232 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1235 memcached_result_free(&results_obj
);
1237 /* Don't read out the second result, but issue a set instead.. */
1238 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1240 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1241 &rlen
, &flags
, &rc
);
1243 test_compare(MEMCACHED_NOTFOUND
, rc
);
1244 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1246 test_compare(MEMCACHED_SUCCESS
, rc
);
1249 return TEST_SUCCESS
;
1252 static test_return_t
mget_end(memcached_st
*memc
)
1254 const char *keys
[]= { "foo", "foo2" };
1255 size_t lengths
[]= { 3, 4 };
1256 const char *values
[]= { "fjord", "41" };
1258 memcached_return_t rc
;
1261 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1263 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[x
], lengths
[x
], values
[x
], strlen(values
[x
]), (time_t)0, (uint32_t)0));
1267 size_t string_length
;
1270 // retrieve both via mget
1271 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1273 char key
[MEMCACHED_MAX_KEY
];
1276 // this should get both
1277 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1279 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1281 test_compare(MEMCACHED_SUCCESS
, rc
);
1283 if (key_length
== 4)
1288 test_compare(string_length
, strlen(values
[val
]));
1289 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1293 // this should indicate end
1294 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1295 test_compare(MEMCACHED_END
, rc
);
1299 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1300 test_compare(MEMCACHED_SUCCESS
, rc
);
1302 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1303 test_compare(key_length
, lengths
[0]);
1304 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1305 test_compare(string_length
, strlen(values
[0]));
1306 test_true(strncmp(values
[0], string
, string_length
) == 0);
1307 test_compare(MEMCACHED_SUCCESS
, rc
);
1310 // this should indicate end
1311 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1312 test_compare(MEMCACHED_END
, rc
);
1315 return TEST_SUCCESS
;
1318 /* Do not copy the style of this code, I just access hosts to testthis function */
1319 static test_return_t
stats_servername_test(memcached_st
*memc
)
1321 memcached_stat_st memc_stat
;
1322 memcached_server_instance_st instance
=
1323 memcached_server_instance_by_position(memc
, 0);
1325 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1327 return TEST_SKIPPED
;
1330 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1331 memcached_server_name(instance
),
1332 memcached_server_port(instance
)));
1334 return TEST_SUCCESS
;
1337 static test_return_t
increment_test(memcached_st
*memc
)
1339 uint64_t new_number
;
1341 test_compare(MEMCACHED_SUCCESS
,
1343 test_literal_param("number"),
1344 test_literal_param("0"),
1345 (time_t)0, (uint32_t)0));
1347 test_compare(MEMCACHED_SUCCESS
,
1348 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1349 test_compare(uint64_t(1), new_number
);
1351 test_compare(MEMCACHED_SUCCESS
,
1352 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1353 test_compare(uint64_t(2), new_number
);
1355 return TEST_SUCCESS
;
1358 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1360 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1362 uint64_t new_number
;
1363 uint64_t initial
= 0;
1365 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1367 test_compare(MEMCACHED_SUCCESS
,
1368 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1369 test_compare(new_number
, initial
);
1371 test_compare(MEMCACHED_SUCCESS
,
1372 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1373 test_compare(new_number
, (initial
+1));
1375 return TEST_SUCCESS
;
1378 static test_return_t
decrement_test(memcached_st
*memc
)
1380 uint64_t new_number
;
1381 memcached_return_t rc
;
1382 const char *value
= "3";
1384 rc
= memcached_set(memc
,
1385 test_literal_param("number"),
1386 value
, strlen(value
),
1387 (time_t)0, (uint32_t)0);
1388 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1390 test_compare(MEMCACHED_SUCCESS
,
1391 memcached_decrement(memc
,
1392 test_literal_param("number"),
1394 test_compare(uint64_t(2), new_number
);
1396 test_compare(MEMCACHED_SUCCESS
,
1397 memcached_decrement(memc
,
1398 test_literal_param("number"),
1400 test_compare(uint64_t(1), new_number
);
1402 return TEST_SUCCESS
;
1405 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1407 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1409 uint64_t new_number
;
1410 uint64_t initial
= 3;
1412 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1414 test_compare(MEMCACHED_SUCCESS
,
1415 memcached_decrement_with_initial(memc
,
1416 test_literal_param("number"),
1417 1, initial
, 0, &new_number
));
1418 test_compare(new_number
, initial
);
1420 test_compare(MEMCACHED_SUCCESS
,
1421 memcached_decrement_with_initial(memc
,
1422 test_literal_param("number"),
1423 1, initial
, 0, &new_number
));
1424 test_compare(new_number
, (initial
- 1));
1426 return TEST_SUCCESS
;
1429 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1431 uint64_t new_number
;
1432 memcached_return_t rc
;
1433 const char *master_key
= "foo";
1434 const char *key
= "number";
1435 const char *value
= "0";
1437 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1439 value
, strlen(value
),
1440 (time_t)0, (uint32_t)0);
1441 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1443 test_compare(MEMCACHED_SUCCESS
,
1444 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1445 test_compare(uint64_t(1), new_number
);
1447 test_compare(MEMCACHED_SUCCESS
,
1448 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1449 test_compare(uint64_t(2), new_number
);
1451 return TEST_SUCCESS
;
1454 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1456 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1458 uint64_t new_number
;
1459 memcached_return_t rc
;
1460 const char *master_key
= "foo";
1461 const char *key
= "number";
1462 uint64_t initial
= 0;
1464 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1466 1, initial
, 0, &new_number
);
1467 test_compare(MEMCACHED_SUCCESS
, rc
);
1468 test_compare(new_number
, initial
);
1470 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1472 1, initial
, 0, &new_number
);
1473 test_compare(MEMCACHED_SUCCESS
, rc
);
1474 test_compare(new_number
, (initial
+1));
1476 return TEST_SUCCESS
;
1479 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1481 uint64_t new_number
;
1482 memcached_return_t rc
;
1483 const char *value
= "3";
1485 rc
= memcached_set_by_key(memc
,
1486 test_literal_param("foo"),
1487 test_literal_param("number"),
1488 value
, strlen(value
),
1489 (time_t)0, (uint32_t)0);
1490 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1492 test_compare(MEMCACHED_SUCCESS
,
1493 memcached_decrement_by_key(memc
,
1494 test_literal_param("foo"),
1495 test_literal_param("number"),
1497 test_compare(uint64_t(2), new_number
);
1499 test_compare(MEMCACHED_SUCCESS
,
1500 memcached_decrement_by_key(memc
,
1501 test_literal_param("foo"),
1502 test_literal_param("number"),
1504 test_compare(uint64_t(1), new_number
);
1506 return TEST_SUCCESS
;
1509 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1511 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1513 uint64_t new_number
;
1514 uint64_t initial
= 3;
1516 test_compare(MEMCACHED_SUCCESS
,
1517 memcached_decrement_with_initial_by_key(memc
,
1518 test_literal_param("foo"),
1519 test_literal_param("number"),
1520 1, initial
, 0, &new_number
));
1521 test_compare(new_number
, initial
);
1523 test_compare(MEMCACHED_SUCCESS
,
1524 memcached_decrement_with_initial_by_key(memc
,
1525 test_literal_param("foo"),
1526 test_literal_param("number"),
1527 1, initial
, 0, &new_number
));
1528 test_compare(new_number
, (initial
- 1));
1530 return TEST_SUCCESS
;
1532 static test_return_t
binary_increment_with_prefix_test(memcached_st
*orig_memc
)
1534 memcached_st
*memc
= memcached_clone(NULL
, orig_memc
);
1536 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1538 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1540 memcached_return_t rc
;
1541 rc
= memcached_set(memc
,
1542 test_literal_param("number"),
1543 test_literal_param("0"),
1544 (time_t)0, (uint32_t)0);
1545 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1547 uint64_t new_number
;
1548 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1549 test_literal_param("number"),
1551 test_compare(uint64_t(1), new_number
);
1553 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1554 test_literal_param("number"),
1556 test_compare(uint64_t(2), new_number
);
1557 memcached_free(memc
);
1559 return TEST_SUCCESS
;
1562 static test_return_t
quit_test(memcached_st
*memc
)
1564 memcached_return_t rc
;
1565 const char *key
= "fudge";
1566 const char *value
= "sanford and sun";
1568 rc
= memcached_set(memc
, key
, strlen(key
),
1569 value
, strlen(value
),
1570 (time_t)10, (uint32_t)3);
1571 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1572 memcached_quit(memc
);
1574 rc
= memcached_set(memc
, key
, strlen(key
),
1575 value
, strlen(value
),
1576 (time_t)50, (uint32_t)9);
1577 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1579 return TEST_SUCCESS
;
1582 static test_return_t
mget_result_test(memcached_st
*memc
)
1584 const char *keys
[]= {"fudge", "son", "food"};
1585 size_t key_length
[]= {5, 3, 4};
1587 memcached_result_st results_obj
;
1588 memcached_result_st
*results
;
1590 results
= memcached_result_create(memc
, &results_obj
);
1592 test_true(&results_obj
== results
);
1594 /* We need to empty the server before continueing test */
1595 test_compare(MEMCACHED_SUCCESS
,
1596 memcached_flush(memc
, 0));
1598 test_compare(MEMCACHED_SUCCESS
,
1599 memcached_mget(memc
, keys
, key_length
, 3));
1601 memcached_return_t rc
;
1602 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1607 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1608 test_false(results
);
1609 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1611 for (uint32_t x
= 0; x
< 3; x
++)
1613 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1614 keys
[x
], key_length
[x
],
1615 (time_t)50, (uint32_t)9);
1616 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1619 test_compare(MEMCACHED_SUCCESS
,
1620 memcached_mget(memc
, keys
, key_length
, 3));
1622 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1625 test_true(&results_obj
== results
);
1626 test_compare(MEMCACHED_SUCCESS
, rc
);
1627 test_memcmp(memcached_result_key_value(results
),
1628 memcached_result_value(results
),
1629 memcached_result_length(results
));
1630 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1633 memcached_result_free(&results_obj
);
1635 return TEST_SUCCESS
;
1638 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1640 const char *keys
[]= {"fudge", "son", "food"};
1641 size_t key_length
[]= {5, 3, 4};
1643 memcached_result_st
*results
;
1645 /* We need to empty the server before continueing test */
1646 test_compare(MEMCACHED_SUCCESS
,
1647 memcached_flush(memc
, 0));
1649 test_compare(MEMCACHED_SUCCESS
,
1650 memcached_mget(memc
, keys
, key_length
, 3));
1652 memcached_return_t rc
;
1653 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1657 test_false(results
);
1658 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1660 for (uint32_t x
= 0; x
< 3; x
++)
1662 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1663 keys
[x
], key_length
[x
],
1664 (time_t)50, (uint32_t)9);
1665 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1668 test_compare(MEMCACHED_SUCCESS
,
1669 memcached_mget(memc
, keys
, key_length
, 3));
1672 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1675 test_compare(MEMCACHED_SUCCESS
, rc
);
1676 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1677 test_memcmp(memcached_result_key_value(results
),
1678 memcached_result_value(results
),
1679 memcached_result_length(results
));
1680 memcached_result_free(results
);
1684 return TEST_SUCCESS
;
1687 /* Count the results */
1688 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1690 size_t *counter
= (size_t *)context
;
1692 *counter
= *counter
+ 1;
1694 return MEMCACHED_SUCCESS
;
1697 static test_return_t
mget_result_function(memcached_st
*memc
)
1699 const char *keys
[]= {"fudge", "son", "food"};
1700 size_t key_length
[]= {5, 3, 4};
1702 memcached_execute_fn callbacks
[1];
1704 /* We need to empty the server before continueing test */
1705 test_compare(MEMCACHED_SUCCESS
,
1706 memcached_flush(memc
, 0));
1707 for (uint32_t x
= 0; x
< 3; x
++)
1709 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1710 keys
[x
], key_length
[x
],
1711 (time_t)50, (uint32_t)9);
1712 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1715 test_compare(MEMCACHED_SUCCESS
,
1716 memcached_mget(memc
, keys
, key_length
, 3));
1718 callbacks
[0]= &callback_counter
;
1721 test_compare(MEMCACHED_SUCCESS
,
1722 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1724 test_compare(size_t(3), counter
);
1726 return TEST_SUCCESS
;
1729 static test_return_t
mget_test(memcached_st
*memc
)
1731 const char *keys
[]= {"fudge", "son", "food"};
1732 size_t key_length
[]= {5, 3, 4};
1734 char return_key
[MEMCACHED_MAX_KEY
];
1735 size_t return_key_length
;
1737 size_t return_value_length
;
1739 /* We need to empty the server before continueing test */
1740 test_compare(MEMCACHED_SUCCESS
,
1741 memcached_flush(memc
, 0));
1743 test_compare(MEMCACHED_SUCCESS
,
1744 memcached_mget(memc
, keys
, key_length
, 3));
1747 memcached_return_t rc
;
1748 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1749 &return_value_length
, &flags
, &rc
)))
1751 test_true(return_value
);
1753 test_false(return_value
);
1754 test_zero(return_value_length
);
1755 test_compare(MEMCACHED_NOTFOUND
, rc
);
1757 for (uint32_t x
= 0; x
< 3; x
++)
1759 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1760 keys
[x
], key_length
[x
],
1761 (time_t)50, (uint32_t)9);
1762 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1764 test_compare(MEMCACHED_SUCCESS
,
1765 memcached_mget(memc
, keys
, key_length
, 3));
1768 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1769 &return_value_length
, &flags
, &rc
)))
1771 test_true(return_value
);
1772 test_compare(MEMCACHED_SUCCESS
, rc
);
1773 if (not memc
->_namespace
)
1775 test_compare(return_key_length
, return_value_length
);
1776 test_memcmp(return_value
, return_key
, return_value_length
);
1782 return TEST_SUCCESS
;
1785 static test_return_t
mget_execute(memcached_st
*original_memc
)
1787 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1789 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1792 size_t max_keys
= 20480;
1795 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1796 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1798 /* First add all of the items.. */
1799 char blob
[1024] = {0};
1801 for (size_t x
= 0; x
< max_keys
; ++x
)
1805 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1807 test_true(keys
[x
] != NULL
);
1808 uint64_t query_id
= memcached_query_id(memc
);
1809 memcached_return_t rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1810 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1811 test_compare(query_id
+1, memcached_query_id(memc
));
1814 /* Try to get all of them with a large multiget */
1816 memcached_execute_fn callbacks
[]= { &callback_counter
};
1817 test_compare(MEMCACHED_SUCCESS
,
1818 memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1819 max_keys
, callbacks
, &counter
, 1));
1822 uint64_t query_id
= memcached_query_id(memc
);
1823 test_compare(MEMCACHED_SUCCESS
,
1824 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1825 test_compare(query_id
, memcached_query_id(memc
));
1827 /* Verify that we got all of the items */
1828 test_true(counter
== max_keys
);
1831 /* Release all allocated resources */
1832 for (size_t x
= 0; x
< max_keys
; ++x
)
1839 memcached_free(memc
);
1841 return TEST_SUCCESS
;
1844 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1846 static test_return_t
key_setup(memcached_st
*memc
)
1848 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1850 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1852 return TEST_SUCCESS
;
1855 static test_return_t
key_teardown(memcached_st
*memc
)
1858 pairs_free(global_pairs
);
1860 return TEST_SUCCESS
;
1863 static test_return_t
block_add_regression(memcached_st
*memc
)
1865 /* First add all of the items.. */
1866 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1868 char blob
[1024] = {0};
1870 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);
1871 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
, memcached_strerror(NULL
, rc
));
1874 return TEST_SUCCESS
;
1877 static test_return_t
binary_add_regression(memcached_st
*memc
)
1879 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1880 test_return_t rc
= block_add_regression(memc
);
1885 static test_return_t
get_stats_keys(memcached_st
*memc
)
1889 memcached_stat_st memc_stat
;
1890 memcached_return_t rc
;
1892 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1893 test_compare(MEMCACHED_SUCCESS
, rc
);
1894 for (ptr
= stat_list
; *ptr
; ptr
++)
1899 return TEST_SUCCESS
;
1902 static test_return_t
version_string_test(memcached_st
*)
1904 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1906 return TEST_SUCCESS
;
1909 static test_return_t
get_stats(memcached_st
*memc
)
1911 memcached_return_t rc
;
1913 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1914 test_compare(MEMCACHED_SUCCESS
, rc
);
1915 test_true(memc_stat
);
1917 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1919 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1920 test_compare(MEMCACHED_SUCCESS
, rc
);
1921 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1926 memcached_stat_free(NULL
, memc_stat
);
1928 return TEST_SUCCESS
;
1931 static test_return_t
add_host_test(memcached_st
*memc
)
1933 char servername
[]= "0.example.com";
1935 memcached_return_t rc
;
1936 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1937 test_compare(1U, memcached_server_list_count(servers
));
1939 for (unsigned int x
= 2; x
< 20; x
++)
1941 char buffer
[SMALL_STRING_LEN
];
1943 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1944 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1946 test_compare(MEMCACHED_SUCCESS
, rc
);
1947 test_compare(x
, memcached_server_list_count(servers
));
1950 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1951 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1953 memcached_server_list_free(servers
);
1955 return TEST_SUCCESS
;
1958 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1960 memcached_return_t rc
;
1962 const char *key
= "not_found";
1963 size_t key_length
= test_literal_param_size("not_found");
1965 test_compare(MEMCACHED_SUCCESS
,
1966 memcached_mget(memc
, &key
, &key_length
, 1));
1968 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1970 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1972 memcached_result_free(result
);
1974 return TEST_SUCCESS
;
1977 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1979 return MEMCACHED_SUCCESS
;
1982 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1984 return MEMCACHED_SUCCESS
;
1987 static test_return_t
callback_test(memcached_st
*memc
)
1989 /* Test User Data */
1993 memcached_return_t rc
;
1995 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1996 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1997 test_true(*test_ptr
== x
);
2000 /* Test Clone Callback */
2002 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2003 void *clone_cb_ptr
= *(void **)&clone_cb
;
2004 void *temp_function
= NULL
;
2006 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
2007 memcached_return_t rc
;
2008 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2009 test_true(temp_function
== clone_cb_ptr
);
2010 test_compare(MEMCACHED_SUCCESS
, rc
);
2013 /* Test Cleanup Callback */
2015 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2016 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2017 void *temp_function
= NULL
;
2018 memcached_return_t rc
;
2020 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2021 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2022 test_true(temp_function
== cleanup_cb_ptr
);
2025 return TEST_SUCCESS
;
2028 /* We don't test the behavior itself, we test the switches */
2029 static test_return_t
behavior_test(memcached_st
*memc
)
2031 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2032 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2034 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2035 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2037 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2038 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2040 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2041 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2043 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2044 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2046 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2047 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2049 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2050 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2052 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2054 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2056 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2057 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2058 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2060 return TEST_SUCCESS
;
2063 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2065 test_compare(MEMCACHED_DEPRECATED
,
2066 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2068 // Platform dependent
2070 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2074 return TEST_SUCCESS
;
2078 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2080 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2081 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2083 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2085 if (memcached_success(rc
))
2094 return TEST_SUCCESS
;
2098 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2100 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2101 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2103 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2105 if (memcached_success(rc
))
2114 return TEST_SUCCESS
;
2117 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, const memcached_return_t expect
)
2119 memcached_return_t rc
;
2120 char return_key
[MEMCACHED_MAX_KEY
];
2121 size_t return_key_length
;
2123 size_t return_value_length
;
2127 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2128 &return_value_length
, &flags
, &rc
)))
2130 test_true(return_value
);
2131 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2136 if (memcached_success(expect
) and memcached_success(rc
))
2138 return TEST_SUCCESS
;
2140 else if (expect
== rc
)
2142 return TEST_SUCCESS
;
2144 fprintf(stderr
, "\n%s:%u %s(#%u)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), keys_returned
);
2146 return TEST_FAILURE
;
2149 /* Test case provided by Cal Haldenbrand */
2150 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2151 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2152 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2154 /* We just keep looking at the same values over and over */
2157 test_compare(MEMCACHED_SUCCESS
,
2158 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2159 test_compare(MEMCACHED_SUCCESS
,
2160 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2164 unsigned long long total
= 0;
2165 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2167 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2168 char randomstuff
[6 * 1024];
2169 memset(randomstuff
, 0, 6 * 1024);
2170 test_true(size
< 6 * 1024); /* Being safe here */
2172 for (uint32_t j
= 0 ; j
< size
;j
++)
2174 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2179 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2180 test_compare(MEMCACHED_SUCCESS
,
2181 memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
));
2183 test_true(total
> HALDENBRAND_KEY_COUNT
);
2185 return TEST_SUCCESS
;
2188 /* Test case provided by Cal Haldenbrand */
2189 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2191 test_compare(MEMCACHED_SUCCESS
,
2192 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2194 test_compare(MEMCACHED_SUCCESS
,
2195 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2198 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576));
2199 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576));
2200 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2201 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2203 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2206 size_t total_value_length
= 0;
2207 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2212 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2213 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2215 memcached_return_t rc
;
2216 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2217 if (memcached_failed(rc
))
2219 if (rc
== MEMCACHED_NOTFOUND
)
2230 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2232 total_value_length
+= val_len
;
2237 return TEST_SUCCESS
;
2240 /* Do a large mget() over all the keys we think exist */
2241 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2243 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
2244 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
2247 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576);
2248 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576);
2249 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2250 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2253 std::vector
<size_t> key_lengths
;
2254 key_lengths
.resize(HALDENBRAND_KEY_COUNT
);
2255 std::vector
<char *> keys
;
2256 keys
.resize(key_lengths
.size());
2257 for (uint32_t x
= 0; x
< key_lengths
.size(); x
++)
2259 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2260 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2261 test_true(key_length
> 0 and key_length
< MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1);
2262 keys
[x
]= strdup(key
);
2263 key_lengths
[x
]= key_length
;
2266 test_compare(MEMCACHED_SUCCESS
,
2267 memcached_mget(memc
, &keys
[0], &key_lengths
[0], key_lengths
.size()));
2269 unsigned int keys_returned
;
2270 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
2271 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2273 for (std::vector
<char *>::iterator iter
= keys
.begin();
2280 return TEST_SUCCESS
;
2283 /* Make sure we behave properly if server list has no values */
2284 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2286 const char *keys
[]= {"fudge", "son", "food"};
2287 size_t key_length
[]= {5, 3, 4};
2289 /* Here we free everything before running a bunch of mget tests */
2290 memcached_servers_reset(memc
);
2293 /* We need to empty the server before continueing test */
2294 test_compare(MEMCACHED_NO_SERVERS
,
2295 memcached_flush(memc
, 0));
2297 test_compare(MEMCACHED_NO_SERVERS
,
2298 memcached_mget(memc
, keys
, key_length
, 3));
2300 unsigned int keys_returned
;
2301 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2302 test_zero(keys_returned
);
2304 for (uint32_t x
= 0; x
< 3; x
++)
2306 test_compare(MEMCACHED_NO_SERVERS
,
2307 memcached_set(memc
, keys
[x
], key_length
[x
],
2308 keys
[x
], key_length
[x
],
2309 (time_t)50, (uint32_t)9));
2312 test_compare(MEMCACHED_NO_SERVERS
,
2313 memcached_mget(memc
, keys
, key_length
, 3));
2317 char return_key
[MEMCACHED_MAX_KEY
];
2318 memcached_return_t rc
;
2319 size_t return_key_length
;
2320 size_t return_value_length
;
2323 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2324 &return_value_length
, &flags
, &rc
)))
2326 test_true(return_value
);
2327 test_compare(MEMCACHED_SUCCESS
, rc
);
2328 test_true(return_key_length
== return_value_length
);
2329 test_memcmp(return_value
, return_key
, return_value_length
);
2335 return TEST_SUCCESS
;
2338 #define VALUE_SIZE_BUG5 1048064
2339 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2341 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2342 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2344 size_t value_length
;
2346 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2348 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2350 insert_data
[x
]= (signed char)rand();
2353 test_compare(MEMCACHED_SUCCESS
,
2354 memcached_flush(memc
, 0));
2356 memcached_return_t rc
;
2357 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2358 test_compare(MEMCACHED_SUCCESS
,
2359 memcached_mget(memc
, keys
, key_length
, 4));
2362 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2365 for (uint32_t x
= 0; x
< 4; x
++)
2367 test_compare(MEMCACHED_SUCCESS
,
2368 memcached_set(memc
, keys
[x
], key_length
[x
],
2369 insert_data
, VALUE_SIZE_BUG5
,
2370 (time_t)0, (uint32_t)0));
2373 for (uint32_t x
= 0; x
< 10; x
++)
2375 value
= memcached_get(memc
, keys
[0], key_length
[0],
2376 &value_length
, &flags
, &rc
);
2377 test_compare(rc
, MEMCACHED_SUCCESS
);
2381 test_compare(MEMCACHED_SUCCESS
,
2382 memcached_mget(memc
, keys
, key_length
, 4));
2384 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2385 test_compare(4U, count
);
2387 delete [] insert_data
;
2389 return TEST_SUCCESS
;
2392 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2394 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2395 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2396 char return_key
[MEMCACHED_MAX_KEY
];
2397 size_t return_key_length
;
2399 size_t value_length
;
2401 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2403 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2405 insert_data
[x
]= (signed char)rand();
2408 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2410 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2412 // We will now confirm that memcached_mget() returns success, but we will
2413 // then check to make sure that no actual keys are returned.
2414 test_compare(MEMCACHED_SUCCESS
,
2415 memcached_mget(memc
, keys
, key_length
, 4));
2417 memcached_return_t rc
;
2419 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2420 &value_length
, &flags
, &rc
)))
2425 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2427 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2429 test_compare(MEMCACHED_SUCCESS
,
2430 memcached_set(memc
, keys
[x
], key_length
[x
],
2431 insert_data
, VALUE_SIZE_BUG5
,
2432 (time_t)0, (uint32_t)0));
2434 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2436 for (uint32_t x
= 0; x
< 2; x
++)
2438 value
= memcached_get(memc
, keys
[0], key_length
[0],
2439 &value_length
, &flags
, &rc
);
2443 test_compare(MEMCACHED_SUCCESS
,
2444 memcached_mget(memc
, keys
, key_length
, 4));
2445 /* We test for purge of partial complete fetches */
2446 for (count
= 3; count
; count
--)
2448 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2449 &value_length
, &flags
, &rc
);
2450 test_compare(MEMCACHED_SUCCESS
, rc
);
2451 test_memcmp(value
, insert_data
, value_length
);
2452 test_true(value_length
);
2456 delete [] insert_data
;
2458 return TEST_SUCCESS
;
2461 static test_return_t
user_supplied_bug8(memcached_st
*)
2463 memcached_return_t rc
;
2465 memcached_st
*memc_clone
;
2467 memcached_server_st
*servers
;
2468 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";
2470 servers
= memcached_servers_parse(server_list
);
2473 mine
= memcached_create(NULL
);
2474 rc
= memcached_server_push(mine
, servers
);
2475 test_compare(MEMCACHED_SUCCESS
, rc
);
2476 memcached_server_list_free(servers
);
2479 memc_clone
= memcached_clone(NULL
, mine
);
2481 memcached_quit(mine
);
2482 memcached_quit(memc_clone
);
2485 memcached_free(mine
);
2486 memcached_free(memc_clone
);
2488 return TEST_SUCCESS
;
2491 /* Test flag store/retrieve */
2492 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2494 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2495 test_true(insert_data
);
2497 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2499 insert_data
[x
]= (signed char)rand();
2502 memcached_flush(memc
, 0);
2504 const char *keys
= "036790384900";
2505 size_t key_length
= strlen(keys
);
2506 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
2507 insert_data
, VALUE_SIZE_BUG5
,
2509 memcached_last_error_message(memc
));
2511 memcached_return_t rc
;
2512 size_t value_length
;
2514 char *value
= memcached_get(memc
, keys
, key_length
,
2515 &value_length
, &flags
, &rc
);
2516 test_compare(245U, flags
);
2520 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2522 char return_key
[MEMCACHED_MAX_KEY
];
2523 size_t return_key_length
;
2525 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2526 &value_length
, &flags
, &rc
);
2527 test_compare(uint32_t(245), flags
);
2530 delete [] insert_data
;
2533 return TEST_SUCCESS
;
2536 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2538 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2539 size_t key_length
[3];
2543 char return_key
[MEMCACHED_MAX_KEY
];
2544 size_t return_key_length
;
2546 size_t return_value_length
;
2549 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2550 key_length
[1]= strlen("fudge&*@#");
2551 key_length
[2]= strlen("for^#@&$not");
2554 for (unsigned int x
= 0; x
< 3; x
++)
2556 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2557 keys
[x
], key_length
[x
],
2558 (time_t)50, (uint32_t)9);
2559 test_compare(MEMCACHED_SUCCESS
, rc
);
2562 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2563 test_compare(MEMCACHED_SUCCESS
, rc
);
2565 /* We need to empty the server before continueing test */
2566 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2567 &return_value_length
, &flags
, &rc
)) != NULL
)
2569 test_true(return_value
);
2573 test_compare(3U, count
);
2575 return TEST_SUCCESS
;
2578 /* We are testing with aggressive timeout to get failures */
2579 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2581 size_t value_length
= 512;
2582 unsigned int set
= 1;
2583 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2585 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2586 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2587 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2589 std::vector
<char> value
;
2590 value
.reserve(value_length
);
2591 for (uint32_t x
= 0; x
< value_length
; x
++)
2593 value
.push_back(char(x
% 127));
2596 for (unsigned int x
= 1; x
<= 100000; ++x
)
2598 memcached_return_t rc
= memcached_set(mclone
,
2599 test_literal_param("foo"),
2600 &value
[0], value
.size(),
2603 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2604 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2605 memcached_strerror(NULL
, rc
));
2607 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2613 memcached_free(mclone
);
2615 return TEST_SUCCESS
;
2619 We are looking failures in the async protocol
2621 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2623 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2625 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2626 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2627 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2629 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2632 std::vector
<char> value
;
2634 for (unsigned int x
= 0; x
< 512; x
++)
2636 value
.push_back(char(x
% 127));
2639 for (unsigned int x
= 1; x
<= 100000; ++x
)
2641 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2645 memcached_free(mclone
);
2647 return TEST_SUCCESS
;
2651 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2653 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2655 memcached_return_t rc
;
2657 size_t value_length
;
2659 uint64_t number_value
;
2661 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2662 &value_length
, &flags
, &rc
);
2664 test_compare(MEMCACHED_NOTFOUND
, rc
);
2666 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2669 /* The binary protocol will set the key if it doesn't exist */
2670 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2672 test_compare(MEMCACHED_SUCCESS
, rc
);
2676 test_compare(MEMCACHED_NOTFOUND
, rc
);
2679 test_compare(MEMCACHED_SUCCESS
,
2680 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2682 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
2686 test_compare(MEMCACHED_SUCCESS
,
2687 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
2688 test_compare(2UL, number_value
);
2690 return TEST_SUCCESS
;
2694 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2695 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2697 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2699 char key
[] = "key34567890";
2700 memcached_return_t rc
;
2701 size_t overflowSize
;
2703 char commandFirst
[]= "set key34567890 0 0 ";
2704 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2705 size_t commandLength
;
2708 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2710 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2712 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2714 char *overflow
= new (std::nothrow
) char[testSize
];
2715 test_true(overflow
);
2717 memset(overflow
, 'x', testSize
);
2718 rc
= memcached_set(memc
, key
, strlen(key
),
2719 overflow
, testSize
, 0, 0);
2720 test_compare(MEMCACHED_SUCCESS
, rc
);
2724 return TEST_SUCCESS
;
2729 Test values of many different sizes
2730 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2731 set key34567890 0 0 8169 \r\n
2732 is sent followed by buffer of size 8169, followed by 8169
2734 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2736 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2738 std::vector
<char> value
;
2739 value
.reserve(18000);
2740 for (size_t x
= 0; x
< 18000; x
++)
2742 value
.push_back((char) (x
% 127));
2745 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2747 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2748 &value
[0], current_length
,
2749 (time_t)0, (uint32_t)0);
2750 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2752 size_t string_length
;
2754 char *string
= memcached_get(memc
, test_literal_param("foo"),
2755 &string_length
, &flags
, &rc
);
2757 test_compare(MEMCACHED_SUCCESS
, rc
);
2758 test_compare(string_length
, current_length
);
2759 test_memcmp(string
, &value
[0], string_length
);
2764 return TEST_SUCCESS
;
2768 Look for zero length value problems
2770 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2772 for (uint32_t x
= 0; x
< 2; x
++)
2774 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2776 (time_t)0, (uint32_t)0);
2778 test_compare(MEMCACHED_SUCCESS
, rc
);
2782 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2783 &length
, &flags
, &rc
);
2785 test_compare(MEMCACHED_SUCCESS
, rc
);
2790 value
= memcached_get(memc
, test_literal_param("mykey"),
2791 &length
, &flags
, &rc
);
2793 test_compare(MEMCACHED_SUCCESS
, rc
);
2794 test_true(value
== NULL
);
2799 return TEST_SUCCESS
;
2802 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2803 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2805 test_compare_hint(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
2807 (time_t)0, UINT32_MAX
),
2808 memcached_last_error_message(memc
));
2813 memcached_return_t rc
;
2814 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2815 &length
, &flags
, &rc
);
2817 test_compare(MEMCACHED_SUCCESS
, rc
);
2820 test_compare(flags
, UINT32_MAX
);
2822 return TEST_SUCCESS
;
2825 #if !defined(__sun) && !defined(__OpenBSD__)
2826 /* Check the validity of chinese key*/
2827 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2829 const char *key
= "豆瓣";
2830 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2831 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2832 value
, strlen(value
),
2835 test_compare(MEMCACHED_SUCCESS
, rc
);
2839 char *value2
= memcached_get(memc
, key
, strlen(key
),
2840 &length
, &flags
, &rc
);
2842 test_true(length
==strlen(value
));
2843 test_compare(MEMCACHED_SUCCESS
, rc
);
2844 test_memcmp(value
, value2
, length
);
2847 return TEST_SUCCESS
;
2855 static test_return_t
user_supplied_bug19(memcached_st
*)
2857 memcached_return_t res
;
2859 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2861 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2864 memcached_free(memc
);
2866 return TEST_SUCCESS
;
2869 /* CAS test from Andei */
2870 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2872 const char *key
= "abc";
2873 size_t key_len
= strlen("abc");
2875 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2877 test_compare(MEMCACHED_SUCCESS
,
2879 test_literal_param("abc"),
2880 test_literal_param("foobar"),
2881 (time_t)0, (uint32_t)0));
2883 test_compare(MEMCACHED_SUCCESS
,
2884 memcached_mget(memc
, &key
, &key_len
, 1));
2886 memcached_result_st result_obj
;
2887 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2890 memcached_result_create(memc
, &result_obj
);
2891 memcached_return_t status
;
2892 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2895 test_compare(MEMCACHED_SUCCESS
, status
);
2897 memcached_result_free(result
);
2899 return TEST_SUCCESS
;
2902 /* Large mget() of missing keys with binary proto
2904 * If many binary quiet commands (such as getq's in an mget) fill the output
2905 * buffer and the server chooses not to respond, memcached_flush hangs. See
2906 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2909 /* sighandler_t function that always asserts false */
2910 static void fail(int)
2916 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2921 return TEST_SKIPPED
;
2923 void (*oldalarm
)(int);
2925 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2926 test_true(memc_clone
);
2928 /* only binproto uses getq for mget */
2929 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2931 /* empty the cache to ensure misses (hence non-responses) */
2932 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2934 std::vector
<size_t> key_lengths
;
2935 key_lengths
.resize(key_count
);
2936 std::vector
<char *> keys
;
2937 keys
.resize(key_lengths
.size());
2938 for (unsigned int x
= 0; x
< key_lengths
.size(); x
++)
2940 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2941 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2942 test_true(key_length
> 0 and key_length
< MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1);
2943 keys
[x
]= strdup(key
);
2944 key_lengths
[x
]= key_length
;
2947 oldalarm
= signal(SIGALRM
, fail
);
2950 test_compare_got(MEMCACHED_SUCCESS
,
2951 memcached_mget(memc_clone
, &keys
[0], &key_lengths
[0], key_count
), memcached_last_error_message(memc_clone
));
2954 signal(SIGALRM
, oldalarm
);
2956 memcached_return_t rc
;
2958 char return_key
[MEMCACHED_MAX_KEY
];
2959 size_t return_key_length
;
2961 size_t return_value_length
;
2962 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2963 &return_value_length
, &flags
, &rc
)))
2965 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2967 test_compare(MEMCACHED_NOTFOUND
, rc
);
2968 test_zero(return_value_length
);
2969 test_zero(return_key_length
);
2970 test_false(return_key
[0]);
2971 test_false(return_value
);
2973 for (std::vector
<char *>::iterator iter
= keys
.begin();
2980 memcached_free(memc_clone
);
2982 return TEST_SUCCESS
;
2986 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
2988 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2990 /* should work as of r580 */
2991 test_compare(TEST_SUCCESS
,
2992 _user_supplied_bug21(memc
, 10));
2994 /* should fail as of r580 */
2995 test_compare(TEST_SUCCESS
,
2996 _user_supplied_bug21(memc
, 1000));
2998 return TEST_SUCCESS
;
3001 static test_return_t
output_ketama_weighted_keys(memcached_st
*)
3003 memcached_st
*memc
= memcached_create(NULL
);
3007 test_compare(MEMCACHED_SUCCESS
,
3008 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
3010 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3011 test_compare(value
, uint64_t(1));
3013 test_compare(MEMCACHED_SUCCESS
,
3014 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3016 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3017 test_true(value
== MEMCACHED_HASH_MD5
);
3020 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3022 memcached_server_st
*server_pool
;
3023 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");
3024 memcached_server_push(memc
, server_pool
);
3026 // @todo this needs to be refactored to actually test something.
3029 if ((fp
= fopen("ketama_keys.txt", "w")))
3033 printf("cannot write to file ketama_keys.txt");
3034 return TEST_FAILURE
;
3037 for (int x
= 0; x
< 10000; x
++)
3040 snprintf(key
, sizeof(key
), "%d", x
);
3042 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3043 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3044 in_port_t port
= memc
->hosts
[server_idx
].port
;
3045 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3046 memcached_server_instance_st instance
=
3047 memcached_server_instance_by_position(memc
, host_index
);
3051 memcached_server_list_free(server_pool
);
3052 memcached_free(memc
);
3054 return TEST_SUCCESS
;
3058 static test_return_t
result_static(memcached_st
*memc
)
3060 memcached_result_st result
;
3061 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3062 test_false(result
.options
.is_allocated
);
3063 test_true(memcached_is_initialized(&result
));
3064 test_true(result_ptr
);
3065 test_true(result_ptr
== &result
);
3067 memcached_result_free(&result
);
3069 test_false(result
.options
.is_allocated
);
3070 test_false(memcached_is_initialized(&result
));
3072 return TEST_SUCCESS
;
3075 static test_return_t
result_alloc(memcached_st
*memc
)
3077 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3078 test_true(result_ptr
);
3079 test_true(result_ptr
->options
.is_allocated
);
3080 test_true(memcached_is_initialized(result_ptr
));
3081 memcached_result_free(result_ptr
);
3083 return TEST_SUCCESS
;
3086 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3089 pairs_free(global_pairs
);
3091 return TEST_SUCCESS
;
3094 static test_return_t
generate_pairs(memcached_st
*)
3096 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3097 global_count
= GLOBAL_COUNT
;
3099 for (size_t x
= 0; x
< global_count
; x
++)
3101 global_keys
[x
]= global_pairs
[x
].key
;
3102 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3105 return TEST_SUCCESS
;
3108 static test_return_t
generate_large_pairs(memcached_st
*)
3110 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3111 global_count
= GLOBAL2_COUNT
;
3113 for (size_t x
= 0; x
< global_count
; x
++)
3115 global_keys
[x
]= global_pairs
[x
].key
;
3116 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3119 return TEST_SUCCESS
;
3122 static test_return_t
generate_data(memcached_st
*memc
)
3124 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3126 test_compare(global_count
, check_execute
);
3128 return TEST_SUCCESS
;
3131 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3133 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3135 test_compare(check_execute
, global_count
);
3137 // @todo hosts used size stats
3138 memcached_return_t rc
;
3139 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3142 for (uint32_t host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3144 /* This test was changes so that "make test" would work properlly */
3147 memcached_server_instance_st instance
=
3148 memcached_server_instance_by_position(memc
, host_index
);
3150 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3152 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3155 memcached_stat_free(NULL
, stat_p
);
3157 return TEST_SUCCESS
;
3159 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3161 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3162 generate_data(memc
);
3164 return TEST_SUCCESS
;
3167 static test_return_t
get_read_count(memcached_st
*memc
)
3169 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3170 test_true(memc_clone
);
3172 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3176 size_t return_value_length
;
3180 for (size_t x
= count
= 0; x
< global_count
; x
++)
3182 memcached_return_t rc
;
3183 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3184 &return_value_length
, &flags
, &rc
);
3185 if (rc
== MEMCACHED_SUCCESS
)
3196 memcached_free(memc_clone
);
3198 return TEST_SUCCESS
;
3201 static test_return_t
get_read(memcached_st
*memc
)
3203 for (size_t x
= 0; x
< global_count
; x
++)
3205 size_t return_value_length
;
3207 memcached_return_t rc
;
3208 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3209 &return_value_length
, &flags
, &rc
);
3211 test_true(return_value);
3212 test_compare(MEMCACHED_SUCCESS, rc);
3214 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3220 return TEST_SUCCESS
;
3223 static test_return_t
mget_read(memcached_st
*memc
)
3226 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3228 test_compare(MEMCACHED_SUCCESS
,
3229 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3231 // Go fetch the keys and test to see if all of them were returned
3233 unsigned int keys_returned
;
3234 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3235 test_true(keys_returned
> 0);
3236 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3239 return TEST_SUCCESS
;
3242 static test_return_t
mget_read_result(memcached_st
*memc
)
3245 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3247 test_compare(MEMCACHED_SUCCESS
,
3248 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3250 /* Turn this into a help function */
3252 memcached_result_st results_obj
;
3253 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3256 memcached_return_t rc
;
3257 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3259 if (rc
== MEMCACHED_IN_PROGRESS
)
3265 test_compare(MEMCACHED_SUCCESS
, rc
);
3267 test_compare(MEMCACHED_END
, rc
);
3269 memcached_result_free(&results_obj
);
3272 return TEST_SUCCESS
;
3275 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3278 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3280 test_compare(MEMCACHED_SUCCESS
,
3281 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3283 memcached_result_st
*results
= NULL
;
3284 memcached_return_t rc
;
3285 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3288 test_compare(MEMCACHED_SUCCESS
, rc
);
3290 test_compare(MEMCACHED_END
, rc
);
3292 memcached_result_free(results
);
3295 return TEST_SUCCESS
;
3298 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3301 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3303 test_compare(MEMCACHED_SUCCESS
,
3304 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3306 // We will scan for just one key
3308 memcached_result_st results_obj
;
3309 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3311 memcached_return_t rc
;
3312 results
= memcached_fetch_result(memc
, results
, &rc
);
3314 test_compare(MEMCACHED_SUCCESS
, rc
);
3316 memcached_result_free(&results_obj
);
3319 // We already have a read happening, lets start up another one.
3320 test_compare(MEMCACHED_SUCCESS
,
3321 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3323 memcached_result_st results_obj
;
3324 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3326 test_false(memcached_is_allocated(results
));
3328 memcached_return_t rc
;
3329 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3332 test_compare(MEMCACHED_SUCCESS
, rc
);
3334 test_compare(MEMCACHED_END
, rc
);
3336 memcached_result_free(&results_obj
);
3339 return TEST_SUCCESS
;
3342 static test_return_t
mget_read_function(memcached_st
*memc
)
3344 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3346 test_compare(MEMCACHED_SUCCESS
,
3347 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3349 memcached_execute_fn callbacks
[]= { &callback_counter
};
3351 test_compare(MEMCACHED_SUCCESS
,
3352 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3354 return TEST_SUCCESS
;
3357 static test_return_t
delete_generate(memcached_st
*memc
)
3359 for (size_t x
= 0; x
< global_count
; x
++)
3361 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3364 return TEST_SUCCESS
;
3367 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3369 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3371 for (size_t x
= 0; x
< global_count
; x
++)
3373 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3376 return TEST_SUCCESS
;
3379 static test_return_t
add_host_test1(memcached_st
*memc
)
3381 memcached_return_t rc
;
3382 char servername
[]= "0.example.com";
3384 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3386 test_compare(1U, memcached_server_list_count(servers
));
3388 for (uint32_t x
= 2; x
< 20; x
++)
3390 char buffer
[SMALL_STRING_LEN
];
3392 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3393 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3395 test_compare(MEMCACHED_SUCCESS
, rc
);
3396 test_compare(x
, memcached_server_list_count(servers
));
3399 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3400 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3402 memcached_server_list_free(servers
);
3404 return TEST_SUCCESS
;
3407 static test_return_t
pre_nonblock(memcached_st
*memc
)
3409 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3411 return TEST_SUCCESS
;
3414 static test_return_t
pre_cork(memcached_st
*memc
)
3417 return TEST_SKIPPED
;
3420 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3421 return TEST_SUCCESS
;
3423 return TEST_SKIPPED
;
3426 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3429 return TEST_SKIPPED
;
3431 test_return_t test_rc
;
3432 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3435 return pre_nonblock(memc
);
3438 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3440 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3441 test_true(memc_clone
);
3443 // The memcached_version needs to be done on a clone, because the server
3444 // will not toggle protocol on an connection.
3445 memcached_version(memc_clone
);
3447 memcached_return_t rc
= MEMCACHED_FAILURE
;
3448 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3450 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3451 test_compare(MEMCACHED_SUCCESS
,
3452 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3453 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3457 memcached_free(memc_clone
);
3458 return TEST_SKIPPED
;
3461 memcached_free(memc_clone
);
3463 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3466 static test_return_t
pre_murmur(memcached_st
*memc
)
3468 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3469 return TEST_SUCCESS
;
3472 static test_return_t
pre_jenkins(memcached_st
*memc
)
3474 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3476 return TEST_SKIPPED
;
3480 static test_return_t
pre_md5(memcached_st
*memc
)
3482 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3484 return TEST_SUCCESS
;
3487 static test_return_t
pre_crc(memcached_st
*memc
)
3489 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3491 return TEST_SUCCESS
;
3494 static test_return_t
pre_hsieh(memcached_st
*memc
)
3496 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
));
3497 return TEST_SUCCESS
;
3500 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3502 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3504 return TEST_SUCCESS
;
3507 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3509 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
));
3511 return TEST_SUCCESS
;
3514 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3516 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3518 return TEST_SUCCESS
;
3521 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3523 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3525 return TEST_SUCCESS
;
3528 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3530 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3531 test_compare(MEMCACHED_SUCCESS
, rc
);
3533 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3534 test_compare(value
, uint64_t(1));
3536 return TEST_SUCCESS
;
3539 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3541 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3542 test_compare(MEMCACHED_SUCCESS
, rc
);
3544 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3545 test_compare(value
, uint64_t(1));
3547 test_compare(MEMCACHED_SUCCESS
,
3548 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3550 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3551 test_compare(MEMCACHED_HASH_MD5
, memcached_hash_t(value
));
3553 return TEST_SUCCESS
;
3556 static test_return_t
pre_replication(memcached_st
*memc
)
3558 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3561 * Make sure that we store the item on all servers
3562 * (master + replicas == number of servers)
3564 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3565 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3567 return TEST_SUCCESS
;
3571 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3573 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3575 return pre_nonblock(memc
);
3579 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3583 #ifdef HARD_MALLOC_TESTS
3584 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3592 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3596 #ifdef HARD_MALLOC_TESTS
3597 void *ret
= malloc(size
+ 8);
3600 ret
= (void*)((caddr_t
)ret
+ 8);
3603 void *ret
= malloc(size
);
3608 memset(ret
, 0xff, size
);
3615 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3617 #ifdef HARD_MALLOC_TESTS
3618 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3619 void *nmem
= realloc(real_ptr
, size
+ 8);
3624 ret
= (void*)((caddr_t
)nmem
+ 8);
3630 return realloc(mem
, size
);
3635 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3637 #ifdef HARD_MALLOC_TESTS
3638 void *mem
= my_malloc(ptr
, nelem
* size
);
3641 memset(mem
, 0, nelem
* size
);
3647 return calloc(nelem
, size
);
3651 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3653 memcached_return_t rc
;
3654 const char *key
= "mine";
3657 /* Make sure be default none exists */
3658 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3660 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3662 /* Test a clean set */
3663 test_compare(MEMCACHED_SUCCESS
,
3664 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3666 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3668 test_memcmp(value
, key
, 4);
3669 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3671 /* Test that we can turn it off */
3672 test_compare(MEMCACHED_SUCCESS
,
3673 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3675 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3677 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3679 /* Now setup for main test */
3680 test_compare(MEMCACHED_SUCCESS
,
3681 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3683 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3685 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3686 test_memcmp(value
, key
, 4);
3688 /* Set to Zero, and then Set to something too large */
3691 memset(long_key
, 0, 255);
3693 test_compare(MEMCACHED_SUCCESS
,
3694 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3696 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3698 test_compare(MEMCACHED_SUCCESS
, rc
);
3700 /* Test a long key for failure */
3701 /* TODO, extend test to determine based on setting, what result should be */
3702 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3703 test_compare(MEMCACHED_SUCCESS
,
3704 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3706 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3707 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3708 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3709 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3711 /* Test for a bad prefix, but with a short key */
3712 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3713 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3715 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3716 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3719 return TEST_SUCCESS
;
3722 static test_return_t
set_namespace(memcached_st
*memc
)
3724 memcached_return_t rc
;
3725 const char *key
= "mine";
3728 // Make sure we default to a null namespace
3729 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3731 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3733 /* Test a clean set */
3734 test_compare(MEMCACHED_SUCCESS
,
3735 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3737 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3739 test_memcmp(value
, key
, 4);
3740 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3742 return TEST_SUCCESS
;
3745 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3747 test_return_if(pre_binary(memc
));
3748 test_return_if(set_namespace(memc
));
3750 return TEST_SUCCESS
;
3753 #ifdef MEMCACHED_ENABLE_DEPRECATED
3754 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3756 void *test_ptr
= NULL
;
3759 memcached_malloc_fn malloc_cb
=
3760 (memcached_malloc_fn
)my_malloc
;
3761 cb_ptr
= *(void **)&malloc_cb
;
3762 memcached_return_t rc
;
3764 test_compare(MEMCACHED_SUCCESS
,
3765 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3766 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3767 test_compare(MEMCACHED_SUCCESS
, rc
);
3768 test_true(test_ptr
== cb_ptr
);
3772 memcached_realloc_fn realloc_cb
=
3773 (memcached_realloc_fn
)my_realloc
;
3774 cb_ptr
= *(void **)&realloc_cb
;
3775 memcached_return_t rc
;
3777 test_compare(MEMCACHED_SUCCESS
,
3778 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3779 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3780 test_compare(MEMCACHED_SUCCESS
, rc
);
3781 test_true(test_ptr
== cb_ptr
);
3785 memcached_free_fn free_cb
=
3786 (memcached_free_fn
)my_free
;
3787 cb_ptr
= *(void **)&free_cb
;
3788 memcached_return_t rc
;
3790 test_compare(MEMCACHED_SUCCESS
,
3791 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3792 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3793 test_compare(MEMCACHED_SUCCESS
, rc
);
3794 test_true(test_ptr
== cb_ptr
);
3797 return TEST_SUCCESS
;
3802 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3804 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3805 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3806 my_realloc
, my_calloc
, NULL
));
3808 test_compare(MEMCACHED_SUCCESS
,
3809 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3810 my_realloc
, my_calloc
, NULL
));
3812 memcached_malloc_fn mem_malloc
;
3813 memcached_free_fn mem_free
;
3814 memcached_realloc_fn mem_realloc
;
3815 memcached_calloc_fn mem_calloc
;
3816 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3817 &mem_realloc
, &mem_calloc
);
3819 test_true(mem_malloc
== my_malloc
);
3820 test_true(mem_realloc
== my_realloc
);
3821 test_true(mem_calloc
== my_calloc
);
3822 test_true(mem_free
== my_free
);
3824 return TEST_SUCCESS
;
3827 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3830 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3831 memcached_hash_t hash
;
3832 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3833 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3836 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3837 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3839 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3841 if (hash
!= MEMCACHED_HASH_CRC
)
3842 return TEST_SKIPPED
;
3844 return TEST_SUCCESS
;
3847 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3850 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3851 memcached_hash_t hash
;
3852 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3853 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3858 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3859 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3861 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3863 if (hash
!= MEMCACHED_HASH_HSIEH
)
3864 return TEST_SKIPPED
;
3867 return TEST_SUCCESS
;
3870 static test_return_t
enable_cas(memcached_st
*memc
)
3872 unsigned int set
= 1;
3874 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3876 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3878 return TEST_SUCCESS
;
3881 return TEST_SKIPPED
;
3884 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3886 memcached_version(memc
);
3888 memcached_server_instance_st instance
=
3889 memcached_server_instance_by_position(memc
, 0);
3891 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3892 or instance
->minor_version
> 2)
3894 return TEST_SUCCESS
;
3897 return TEST_SKIPPED
;
3900 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3904 memcached_servers_reset(memc
);
3905 const char *socket_file
= default_socket();
3907 test_skip(0, stat(socket_file
, &buf
));
3909 test_compare(MEMCACHED_SUCCESS
,
3910 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
3912 return TEST_SUCCESS
;
3915 static test_return_t
pre_nodelay(memcached_st
*memc
)
3917 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3918 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3920 return TEST_SUCCESS
;
3923 static test_return_t
pre_settimer(memcached_st
*memc
)
3925 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3926 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3928 return TEST_SUCCESS
;
3931 static test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3933 const uint64_t timeout
= 100; // Not using, just checking that it sets
3935 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3937 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3939 return TEST_SUCCESS
;
3942 static test_return_t
noreply_test(memcached_st
*memc
)
3944 test_compare(MEMCACHED_SUCCESS
,
3945 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, true));
3946 test_compare(MEMCACHED_SUCCESS
,
3947 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true));
3948 test_compare(MEMCACHED_SUCCESS
,
3949 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
3950 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3951 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3952 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3954 memcached_return_t ret
;
3955 for (int count
= 0; count
< 5; ++count
)
3957 for (size_t x
= 0; x
< 100; ++x
)
3960 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3961 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3963 size_t len
= (size_t)check_length
;
3968 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3971 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3974 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3977 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3980 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3986 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, ret
));
3990 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3991 ** API and is _ONLY_ done this way to verify that the library works the
3992 ** way it is supposed to do!!!!
3995 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3997 memcached_server_instance_st instance
=
3998 memcached_server_instance_by_position(memc
, x
);
3999 no_msg
+=(int)(instance
->cursor_active
);
4002 test_true(no_msg
== 0);
4003 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4006 ** Now validate that all items was set properly!
4008 for (size_t x
= 0; x
< 100; ++x
)
4012 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4014 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4016 size_t len
= (size_t)check_length
;
4019 char* value
=memcached_get(memc
, key
, strlen(key
),
4020 &length
, &flags
, &ret
);
4021 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
4024 case 0: /* FALLTHROUGH */
4025 case 1: /* FALLTHROUGH */
4027 test_true(strncmp(value
, key
, len
) == 0);
4028 test_true(len
== length
);
4031 test_true(length
== len
* 2);
4034 test_true(length
== len
* 3);
4044 /* Try setting an illegal cas value (should not return an error to
4045 * the caller (because we don't expect a return message from the server)
4047 const char* keys
[]= {"0"};
4048 size_t lengths
[]= {1};
4051 memcached_result_st results_obj
;
4052 memcached_result_st
*results
;
4053 test_compare(MEMCACHED_SUCCESS
,
4054 memcached_mget(memc
, keys
, lengths
, 1));
4056 results
= memcached_result_create(memc
, &results_obj
);
4058 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4060 test_compare(MEMCACHED_SUCCESS
, ret
);
4061 uint64_t cas
= memcached_result_cas(results
);
4062 memcached_result_free(&results_obj
);
4064 test_compare(MEMCACHED_SUCCESS
,
4065 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4068 * The item will have a new cas value, so try to set it again with the old
4069 * value. This should fail!
4071 test_compare(MEMCACHED_SUCCESS
,
4072 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4073 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4074 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4075 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4078 return TEST_SUCCESS
;
4081 static test_return_t
analyzer_test(memcached_st
*memc
)
4083 memcached_return_t rc
;
4084 memcached_analysis_st
*report
;
4086 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4087 test_compare(MEMCACHED_SUCCESS
, rc
);
4088 test_true(memc_stat
);
4090 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4091 test_compare(MEMCACHED_SUCCESS
, rc
);
4095 memcached_stat_free(NULL
, memc_stat
);
4097 return TEST_SUCCESS
;
4100 /* Count the objects */
4102 static test_return_t
dump_test(memcached_st
*memc
)
4104 /* No support for Binary protocol yet */
4105 test_skip(false, memc
->flags
.binary_protocol
);
4107 test_compare(TEST_SUCCESS
, set_test3(memc
));
4109 // confirm_key_count() call dump
4110 size_t counter
= confirm_key_count(memc
);
4112 /* We may have more then 32 if our previous flush has not completed */
4113 test_true(counter
>= 32);
4115 return TEST_SUCCESS
;
4118 static test_return_t
util_version_test(memcached_st
*memc
)
4120 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
4121 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
4123 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4125 // We expect failure
4128 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4129 fprintf(stderr
, "\nDumping Server Information\n\n");
4130 memcached_server_fn callbacks
[1];
4132 callbacks
[0]= dump_server_information
;
4133 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4134 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4136 test_true(if_successful
== false);
4138 memcached_server_instance_st instance
=
4139 memcached_server_instance_by_position(memc
, 0);
4141 memcached_version(memc
);
4143 // We only use one binary when we test, so this should be just fine.
4144 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4145 test_true(if_successful
== true);
4147 if (instance
->micro_version
> 0)
4149 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4151 else if (instance
->minor_version
> 0)
4153 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4155 else if (instance
->major_version
> 0)
4157 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4160 test_true(if_successful
== true);
4162 if (instance
->micro_version
> 0)
4164 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4166 else if (instance
->minor_version
> 0)
4168 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4170 else if (instance
->major_version
> 0)
4172 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4175 test_true(if_successful
== false);
4177 return TEST_SUCCESS
;
4180 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4182 memcached_return_t rc
;
4183 memcached_server_instance_st instance
=
4184 memcached_server_instance_by_position(memc
, 0);
4186 // Test both the version that returns a code, and the one that does not.
4187 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4188 memcached_server_port(instance
) -1, NULL
) == -1);
4190 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4191 memcached_server_port(instance
) -1, &rc
) == -1);
4192 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4194 return TEST_SUCCESS
;
4198 static test_return_t
getpid_test(memcached_st
*memc
)
4200 memcached_return_t rc
;
4201 memcached_server_instance_st instance
=
4202 memcached_server_instance_by_position(memc
, 0);
4204 // Test both the version that returns a code, and the one that does not.
4205 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4206 memcached_server_port(instance
), NULL
) > -1);
4208 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4209 memcached_server_port(instance
), &rc
) > -1);
4210 test_compare(MEMCACHED_SUCCESS
, rc
);
4212 return TEST_SUCCESS
;
4215 static test_return_t
ping_test(memcached_st
*memc
)
4217 memcached_return_t rc
;
4218 memcached_server_instance_st instance
=
4219 memcached_server_instance_by_position(memc
, 0);
4221 // Test both the version that returns a code, and the one that does not.
4222 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4223 memcached_server_port(instance
), NULL
));
4225 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4226 memcached_server_port(instance
), &rc
));
4228 test_compare(MEMCACHED_SUCCESS
, rc
);
4230 return TEST_SUCCESS
;
4235 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4239 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4240 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4241 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4242 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4243 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4244 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4245 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4246 #ifdef HAVE_HSIEH_HASH
4247 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4249 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4250 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4251 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4253 return TEST_SUCCESS
;
4257 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4259 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4261 test_compare(MEMCACHED_SUCCESS
,
4262 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4263 (uint64_t)MEMCACHED_HASH_HSIEH
));
4265 return TEST_SUCCESS
;
4268 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4270 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4272 test_compare(MEMCACHED_SUCCESS
,
4273 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
4275 return TEST_SUCCESS
;
4278 static test_return_t
one_at_a_time_run (memcached_st
*)
4283 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4285 test_compare(one_at_a_time_values
[x
],
4286 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
4289 return TEST_SUCCESS
;
4292 static test_return_t
md5_run (memcached_st
*)
4297 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4299 test_compare(md5_values
[x
],
4300 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
4303 return TEST_SUCCESS
;
4306 static test_return_t
crc_run (memcached_st
*)
4311 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4313 test_compare(crc_values
[x
],
4314 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
4317 return TEST_SUCCESS
;
4320 static test_return_t
fnv1_64_run (memcached_st
*)
4322 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
4327 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4329 test_compare(fnv1_64_values
[x
],
4330 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
4333 return TEST_SUCCESS
;
4336 static test_return_t
fnv1a_64_run (memcached_st
*)
4338 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
4343 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4345 test_compare(fnv1a_64_values
[x
],
4346 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
4349 return TEST_SUCCESS
;
4352 static test_return_t
fnv1_32_run (memcached_st
*)
4357 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4359 test_compare(fnv1_32_values
[x
],
4360 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
4363 return TEST_SUCCESS
;
4366 static test_return_t
fnv1a_32_run (memcached_st
*)
4371 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4373 test_compare(fnv1a_32_values
[x
],
4374 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
4377 return TEST_SUCCESS
;
4380 static test_return_t
hsieh_run (memcached_st
*)
4382 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4387 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4389 test_compare(hsieh_values
[x
],
4390 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
4393 return TEST_SUCCESS
;
4396 static test_return_t
murmur_run (memcached_st
*)
4398 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4400 #ifdef WORDS_BIGENDIAN
4401 (void)murmur_values
;
4402 return TEST_SKIPPED
;
4407 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4409 test_compare(murmur_values
[x
],
4410 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
4413 return TEST_SUCCESS
;
4417 static test_return_t
jenkins_run (memcached_st
*)
4422 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4424 test_compare(jenkins_values
[x
],
4425 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
4428 return TEST_SUCCESS
;
4431 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
4433 return libhashkit_md5(string
, string_length
);
4436 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
4438 return libhashkit_crc32(string
, string_length
);
4441 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4447 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
4449 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};
4450 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};
4452 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4454 hashkit_clone(&new_kit
, kit
);
4455 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4457 memcached_set_hashkit(memc
, &new_kit
);
4460 Verify Setting the hash.
4462 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4466 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4467 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4472 Now check memcached_st.
4474 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4478 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4479 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4482 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4484 memcached_set_hashkit(memc
, &new_kit
);
4487 Verify Setting the hash.
4489 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4493 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4494 test_true(crc_values
[x
] == hash_val
);
4497 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4501 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4502 test_compare(crc_hosts
[x
], hash_val
);
4505 memcached_free(memc
);
4507 return TEST_SUCCESS
;
4511 Test case adapted from John Gorman <johngorman2@gmail.com>
4513 We are testing the error condition when we connect to a server via memcached_get()
4514 but find that the server is not available.
4516 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4518 const char *key
= "MemcachedLives";
4521 memcached_return rc
;
4524 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4526 // See if memcached is reachable.
4527 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4531 test_true(memcached_failed(rc
));
4533 memcached_free(tl_memc_h
);
4535 return TEST_SUCCESS
;
4539 We connect to a server which exists, but search for a key that does not exist.
4541 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4543 const char *key
= "MemcachedKeyNotEXIST";
4546 memcached_return rc
;
4548 // See if memcached is reachable.
4549 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4553 test_compare(MEMCACHED_NOTFOUND
, rc
);
4555 return TEST_SUCCESS
;
4559 Test case adapted from John Gorman <johngorman2@gmail.com>
4561 We are testing the error condition when we connect to a server via memcached_get_by_key()
4562 but find that the server is not available.
4564 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4567 memcached_st
*tl_memc_h
;
4568 memcached_server_st
*servers
;
4570 const char *key
= "MemcachedLives";
4573 memcached_return rc
;
4577 tl_memc_h
= memcached_create(NULL
);
4578 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4579 memcached_server_push(tl_memc_h
, servers
);
4580 memcached_server_list_free(servers
);
4582 // See if memcached is reachable.
4583 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4587 test_true(memcached_failed(rc
));
4589 memcached_free(tl_memc_h
);
4591 return TEST_SUCCESS
;
4595 We connect to a server which exists, but search for a key that does not exist.
4597 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4599 const char *key
= "MemcachedKeyNotEXIST";
4602 memcached_return rc
;
4605 // See if memcached is reachable.
4606 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4610 test_compare(MEMCACHED_NOTFOUND
, rc
);
4612 return TEST_SUCCESS
;
4615 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4617 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4619 const char *key
= "regression_bug_434484";
4620 size_t keylen
= strlen(key
);
4622 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4623 test_compare(MEMCACHED_NOTSTORED
, ret
);
4625 size_t size
= 2048 * 1024;
4626 char *data
= (char*)calloc(1, size
);
4628 test_compare(MEMCACHED_E2BIG
,
4629 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4632 return TEST_SUCCESS
;
4635 static test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4637 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4639 memcached_return_t rc
;
4641 memcached_execute_fn callbacks
[]= { &callback_counter
};
4644 * I only want to hit only _one_ server so I know the number of requests I'm
4645 * sending in the pipleine to the server. Let's try to do a multiget of
4646 * 1024 (that should satisfy most users don't you think?). Future versions
4647 * will include a mget_execute function call if you need a higher number.
4649 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4651 const size_t max_keys
= 1024;
4652 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4653 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4655 for (size_t x
= 0; x
< max_keys
; ++x
)
4659 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4665 * Run two times.. the first time we should have 100% cache miss,
4666 * and the second time we should have 100% cache hits
4668 for (size_t y
= 0; y
< 2; y
++)
4670 test_compare(MEMCACHED_SUCCESS
,
4671 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4673 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4674 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4678 /* The first iteration should give me a 100% cache miss. verify that*/
4679 char blob
[1024]= { 0 };
4681 test_false(counter
);
4683 for (size_t x
= 0; x
< max_keys
; ++x
)
4685 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4686 blob
, sizeof(blob
), 0, 0);
4687 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4692 /* Verify that we received all of the key/value pairs */
4693 test_compare(counter
, max_keys
);
4697 /* Release allocated resources */
4698 for (size_t x
= 0; x
< max_keys
; ++x
)
4705 memcached_free(memc
);
4707 return TEST_SUCCESS
;
4710 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4712 memcached_return_t rc
;
4713 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4714 test_compare(MEMCACHED_SUCCESS
, rc
);
4716 return regression_bug_434843(memc
);
4719 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4721 memcached_return_t rc
;
4722 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4723 test_compare(MEMCACHED_SUCCESS
, rc
);
4725 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4726 test_compare(MEMCACHED_SUCCESS
, rc
);
4727 test_true(bytes_str
);
4728 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4730 test_compare(MEMCACHED_SUCCESS
, rc
);
4731 test_true(bytes_read_str
);
4733 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4734 "bytes_written", &rc
);
4735 test_compare(MEMCACHED_SUCCESS
, rc
);
4736 test_true(bytes_written_str
);
4738 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4739 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4740 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4742 test_true(bytes
!= bytes_read
);
4743 test_true(bytes
!= bytes_written
);
4745 /* Release allocated resources */
4747 free(bytes_read_str
);
4748 free(bytes_written_str
);
4749 memcached_stat_free(NULL
, memc_stat
);
4751 return TEST_SUCCESS
;
4755 * The test case isn't obvious so I should probably document why
4756 * it works the way it does. Bug 442914 was caused by a bug
4757 * in the logic in memcached_purge (it did not handle the case
4758 * where the number of bytes sent was equal to the watermark).
4759 * In this test case, create messages so that we hit that case
4760 * and then disable noreply mode and issue a new command to
4761 * verify that it isn't stuck. If we change the format for the
4762 * delete command or the watermarks, we need to update this
4765 static test_return_t
regression_bug_442914(memcached_st
*memc
)
4767 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4768 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4770 uint32_t number_of_hosts
= memcached_server_count(memc
);
4771 memc
->number_of_hosts
= 1;
4776 for (uint32_t x
= 0; x
< 250; ++x
)
4778 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4779 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4780 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4783 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
4786 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4787 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4789 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4790 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
4792 memc
->number_of_hosts
= number_of_hosts
;
4794 return TEST_SUCCESS
;
4797 static test_return_t
regression_bug_447342(memcached_st
*memc
)
4799 memcached_server_instance_st instance_one
;
4800 memcached_server_instance_st instance_two
;
4802 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4803 return TEST_SKIPPED
;
4805 test_compare(MEMCACHED_SUCCESS
,
4806 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4808 const unsigned int max_keys
= 100;
4809 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4810 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4812 for (unsigned int x
= 0; x
< max_keys
; ++x
)
4816 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4819 test_compare(MEMCACHED_SUCCESS
,
4820 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
4824 ** We are using the quiet commands to store the replicas, so we need
4825 ** to ensure that all of them are processed before we can continue.
4826 ** In the test we go directly from storing the object to trying to
4827 ** receive the object from all of the different servers, so we
4828 ** could end up in a race condition (the memcached server hasn't yet
4829 ** processed the quiet command from the replication set when it process
4830 ** the request from the other client (created by the clone)). As a
4831 ** workaround for that we call memcached_quit to send the quit command
4832 ** to the server and wait for the response ;-) If you use the test code
4833 ** as an example for your own code, please note that you shouldn't need
4836 memcached_quit(memc
);
4838 /* Verify that all messages are stored, and we didn't stuff too much
4841 test_compare(MEMCACHED_SUCCESS
,
4842 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4844 unsigned int counter
= 0;
4845 memcached_execute_fn callbacks
[]= { &callback_counter
};
4846 test_compare(MEMCACHED_SUCCESS
,
4847 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4849 /* Verify that we received all of the key/value pairs */
4850 test_compare(counter
, max_keys
);
4852 memcached_quit(memc
);
4854 * Don't do the following in your code. I am abusing the internal details
4855 * within the library, and this is not a supported interface.
4856 * This is to verify correct behavior in the library. Fake that two servers
4859 instance_one
= memcached_server_instance_by_position(memc
, 0);
4860 instance_two
= memcached_server_instance_by_position(memc
, 2);
4861 in_port_t port0
= instance_one
->port
;
4862 in_port_t port2
= instance_two
->port
;
4864 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4865 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4867 test_compare(MEMCACHED_SUCCESS
,
4868 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4871 test_compare(MEMCACHED_SUCCESS
,
4872 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4873 test_compare(counter
, (unsigned int)max_keys
);
4875 /* restore the memc handle */
4876 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4877 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4879 memcached_quit(memc
);
4881 /* Remove half of the objects */
4882 for (size_t x
= 0; x
< max_keys
; ++x
)
4886 test_compare(MEMCACHED_SUCCESS
,
4887 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
4891 memcached_quit(memc
);
4892 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4893 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4895 /* now retry the command, this time we should have cache misses */
4896 test_compare(MEMCACHED_SUCCESS
,
4897 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4900 test_compare(MEMCACHED_SUCCESS
,
4901 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4902 test_compare(counter
, (unsigned int)(max_keys
>> 1));
4904 /* Release allocated resources */
4905 for (size_t x
= 0; x
< max_keys
; ++x
)
4912 /* restore the memc handle */
4913 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4914 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4916 return TEST_SUCCESS
;
4919 static test_return_t
regression_bug_463297(memcached_st
*memc
)
4921 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4922 test_true(memc_clone
);
4923 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4925 memcached_server_instance_st instance
=
4926 memcached_server_instance_by_position(memc_clone
, 0);
4928 if (instance
->major_version
> 1 ||
4929 (instance
->major_version
== 1 &&
4930 instance
->minor_version
> 2))
4932 /* Binary protocol doesn't support deferred delete */
4933 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4934 test_true(bin_clone
);
4935 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4936 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4937 memcached_free(bin_clone
);
4939 memcached_quit(memc_clone
);
4941 /* If we know the server version, deferred delete should fail
4942 * with invalid arguments */
4943 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4945 /* If we don't know the server version, we should get a protocol error */
4946 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4948 /* but there is a bug in some of the memcached servers (1.4) that treats
4949 * the counter as noreply so it doesn't send the proper error message
4951 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4953 /* And buffered mode should be disabled and we should get protocol error */
4954 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4955 rc
= memcached_delete(memc
, "foo", 3, 1);
4956 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4958 /* Same goes for noreply... */
4959 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4960 rc
= memcached_delete(memc
, "foo", 3, 1);
4961 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4963 /* but a normal request should go through (and be buffered) */
4964 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4965 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4967 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4968 /* unbuffered noreply should be success */
4969 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4970 /* unbuffered with reply should be not found... */
4971 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4972 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4975 memcached_free(memc_clone
);
4976 return TEST_SUCCESS
;
4980 /* Test memcached_server_get_last_disconnect
4981 * For a working server set, shall be NULL
4982 * For a set of non existing server, shall not be NULL
4984 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4986 memcached_return_t rc
;
4987 memcached_server_instance_st disconnected_server
;
4989 /* With the working set of server */
4990 const char *key
= "marmotte";
4991 const char *value
= "milka";
4993 memcached_reset_last_disconnected_server(memc
);
4994 test_false(memc
->last_disconnected_server
);
4995 rc
= memcached_set(memc
, key
, strlen(key
),
4996 value
, strlen(value
),
4997 (time_t)0, (uint32_t)0);
4998 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5000 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5001 test_false(disconnected_server
);
5003 /* With a non existing server */
5005 memcached_server_st
*servers
;
5007 const char *server_list
= "localhost:9";
5009 servers
= memcached_servers_parse(server_list
);
5011 mine
= memcached_create(NULL
);
5012 rc
= memcached_server_push(mine
, servers
);
5013 test_compare(MEMCACHED_SUCCESS
, rc
);
5014 memcached_server_list_free(servers
);
5017 rc
= memcached_set(mine
, key
, strlen(key
),
5018 value
, strlen(value
),
5019 (time_t)0, (uint32_t)0);
5020 test_true(memcached_failed(rc
));
5022 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5023 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5024 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5025 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5027 memcached_quit(mine
);
5028 memcached_free(mine
);
5030 return TEST_SUCCESS
;
5033 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5035 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5036 char buffer
[BUFSIZ
];
5038 test_compare(MEMCACHED_SUCCESS
,
5039 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5041 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5044 // We will just use the error strings as our keys
5045 uint32_t counter
= 100;
5048 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5050 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5051 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5052 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
5054 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5055 test_true(disconnected_server
);
5056 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5057 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5061 memcached_reset_last_disconnected_server(memc
);
5066 memcached_free(memc
);
5068 return TEST_SUCCESS
;
5071 static test_return_t
test_verbosity(memcached_st
*memc
)
5073 memcached_verbosity(memc
, 3);
5075 return TEST_SUCCESS
;
5079 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5080 const char *key
, size_t key_length
,
5081 const char *value
, size_t value_length
,
5091 return MEMCACHED_SUCCESS
;
5094 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5096 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5097 test_compare(MEMCACHED_SUCCESS
, rc
);
5099 test_compare(MEMCACHED_SUCCESS
,
5100 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
5102 test_compare(MEMCACHED_SUCCESS
,
5103 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
5105 test_compare(MEMCACHED_SUCCESS
,
5106 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
5108 return TEST_SUCCESS
;
5112 * This test ensures that the failure counter isn't incremented during
5113 * normal termination of the memcached instance.
5115 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5117 memcached_return_t rc
;
5118 memcached_server_instance_st instance
;
5120 /* Set value to force connection to the server */
5121 const char *key
= "marmotte";
5122 const char *value
= "milka";
5125 * Please note that I'm abusing the internal structures in libmemcached
5126 * in a non-portable way and you shouldn't be doing this. I'm only
5127 * doing this in order to verify that the library works the way it should
5129 uint32_t number_of_hosts
= memcached_server_count(memc
);
5130 memc
->number_of_hosts
= 1;
5132 /* Ensure that we are connected to the server by setting a value */
5133 rc
= memcached_set(memc
, key
, strlen(key
),
5134 value
, strlen(value
),
5135 (time_t)0, (uint32_t)0);
5136 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5139 instance
= memcached_server_instance_by_position(memc
, 0);
5140 /* The test is to see that the memcached_quit doesn't increase the
5141 * the server failure conter, so let's ensure that it is zero
5142 * before sending quit
5144 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5146 memcached_quit(memc
);
5148 /* Verify that it memcached_quit didn't increment the failure counter
5149 * Please note that this isn't bullet proof, because an error could
5152 test_zero(instance
->server_failure_counter
);
5154 /* restore the instance */
5155 memc
->number_of_hosts
= number_of_hosts
;
5157 return TEST_SUCCESS
;
5161 * This tests ensures expected disconnections (for some behavior changes
5162 * for instance) do not wrongly increase failure counter
5164 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5166 /* Set value to force connection to the server */
5167 const char *key
= "marmotte";
5168 const char *value
= "milka";
5170 test_compare_hint(MEMCACHED_SUCCESS
,
5171 memcached_set(memc
, key
, strlen(key
),
5172 value
, strlen(value
),
5173 (time_t)0, (uint32_t)0),
5174 memcached_last_error_message(memc
));
5177 /* put failure limit to 1 */
5178 test_compare(MEMCACHED_SUCCESS
,
5179 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
5181 /* Put a retry timeout to effectively activate failure_limit effect */
5182 test_compare(MEMCACHED_SUCCESS
,
5183 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, true));
5185 /* change behavior that triggers memcached_quit()*/
5186 test_compare(MEMCACHED_SUCCESS
,
5187 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
5190 /* Check if we still are connected */
5192 size_t string_length
;
5193 memcached_return rc
;
5194 char *string
= memcached_get(memc
, key
, strlen(key
),
5195 &string_length
, &flags
, &rc
);
5197 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5201 return TEST_SUCCESS
;
5206 * Test that ensures mget_execute does not end into recursive calls that finally fails
5208 static test_return_t
regression_bug_490486(memcached_st
*original_memc
)
5212 return TEST_SKIPPED
; // My MAC can't handle this test
5215 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
5218 * I only want to hit _one_ server so I know the number of requests I'm
5219 * sending in the pipeline.
5221 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
5224 size_t max_keys
= 20480;
5226 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5227 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5229 /* First add all of the items.. */
5230 char blob
[1024]= { 0 };
5231 for (size_t x
= 0; x
< max_keys
; ++x
)
5234 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5237 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5238 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5243 /* Try to get all of them with a large multiget */
5245 memcached_execute_function callbacks
[]= { &callback_counter
};
5246 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5247 (size_t)max_keys
, callbacks
, &counter
, 1);
5248 test_compare(MEMCACHED_SUCCESS
, rc
);
5250 char* the_value
= NULL
;
5251 char the_key
[MEMCACHED_MAX_KEY
];
5252 size_t the_key_length
;
5253 size_t the_value_length
;
5257 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5259 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5265 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5268 test_compare(MEMCACHED_END
, rc
);
5270 /* Verify that we got all of the items */
5271 test_compare(counter
, max_keys
);
5274 /* Release all allocated resources */
5275 for (size_t x
= 0; x
< max_keys
; ++x
)
5282 memcached_free(memc
);
5284 return TEST_SUCCESS
;
5287 static test_return_t
regression_bug_583031(memcached_st
*)
5289 memcached_st
*memc
= memcached_create(NULL
);
5291 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5293 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5294 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5295 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5296 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5297 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5298 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5300 memcached_return_t rc
;
5304 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5308 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5310 memcached_free(memc
);
5312 return TEST_SUCCESS
;
5315 static test_return_t
regression_bug_581030(memcached_st
*)
5318 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5319 test_false(local_stat
);
5321 memcached_stat_free(NULL
, NULL
);
5324 return TEST_SUCCESS
;
5327 #define regression_bug_655423_COUNT 6000
5328 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5330 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5331 memc
= NULL
; // Just to make sure it is not used
5336 return TEST_SKIPPED
;
5339 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5340 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5341 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5342 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5344 memset(payload
, int('x'), sizeof(payload
));
5346 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5348 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5349 snprintf(key
, sizeof(key
), "%u", x
);
5351 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5354 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5356 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5357 snprintf(key
, sizeof(key
), "%u", x
);
5359 size_t value_length
;
5360 memcached_return_t rc
;
5361 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5363 if (rc
== MEMCACHED_NOTFOUND
)
5366 test_zero(value_length
);
5370 test_compare(MEMCACHED_SUCCESS
, rc
);
5372 test_compare(100LLU, value_length
);
5376 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5377 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5378 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5380 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5381 snprintf(key
, sizeof(key
), "%u", x
);
5383 keys
[x
]= strdup(key
);
5385 key_length
[x
]= strlen(key
);
5386 test_true(key_length
[x
]);
5389 test_compare(MEMCACHED_SUCCESS
,
5390 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5393 memcached_result_st
*result
= NULL
;
5394 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5396 test_compare(size_t(100), memcached_result_length(result
));
5400 test_true(count
> 100); // If we don't get back atleast this, something is up
5402 /* Release all allocated resources */
5403 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5411 memcached_free(clone
);
5413 return TEST_SUCCESS
;
5417 * Test that ensures that buffered set to not trigger problems during io_flush
5419 #define regression_bug_490520_COUNT 200480
5420 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5422 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5423 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5424 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5425 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5426 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5428 memc
->number_of_hosts
= 1;
5430 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5431 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5433 /* First add all of the items.. */
5434 char blob
[3333] = {0};
5435 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5438 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5442 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5443 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5446 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5453 return TEST_SUCCESS
;
5457 static test_return_t
regression_bug_854604(memcached_st
*)
5461 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
5463 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
5465 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
5466 test_compare(buffer
[0], 0);
5468 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
5469 test_true(strlen(buffer
));
5471 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
5472 test_true(strlen(buffer
));
5474 return TEST_SUCCESS
;
5477 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5479 fprintf(stderr
, "Iteration #%u: ", it
);
5481 if (error
== MEMCACHED_ERRNO
)
5483 fprintf(stderr
, "system error %d from %s: %s\n",
5484 errno
, what
, strerror(errno
));
5488 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5489 memcached_strerror(mc
, error
));
5493 #define TEST_CONSTANT_CREATION 200
5495 static test_return_t
regression_bug_(memcached_st
*memc
)
5497 const char *remote_server
;
5500 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5502 return TEST_SKIPPED
;
5505 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5507 memcached_st
* mc
= memcached_create(NULL
);
5508 memcached_return rc
;
5510 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5511 if (rc
!= MEMCACHED_SUCCESS
)
5513 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5516 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5517 if (rc
!= MEMCACHED_SUCCESS
)
5519 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5522 rc
= memcached_server_add(mc
, remote_server
, 0);
5523 if (rc
!= MEMCACHED_SUCCESS
)
5525 memcached_die(mc
, rc
, "memcached_server_add", x
);
5528 const char *set_key
= "akey";
5529 const size_t set_key_len
= strlen(set_key
);
5530 const char *set_value
= "a value";
5531 const size_t set_value_len
= strlen(set_value
);
5533 if (rc
== MEMCACHED_SUCCESS
)
5537 size_t get_value_len
;
5539 uint32_t get_value_flags
;
5541 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5542 &get_value_flags
, &rc
);
5543 if (rc
!= MEMCACHED_SUCCESS
)
5545 memcached_die(mc
, rc
, "memcached_get", x
);
5551 (get_value_len
!= set_value_len
5552 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5554 fprintf(stderr
, "Values don't match?\n");
5555 rc
= MEMCACHED_FAILURE
;
5561 rc
= memcached_set(mc
,
5562 set_key
, set_key_len
,
5563 set_value
, set_value_len
,
5567 if (rc
!= MEMCACHED_SUCCESS
)
5569 memcached_die(mc
, rc
, "memcached_set", x
);
5576 if (rc
!= MEMCACHED_SUCCESS
)
5582 return TEST_SUCCESS
;
5585 /* Clean the server before beginning testing */
5587 {"util_version", true, (test_callback_fn
*)util_version_test
},
5588 {"flush", false, (test_callback_fn
*)flush_test
},
5589 {"init", false, (test_callback_fn
*)init_test
},
5590 {"allocation", false, (test_callback_fn
*)allocation_test
},
5591 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5592 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5593 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5594 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5595 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5596 {"clone_test", false, (test_callback_fn
*)clone_test
},
5597 {"connection_test", false, (test_callback_fn
*)connection_test
},
5598 {"callback_test", false, (test_callback_fn
*)callback_test
},
5599 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5600 {"set", false, (test_callback_fn
*)set_test
},
5601 {"set2", false, (test_callback_fn
*)set_test2
},
5602 {"set3", false, (test_callback_fn
*)set_test3
},
5603 {"dump", true, (test_callback_fn
*)dump_test
},
5604 {"add", true, (test_callback_fn
*)add_test
},
5605 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5606 {"replace", true, (test_callback_fn
*)replace_test
},
5607 {"delete", true, (test_callback_fn
*)delete_test
},
5608 {"get", true, (test_callback_fn
*)get_test
},
5609 {"get2", false, (test_callback_fn
*)get_test2
},
5610 {"get3", false, (test_callback_fn
*)get_test3
},
5611 {"get4", false, (test_callback_fn
*)get_test4
},
5612 {"partial mget", false, (test_callback_fn
*)get_test5
},
5613 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5614 {"increment", false, (test_callback_fn
*)increment_test
},
5615 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5616 {"decrement", false, (test_callback_fn
*)decrement_test
},
5617 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5618 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5619 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5620 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5621 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5622 {"binary_increment_with_prefix", 1, (test_callback_fn
*)binary_increment_with_prefix_test
},
5623 {"quit", false, (test_callback_fn
*)quit_test
},
5624 {"mget", true, (test_callback_fn
*)mget_test
},
5625 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5626 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5627 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5628 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5629 {"mget_end", false, (test_callback_fn
*)mget_end
},
5630 {"get_stats", false, (test_callback_fn
*)get_stats
},
5631 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5632 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5633 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5634 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
5635 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5636 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5637 {"read_through", true, (test_callback_fn
*)read_through
},
5638 {"delete_through", true, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER
},
5639 {"noreply", true, (test_callback_fn
*)noreply_test
},
5640 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5641 {"memcached_pool_st", true, (test_callback_fn
*)connection_pool_test
},
5642 {"memcached_pool_st #2", true, (test_callback_fn
*)connection_pool2_test
},
5644 {"memcached_pool_st #3", true, (test_callback_fn
*)connection_pool3_test
},
5646 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
5647 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
5648 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
5649 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
5650 {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_NOTFOUND
},
5651 {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_SUCCESS
},
5652 {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_by_key_NOTFOUND
},
5653 {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_by_key_SUCCESS
},
5654 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5655 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5659 test_st touch_tests
[] ={
5660 {"memcached_touch", 0, (test_callback_fn
*)test_memcached_touch
},
5661 {"memcached_touch_with_prefix", 0, (test_callback_fn
*)test_memcached_touch_by_key
},
5665 test_st behavior_tests
[] ={
5666 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5667 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5668 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5669 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5670 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5671 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5672 {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test
},
5673 {"MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY", false, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY
},
5677 test_st libmemcachedutil_tests
[] ={
5678 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5679 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5680 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5684 test_st basic_tests
[] ={
5685 {"init", true, (test_callback_fn
*)basic_init_test
},
5686 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5687 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5688 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5689 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5690 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5691 {"memcached_return_t", false, (test_callback_fn
*)memcached_return_t_TEST
},
5695 test_st regression_binary_vs_block
[] ={
5696 {"block add", true, (test_callback_fn
*)block_add_regression
},
5697 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
5701 test_st async_tests
[] ={
5702 {"add", true, (test_callback_fn
*)add_wrapper
},
5706 test_st memcached_server_get_last_disconnect_tests
[] ={
5707 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
5708 {0, 0, (test_callback_fn
*)0}
5712 test_st result_tests
[] ={
5713 {"result static", false, (test_callback_fn
*)result_static
},
5714 {"result alloc", false, (test_callback_fn
*)result_alloc
},
5715 {0, 0, (test_callback_fn
*)0}
5718 test_st version_1_2_3
[] ={
5719 {"append", false, (test_callback_fn
*)append_test
},
5720 {"prepend", false, (test_callback_fn
*)prepend_test
},
5721 {"cas", false, (test_callback_fn
*)cas_test
},
5722 {"cas2", false, (test_callback_fn
*)cas2_test
},
5723 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
5724 {0, 0, (test_callback_fn
*)0}
5727 test_st haldenbrand_tests
[] ={
5728 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
5729 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
5730 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
5731 {0, 0, (test_callback_fn
*)0}
5734 test_st user_tests
[] ={
5735 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
5736 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
5737 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
5738 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
5739 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
5740 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
5741 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
5742 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
5743 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
5744 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
5745 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
5746 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
5747 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
5748 #if !defined(__sun) && !defined(__OpenBSD__)
5750 ** It seems to be something weird with the character sets..
5751 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5752 ** guess I need to find out how this is supposed to work.. Perhaps I need
5753 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5754 ** so just disable the code for now...).
5756 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
5758 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
5759 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
5760 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
5761 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
5762 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
5763 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
5764 {0, 0, (test_callback_fn
*)0}
5767 test_st replication_tests
[]= {
5768 {"set", true, (test_callback_fn
*)replication_set_test
},
5769 {"get", false, (test_callback_fn
*)replication_get_test
},
5770 {"mget", false, (test_callback_fn
*)replication_mget_test
},
5771 {"delete", true, (test_callback_fn
*)replication_delete_test
},
5772 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
5773 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
5774 {0, 0, (test_callback_fn
*)0}
5778 * The following test suite is used to verify that we don't introduce
5779 * regression bugs. If you want more information about the bug / test,
5780 * you should look in the bug report at
5781 * http://bugs.launchpad.net/libmemcached
5783 test_st regression_tests
[]= {
5784 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
5785 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
5786 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
5787 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
5788 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
5789 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
5790 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
5791 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
5792 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
5793 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
5794 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
5795 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
5796 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
5797 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
5798 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
5799 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
5800 {"lp:854604", true, (test_callback_fn
*)regression_bug_854604
},
5801 {0, false, (test_callback_fn
*)0}
5804 test_st ketama_compatibility
[]= {
5805 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
5806 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
5807 {0, 0, (test_callback_fn
*)0}
5810 test_st generate_tests
[] ={
5811 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5812 {"generate_data", true, (test_callback_fn
*)generate_data
},
5813 {"get_read", false, (test_callback_fn
*)get_read
},
5814 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
5815 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5816 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
5817 {"generate_data", true, (test_callback_fn
*)generate_data
},
5818 {"mget_read", false, (test_callback_fn
*)mget_read
},
5819 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
5820 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
5821 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
5822 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
5823 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5824 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
5825 {"generate_data", true, (test_callback_fn
*)generate_data
},
5826 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
5827 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5828 {0, 0, (test_callback_fn
*)0}
5831 test_st consistent_tests
[] ={
5832 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5833 {"generate_data", true, (test_callback_fn
*)generate_data
},
5834 {"get_read", 0, (test_callback_fn
*)get_read_count
},
5835 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5836 {0, 0, (test_callback_fn
*)0}
5839 test_st consistent_weighted_tests
[] ={
5840 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5841 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
5842 {"get_read", false, (test_callback_fn
*)get_read_count
},
5843 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
5844 {0, 0, (test_callback_fn
*)0}
5847 test_st hsieh_availability
[] ={
5848 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
5849 {0, 0, (test_callback_fn
*)0}
5852 test_st murmur_availability
[] ={
5853 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
5854 {0, 0, (test_callback_fn
*)0}
5858 test_st hash_sanity
[] ={
5859 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
5860 {0, 0, (test_callback_fn
*)0}
5864 test_st ketama_auto_eject_hosts
[] ={
5865 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
5866 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
5867 {0, 0, (test_callback_fn
*)0}
5870 test_st hash_tests
[] ={
5871 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
5872 {"md5", false, (test_callback_fn
*)md5_run
},
5873 {"crc", false, (test_callback_fn
*)crc_run
},
5874 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
5875 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
5876 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
5877 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
5878 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
5879 {"murmur", false, (test_callback_fn
*)murmur_run
},
5880 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
5881 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
5882 {0, 0, (test_callback_fn
*)0}
5885 test_st error_conditions
[] ={
5886 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
5887 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
5888 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
5889 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5890 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
5891 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
5892 {0, 0, (test_callback_fn
*)0}
5895 test_st parser_tests
[] ={
5896 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
5897 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
5898 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
5899 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
5900 {"hash", false, (test_callback_fn
*)parser_hash_test
},
5901 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
5902 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
5903 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
5904 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
5905 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
5906 {"server", false, (test_callback_fn
*)server_test
},
5907 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
5908 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
5909 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
5910 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
5911 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
5912 {0, 0, (test_callback_fn
*)0}
5915 test_st virtual_bucket_tests
[] ={
5916 {"basic", false, (test_callback_fn
*)virtual_back_map
},
5917 {0, 0, (test_callback_fn
*)0}
5920 test_st memcached_server_add_tests
[] ={
5921 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
5922 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
5923 {0, 0, (test_callback_fn
*)0}
5926 test_st namespace_tests
[] ={
5927 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
5928 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
5929 {0, 0, (test_callback_fn
*)0}
5932 collection_st collection
[] ={
5934 {"hash_sanity", 0, 0, hash_sanity
},
5936 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
5937 {"basic", 0, 0, basic_tests
},
5938 {"hsieh_availability", 0, 0, hsieh_availability
},
5939 {"murmur_availability", 0, 0, murmur_availability
},
5940 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
5941 {"block", 0, 0, tests
},
5942 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
5943 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
5944 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5945 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
5946 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
5947 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
5948 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
5949 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
5950 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
5951 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
5952 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
5953 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
5954 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
5955 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
5956 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
5957 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
5958 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
5959 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
5960 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
5961 #ifdef MEMCACHED_ENABLE_DEPRECATED
5962 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
5964 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
5965 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
5966 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
5967 {"specific namespace", 0, 0, namespace_tests
},
5968 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
5969 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
5970 {"result", 0, 0, result_tests
},
5971 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
5972 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
5973 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
5974 {"user written tests", 0, 0, user_tests
},
5975 {"generate", 0, 0, generate_tests
},
5976 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
5977 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
5978 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
5979 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
5980 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
5981 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
5982 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
5984 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
5985 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
5986 {"consistent_not", 0, 0, consistent_tests
},
5987 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
5988 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
5989 {"ketama_compat", 0, 0, ketama_compatibility
},
5990 {"test_hashes", 0, 0, hash_tests
},
5991 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
5992 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
5993 {"regression", 0, 0, regression_tests
},
5994 {"behaviors", 0, 0, behavior_tests
},
5995 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
5996 {"error_conditions", 0, 0, error_conditions
},
5997 {"parser", 0, 0, parser_tests
},
5998 {"virtual buckets", 0, 0, virtual_bucket_tests
},
5999 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6000 {"touch", 0, 0, touch_tests
},
6004 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
6006 #include "tests/libmemcached_world.h"
6008 void get_world(Framework
*world
)
6010 world
->collections
= collection
;
6012 world
->_create
= (test_callback_create_fn
*)world_create
;
6013 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6015 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6016 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6017 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6018 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6019 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6021 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6022 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6024 world
->set_runner(&defualt_libmemcached_runner
);
6026 world
->set_socket();