1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 #include <libtest/test.hpp>
45 #include <libmemcached-1.0/memcached.h>
46 #include <libmemcached/is.h>
47 #include <libmemcached/server_instance.h>
49 #include <libhashkit-1.0/hashkit.h>
55 #include <semaphore.h>
59 #include <sys/types.h>
64 #include <libtest/server.h>
66 #include "clients/generator.h"
67 #include "clients/execute.h"
69 #define SMALL_STRING_LEN 1024
71 #include <libtest/test.hpp>
73 #include "tests/basic.h"
74 #include "tests/debug.h"
75 #include "tests/deprecated.h"
76 #include "tests/error_conditions.h"
77 #include "tests/exist.h"
78 #include "tests/ketama.h"
79 #include "tests/namespace.h"
80 #include "tests/parser.h"
81 #include "tests/touch.h"
82 #include "tests/callbacks.h"
83 #include "tests/pool.h"
84 #include "tests/print.h"
85 #include "tests/replication.h"
86 #include "tests/server_add.h"
87 #include "tests/virtual_buckets.h"
89 using namespace libtest
;
91 #include <libmemcached/util.h>
93 #include "hash_results.h"
95 #define GLOBAL_COUNT 10000
96 #define GLOBAL2_COUNT 100
97 #define SERVERS_TO_CREATE 5
98 static uint32_t global_count
;
100 static pairs_st
*global_pairs
;
101 static const char *global_keys
[GLOBAL_COUNT
];
102 static size_t global_keys_length
[GLOBAL_COUNT
];
105 @note This should be testing to see if the server really supports the binary protocol.
107 static test_return_t
pre_binary(memcached_st
*memc
)
109 test_skip(true, libmemcached_util_version_check(memc
, 1, 4, 4));
110 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
115 static memcached_st
* create_single_instance_memcached(const memcached_st
*original_memc
, const char *options
)
118 * I only want to hit _one_ server so I know the number of requests I'm
119 * sending in the pipeline.
121 memcached_server_instance_st instance
= memcached_server_instance_by_position(original_memc
, 0);
123 char server_string
[1024];
124 int server_string_length
;
127 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d %s",
128 memcached_server_name(instance
), int(memcached_server_port(instance
)),
133 server_string_length
= snprintf(server_string
, sizeof(server_string
), "--server=%s:%d",
134 memcached_server_name(instance
), int(memcached_server_port(instance
)));
137 if (server_string_length
<= 0)
143 if (memcached_failed(libmemcached_check_configuration(server_string
, server_string_length
, buffer
, sizeof(buffer
))))
145 Error
<< "Failed to parse " << server_string_length
;
149 return memcached(server_string
, server_string_length
);
153 static test_return_t
init_test(memcached_st
*not_used
)
158 (void)memcached_create(&memc
);
159 memcached_free(&memc
);
164 #define TEST_PORT_COUNT 7
165 in_port_t test_ports
[TEST_PORT_COUNT
];
167 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
168 const memcached_server_st
*server
,
172 size_t bigger
= *((size_t *)(context
));
174 assert(bigger
<= memcached_server_port(server
));
175 *((size_t *)(context
))= memcached_server_port(server
);
177 return MEMCACHED_SUCCESS
;
180 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
181 const memcached_server_st
*instance
,
185 FILE *stream
= (FILE *)context
;
188 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
189 memcached_server_name(instance
),
190 memcached_server_port(instance
),
191 instance
->major_version
,
192 instance
->minor_version
,
193 instance
->micro_version
);
195 return MEMCACHED_SUCCESS
;
198 static test_return_t
server_sort_test(memcached_st
*ptr
)
200 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
202 memcached_return_t rc
;
203 memcached_server_fn callbacks
[1];
204 memcached_st
*local_memc
;
207 local_memc
= memcached_create(NULL
);
208 test_true(local_memc
);
209 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
211 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
213 test_ports
[x
]= (in_port_t
)random() % 64000;
214 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
215 test_compare(memcached_server_count(local_memc
), x
+1);
217 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
219 test_compare(MEMCACHED_SUCCESS
, rc
);
222 callbacks
[0]= server_display_function
;
223 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
226 memcached_free(local_memc
);
231 static test_return_t
server_sort2_test(memcached_st
*ptr
)
233 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
234 memcached_server_fn callbacks
[1];
235 memcached_st
*local_memc
;
236 memcached_server_instance_st instance
;
239 local_memc
= memcached_create(NULL
);
240 test_true(local_memc
);
241 test_compare(MEMCACHED_SUCCESS
,
242 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
244 test_compare(MEMCACHED_SUCCESS
,
245 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
246 instance
= memcached_server_instance_by_position(local_memc
, 0);
247 test_compare(in_port_t(43043), memcached_server_port(instance
));
249 test_compare(MEMCACHED_SUCCESS
,
250 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
252 instance
= memcached_server_instance_by_position(local_memc
, 0);
253 test_compare(in_port_t(43042), memcached_server_port(instance
));
255 instance
= memcached_server_instance_by_position(local_memc
, 1);
256 test_compare(in_port_t(43043), memcached_server_port(instance
));
258 callbacks
[0]= server_display_function
;
259 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
262 memcached_free(local_memc
);
267 static test_return_t
memcached_server_remove_test(memcached_st
*)
269 const char *server_string
= "--server=localhost:4444 --server=localhost:4445 --server=localhost:4446 --server=localhost:4447 --server=localhost --server=memcache1.memcache.bk.sapo.pt:11211 --server=memcache1.memcache.bk.sapo.pt:11212 --server=memcache1.memcache.bk.sapo.pt:11213 --server=memcache1.memcache.bk.sapo.pt:11214 --server=memcache2.memcache.bk.sapo.pt:11211 --server=memcache2.memcache.bk.sapo.pt:11212 --server=memcache2.memcache.bk.sapo.pt:11213 --server=memcache2.memcache.bk.sapo.pt:11214";
272 test_compare(MEMCACHED_SUCCESS
,
273 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
274 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
277 memcached_server_fn callbacks
[1];
278 callbacks
[0]= server_print_callback
;
279 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
281 memcached_free(memc
);
286 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
287 const memcached_server_st
*server
,
291 uint32_t x
= *((uint32_t *)(context
));
293 if (! (test_ports
[x
] == server
->port
))
295 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
296 return MEMCACHED_FAILURE
;
299 *((uint32_t *)(context
))= ++x
;
301 return MEMCACHED_SUCCESS
;
304 static test_return_t
server_unsort_test(memcached_st
*ptr
)
306 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
307 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
308 memcached_server_fn callbacks
[1];
309 memcached_st
*local_memc
;
312 local_memc
= memcached_create(NULL
);
313 test_true(local_memc
);
315 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
317 test_ports
[x
]= (in_port_t
)(random() % 64000);
318 test_compare(MEMCACHED_SUCCESS
,
319 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
320 test_compare(memcached_server_count(local_memc
), x
+1);
322 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
326 callbacks
[0]= server_display_unsort_function
;
327 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
329 /* Now we sort old data! */
330 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
331 callbacks
[0]= server_display_function
;
332 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
335 memcached_free(local_memc
);
340 static test_return_t
allocation_test(memcached_st
*not_used
)
344 memc
= memcached_create(NULL
);
346 memcached_free(memc
);
351 static test_return_t
clone_test(memcached_st
*memc
)
355 memcached_st
*memc_clone
;
356 memc_clone
= memcached_clone(NULL
, NULL
);
357 test_true(memc_clone
);
358 memcached_free(memc_clone
);
361 /* Can we init from null? */
363 memcached_st
*memc_clone
;
364 memc_clone
= memcached_clone(NULL
, memc
);
365 test_true(memc_clone
);
368 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
369 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
370 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
371 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
374 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
375 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
376 test_true(memc_clone
->distribution
== memc
->distribution
);
377 { // Test all of the flags
378 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
379 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
380 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
381 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
382 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
383 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
384 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
385 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
386 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
387 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
388 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
389 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
390 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
392 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
393 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
394 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
395 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
396 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
397 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
398 test_true(memc_clone
->on_clone
== memc
->on_clone
);
399 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
400 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
401 test_true(memc_clone
->recv_size
== memc
->recv_size
);
402 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
403 test_true(memc_clone
->send_size
== memc
->send_size
);
404 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
405 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
406 test_true(memc_clone
->user_data
== memc
->user_data
);
408 memcached_free(memc_clone
);
411 /* Can we init from struct? */
413 memcached_st declared_clone
;
414 memcached_st
*memc_clone
;
415 memset(&declared_clone
, 0 , sizeof(memcached_st
));
416 memc_clone
= memcached_clone(&declared_clone
, NULL
);
417 test_true(memc_clone
);
418 memcached_free(memc_clone
);
421 /* Can we init from struct? */
423 memcached_st declared_clone
;
424 memcached_st
*memc_clone
;
425 memset(&declared_clone
, 0 , sizeof(memcached_st
));
426 memc_clone
= memcached_clone(&declared_clone
, memc
);
427 test_true(memc_clone
);
428 memcached_free(memc_clone
);
434 static test_return_t
userdata_test(memcached_st
*memc
)
437 test_false(memcached_set_user_data(memc
, foo
));
438 test_true(memcached_get_user_data(memc
) == foo
);
439 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
444 static test_return_t
connection_test(memcached_st
*memc
)
446 test_compare(MEMCACHED_SUCCESS
,
447 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
452 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
454 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
456 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
458 test_compare(36, int(MEMCACHED_BEHAVIOR_MAX
));
463 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
465 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
467 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
469 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
474 static test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
476 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
477 982370485U, 1263635348U, 4242906218U, 3829656100U,
478 1891735253U, 334139633U, 2257084983U, 3088286104U,
479 13199785U, 2542027183U, 1097051614U, 199566778U,
480 2748246961U, 2465192557U, 1664094137U, 2405439045U,
481 1842224848U, 692413798U, 3479807801U, 919913813U,
482 4269430871U, 610793021U, 527273862U, 1437122909U,
483 2300930706U, 2943759320U, 674306647U, 2400528935U,
484 54481931U, 4186304426U, 1741088401U, 2979625118U,
485 4159057246U, 3425930182U, 2593724503U, 1868899624U,
486 1769812374U, 2302537950U, 1110330676U, 3365377466U,
487 1336171666U, 3021258493U, 2334992265U, 3861994737U,
490 // You have updated the memcache_error messages but not updated docs/tests.
491 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
494 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
495 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
496 MEMCACHED_HASH_JENKINS
);
497 if (values
[rc
] != hash_val
)
499 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
500 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
502 test_compare(values
[rc
], hash_val
);
504 test_compare(48, int(MEMCACHED_MAXIMUM_RETURN
));
509 static test_return_t
set_test(memcached_st
*memc
)
511 memcached_return_t rc
= memcached_set(memc
,
512 test_literal_param("foo"),
513 test_literal_param("when we sanitize"),
514 time_t(0), (uint32_t)0);
515 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
520 static test_return_t
append_test(memcached_st
*memc
)
522 memcached_return_t rc
;
523 const char *key
= "fig";
524 const char *in_value
= "we";
525 char *out_value
= NULL
;
529 rc
= memcached_flush(memc
, 0);
530 test_compare(MEMCACHED_SUCCESS
, rc
);
532 rc
= memcached_set(memc
, key
, strlen(key
),
533 in_value
, strlen(in_value
),
534 (time_t)0, (uint32_t)0);
535 test_compare(MEMCACHED_SUCCESS
, rc
);
537 rc
= memcached_append(memc
, key
, strlen(key
),
538 " the", strlen(" the"),
539 (time_t)0, (uint32_t)0);
540 test_compare(MEMCACHED_SUCCESS
, rc
);
542 rc
= memcached_append(memc
, key
, strlen(key
),
543 " people", strlen(" people"),
544 (time_t)0, (uint32_t)0);
545 test_compare(MEMCACHED_SUCCESS
, rc
);
547 out_value
= memcached_get(memc
, key
, strlen(key
),
548 &value_length
, &flags
, &rc
);
549 test_memcmp(out_value
, "we the people", strlen("we the people"));
550 test_compare(strlen("we the people"), value_length
);
551 test_compare(MEMCACHED_SUCCESS
, rc
);
557 static test_return_t
append_binary_test(memcached_st
*memc
)
559 memcached_return_t rc
;
560 const char *key
= "numbers";
561 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
567 rc
= memcached_flush(memc
, 0);
568 test_compare(MEMCACHED_SUCCESS
, rc
);
570 rc
= memcached_set(memc
,
573 (time_t)0, (uint32_t)0);
574 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
576 for (x
= 0; store_list
[x
] ; x
++)
578 rc
= memcached_append(memc
,
580 (char *)&store_list
[x
], sizeof(uint32_t),
581 (time_t)0, (uint32_t)0);
582 test_compare(MEMCACHED_SUCCESS
, rc
);
585 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
586 &value_length
, &flags
, &rc
);
587 test_compare(value_length
, sizeof(uint32_t) * x
);
588 test_compare(MEMCACHED_SUCCESS
, rc
);
590 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
592 test_compare(*ptr
, store_list
[x
- counter
]);
600 static test_return_t
cas2_test(memcached_st
*memc
)
602 memcached_return_t rc
;
603 const char *keys
[]= {"fudge", "son", "food"};
604 size_t key_length
[]= {5, 3, 4};
605 const char *value
= "we the people";
606 size_t value_length
= strlen("we the people");
607 memcached_result_st results_obj
;
608 memcached_result_st
*results
;
611 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
613 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
615 for (uint32_t x
= 0; x
< 3; x
++)
617 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
618 keys
[x
], key_length
[x
],
619 (time_t)50, (uint32_t)9);
620 test_compare(MEMCACHED_SUCCESS
, rc
);
623 test_compare(MEMCACHED_SUCCESS
,
624 memcached_mget(memc
, keys
, key_length
, 3));
626 results
= memcached_result_create(memc
, &results_obj
);
629 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
631 test_true(results
->item_cas
);
632 test_compare(MEMCACHED_SUCCESS
, rc
);
633 test_true(memcached_result_cas(results
));
635 test_memcmp(value
, "we the people", strlen("we the people"));
636 test_compare(strlen("we the people"), value_length
);
637 test_compare(MEMCACHED_SUCCESS
, rc
);
639 memcached_result_free(&results_obj
);
644 static test_return_t
cas_test(memcached_st
*memc
)
646 memcached_return_t rc
;
647 const char *key
= "fun";
648 size_t key_length
= strlen(key
);
649 const char *value
= "we the people";
650 const char* keys
[2] = { key
, NULL
};
651 size_t keylengths
[2] = { strlen(key
), 0 };
652 size_t value_length
= strlen(value
);
653 const char *value2
= "change the value";
654 size_t value2_length
= strlen(value2
);
656 memcached_result_st results_obj
;
657 memcached_result_st
*results
;
660 rc
= memcached_flush(memc
, 0);
661 test_compare(MEMCACHED_SUCCESS
, rc
);
663 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
665 rc
= memcached_set(memc
, key
, strlen(key
),
666 value
, strlen(value
),
667 (time_t)0, (uint32_t)0);
668 test_compare(MEMCACHED_SUCCESS
, rc
);
670 test_compare(MEMCACHED_SUCCESS
,
671 memcached_mget(memc
, keys
, keylengths
, 1));
673 results
= memcached_result_create(memc
, &results_obj
);
676 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
678 test_compare(MEMCACHED_SUCCESS
, rc
);
679 test_true(memcached_result_cas(results
));
680 test_memcmp(value
, memcached_result_value(results
), value_length
);
681 test_compare(strlen(memcached_result_value(results
)), value_length
);
682 test_compare(MEMCACHED_SUCCESS
, rc
);
683 uint64_t cas
= memcached_result_cas(results
);
686 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
687 test_true(rc
== MEMCACHED_END
);
688 test_true(results
== NULL
);
691 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
692 test_compare(MEMCACHED_SUCCESS
, rc
);
695 * The item will have a new cas value, so try to set it again with the old
696 * value. This should fail!
698 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
699 test_compare(MEMCACHED_DATA_EXISTS
, rc
);
701 memcached_result_free(&results_obj
);
706 static test_return_t
prepend_test(memcached_st
*memc
)
708 memcached_return_t rc
;
709 const char *key
= "fig";
710 const char *value
= "people";
711 char *out_value
= NULL
;
715 rc
= memcached_flush(memc
, 0);
716 test_compare(MEMCACHED_SUCCESS
, rc
);
718 rc
= memcached_set(memc
, key
, strlen(key
),
719 value
, strlen(value
),
720 (time_t)0, (uint32_t)0);
721 test_compare(MEMCACHED_SUCCESS
, rc
);
723 rc
= memcached_prepend(memc
, key
, strlen(key
),
724 "the ", strlen("the "),
725 (time_t)0, (uint32_t)0);
726 test_compare(MEMCACHED_SUCCESS
, rc
);
728 rc
= memcached_prepend(memc
, key
, strlen(key
),
729 "we ", strlen("we "),
730 (time_t)0, (uint32_t)0);
731 test_compare(MEMCACHED_SUCCESS
, rc
);
733 out_value
= memcached_get(memc
, key
, strlen(key
),
734 &value_length
, &flags
, &rc
);
735 test_memcmp(out_value
, "we the people", strlen("we the people"));
736 test_compare(strlen("we the people"), value_length
);
737 test_compare(MEMCACHED_SUCCESS
, rc
);
744 Set the value, then quit to make sure it is flushed.
745 Come back in and test that add fails.
747 static test_return_t
add_test(memcached_st
*memc
)
749 memcached_return_t rc
;
750 const char *key
= "foo";
751 const char *value
= "when we sanitize";
752 unsigned long long setting_value
;
754 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
756 rc
= memcached_set(memc
, key
, strlen(key
),
757 value
, strlen(value
),
758 (time_t)0, (uint32_t)0);
759 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
760 memcached_quit(memc
);
761 rc
= memcached_add(memc
, key
, strlen(key
),
762 value
, strlen(value
),
763 (time_t)0, (uint32_t)0);
765 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
768 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
772 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
779 ** There was a problem of leaking filedescriptors in the initial release
780 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
781 ** systems it seems that the kernel is slow on reclaiming the resources
782 ** because the connects starts to time out (the test doesn't do much
783 ** anyway, so just loop 10 iterations)
785 static test_return_t
add_wrapper(memcached_st
*memc
)
787 unsigned int max
= 10000;
795 for (uint32_t x
= 0; x
< max
; x
++)
801 static test_return_t
replace_test(memcached_st
*memc
)
803 memcached_return_t rc
;
804 const char *key
= "foo";
805 const char *value
= "when we sanitize";
806 const char *original
= "first we insert some data";
808 rc
= memcached_set(memc
, key
, strlen(key
),
809 original
, strlen(original
),
810 (time_t)0, (uint32_t)0);
811 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
813 test_compare(MEMCACHED_SUCCESS
,
814 memcached_replace(memc
, key
, strlen(key
),
815 value
, strlen(value
),
816 (time_t)0, (uint32_t)0));
821 static test_return_t
delete_test(memcached_st
*memc
)
823 memcached_return_t rc
;
824 const char *key
= "foo";
825 const char *value
= "when we sanitize";
827 rc
= memcached_set(memc
, key
, strlen(key
),
828 value
, strlen(value
),
829 (time_t)0, (uint32_t)0);
830 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
832 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
833 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
838 static test_return_t
flush_test(memcached_st
*memc
)
840 uint64_t query_id
= memcached_query_id(memc
);
841 test_compare(MEMCACHED_SUCCESS
,
842 memcached_flush(memc
, 0));
843 test_compare(query_id
+1, memcached_query_id(memc
));
848 static memcached_return_t
server_function(const memcached_st
*ptr
,
849 const memcached_server_st
*server
,
852 (void)ptr
; (void)server
; (void)context
;
855 return MEMCACHED_SUCCESS
;
858 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
861 strncpy(context
, "foo bad", sizeof(context
));
862 memcached_server_fn callbacks
[1];
864 callbacks
[0]= server_function
;
865 memcached_server_cursor(memc
, callbacks
, context
, 1);
869 static test_return_t
bad_key_test(memcached_st
*memc
)
871 memcached_return_t rc
;
872 const char *key
= "foo bad";
874 memcached_st
*memc_clone
;
876 uint64_t query_id
= memcached_query_id(memc
);
878 // Just skip if we are in binary mode.
879 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
881 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
883 memc_clone
= memcached_clone(NULL
, memc
);
884 test_true(memc_clone
);
886 query_id
= memcached_query_id(memc_clone
);
887 test_compare(MEMCACHED_SUCCESS
,
888 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
889 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
891 /* All keys are valid in the binary protocol (except for length) */
892 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
894 uint64_t before_query_id
= memcached_query_id(memc_clone
);
896 size_t string_length
;
897 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
898 &string_length
, &flags
, &rc
);
899 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
900 test_zero(string_length
);
903 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
905 query_id
= memcached_query_id(memc_clone
);
906 test_compare(MEMCACHED_SUCCESS
,
907 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
908 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
910 size_t string_length
;
911 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
912 &string_length
, &flags
, &rc
);
913 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
914 test_zero(string_length
);
918 /* Test multi key for bad keys */
919 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
920 size_t key_lengths
[] = { 7, 7, 7 };
921 query_id
= memcached_query_id(memc_clone
);
922 test_compare(MEMCACHED_SUCCESS
,
923 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
924 test_compare(query_id
, memcached_query_id(memc_clone
));
926 query_id
= memcached_query_id(memc_clone
);
927 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
928 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
929 test_compare(query_id
+1, memcached_query_id(memc_clone
));
931 query_id
= memcached_query_id(memc_clone
);
932 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
933 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
934 test_compare(query_id
+1, memcached_query_id(memc_clone
));
936 /* The following test should be moved to the end of this function when the
937 memcached server is updated to allow max size length of the keys in the
940 test_compare(MEMCACHED_SUCCESS
,
941 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
943 std::vector
<char> longkey
;
944 longkey
.reserve(MEMCACHED_MAX_KEY
);
945 longkey
.insert(longkey
.end(), MEMCACHED_MAX_KEY
, 'a');
946 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
948 size_t string_length
;
950 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
951 test_compare(MEMCACHED_NOTFOUND
, rc
);
952 test_zero(string_length
);
954 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
955 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
956 test_zero(string_length
);
960 /* Make sure zero length keys are marked as bad */
962 test_compare(MEMCACHED_SUCCESS
,
963 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
964 size_t string_length
;
965 char *string
= memcached_get(memc_clone
, key
, 0,
966 &string_length
, &flags
, &rc
);
967 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
968 test_zero(string_length
);
972 memcached_free(memc_clone
);
977 #define READ_THROUGH_VALUE "set for me"
978 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
981 memcached_result_st
*result
)
983 (void)memc
;(void)key
;(void)key_length
;
984 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
987 #ifndef __INTEL_COMPILER
988 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
991 static test_return_t
read_through(memcached_st
*memc
)
993 memcached_return_t rc
;
994 const char *key
= "foo";
996 size_t string_length
;
998 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
1000 string
= memcached_get(memc
, key
, strlen(key
),
1001 &string_length
, &flags
, &rc
);
1003 test_compare(MEMCACHED_NOTFOUND
, rc
);
1004 test_false(string_length
);
1007 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
);
1008 test_compare(MEMCACHED_SUCCESS
, rc
);
1010 string
= memcached_get(memc
, key
, strlen(key
),
1011 &string_length
, &flags
, &rc
);
1013 test_compare(MEMCACHED_SUCCESS
, rc
);
1014 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1015 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1016 test_strcmp(READ_THROUGH_VALUE
, string
);
1019 string
= memcached_get(memc
, key
, strlen(key
),
1020 &string_length
, &flags
, &rc
);
1022 test_compare(MEMCACHED_SUCCESS
, rc
);
1024 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
1025 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
1026 test_strcmp(READ_THROUGH_VALUE
, string
);
1029 return TEST_SUCCESS
;
1032 static test_return_t
get_test(memcached_st
*memc
)
1034 memcached_return_t rc
;
1035 const char *key
= "foo";
1037 size_t string_length
;
1040 uint64_t query_id
= memcached_query_id(memc
);
1041 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
1042 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
1043 test_compare(query_id
+1, memcached_query_id(memc
));
1045 string
= memcached_get(memc
, key
, strlen(key
),
1046 &string_length
, &flags
, &rc
);
1048 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1049 test_false(string_length
);
1052 return TEST_SUCCESS
;
1055 static test_return_t
get_test2(memcached_st
*memc
)
1057 const char *key
= "foo";
1058 const char *value
= "when we sanitize";
1060 uint64_t query_id
= memcached_query_id(memc
);
1061 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1062 value
, strlen(value
),
1063 (time_t)0, (uint32_t)0);
1064 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1065 test_compare(query_id
+1, memcached_query_id(memc
));
1067 query_id
= memcached_query_id(memc
);
1068 test_true(query_id
);
1071 size_t string_length
;
1072 char *string
= memcached_get(memc
, key
, strlen(key
),
1073 &string_length
, &flags
, &rc
);
1074 test_compare(query_id
+1, memcached_query_id(memc
));
1076 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1077 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1079 test_compare(strlen(value
), string_length
);
1080 test_memcmp(string
, value
, string_length
);
1084 return TEST_SUCCESS
;
1087 static test_return_t
set_test2(memcached_st
*memc
)
1089 for (uint32_t x
= 0; x
< 10; x
++)
1091 memcached_return_t rc
= memcached_set(memc
,
1092 test_literal_param("foo"),
1093 test_literal_param("train in the brain"),
1094 time_t(0), uint32_t(0));
1095 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1098 return TEST_SUCCESS
;
1101 static test_return_t
set_test3(memcached_st
*memc
)
1103 size_t value_length
= 8191;
1105 std::vector
<char> value
;
1106 value
.reserve(value_length
);
1107 for (uint32_t x
= 0; x
< value_length
; x
++)
1109 value
.push_back(char(x
% 127));
1112 /* The dump test relies on there being at least 32 items in memcached */
1113 for (uint32_t x
= 0; x
< 32; x
++)
1117 snprintf(key
, sizeof(key
), "foo%u", x
);
1119 uint64_t query_id
= memcached_query_id(memc
);
1120 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1121 &value
[0], value
.size(),
1122 (time_t)0, (uint32_t)0);
1123 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1124 test_compare(query_id
+1, memcached_query_id(memc
));
1127 return TEST_SUCCESS
;
1130 static test_return_t
get_test3(memcached_st
*memc
)
1132 const char *key
= "foo";
1133 size_t value_length
= 8191;
1135 std::vector
<char> value
;
1136 value
.reserve(value_length
);
1137 for (uint32_t x
= 0; x
< value_length
; x
++)
1139 value
.push_back(char(x
% 127));
1142 memcached_return_t rc
;
1143 rc
= memcached_set(memc
, key
, strlen(key
),
1144 &value
[0], value
.size(),
1145 (time_t)0, (uint32_t)0);
1146 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1148 size_t string_length
;
1150 char *string
= memcached_get(memc
, key
, strlen(key
),
1151 &string_length
, &flags
, &rc
);
1153 test_compare(MEMCACHED_SUCCESS
, rc
);
1155 test_compare(string_length
, value_length
);
1156 test_memcmp(string
, &value
[0], string_length
);
1160 return TEST_SUCCESS
;
1163 static test_return_t
get_test4(memcached_st
*memc
)
1165 const char *key
= "foo";
1166 size_t value_length
= 8191;
1168 std::vector
<char> value
;
1169 value
.reserve(value_length
);
1170 for (uint32_t x
= 0; x
< value_length
; x
++)
1172 value
.push_back(char(x
% 127));
1175 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1176 &value
[0], value
.size(),
1177 (time_t)0, (uint32_t)0);
1178 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1180 for (uint32_t x
= 0; x
< 10; x
++)
1183 size_t string_length
;
1184 char *string
= memcached_get(memc
, key
, strlen(key
),
1185 &string_length
, &flags
, &rc
);
1187 test_compare(MEMCACHED_SUCCESS
, rc
);
1189 test_compare(string_length
, value_length
);
1190 test_memcmp(string
, &value
[0], string_length
);
1194 return TEST_SUCCESS
;
1198 * This test verifies that memcached_read_one_response doesn't try to
1199 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1200 * responses before you execute a storage command.
1202 static test_return_t
get_test5(memcached_st
*memc
)
1205 ** Request the same key twice, to ensure that we hash to the same server
1206 ** (so that we have multiple response values queued up) ;-)
1208 const char *keys
[]= { "key", "key" };
1209 size_t lengths
[]= { 3, 3 };
1213 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1214 keys
[0], lengths
[0], 0, 0);
1215 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1217 memcached_result_st results_obj
;
1218 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1221 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1224 memcached_result_free(&results_obj
);
1226 /* Don't read out the second result, but issue a set instead.. */
1227 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1229 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1230 &rlen
, &flags
, &rc
);
1232 test_compare(MEMCACHED_NOTFOUND
, rc
);
1233 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1235 test_compare(MEMCACHED_SUCCESS
, rc
);
1238 return TEST_SUCCESS
;
1241 static test_return_t
mget_end(memcached_st
*memc
)
1243 const char *keys
[]= { "foo", "foo2" };
1244 size_t lengths
[]= { 3, 4 };
1245 const char *values
[]= { "fjord", "41" };
1247 memcached_return_t rc
;
1250 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1252 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[x
], lengths
[x
], values
[x
], strlen(values
[x
]), (time_t)0, (uint32_t)0));
1256 size_t string_length
;
1259 // retrieve both via mget
1260 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1262 char key
[MEMCACHED_MAX_KEY
];
1265 // this should get both
1266 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1268 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1270 test_compare(MEMCACHED_SUCCESS
, rc
);
1272 if (key_length
== 4)
1277 test_compare(string_length
, strlen(values
[val
]));
1278 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1282 // this should indicate end
1283 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1284 test_compare(MEMCACHED_END
, rc
);
1288 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1289 test_compare(MEMCACHED_SUCCESS
, rc
);
1291 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1292 test_compare(key_length
, lengths
[0]);
1293 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1294 test_compare(string_length
, strlen(values
[0]));
1295 test_true(strncmp(values
[0], string
, string_length
) == 0);
1296 test_compare(MEMCACHED_SUCCESS
, rc
);
1299 // this should indicate end
1300 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1301 test_compare(MEMCACHED_END
, rc
);
1304 return TEST_SUCCESS
;
1307 /* Do not copy the style of this code, I just access hosts to testthis function */
1308 static test_return_t
stats_servername_test(memcached_st
*memc
)
1310 memcached_stat_st memc_stat
;
1311 memcached_server_instance_st instance
=
1312 memcached_server_instance_by_position(memc
, 0);
1314 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1316 return TEST_SKIPPED
;
1319 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1320 memcached_server_name(instance
),
1321 memcached_server_port(instance
)));
1323 return TEST_SUCCESS
;
1326 static test_return_t
increment_test(memcached_st
*memc
)
1328 uint64_t new_number
;
1330 test_compare(MEMCACHED_SUCCESS
,
1332 test_literal_param("number"),
1333 test_literal_param("0"),
1334 (time_t)0, (uint32_t)0));
1336 test_compare(MEMCACHED_SUCCESS
,
1337 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1338 test_compare(uint64_t(1), new_number
);
1340 test_compare(MEMCACHED_SUCCESS
,
1341 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1342 test_compare(uint64_t(2), new_number
);
1344 return TEST_SUCCESS
;
1347 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1349 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1351 uint64_t new_number
;
1352 uint64_t initial
= 0;
1354 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1356 test_compare(MEMCACHED_SUCCESS
,
1357 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1358 test_compare(new_number
, initial
);
1360 test_compare(MEMCACHED_SUCCESS
,
1361 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1362 test_compare(new_number
, (initial
+1));
1364 return TEST_SUCCESS
;
1367 static test_return_t
decrement_test(memcached_st
*memc
)
1369 uint64_t new_number
;
1370 memcached_return_t rc
;
1371 const char *value
= "3";
1373 rc
= memcached_set(memc
,
1374 test_literal_param("number"),
1375 value
, strlen(value
),
1376 (time_t)0, (uint32_t)0);
1377 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1379 test_compare(MEMCACHED_SUCCESS
,
1380 memcached_decrement(memc
,
1381 test_literal_param("number"),
1383 test_compare(uint64_t(2), new_number
);
1385 test_compare(MEMCACHED_SUCCESS
,
1386 memcached_decrement(memc
,
1387 test_literal_param("number"),
1389 test_compare(uint64_t(1), new_number
);
1391 return TEST_SUCCESS
;
1394 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1396 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1398 uint64_t new_number
;
1399 uint64_t initial
= 3;
1401 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1403 test_compare(MEMCACHED_SUCCESS
,
1404 memcached_decrement_with_initial(memc
,
1405 test_literal_param("number"),
1406 1, initial
, 0, &new_number
));
1407 test_compare(new_number
, initial
);
1409 test_compare(MEMCACHED_SUCCESS
,
1410 memcached_decrement_with_initial(memc
,
1411 test_literal_param("number"),
1412 1, initial
, 0, &new_number
));
1413 test_compare(new_number
, (initial
- 1));
1415 return TEST_SUCCESS
;
1418 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1420 uint64_t new_number
;
1421 memcached_return_t rc
;
1422 const char *master_key
= "foo";
1423 const char *key
= "number";
1424 const char *value
= "0";
1426 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1428 value
, strlen(value
),
1429 (time_t)0, (uint32_t)0);
1430 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1432 test_compare(MEMCACHED_SUCCESS
,
1433 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1434 test_compare(uint64_t(1), new_number
);
1436 test_compare(MEMCACHED_SUCCESS
,
1437 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1438 test_compare(uint64_t(2), new_number
);
1440 return TEST_SUCCESS
;
1443 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1445 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1447 uint64_t new_number
;
1448 memcached_return_t rc
;
1449 const char *master_key
= "foo";
1450 const char *key
= "number";
1451 uint64_t initial
= 0;
1453 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1455 1, initial
, 0, &new_number
);
1456 test_compare(MEMCACHED_SUCCESS
, rc
);
1457 test_compare(new_number
, initial
);
1459 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1461 1, initial
, 0, &new_number
);
1462 test_compare(MEMCACHED_SUCCESS
, rc
);
1463 test_compare(new_number
, (initial
+1));
1465 return TEST_SUCCESS
;
1468 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1470 uint64_t new_number
;
1471 memcached_return_t rc
;
1472 const char *value
= "3";
1474 rc
= memcached_set_by_key(memc
,
1475 test_literal_param("foo"),
1476 test_literal_param("number"),
1477 value
, strlen(value
),
1478 (time_t)0, (uint32_t)0);
1479 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1481 test_compare(MEMCACHED_SUCCESS
,
1482 memcached_decrement_by_key(memc
,
1483 test_literal_param("foo"),
1484 test_literal_param("number"),
1486 test_compare(uint64_t(2), new_number
);
1488 test_compare(MEMCACHED_SUCCESS
,
1489 memcached_decrement_by_key(memc
,
1490 test_literal_param("foo"),
1491 test_literal_param("number"),
1493 test_compare(uint64_t(1), new_number
);
1495 return TEST_SUCCESS
;
1498 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1500 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1502 uint64_t new_number
;
1503 uint64_t initial
= 3;
1505 test_compare(MEMCACHED_SUCCESS
,
1506 memcached_decrement_with_initial_by_key(memc
,
1507 test_literal_param("foo"),
1508 test_literal_param("number"),
1509 1, initial
, 0, &new_number
));
1510 test_compare(new_number
, initial
);
1512 test_compare(MEMCACHED_SUCCESS
,
1513 memcached_decrement_with_initial_by_key(memc
,
1514 test_literal_param("foo"),
1515 test_literal_param("number"),
1516 1, initial
, 0, &new_number
));
1517 test_compare(new_number
, (initial
- 1));
1519 return TEST_SUCCESS
;
1521 static test_return_t
binary_increment_with_prefix_test(memcached_st
*orig_memc
)
1523 memcached_st
*memc
= memcached_clone(NULL
, orig_memc
);
1525 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1527 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1529 memcached_return_t rc
;
1530 rc
= memcached_set(memc
,
1531 test_literal_param("number"),
1532 test_literal_param("0"),
1533 (time_t)0, (uint32_t)0);
1534 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1536 uint64_t new_number
;
1537 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1538 test_literal_param("number"),
1540 test_compare(uint64_t(1), new_number
);
1542 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1543 test_literal_param("number"),
1545 test_compare(uint64_t(2), new_number
);
1546 memcached_free(memc
);
1548 return TEST_SUCCESS
;
1551 static test_return_t
quit_test(memcached_st
*memc
)
1553 memcached_return_t rc
;
1554 const char *key
= "fudge";
1555 const char *value
= "sanford and sun";
1557 rc
= memcached_set(memc
, key
, strlen(key
),
1558 value
, strlen(value
),
1559 (time_t)10, (uint32_t)3);
1560 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1561 memcached_quit(memc
);
1563 rc
= memcached_set(memc
, key
, strlen(key
),
1564 value
, strlen(value
),
1565 (time_t)50, (uint32_t)9);
1566 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1568 return TEST_SUCCESS
;
1571 static test_return_t
mget_result_test(memcached_st
*memc
)
1573 const char *keys
[]= {"fudge", "son", "food"};
1574 size_t key_length
[]= {5, 3, 4};
1576 memcached_result_st results_obj
;
1577 memcached_result_st
*results
;
1579 results
= memcached_result_create(memc
, &results_obj
);
1581 test_true(&results_obj
== results
);
1583 /* We need to empty the server before continueing test */
1584 test_compare(MEMCACHED_SUCCESS
,
1585 memcached_flush(memc
, 0));
1587 test_compare(MEMCACHED_SUCCESS
,
1588 memcached_mget(memc
, keys
, key_length
, 3));
1590 memcached_return_t rc
;
1591 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1596 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1597 test_false(results
);
1598 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1600 for (uint32_t x
= 0; x
< 3; x
++)
1602 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1603 keys
[x
], key_length
[x
],
1604 (time_t)50, (uint32_t)9);
1605 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1608 test_compare(MEMCACHED_SUCCESS
,
1609 memcached_mget(memc
, keys
, key_length
, 3));
1611 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1614 test_true(&results_obj
== results
);
1615 test_compare(MEMCACHED_SUCCESS
, rc
);
1616 test_memcmp(memcached_result_key_value(results
),
1617 memcached_result_value(results
),
1618 memcached_result_length(results
));
1619 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1622 memcached_result_free(&results_obj
);
1624 return TEST_SUCCESS
;
1627 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1629 const char *keys
[]= {"fudge", "son", "food"};
1630 size_t key_length
[]= {5, 3, 4};
1632 memcached_result_st
*results
;
1634 /* We need to empty the server before continueing test */
1635 test_compare(MEMCACHED_SUCCESS
,
1636 memcached_flush(memc
, 0));
1638 test_compare(MEMCACHED_SUCCESS
,
1639 memcached_mget(memc
, keys
, key_length
, 3));
1641 memcached_return_t rc
;
1642 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1646 test_false(results
);
1647 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1649 for (uint32_t x
= 0; x
< 3; x
++)
1651 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1652 keys
[x
], key_length
[x
],
1653 (time_t)50, (uint32_t)9);
1654 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1657 test_compare(MEMCACHED_SUCCESS
,
1658 memcached_mget(memc
, keys
, key_length
, 3));
1661 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1664 test_compare(MEMCACHED_SUCCESS
, rc
);
1665 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1666 test_memcmp(memcached_result_key_value(results
),
1667 memcached_result_value(results
),
1668 memcached_result_length(results
));
1669 memcached_result_free(results
);
1673 return TEST_SUCCESS
;
1676 /* Count the results */
1677 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1679 size_t *counter
= (size_t *)context
;
1681 *counter
= *counter
+ 1;
1683 return MEMCACHED_SUCCESS
;
1686 static test_return_t
mget_result_function(memcached_st
*memc
)
1688 const char *keys
[]= {"fudge", "son", "food"};
1689 size_t key_length
[]= {5, 3, 4};
1691 memcached_execute_fn callbacks
[1];
1693 /* We need to empty the server before continueing test */
1694 test_compare(MEMCACHED_SUCCESS
,
1695 memcached_flush(memc
, 0));
1696 for (uint32_t x
= 0; x
< 3; x
++)
1698 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1699 keys
[x
], key_length
[x
],
1700 (time_t)50, (uint32_t)9);
1701 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1704 test_compare(MEMCACHED_SUCCESS
,
1705 memcached_mget(memc
, keys
, key_length
, 3));
1707 callbacks
[0]= &callback_counter
;
1710 test_compare(MEMCACHED_SUCCESS
,
1711 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1713 test_compare(size_t(3), counter
);
1715 return TEST_SUCCESS
;
1718 static test_return_t
mget_test(memcached_st
*memc
)
1720 const char *keys
[]= {"fudge", "son", "food"};
1721 size_t key_length
[]= {5, 3, 4};
1723 char return_key
[MEMCACHED_MAX_KEY
];
1724 size_t return_key_length
;
1726 size_t return_value_length
;
1728 /* We need to empty the server before continueing test */
1729 test_compare(MEMCACHED_SUCCESS
,
1730 memcached_flush(memc
, 0));
1732 test_compare(MEMCACHED_SUCCESS
,
1733 memcached_mget(memc
, keys
, key_length
, 3));
1736 memcached_return_t rc
;
1737 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1738 &return_value_length
, &flags
, &rc
)))
1740 test_true(return_value
);
1742 test_false(return_value
);
1743 test_zero(return_value_length
);
1744 test_compare(MEMCACHED_NOTFOUND
, rc
);
1746 for (uint32_t x
= 0; x
< 3; x
++)
1748 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1749 keys
[x
], key_length
[x
],
1750 (time_t)50, (uint32_t)9);
1751 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1753 test_compare(MEMCACHED_SUCCESS
,
1754 memcached_mget(memc
, keys
, key_length
, 3));
1757 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1758 &return_value_length
, &flags
, &rc
)))
1760 test_true(return_value
);
1761 test_compare(MEMCACHED_SUCCESS
, rc
);
1762 if (not memc
->_namespace
)
1764 test_compare(return_key_length
, return_value_length
);
1765 test_memcmp(return_value
, return_key
, return_value_length
);
1771 return TEST_SUCCESS
;
1774 static test_return_t
mget_execute(memcached_st
*original_memc
)
1776 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1778 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
1781 size_t max_keys
= 20480;
1784 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1785 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1787 /* First add all of the items.. */
1788 char blob
[1024] = {0};
1790 for (size_t x
= 0; x
< max_keys
; ++x
)
1794 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1796 test_true(keys
[x
] != NULL
);
1797 uint64_t query_id
= memcached_query_id(memc
);
1798 memcached_return_t rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1799 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1800 test_compare(query_id
+1, memcached_query_id(memc
));
1803 /* Try to get all of them with a large multiget */
1805 memcached_execute_fn callbacks
[]= { &callback_counter
};
1806 test_compare(MEMCACHED_SUCCESS
,
1807 memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1808 max_keys
, callbacks
, &counter
, 1));
1811 uint64_t query_id
= memcached_query_id(memc
);
1812 test_compare(MEMCACHED_SUCCESS
,
1813 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1814 test_compare(query_id
, memcached_query_id(memc
));
1816 /* Verify that we got all of the items */
1817 test_true(counter
== max_keys
);
1820 /* Release all allocated resources */
1821 for (size_t x
= 0; x
< max_keys
; ++x
)
1828 memcached_free(memc
);
1830 return TEST_SUCCESS
;
1833 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1835 static test_return_t
key_setup(memcached_st
*memc
)
1837 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1839 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1841 return TEST_SUCCESS
;
1844 static test_return_t
key_teardown(memcached_st
*memc
)
1847 pairs_free(global_pairs
);
1849 return TEST_SUCCESS
;
1852 static test_return_t
block_add_regression(memcached_st
*memc
)
1854 /* First add all of the items.. */
1855 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1857 memcached_return_t rc
;
1858 char blob
[1024] = {0};
1860 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1861 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1864 return TEST_SUCCESS
;
1867 static test_return_t
binary_add_regression(memcached_st
*memc
)
1869 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1870 test_return_t rc
= block_add_regression(memc
);
1871 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1875 static test_return_t
get_stats_keys(memcached_st
*memc
)
1879 memcached_stat_st memc_stat
;
1880 memcached_return_t rc
;
1882 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1883 test_compare(MEMCACHED_SUCCESS
, rc
);
1884 for (ptr
= stat_list
; *ptr
; ptr
++)
1889 return TEST_SUCCESS
;
1892 static test_return_t
version_string_test(memcached_st
*)
1894 test_strcmp(LIBMEMCACHED_VERSION_STRING
, memcached_lib_version());
1896 return TEST_SUCCESS
;
1899 static test_return_t
get_stats(memcached_st
*memc
)
1901 memcached_return_t rc
;
1903 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1904 test_compare(MEMCACHED_SUCCESS
, rc
);
1905 test_true(memc_stat
);
1907 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1909 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1910 test_compare(MEMCACHED_SUCCESS
, rc
);
1911 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1916 memcached_stat_free(NULL
, memc_stat
);
1918 return TEST_SUCCESS
;
1921 static test_return_t
add_host_test(memcached_st
*memc
)
1923 char servername
[]= "0.example.com";
1925 memcached_return_t rc
;
1926 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1927 test_compare(1U, memcached_server_list_count(servers
));
1929 for (unsigned int x
= 2; x
< 20; x
++)
1931 char buffer
[SMALL_STRING_LEN
];
1933 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1934 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1936 test_compare(MEMCACHED_SUCCESS
, rc
);
1937 test_compare(x
, memcached_server_list_count(servers
));
1940 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1941 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
1943 memcached_server_list_free(servers
);
1945 return TEST_SUCCESS
;
1948 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1950 memcached_return_t rc
;
1952 const char *key
= "not_found";
1953 size_t key_length
= test_literal_param_size("not_found");
1955 test_compare(MEMCACHED_SUCCESS
,
1956 memcached_mget(memc
, &key
, &key_length
, 1));
1958 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
1960 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1962 memcached_result_free(result
);
1964 return TEST_SUCCESS
;
1967 static memcached_return_t
clone_test_callback(memcached_st
*, memcached_st
*)
1969 return MEMCACHED_SUCCESS
;
1972 static memcached_return_t
cleanup_test_callback(memcached_st
*)
1974 return MEMCACHED_SUCCESS
;
1977 static test_return_t
callback_test(memcached_st
*memc
)
1979 /* Test User Data */
1983 memcached_return_t rc
;
1985 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
));
1986 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1987 test_true(*test_ptr
== x
);
1990 /* Test Clone Callback */
1992 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
1993 void *clone_cb_ptr
= *(void **)&clone_cb
;
1994 void *temp_function
= NULL
;
1996 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, clone_cb_ptr
));
1997 memcached_return_t rc
;
1998 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
1999 test_true(temp_function
== clone_cb_ptr
);
2000 test_compare(MEMCACHED_SUCCESS
, rc
);
2003 /* Test Cleanup Callback */
2005 memcached_cleanup_fn cleanup_cb
= (memcached_cleanup_fn
)cleanup_test_callback
;
2006 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2007 void *temp_function
= NULL
;
2008 memcached_return_t rc
;
2010 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, cleanup_cb_ptr
));
2011 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2012 test_true(temp_function
== cleanup_cb_ptr
);
2015 return TEST_SUCCESS
;
2018 /* We don't test the behavior itself, we test the switches */
2019 static test_return_t
behavior_test(memcached_st
*memc
)
2021 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
2022 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2024 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
2025 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2027 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
2028 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2030 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
2031 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
2033 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
2034 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
2036 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
2037 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2039 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
2040 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
2042 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
2044 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
2046 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2047 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
2048 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2050 return TEST_SUCCESS
;
2053 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2055 test_compare(MEMCACHED_DEPRECATED
,
2056 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
2058 // Platform dependent
2060 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2064 return TEST_SUCCESS
;
2068 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2070 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
2071 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2073 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2075 if (memcached_success(rc
))
2084 return TEST_SUCCESS
;
2088 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2090 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
2091 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2093 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2095 if (memcached_success(rc
))
2104 return TEST_SUCCESS
;
2107 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, const memcached_return_t expect
)
2109 memcached_return_t rc
;
2110 char return_key
[MEMCACHED_MAX_KEY
];
2111 size_t return_key_length
;
2113 size_t return_value_length
;
2117 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2118 &return_value_length
, &flags
, &rc
)))
2120 test_true(return_value
);
2121 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2126 if (memcached_success(expect
) and memcached_success(rc
))
2128 return TEST_SUCCESS
;
2130 else if (expect
== rc
)
2132 return TEST_SUCCESS
;
2134 fprintf(stderr
, "\n%s:%u %s(#%u)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), keys_returned
);
2136 return TEST_FAILURE
;
2139 /* Test case provided by Cal Haldenbrand */
2140 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2141 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2142 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2144 /* We just keep looking at the same values over and over */
2147 test_compare(MEMCACHED_SUCCESS
,
2148 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2149 test_compare(MEMCACHED_SUCCESS
,
2150 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2154 unsigned long long total
= 0;
2155 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2157 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2158 char randomstuff
[6 * 1024];
2159 memset(randomstuff
, 0, 6 * 1024);
2160 test_true(size
< 6 * 1024); /* Being safe here */
2162 for (uint32_t j
= 0 ; j
< size
;j
++)
2164 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2169 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2170 test_compare(MEMCACHED_SUCCESS
,
2171 memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
));
2173 test_true(total
> HALDENBRAND_KEY_COUNT
);
2175 return TEST_SUCCESS
;
2178 /* Test case provided by Cal Haldenbrand */
2179 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2181 test_compare(MEMCACHED_SUCCESS
,
2182 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true));
2184 test_compare(MEMCACHED_SUCCESS
,
2185 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
2188 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576));
2189 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576));
2190 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2191 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2193 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2196 size_t total_value_length
= 0;
2197 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2202 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2203 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2205 memcached_return_t rc
;
2206 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2207 if (memcached_failed(rc
))
2209 if (rc
== MEMCACHED_NOTFOUND
)
2220 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2222 total_value_length
+= val_len
;
2227 return TEST_SUCCESS
;
2230 /* Do a large mget() over all the keys we think exist */
2231 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2233 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1));
2234 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
2237 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, 20 * 1024576);
2238 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, 20 * 1024576);
2239 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2240 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2243 size_t key_lengths
[HALDENBRAND_KEY_COUNT
];
2244 char **keys
= static_cast<char **>(calloc(HALDENBRAND_KEY_COUNT
, sizeof(char *)));
2246 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2248 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2249 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2250 test_true(key_length
);
2251 keys
[x
]= strdup(key
);
2253 key_lengths
[x
]= key_length
;
2254 test_compare(size_t(key_length
), strlen(keys
[x
]));
2257 test_compare(MEMCACHED_SUCCESS
,
2258 memcached_mget(memc
, (const char **)keys
, key_lengths
, HALDENBRAND_KEY_COUNT
));
2260 unsigned int keys_returned
;
2261 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
2262 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2264 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2270 return TEST_SUCCESS
;
2273 /* Make sure we behave properly if server list has no values */
2274 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2276 const char *keys
[]= {"fudge", "son", "food"};
2277 size_t key_length
[]= {5, 3, 4};
2279 /* Here we free everything before running a bunch of mget tests */
2280 memcached_servers_reset(memc
);
2283 /* We need to empty the server before continueing test */
2284 test_compare(MEMCACHED_NO_SERVERS
,
2285 memcached_flush(memc
, 0));
2287 test_compare(MEMCACHED_NO_SERVERS
,
2288 memcached_mget(memc
, keys
, key_length
, 3));
2290 unsigned int keys_returned
;
2291 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2292 test_zero(keys_returned
);
2294 for (uint32_t x
= 0; x
< 3; x
++)
2296 test_compare(MEMCACHED_NO_SERVERS
,
2297 memcached_set(memc
, keys
[x
], key_length
[x
],
2298 keys
[x
], key_length
[x
],
2299 (time_t)50, (uint32_t)9));
2302 test_compare(MEMCACHED_NO_SERVERS
,
2303 memcached_mget(memc
, keys
, key_length
, 3));
2307 char return_key
[MEMCACHED_MAX_KEY
];
2308 memcached_return_t rc
;
2309 size_t return_key_length
;
2310 size_t return_value_length
;
2313 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2314 &return_value_length
, &flags
, &rc
)))
2316 test_true(return_value
);
2317 test_compare(MEMCACHED_SUCCESS
, rc
);
2318 test_true(return_key_length
== return_value_length
);
2319 test_memcmp(return_value
, return_key
, return_value_length
);
2325 return TEST_SUCCESS
;
2328 #define VALUE_SIZE_BUG5 1048064
2329 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2331 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2332 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2334 size_t value_length
;
2336 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2338 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2340 insert_data
[x
]= (signed char)rand();
2343 test_compare(MEMCACHED_SUCCESS
,
2344 memcached_flush(memc
, 0));
2346 memcached_return_t rc
;
2347 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
2348 test_compare(MEMCACHED_SUCCESS
,
2349 memcached_mget(memc
, keys
, key_length
, 4));
2352 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2355 for (uint32_t x
= 0; x
< 4; x
++)
2357 test_compare(MEMCACHED_SUCCESS
,
2358 memcached_set(memc
, keys
[x
], key_length
[x
],
2359 insert_data
, VALUE_SIZE_BUG5
,
2360 (time_t)0, (uint32_t)0));
2363 for (uint32_t x
= 0; x
< 10; x
++)
2365 value
= memcached_get(memc
, keys
[0], key_length
[0],
2366 &value_length
, &flags
, &rc
);
2367 test_compare(rc
, MEMCACHED_SUCCESS
);
2371 test_compare(MEMCACHED_SUCCESS
,
2372 memcached_mget(memc
, keys
, key_length
, 4));
2374 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2375 test_compare(4U, count
);
2377 delete [] insert_data
;
2379 return TEST_SUCCESS
;
2382 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2384 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2385 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2386 char return_key
[MEMCACHED_MAX_KEY
];
2387 size_t return_key_length
;
2389 size_t value_length
;
2391 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2393 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2395 insert_data
[x
]= (signed char)rand();
2398 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2400 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2402 // We will now confirm that memcached_mget() returns success, but we will
2403 // then check to make sure that no actual keys are returned.
2404 test_compare(MEMCACHED_SUCCESS
,
2405 memcached_mget(memc
, keys
, key_length
, 4));
2407 memcached_return_t rc
;
2409 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2410 &value_length
, &flags
, &rc
)))
2415 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2417 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2419 test_compare(MEMCACHED_SUCCESS
,
2420 memcached_set(memc
, keys
[x
], key_length
[x
],
2421 insert_data
, VALUE_SIZE_BUG5
,
2422 (time_t)0, (uint32_t)0));
2424 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2426 for (uint32_t x
= 0; x
< 2; x
++)
2428 value
= memcached_get(memc
, keys
[0], key_length
[0],
2429 &value_length
, &flags
, &rc
);
2433 test_compare(MEMCACHED_SUCCESS
,
2434 memcached_mget(memc
, keys
, key_length
, 4));
2435 /* We test for purge of partial complete fetches */
2436 for (count
= 3; count
; count
--)
2438 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2439 &value_length
, &flags
, &rc
);
2440 test_compare(MEMCACHED_SUCCESS
, rc
);
2441 test_memcmp(value
, insert_data
, value_length
);
2442 test_true(value_length
);
2446 delete [] insert_data
;
2448 return TEST_SUCCESS
;
2451 static test_return_t
user_supplied_bug8(memcached_st
*)
2453 memcached_return_t rc
;
2455 memcached_st
*memc_clone
;
2457 memcached_server_st
*servers
;
2458 const char *server_list
= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
2460 servers
= memcached_servers_parse(server_list
);
2463 mine
= memcached_create(NULL
);
2464 rc
= memcached_server_push(mine
, servers
);
2465 test_compare(MEMCACHED_SUCCESS
, rc
);
2466 memcached_server_list_free(servers
);
2469 memc_clone
= memcached_clone(NULL
, mine
);
2471 memcached_quit(mine
);
2472 memcached_quit(memc_clone
);
2475 memcached_free(mine
);
2476 memcached_free(memc_clone
);
2478 return TEST_SUCCESS
;
2481 /* Test flag store/retrieve */
2482 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2484 const char *keys
= "036790384900";
2485 size_t key_length
= strlen(keys
);
2486 char return_key
[MEMCACHED_MAX_KEY
];
2487 size_t return_key_length
;
2489 size_t value_length
;
2491 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2493 for (unsigned int x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2495 insert_data
[x
]= (signed char)rand();
2498 memcached_flush(memc
, 0);
2501 memcached_return_t rc
= memcached_set(memc
, keys
, key_length
,
2502 insert_data
, VALUE_SIZE_BUG5
,
2504 test_compare(MEMCACHED_SUCCESS
, rc
);
2507 value
= memcached_get(memc
, keys
, key_length
,
2508 &value_length
, &flags
, &rc
);
2509 test_compare(245U, flags
);
2513 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
2516 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2517 &value_length
, &flags
, &rc
);
2518 test_compare(uint32_t(245), flags
);
2521 delete [] insert_data
;
2524 return TEST_SUCCESS
;
2527 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2529 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2530 size_t key_length
[3];
2534 char return_key
[MEMCACHED_MAX_KEY
];
2535 size_t return_key_length
;
2537 size_t return_value_length
;
2540 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2541 key_length
[1]= strlen("fudge&*@#");
2542 key_length
[2]= strlen("for^#@&$not");
2545 for (unsigned int x
= 0; x
< 3; x
++)
2547 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2548 keys
[x
], key_length
[x
],
2549 (time_t)50, (uint32_t)9);
2550 test_compare(MEMCACHED_SUCCESS
, rc
);
2553 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2554 test_compare(MEMCACHED_SUCCESS
, rc
);
2556 /* We need to empty the server before continueing test */
2557 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2558 &return_value_length
, &flags
, &rc
)) != NULL
)
2560 test_true(return_value
);
2564 test_compare(3U, count
);
2566 return TEST_SUCCESS
;
2569 /* We are testing with aggressive timeout to get failures */
2570 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2572 size_t value_length
= 512;
2573 unsigned int set
= 1;
2574 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2576 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2577 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2578 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2580 std::vector
<char> value
;
2581 value
.reserve(value_length
);
2582 for (uint32_t x
= 0; x
< value_length
; x
++)
2584 value
.push_back(char(x
% 127));
2587 for (unsigned int x
= 1; x
<= 100000; ++x
)
2589 memcached_return_t rc
= memcached_set(mclone
,
2590 test_literal_param("foo"),
2591 &value
[0], value
.size(),
2594 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2595 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2596 memcached_strerror(NULL
, rc
));
2598 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2604 memcached_free(mclone
);
2606 return TEST_SUCCESS
;
2610 We are looking failures in the async protocol
2612 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2614 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2616 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
2617 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2618 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
2620 test_compare(-1, int32_t(memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
2623 std::vector
<char> value
;
2625 for (unsigned int x
= 0; x
< 512; x
++)
2627 value
.push_back(char(x
% 127));
2630 for (unsigned int x
= 1; x
<= 100000; ++x
)
2632 memcached_return_t rc
= memcached_set(mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
2636 memcached_free(mclone
);
2638 return TEST_SUCCESS
;
2642 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2644 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2646 memcached_return_t rc
;
2648 size_t value_length
;
2650 uint64_t number_value
;
2652 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2653 &value_length
, &flags
, &rc
);
2654 test_true(value
== NULL
);
2655 test_compare(MEMCACHED_NOTFOUND
, rc
);
2657 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2659 test_true(value
== NULL
);
2660 /* The binary protocol will set the key if it doesn't exist */
2661 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2663 test_compare(MEMCACHED_SUCCESS
, rc
);
2667 test_compare(MEMCACHED_NOTFOUND
, rc
);
2670 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2672 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2673 &value_length
, &flags
, &rc
);
2675 test_compare(MEMCACHED_SUCCESS
, rc
);
2678 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2680 test_true(number_value
== 2);
2681 test_compare(MEMCACHED_SUCCESS
, rc
);
2683 return TEST_SUCCESS
;
2687 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2688 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2690 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2692 char key
[] = "key34567890";
2693 memcached_return_t rc
;
2694 size_t overflowSize
;
2696 char commandFirst
[]= "set key34567890 0 0 ";
2697 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2698 size_t commandLength
;
2701 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2703 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2705 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2707 char *overflow
= new (std::nothrow
) char[testSize
];
2708 test_true(overflow
);
2710 memset(overflow
, 'x', testSize
);
2711 rc
= memcached_set(memc
, key
, strlen(key
),
2712 overflow
, testSize
, 0, 0);
2713 test_compare(MEMCACHED_SUCCESS
, rc
);
2717 return TEST_SUCCESS
;
2722 Test values of many different sizes
2723 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2724 set key34567890 0 0 8169 \r\n
2725 is sent followed by buffer of size 8169, followed by 8169
2727 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2729 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2731 std::vector
<char> value
;
2732 value
.reserve(18000);
2733 for (size_t x
= 0; x
< 18000; x
++)
2735 value
.push_back((char) (x
% 127));
2738 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2740 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2741 &value
[0], current_length
,
2742 (time_t)0, (uint32_t)0);
2743 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2745 size_t string_length
;
2747 char *string
= memcached_get(memc
, test_literal_param("foo"),
2748 &string_length
, &flags
, &rc
);
2750 test_compare(MEMCACHED_SUCCESS
, rc
);
2751 test_compare(string_length
, current_length
);
2752 test_memcmp(string
, &value
[0], string_length
);
2757 return TEST_SUCCESS
;
2761 Look for zero length value problems
2763 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2765 for (uint32_t x
= 0; x
< 2; x
++)
2767 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2769 (time_t)0, (uint32_t)0);
2771 test_compare(MEMCACHED_SUCCESS
, rc
);
2775 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2776 &length
, &flags
, &rc
);
2778 test_compare(MEMCACHED_SUCCESS
, rc
);
2783 value
= memcached_get(memc
, test_literal_param("mykey"),
2784 &length
, &flags
, &rc
);
2786 test_compare(MEMCACHED_SUCCESS
, rc
);
2787 test_true(value
== NULL
);
2792 return TEST_SUCCESS
;
2795 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2796 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2798 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2800 (time_t)0, UINT32_MAX
);
2802 test_compare(MEMCACHED_SUCCESS
, rc
);
2806 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2807 &length
, &flags
, &rc
);
2809 test_compare(MEMCACHED_SUCCESS
, rc
);
2810 test_true(value
== NULL
);
2812 test_compare(flags
, UINT32_MAX
);
2814 return TEST_SUCCESS
;
2817 #if !defined(__sun) && !defined(__OpenBSD__)
2818 /* Check the validity of chinese key*/
2819 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2821 const char *key
= "豆瓣";
2822 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2823 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2824 value
, strlen(value
),
2827 test_compare(MEMCACHED_SUCCESS
, rc
);
2831 char *value2
= memcached_get(memc
, key
, strlen(key
),
2832 &length
, &flags
, &rc
);
2834 test_true(length
==strlen(value
));
2835 test_compare(MEMCACHED_SUCCESS
, rc
);
2836 test_memcmp(value
, value2
, length
);
2839 return TEST_SUCCESS
;
2847 static test_return_t
user_supplied_bug19(memcached_st
*)
2849 memcached_return_t res
;
2851 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2853 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2856 memcached_free(memc
);
2858 return TEST_SUCCESS
;
2861 /* CAS test from Andei */
2862 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2864 const char *key
= "abc";
2865 size_t key_len
= strlen("abc");
2867 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2869 test_compare(MEMCACHED_SUCCESS
,
2871 test_literal_param("abc"),
2872 test_literal_param("foobar"),
2873 (time_t)0, (uint32_t)0));
2875 test_compare(MEMCACHED_SUCCESS
,
2876 memcached_mget(memc
, &key
, &key_len
, 1));
2878 memcached_result_st result_obj
;
2879 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2882 memcached_result_create(memc
, &result_obj
);
2883 memcached_return_t status
;
2884 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2887 test_compare(MEMCACHED_SUCCESS
, status
);
2889 memcached_result_free(result
);
2891 return TEST_SUCCESS
;
2894 /* Large mget() of missing keys with binary proto
2896 * If many binary quiet commands (such as getq's in an mget) fill the output
2897 * buffer and the server chooses not to respond, memcached_flush hangs. See
2898 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2901 /* sighandler_t function that always asserts false */
2902 static void fail(int)
2908 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2913 return TEST_SKIPPED
;
2915 void (*oldalarm
)(int);
2917 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2918 test_true(memc_clone
);
2920 /* only binproto uses getq for mget */
2921 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2923 /* empty the cache to ensure misses (hence non-responses) */
2924 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2926 size_t* key_lengths
= new (std::nothrow
) size_t[key_count
];
2927 test_true(key_lengths
);
2928 char **keys
= static_cast<char **>(calloc(key_count
, sizeof(char *)));
2930 for (unsigned int x
= 0; x
< key_count
; x
++)
2934 snprintf(buffer
, 30, "%u", x
);
2935 keys
[x
]= strdup(buffer
);
2937 key_lengths
[x
]= strlen(keys
[x
]);
2940 oldalarm
= signal(SIGALRM
, fail
);
2943 test_compare_got(MEMCACHED_SUCCESS
,
2944 memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
), memcached_last_error_message(memc_clone
));
2947 signal(SIGALRM
, oldalarm
);
2949 memcached_return_t rc
;
2951 char return_key
[MEMCACHED_MAX_KEY
];
2952 size_t return_key_length
;
2954 size_t return_value_length
;
2955 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2956 &return_value_length
, &flags
, &rc
)))
2958 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
2960 test_compare(MEMCACHED_NOTFOUND
, rc
);
2961 test_zero(return_value_length
);
2962 test_zero(return_key_length
);
2963 test_false(return_key
[0]);
2964 test_false(return_value
);
2966 for (unsigned int x
= 0; x
< key_count
; x
++)
2971 delete [] key_lengths
;
2973 memcached_free(memc_clone
);
2975 return TEST_SUCCESS
;
2979 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
2981 test_skip(TEST_SUCCESS
, pre_binary(memc
));
2983 /* should work as of r580 */
2984 test_compare(TEST_SUCCESS
,
2985 _user_supplied_bug21(memc
, 10));
2987 /* should fail as of r580 */
2988 test_compare(TEST_SUCCESS
,
2989 _user_supplied_bug21(memc
, 1000));
2991 return TEST_SUCCESS
;
2994 static test_return_t
output_ketama_weighted_keys(memcached_st
*)
2996 memcached_st
*memc
= memcached_create(NULL
);
3000 test_compare(MEMCACHED_SUCCESS
,
3001 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
3003 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3004 test_compare(value
, uint64_t(1));
3006 test_compare(MEMCACHED_SUCCESS
,
3007 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3009 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3010 test_true(value
== MEMCACHED_HASH_MD5
);
3013 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3015 memcached_server_st
*server_pool
;
3016 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");
3017 memcached_server_push(memc
, server_pool
);
3019 // @todo this needs to be refactored to actually test something.
3022 if ((fp
= fopen("ketama_keys.txt", "w")))
3026 printf("cannot write to file ketama_keys.txt");
3027 return TEST_FAILURE
;
3030 for (int x
= 0; x
< 10000; x
++)
3033 snprintf(key
, sizeof(key
), "%d", x
);
3035 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3036 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3037 in_port_t port
= memc
->hosts
[server_idx
].port
;
3038 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3039 memcached_server_instance_st instance
=
3040 memcached_server_instance_by_position(memc
, host_index
);
3044 memcached_server_list_free(server_pool
);
3045 memcached_free(memc
);
3047 return TEST_SUCCESS
;
3051 static test_return_t
result_static(memcached_st
*memc
)
3053 memcached_result_st result
;
3054 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3055 test_false(result
.options
.is_allocated
);
3056 test_true(memcached_is_initialized(&result
));
3057 test_true(result_ptr
);
3058 test_true(result_ptr
== &result
);
3060 memcached_result_free(&result
);
3062 test_false(result
.options
.is_allocated
);
3063 test_false(memcached_is_initialized(&result
));
3065 return TEST_SUCCESS
;
3068 static test_return_t
result_alloc(memcached_st
*memc
)
3070 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3071 test_true(result_ptr
);
3072 test_true(result_ptr
->options
.is_allocated
);
3073 test_true(memcached_is_initialized(result_ptr
));
3074 memcached_result_free(result_ptr
);
3076 return TEST_SUCCESS
;
3079 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3082 pairs_free(global_pairs
);
3084 return TEST_SUCCESS
;
3087 static test_return_t
generate_pairs(memcached_st
*)
3089 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3090 global_count
= GLOBAL_COUNT
;
3092 for (size_t x
= 0; x
< global_count
; x
++)
3094 global_keys
[x
]= global_pairs
[x
].key
;
3095 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3098 return TEST_SUCCESS
;
3101 static test_return_t
generate_large_pairs(memcached_st
*)
3103 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3104 global_count
= GLOBAL2_COUNT
;
3106 for (size_t x
= 0; x
< global_count
; x
++)
3108 global_keys
[x
]= global_pairs
[x
].key
;
3109 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3112 return TEST_SUCCESS
;
3115 static test_return_t
generate_data(memcached_st
*memc
)
3117 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3119 test_compare(check_execute
, global_count
);
3121 return TEST_SUCCESS
;
3124 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3126 uint32_t host_index
= 0;
3127 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3129 test_true(check_execute
== global_count
);
3131 // @todo hosts used size stats
3132 memcached_return_t rc
;
3133 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3136 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3138 /* This test was changes so that "make test" would work properlly */
3141 memcached_server_instance_st instance
=
3142 memcached_server_instance_by_position(memc
, host_index
);
3144 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3146 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3149 memcached_stat_free(NULL
, stat_p
);
3151 return TEST_SUCCESS
;
3153 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3155 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3156 generate_data(memc
);
3158 return TEST_SUCCESS
;
3161 static test_return_t
get_read_count(memcached_st
*memc
)
3163 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3164 test_true(memc_clone
);
3166 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3170 size_t return_value_length
;
3174 for (size_t x
= count
= 0; x
< global_count
; x
++)
3176 memcached_return_t rc
;
3177 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3178 &return_value_length
, &flags
, &rc
);
3179 if (rc
== MEMCACHED_SUCCESS
)
3190 memcached_free(memc_clone
);
3192 return TEST_SUCCESS
;
3195 static test_return_t
get_read(memcached_st
*memc
)
3197 for (size_t x
= 0; x
< global_count
; x
++)
3199 size_t return_value_length
;
3201 memcached_return_t rc
;
3202 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3203 &return_value_length
, &flags
, &rc
);
3205 test_true(return_value);
3206 test_compare(MEMCACHED_SUCCESS, rc);
3208 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3214 return TEST_SUCCESS
;
3217 static test_return_t
mget_read(memcached_st
*memc
)
3220 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3222 test_compare(MEMCACHED_SUCCESS
,
3223 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3225 // Go fetch the keys and test to see if all of them were returned
3227 unsigned int keys_returned
;
3228 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3229 test_true(keys_returned
> 0);
3230 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3233 return TEST_SUCCESS
;
3236 static test_return_t
mget_read_result(memcached_st
*memc
)
3239 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3241 test_compare(MEMCACHED_SUCCESS
,
3242 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3244 /* Turn this into a help function */
3246 memcached_result_st results_obj
;
3247 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3250 memcached_return_t rc
;
3251 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3253 if (rc
== MEMCACHED_IN_PROGRESS
)
3259 test_compare(MEMCACHED_SUCCESS
, rc
);
3261 test_compare(MEMCACHED_END
, rc
);
3263 memcached_result_free(&results_obj
);
3266 return TEST_SUCCESS
;
3269 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3272 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3274 test_compare(MEMCACHED_SUCCESS
,
3275 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3277 memcached_result_st
*results
= NULL
;
3278 memcached_return_t rc
;
3279 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3282 test_compare(MEMCACHED_SUCCESS
, rc
);
3284 test_compare(MEMCACHED_END
, rc
);
3286 memcached_result_free(results
);
3289 return TEST_SUCCESS
;
3292 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3295 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3297 test_compare(MEMCACHED_SUCCESS
,
3298 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3300 // We will scan for just one key
3302 memcached_result_st results_obj
;
3303 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3305 memcached_return_t rc
;
3306 results
= memcached_fetch_result(memc
, results
, &rc
);
3308 test_compare(MEMCACHED_SUCCESS
, rc
);
3310 memcached_result_free(&results_obj
);
3313 // We already have a read happening, lets start up another one.
3314 test_compare(MEMCACHED_SUCCESS
,
3315 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3317 memcached_result_st results_obj
;
3318 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3320 test_false(memcached_is_allocated(results
));
3322 memcached_return_t rc
;
3323 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3326 test_compare(MEMCACHED_SUCCESS
, rc
);
3328 test_compare(MEMCACHED_END
, rc
);
3330 memcached_result_free(&results_obj
);
3333 return TEST_SUCCESS
;
3336 static test_return_t
mget_read_function(memcached_st
*memc
)
3338 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3340 test_compare(MEMCACHED_SUCCESS
,
3341 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3343 memcached_execute_fn callbacks
[]= { &callback_counter
};
3345 test_compare(MEMCACHED_SUCCESS
,
3346 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3348 return TEST_SUCCESS
;
3351 static test_return_t
delete_generate(memcached_st
*memc
)
3353 for (size_t x
= 0; x
< global_count
; x
++)
3355 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3358 return TEST_SUCCESS
;
3361 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3363 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3365 for (size_t x
= 0; x
< global_count
; x
++)
3367 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3370 return TEST_SUCCESS
;
3373 static test_return_t
add_host_test1(memcached_st
*memc
)
3375 memcached_return_t rc
;
3376 char servername
[]= "0.example.com";
3378 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3380 test_compare(1U, memcached_server_list_count(servers
));
3382 for (uint32_t x
= 2; x
< 20; x
++)
3384 char buffer
[SMALL_STRING_LEN
];
3386 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3387 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3389 test_compare(MEMCACHED_SUCCESS
, rc
);
3390 test_compare(x
, memcached_server_list_count(servers
));
3393 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3394 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3396 memcached_server_list_free(servers
);
3398 return TEST_SUCCESS
;
3401 static test_return_t
pre_nonblock(memcached_st
*memc
)
3403 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3405 return TEST_SUCCESS
;
3408 static test_return_t
pre_cork(memcached_st
*memc
)
3411 return TEST_SKIPPED
;
3414 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3415 return TEST_SUCCESS
;
3417 return TEST_SKIPPED
;
3420 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3423 return TEST_SKIPPED
;
3425 test_return_t test_rc
;
3426 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3429 return pre_nonblock(memc
);
3432 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3434 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3435 test_true(memc_clone
);
3437 // The memcached_version needs to be done on a clone, because the server
3438 // will not toggle protocol on an connection.
3439 memcached_version(memc_clone
);
3441 memcached_return_t rc
= MEMCACHED_FAILURE
;
3442 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3444 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3445 test_compare(MEMCACHED_SUCCESS
,
3446 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3447 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3451 memcached_free(memc_clone
);
3452 return TEST_SKIPPED
;
3455 memcached_free(memc_clone
);
3457 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3460 static test_return_t
pre_murmur(memcached_st
*memc
)
3462 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3463 return TEST_SUCCESS
;
3466 static test_return_t
pre_jenkins(memcached_st
*memc
)
3468 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3470 return TEST_SUCCESS
;
3474 static test_return_t
pre_md5(memcached_st
*memc
)
3476 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3478 return TEST_SUCCESS
;
3481 static test_return_t
pre_crc(memcached_st
*memc
)
3483 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3485 return TEST_SUCCESS
;
3488 static test_return_t
pre_hsieh(memcached_st
*memc
)
3490 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
));
3491 return TEST_SUCCESS
;
3494 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3496 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3498 return TEST_SUCCESS
;
3501 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3503 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
));
3505 return TEST_SUCCESS
;
3508 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3510 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3512 return TEST_SUCCESS
;
3515 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3517 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3519 return TEST_SUCCESS
;
3522 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3524 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3525 test_compare(MEMCACHED_SUCCESS
, rc
);
3527 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3528 test_compare(value
, uint64_t(1));
3530 return TEST_SUCCESS
;
3533 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3535 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3536 test_compare(MEMCACHED_SUCCESS
, rc
);
3538 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3539 test_compare(value
, uint64_t(1));
3541 test_compare(MEMCACHED_SUCCESS
,
3542 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3544 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3545 test_compare(MEMCACHED_HASH_MD5
, memcached_hash_t(value
));
3547 return TEST_SUCCESS
;
3550 static test_return_t
pre_replication(memcached_st
*memc
)
3552 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3555 * Make sure that we store the item on all servers
3556 * (master + replicas == number of servers)
3558 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3559 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3561 return TEST_SUCCESS
;
3565 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3567 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3569 return pre_nonblock(memc
);
3573 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3577 #ifdef HARD_MALLOC_TESTS
3578 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3586 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3590 #ifdef HARD_MALLOC_TESTS
3591 void *ret
= malloc(size
+ 8);
3594 ret
= (void*)((caddr_t
)ret
+ 8);
3597 void *ret
= malloc(size
);
3602 memset(ret
, 0xff, size
);
3609 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3611 #ifdef HARD_MALLOC_TESTS
3612 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3613 void *nmem
= realloc(real_ptr
, size
+ 8);
3618 ret
= (void*)((caddr_t
)nmem
+ 8);
3624 return realloc(mem
, size
);
3629 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3631 #ifdef HARD_MALLOC_TESTS
3632 void *mem
= my_malloc(ptr
, nelem
* size
);
3635 memset(mem
, 0, nelem
* size
);
3641 return calloc(nelem
, size
);
3645 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3647 memcached_return_t rc
;
3648 const char *key
= "mine";
3651 /* Make sure be default none exists */
3652 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3654 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3656 /* Test a clean set */
3657 test_compare(MEMCACHED_SUCCESS
,
3658 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3660 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3662 test_memcmp(value
, key
, 4);
3663 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3665 /* Test that we can turn it off */
3666 test_compare(MEMCACHED_SUCCESS
,
3667 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3669 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3671 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3673 /* Now setup for main test */
3674 test_compare(MEMCACHED_SUCCESS
,
3675 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3677 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3679 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3680 test_memcmp(value
, key
, 4);
3682 /* Set to Zero, and then Set to something too large */
3685 memset(long_key
, 0, 255);
3687 test_compare(MEMCACHED_SUCCESS
,
3688 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3690 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3692 test_compare(MEMCACHED_SUCCESS
, rc
);
3694 /* Test a long key for failure */
3695 /* TODO, extend test to determine based on setting, what result should be */
3696 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3697 test_compare(MEMCACHED_SUCCESS
,
3698 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3700 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3701 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3702 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3703 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3705 /* Test for a bad prefix, but with a short key */
3706 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3707 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3709 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3710 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3713 return TEST_SUCCESS
;
3716 static test_return_t
set_namespace(memcached_st
*memc
)
3718 memcached_return_t rc
;
3719 const char *key
= "mine";
3722 // Make sure we default to a null namespace
3723 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3725 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3727 /* Test a clean set */
3728 test_compare(MEMCACHED_SUCCESS
,
3729 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3731 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3733 test_memcmp(value
, key
, 4);
3734 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3736 return TEST_SUCCESS
;
3739 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3741 test_return_if(pre_binary(memc
));
3742 test_return_if(set_namespace(memc
));
3744 return TEST_SUCCESS
;
3747 #ifdef MEMCACHED_ENABLE_DEPRECATED
3748 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3750 void *test_ptr
= NULL
;
3753 memcached_malloc_fn malloc_cb
=
3754 (memcached_malloc_fn
)my_malloc
;
3755 cb_ptr
= *(void **)&malloc_cb
;
3756 memcached_return_t rc
;
3758 test_compare(MEMCACHED_SUCCESS
,
3759 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3760 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3761 test_compare(MEMCACHED_SUCCESS
, rc
);
3762 test_true(test_ptr
== cb_ptr
);
3766 memcached_realloc_fn realloc_cb
=
3767 (memcached_realloc_fn
)my_realloc
;
3768 cb_ptr
= *(void **)&realloc_cb
;
3769 memcached_return_t rc
;
3771 test_compare(MEMCACHED_SUCCESS
,
3772 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3773 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3774 test_compare(MEMCACHED_SUCCESS
, rc
);
3775 test_true(test_ptr
== cb_ptr
);
3779 memcached_free_fn free_cb
=
3780 (memcached_free_fn
)my_free
;
3781 cb_ptr
= *(void **)&free_cb
;
3782 memcached_return_t rc
;
3784 test_compare(MEMCACHED_SUCCESS
,
3785 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3786 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3787 test_compare(MEMCACHED_SUCCESS
, rc
);
3788 test_true(test_ptr
== cb_ptr
);
3791 return TEST_SUCCESS
;
3796 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3798 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3799 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3800 my_realloc
, my_calloc
, NULL
));
3802 test_compare(MEMCACHED_SUCCESS
,
3803 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3804 my_realloc
, my_calloc
, NULL
));
3806 memcached_malloc_fn mem_malloc
;
3807 memcached_free_fn mem_free
;
3808 memcached_realloc_fn mem_realloc
;
3809 memcached_calloc_fn mem_calloc
;
3810 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3811 &mem_realloc
, &mem_calloc
);
3813 test_true(mem_malloc
== my_malloc
);
3814 test_true(mem_realloc
== my_realloc
);
3815 test_true(mem_calloc
== my_calloc
);
3816 test_true(mem_free
== my_free
);
3818 return TEST_SUCCESS
;
3821 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3824 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3825 memcached_hash_t hash
;
3826 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3827 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3830 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3831 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3833 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3835 if (hash
!= MEMCACHED_HASH_CRC
)
3836 return TEST_SKIPPED
;
3838 return TEST_SUCCESS
;
3841 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3844 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3845 memcached_hash_t hash
;
3846 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3847 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3852 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3853 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3855 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3857 if (hash
!= MEMCACHED_HASH_HSIEH
)
3858 return TEST_SKIPPED
;
3861 return TEST_SUCCESS
;
3864 static test_return_t
enable_cas(memcached_st
*memc
)
3866 unsigned int set
= 1;
3868 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3870 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3872 return TEST_SUCCESS
;
3875 return TEST_SKIPPED
;
3878 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3880 memcached_version(memc
);
3882 memcached_server_instance_st instance
=
3883 memcached_server_instance_by_position(memc
, 0);
3885 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3886 or instance
->minor_version
> 2)
3888 return TEST_SUCCESS
;
3891 return TEST_SKIPPED
;
3894 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3898 memcached_servers_reset(memc
);
3899 const char *socket_file
= default_socket();
3901 test_skip(0, stat(socket_file
, &buf
));
3903 test_compare(MEMCACHED_SUCCESS
,
3904 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
3906 return TEST_SUCCESS
;
3909 static test_return_t
pre_nodelay(memcached_st
*memc
)
3911 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3912 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3914 return TEST_SUCCESS
;
3917 static test_return_t
pre_settimer(memcached_st
*memc
)
3919 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
3920 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
3922 return TEST_SUCCESS
;
3925 static test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
3927 const uint64_t timeout
= 100; // Not using, just checking that it sets
3929 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
3931 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
3933 return TEST_SUCCESS
;
3936 static test_return_t
noreply_test(memcached_st
*memc
)
3938 test_compare(MEMCACHED_SUCCESS
,
3939 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
3940 test_compare(MEMCACHED_SUCCESS
,
3941 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1));
3942 test_compare(MEMCACHED_SUCCESS
,
3943 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
3944 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
3945 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
3946 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
3948 memcached_return_t ret
;
3949 for (int count
= 0; count
< 5; ++count
)
3951 for (size_t x
= 0; x
< 100; ++x
)
3954 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
3955 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
3957 size_t len
= (size_t)check_length
;
3962 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
3965 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
3968 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
3971 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
3974 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
3980 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, ret
));
3984 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3985 ** API and is _ONLY_ done this way to verify that the library works the
3986 ** way it is supposed to do!!!!
3989 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
3991 memcached_server_instance_st instance
=
3992 memcached_server_instance_by_position(memc
, x
);
3993 no_msg
+=(int)(instance
->cursor_active
);
3996 test_true(no_msg
== 0);
3997 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4000 ** Now validate that all items was set properly!
4002 for (size_t x
= 0; x
< 100; ++x
)
4006 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4008 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4010 size_t len
= (size_t)check_length
;
4013 char* value
=memcached_get(memc
, key
, strlen(key
),
4014 &length
, &flags
, &ret
);
4015 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
4018 case 0: /* FALLTHROUGH */
4019 case 1: /* FALLTHROUGH */
4021 test_true(strncmp(value
, key
, len
) == 0);
4022 test_true(len
== length
);
4025 test_true(length
== len
* 2);
4028 test_true(length
== len
* 3);
4038 /* Try setting an illegal cas value (should not return an error to
4039 * the caller (because we don't expect a return message from the server)
4041 const char* keys
[]= {"0"};
4042 size_t lengths
[]= {1};
4045 memcached_result_st results_obj
;
4046 memcached_result_st
*results
;
4047 test_compare(MEMCACHED_SUCCESS
,
4048 memcached_mget(memc
, keys
, lengths
, 1));
4050 results
= memcached_result_create(memc
, &results_obj
);
4052 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4054 test_compare(MEMCACHED_SUCCESS
, ret
);
4055 uint64_t cas
= memcached_result_cas(results
);
4056 memcached_result_free(&results_obj
);
4058 test_compare(MEMCACHED_SUCCESS
,
4059 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4062 * The item will have a new cas value, so try to set it again with the old
4063 * value. This should fail!
4065 test_compare(MEMCACHED_SUCCESS
,
4066 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4067 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4068 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4069 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4072 return TEST_SUCCESS
;
4075 static test_return_t
analyzer_test(memcached_st
*memc
)
4077 memcached_return_t rc
;
4078 memcached_analysis_st
*report
;
4080 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4081 test_compare(MEMCACHED_SUCCESS
, rc
);
4082 test_true(memc_stat
);
4084 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4085 test_compare(MEMCACHED_SUCCESS
, rc
);
4089 memcached_stat_free(NULL
, memc_stat
);
4091 return TEST_SUCCESS
;
4094 /* Count the objects */
4096 static test_return_t
dump_test(memcached_st
*memc
)
4098 /* No support for Binary protocol yet */
4099 test_skip(false, memc
->flags
.binary_protocol
);
4101 test_compare(TEST_SUCCESS
, set_test3(memc
));
4103 // confirm_key_count() call dump
4104 size_t counter
= confirm_key_count(memc
);
4106 /* We may have more then 32 if our previous flush has not completed */
4107 test_true(counter
>= 32);
4109 return TEST_SUCCESS
;
4112 static test_return_t
util_version_test(memcached_st
*memc
)
4114 test_compare_hint(MEMCACHED_SUCCESS
, memcached_version(memc
), memcached_last_error_message(memc
));
4115 test_true(libmemcached_util_version_check(memc
, 0, 0, 0));
4117 bool if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4119 // We expect failure
4122 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4123 fprintf(stderr
, "\nDumping Server Information\n\n");
4124 memcached_server_fn callbacks
[1];
4126 callbacks
[0]= dump_server_information
;
4127 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4128 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4130 test_true(if_successful
== false);
4132 memcached_server_instance_st instance
=
4133 memcached_server_instance_by_position(memc
, 0);
4135 memcached_version(memc
);
4137 // We only use one binary when we test, so this should be just fine.
4138 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4139 test_true(if_successful
== true);
4141 if (instance
->micro_version
> 0)
4143 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4145 else if (instance
->minor_version
> 0)
4147 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4149 else if (instance
->major_version
> 0)
4151 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4154 test_true(if_successful
== true);
4156 if (instance
->micro_version
> 0)
4158 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4160 else if (instance
->minor_version
> 0)
4162 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4164 else if (instance
->major_version
> 0)
4166 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4169 test_true(if_successful
== false);
4171 return TEST_SUCCESS
;
4174 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4176 memcached_return_t rc
;
4177 memcached_server_instance_st instance
=
4178 memcached_server_instance_by_position(memc
, 0);
4180 // Test both the version that returns a code, and the one that does not.
4181 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4182 memcached_server_port(instance
) -1, NULL
) == -1);
4184 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4185 memcached_server_port(instance
) -1, &rc
) == -1);
4186 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4188 return TEST_SUCCESS
;
4192 static test_return_t
getpid_test(memcached_st
*memc
)
4194 memcached_return_t rc
;
4195 memcached_server_instance_st instance
=
4196 memcached_server_instance_by_position(memc
, 0);
4198 // Test both the version that returns a code, and the one that does not.
4199 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4200 memcached_server_port(instance
), NULL
) > -1);
4202 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4203 memcached_server_port(instance
), &rc
) > -1);
4204 test_compare(MEMCACHED_SUCCESS
, rc
);
4206 return TEST_SUCCESS
;
4209 static test_return_t
ping_test(memcached_st
*memc
)
4211 memcached_return_t rc
;
4212 memcached_server_instance_st instance
=
4213 memcached_server_instance_by_position(memc
, 0);
4215 // Test both the version that returns a code, and the one that does not.
4216 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4217 memcached_server_port(instance
), NULL
));
4219 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4220 memcached_server_port(instance
), &rc
));
4222 test_compare(MEMCACHED_SUCCESS
, rc
);
4224 return TEST_SUCCESS
;
4229 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4233 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4234 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4235 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4236 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4237 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4238 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4239 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4240 #ifdef HAVE_HSIEH_HASH
4241 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4243 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4244 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4245 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4247 return TEST_SUCCESS
;
4251 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4253 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4255 test_compare(MEMCACHED_SUCCESS
,
4256 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4257 (uint64_t)MEMCACHED_HASH_HSIEH
));
4259 return TEST_SUCCESS
;
4262 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4264 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4266 test_compare(MEMCACHED_SUCCESS
,
4267 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
4269 return TEST_SUCCESS
;
4272 static test_return_t
one_at_a_time_run (memcached_st
*)
4277 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4279 test_compare(one_at_a_time_values
[x
],
4280 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
4283 return TEST_SUCCESS
;
4286 static test_return_t
md5_run (memcached_st
*)
4291 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4293 test_compare(md5_values
[x
],
4294 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
4297 return TEST_SUCCESS
;
4300 static test_return_t
crc_run (memcached_st
*)
4305 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4307 test_compare(crc_values
[x
],
4308 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
4311 return TEST_SUCCESS
;
4314 static test_return_t
fnv1_64_run (memcached_st
*)
4316 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
4321 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4323 test_compare(fnv1_64_values
[x
],
4324 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
4327 return TEST_SUCCESS
;
4330 static test_return_t
fnv1a_64_run (memcached_st
*)
4332 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
4337 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4339 test_compare(fnv1a_64_values
[x
],
4340 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
4343 return TEST_SUCCESS
;
4346 static test_return_t
fnv1_32_run (memcached_st
*)
4351 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4353 test_compare(fnv1_32_values
[x
],
4354 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
4357 return TEST_SUCCESS
;
4360 static test_return_t
fnv1a_32_run (memcached_st
*)
4365 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4367 test_compare(fnv1a_32_values
[x
],
4368 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
4371 return TEST_SUCCESS
;
4374 static test_return_t
hsieh_run (memcached_st
*)
4376 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4381 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4383 test_compare(hsieh_values
[x
],
4384 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
4387 return TEST_SUCCESS
;
4390 static test_return_t
murmur_run (memcached_st
*)
4392 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4394 #ifdef WORDS_BIGENDIAN
4395 (void)murmur_values
;
4396 return TEST_SKIPPED
;
4401 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4403 test_compare(murmur_values
[x
],
4404 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
4407 return TEST_SUCCESS
;
4411 static test_return_t
jenkins_run (memcached_st
*)
4416 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4418 test_compare(jenkins_values
[x
],
4419 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
4422 return TEST_SUCCESS
;
4425 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
4427 return libhashkit_md5(string
, string_length
);
4430 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
4432 return libhashkit_crc32(string
, string_length
);
4435 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4441 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
4443 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};
4444 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};
4446 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4448 hashkit_clone(&new_kit
, kit
);
4449 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4451 memcached_set_hashkit(memc
, &new_kit
);
4454 Verify Setting the hash.
4456 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4460 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4461 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4466 Now check memcached_st.
4468 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4472 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4473 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4476 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4478 memcached_set_hashkit(memc
, &new_kit
);
4481 Verify Setting the hash.
4483 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4487 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4488 test_true(crc_values
[x
] == hash_val
);
4491 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4495 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4496 test_compare(crc_hosts
[x
], hash_val
);
4499 memcached_free(memc
);
4501 return TEST_SUCCESS
;
4505 Test case adapted from John Gorman <johngorman2@gmail.com>
4507 We are testing the error condition when we connect to a server via memcached_get()
4508 but find that the server is not available.
4510 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4512 const char *key
= "MemcachedLives";
4515 memcached_return rc
;
4518 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4520 // See if memcached is reachable.
4521 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4525 test_true(memcached_failed(rc
));
4527 memcached_free(tl_memc_h
);
4529 return TEST_SUCCESS
;
4533 We connect to a server which exists, but search for a key that does not exist.
4535 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4537 const char *key
= "MemcachedKeyNotEXIST";
4540 memcached_return rc
;
4542 // See if memcached is reachable.
4543 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4547 test_compare(MEMCACHED_NOTFOUND
, rc
);
4549 return TEST_SUCCESS
;
4553 Test case adapted from John Gorman <johngorman2@gmail.com>
4555 We are testing the error condition when we connect to a server via memcached_get_by_key()
4556 but find that the server is not available.
4558 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4561 memcached_st
*tl_memc_h
;
4562 memcached_server_st
*servers
;
4564 const char *key
= "MemcachedLives";
4567 memcached_return rc
;
4571 tl_memc_h
= memcached_create(NULL
);
4572 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4573 memcached_server_push(tl_memc_h
, servers
);
4574 memcached_server_list_free(servers
);
4576 // See if memcached is reachable.
4577 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4581 test_true(memcached_failed(rc
));
4583 memcached_free(tl_memc_h
);
4585 return TEST_SUCCESS
;
4589 We connect to a server which exists, but search for a key that does not exist.
4591 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4593 const char *key
= "MemcachedKeyNotEXIST";
4596 memcached_return rc
;
4599 // See if memcached is reachable.
4600 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4604 test_compare(MEMCACHED_NOTFOUND
, rc
);
4606 return TEST_SUCCESS
;
4609 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4611 test_skip(TEST_SUCCESS
, pre_binary(memc
));
4613 const char *key
= "regression_bug_434484";
4614 size_t keylen
= strlen(key
);
4616 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4617 test_compare(MEMCACHED_NOTSTORED
, ret
);
4619 size_t size
= 2048 * 1024;
4620 char *data
= (char*)calloc(1, size
);
4622 test_compare(MEMCACHED_E2BIG
,
4623 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4626 return TEST_SUCCESS
;
4629 static test_return_t
regression_bug_434843(memcached_st
*original_memc
)
4631 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
4633 memcached_return_t rc
;
4635 memcached_execute_fn callbacks
[]= { &callback_counter
};
4638 * I only want to hit only _one_ server so I know the number of requests I'm
4639 * sending in the pipleine to the server. Let's try to do a multiget of
4640 * 1024 (that should satisfy most users don't you think?). Future versions
4641 * will include a mget_execute function call if you need a higher number.
4643 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
4645 const size_t max_keys
= 1024;
4646 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4647 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4649 for (size_t x
= 0; x
< max_keys
; ++x
)
4653 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4659 * Run two times.. the first time we should have 100% cache miss,
4660 * and the second time we should have 100% cache hits
4662 for (size_t y
= 0; y
< 2; y
++)
4664 test_compare(MEMCACHED_SUCCESS
,
4665 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4667 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4668 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4672 /* The first iteration should give me a 100% cache miss. verify that*/
4673 char blob
[1024]= { 0 };
4675 test_false(counter
);
4677 for (size_t x
= 0; x
< max_keys
; ++x
)
4679 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4680 blob
, sizeof(blob
), 0, 0);
4681 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4686 /* Verify that we received all of the key/value pairs */
4687 test_compare(counter
, max_keys
);
4691 /* Release allocated resources */
4692 for (size_t x
= 0; x
< max_keys
; ++x
)
4699 memcached_free(memc
);
4701 return TEST_SUCCESS
;
4704 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4706 memcached_return_t rc
;
4707 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4708 test_compare(MEMCACHED_SUCCESS
, rc
);
4710 return regression_bug_434843(memc
);
4713 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4715 memcached_return_t rc
;
4716 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4717 test_compare(MEMCACHED_SUCCESS
, rc
);
4719 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4720 test_compare(MEMCACHED_SUCCESS
, rc
);
4721 test_true(bytes_str
);
4722 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4724 test_compare(MEMCACHED_SUCCESS
, rc
);
4725 test_true(bytes_read_str
);
4727 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4728 "bytes_written", &rc
);
4729 test_compare(MEMCACHED_SUCCESS
, rc
);
4730 test_true(bytes_written_str
);
4732 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4733 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4734 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4736 test_true(bytes
!= bytes_read
);
4737 test_true(bytes
!= bytes_written
);
4739 /* Release allocated resources */
4741 free(bytes_read_str
);
4742 free(bytes_written_str
);
4743 memcached_stat_free(NULL
, memc_stat
);
4745 return TEST_SUCCESS
;
4749 * The test case isn't obvious so I should probably document why
4750 * it works the way it does. Bug 442914 was caused by a bug
4751 * in the logic in memcached_purge (it did not handle the case
4752 * where the number of bytes sent was equal to the watermark).
4753 * In this test case, create messages so that we hit that case
4754 * and then disable noreply mode and issue a new command to
4755 * verify that it isn't stuck. If we change the format for the
4756 * delete command or the watermarks, we need to update this
4759 static test_return_t
regression_bug_442914(memcached_st
*memc
)
4761 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4762 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4764 uint32_t number_of_hosts
= memcached_server_count(memc
);
4765 memc
->number_of_hosts
= 1;
4770 for (uint32_t x
= 0; x
< 250; ++x
)
4772 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4773 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4774 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4777 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
4780 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4781 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4783 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4784 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
4786 memc
->number_of_hosts
= number_of_hosts
;
4788 return TEST_SUCCESS
;
4791 static test_return_t
regression_bug_447342(memcached_st
*memc
)
4793 memcached_server_instance_st instance_one
;
4794 memcached_server_instance_st instance_two
;
4796 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
4797 return TEST_SKIPPED
;
4799 test_compare(MEMCACHED_SUCCESS
,
4800 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
4802 const unsigned int max_keys
= 100;
4803 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4804 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4806 for (unsigned int x
= 0; x
< max_keys
; ++x
)
4810 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4813 test_compare(MEMCACHED_SUCCESS
,
4814 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
4818 ** We are using the quiet commands to store the replicas, so we need
4819 ** to ensure that all of them are processed before we can continue.
4820 ** In the test we go directly from storing the object to trying to
4821 ** receive the object from all of the different servers, so we
4822 ** could end up in a race condition (the memcached server hasn't yet
4823 ** processed the quiet command from the replication set when it process
4824 ** the request from the other client (created by the clone)). As a
4825 ** workaround for that we call memcached_quit to send the quit command
4826 ** to the server and wait for the response ;-) If you use the test code
4827 ** as an example for your own code, please note that you shouldn't need
4830 memcached_quit(memc
);
4832 /* Verify that all messages are stored, and we didn't stuff too much
4835 test_compare(MEMCACHED_SUCCESS
,
4836 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4838 unsigned int counter
= 0;
4839 memcached_execute_fn callbacks
[]= { &callback_counter
};
4840 test_compare(MEMCACHED_SUCCESS
,
4841 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4843 /* Verify that we received all of the key/value pairs */
4844 test_compare(counter
, max_keys
);
4846 memcached_quit(memc
);
4848 * Don't do the following in your code. I am abusing the internal details
4849 * within the library, and this is not a supported interface.
4850 * This is to verify correct behavior in the library. Fake that two servers
4853 instance_one
= memcached_server_instance_by_position(memc
, 0);
4854 instance_two
= memcached_server_instance_by_position(memc
, 2);
4855 in_port_t port0
= instance_one
->port
;
4856 in_port_t port2
= instance_two
->port
;
4858 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4859 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4861 test_compare(MEMCACHED_SUCCESS
,
4862 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4865 test_compare(MEMCACHED_SUCCESS
,
4866 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4867 test_compare(counter
, (unsigned int)max_keys
);
4869 /* restore the memc handle */
4870 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4871 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4873 memcached_quit(memc
);
4875 /* Remove half of the objects */
4876 for (size_t x
= 0; x
< max_keys
; ++x
)
4880 test_compare(MEMCACHED_SUCCESS
,
4881 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
4885 memcached_quit(memc
);
4886 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
4887 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
4889 /* now retry the command, this time we should have cache misses */
4890 test_compare(MEMCACHED_SUCCESS
,
4891 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
4894 test_compare(MEMCACHED_SUCCESS
,
4895 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4896 test_compare(counter
, (unsigned int)(max_keys
>> 1));
4898 /* Release allocated resources */
4899 for (size_t x
= 0; x
< max_keys
; ++x
)
4906 /* restore the memc handle */
4907 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
4908 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
4910 return TEST_SUCCESS
;
4913 static test_return_t
regression_bug_463297(memcached_st
*memc
)
4915 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
4916 test_true(memc_clone
);
4917 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
4919 memcached_server_instance_st instance
=
4920 memcached_server_instance_by_position(memc_clone
, 0);
4922 if (instance
->major_version
> 1 ||
4923 (instance
->major_version
== 1 &&
4924 instance
->minor_version
> 2))
4926 /* Binary protocol doesn't support deferred delete */
4927 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
4928 test_true(bin_clone
);
4929 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
4930 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
4931 memcached_free(bin_clone
);
4933 memcached_quit(memc_clone
);
4935 /* If we know the server version, deferred delete should fail
4936 * with invalid arguments */
4937 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
4939 /* If we don't know the server version, we should get a protocol error */
4940 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
4942 /* but there is a bug in some of the memcached servers (1.4) that treats
4943 * the counter as noreply so it doesn't send the proper error message
4945 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4947 /* And buffered mode should be disabled and we should get protocol error */
4948 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
4949 rc
= memcached_delete(memc
, "foo", 3, 1);
4950 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4952 /* Same goes for noreply... */
4953 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4954 rc
= memcached_delete(memc
, "foo", 3, 1);
4955 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
4957 /* but a normal request should go through (and be buffered) */
4958 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
4959 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4961 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
4962 /* unbuffered noreply should be success */
4963 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
4964 /* unbuffered with reply should be not found... */
4965 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
4966 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
4969 memcached_free(memc_clone
);
4970 return TEST_SUCCESS
;
4974 /* Test memcached_server_get_last_disconnect
4975 * For a working server set, shall be NULL
4976 * For a set of non existing server, shall not be NULL
4978 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
4980 memcached_return_t rc
;
4981 memcached_server_instance_st disconnected_server
;
4983 /* With the working set of server */
4984 const char *key
= "marmotte";
4985 const char *value
= "milka";
4987 memcached_reset_last_disconnected_server(memc
);
4988 test_false(memc
->last_disconnected_server
);
4989 rc
= memcached_set(memc
, key
, strlen(key
),
4990 value
, strlen(value
),
4991 (time_t)0, (uint32_t)0);
4992 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4994 disconnected_server
= memcached_server_get_last_disconnect(memc
);
4995 test_false(disconnected_server
);
4997 /* With a non existing server */
4999 memcached_server_st
*servers
;
5001 const char *server_list
= "localhost:9";
5003 servers
= memcached_servers_parse(server_list
);
5005 mine
= memcached_create(NULL
);
5006 rc
= memcached_server_push(mine
, servers
);
5007 test_compare(MEMCACHED_SUCCESS
, rc
);
5008 memcached_server_list_free(servers
);
5011 rc
= memcached_set(mine
, key
, strlen(key
),
5012 value
, strlen(value
),
5013 (time_t)0, (uint32_t)0);
5014 test_true(memcached_failed(rc
));
5016 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5017 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5018 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5019 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5021 memcached_quit(mine
);
5022 memcached_free(mine
);
5024 return TEST_SUCCESS
;
5027 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5029 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5030 char buffer
[BUFSIZ
];
5032 test_compare(MEMCACHED_SUCCESS
,
5033 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5035 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5038 // We will just use the error strings as our keys
5039 uint32_t counter
= 100;
5042 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5044 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5045 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5046 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
5048 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5049 test_true(disconnected_server
);
5050 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5051 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5055 memcached_reset_last_disconnected_server(memc
);
5060 memcached_free(memc
);
5062 return TEST_SUCCESS
;
5065 static test_return_t
test_verbosity(memcached_st
*memc
)
5067 memcached_verbosity(memc
, 3);
5069 return TEST_SUCCESS
;
5073 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5074 const char *key
, size_t key_length
,
5075 const char *value
, size_t value_length
,
5085 return MEMCACHED_SUCCESS
;
5088 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5090 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5091 test_compare(MEMCACHED_SUCCESS
, rc
);
5093 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5094 test_compare(MEMCACHED_SUCCESS
, rc
);
5096 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5097 test_compare(MEMCACHED_SUCCESS
, rc
);
5099 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5100 test_compare(MEMCACHED_SUCCESS
, rc
);
5102 return TEST_SUCCESS
;
5106 * This test ensures that the failure counter isn't incremented during
5107 * normal termination of the memcached instance.
5109 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5111 memcached_return_t rc
;
5112 memcached_server_instance_st instance
;
5114 /* Set value to force connection to the server */
5115 const char *key
= "marmotte";
5116 const char *value
= "milka";
5119 * Please note that I'm abusing the internal structures in libmemcached
5120 * in a non-portable way and you shouldn't be doing this. I'm only
5121 * doing this in order to verify that the library works the way it should
5123 uint32_t number_of_hosts
= memcached_server_count(memc
);
5124 memc
->number_of_hosts
= 1;
5126 /* Ensure that we are connected to the server by setting a value */
5127 rc
= memcached_set(memc
, key
, strlen(key
),
5128 value
, strlen(value
),
5129 (time_t)0, (uint32_t)0);
5130 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5133 instance
= memcached_server_instance_by_position(memc
, 0);
5134 /* The test is to see that the memcached_quit doesn't increase the
5135 * the server failure conter, so let's ensure that it is zero
5136 * before sending quit
5138 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5140 memcached_quit(memc
);
5142 /* Verify that it memcached_quit didn't increment the failure counter
5143 * Please note that this isn't bullet proof, because an error could
5146 test_zero(instance
->server_failure_counter
);
5148 /* restore the instance */
5149 memc
->number_of_hosts
= number_of_hosts
;
5151 return TEST_SUCCESS
;
5155 * This tests ensures expected disconnections (for some behavior changes
5156 * for instance) do not wrongly increase failure counter
5158 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5160 memcached_return rc
;
5162 memcached_st
*memc_clone
;
5163 memc_clone
= memcached_clone(NULL
, memc
);
5164 test_true(memc_clone
);
5166 /* Set value to force connection to the server */
5167 const char *key
= "marmotte";
5168 const char *value
= "milka";
5169 char *string
= NULL
;
5170 size_t string_length
;
5173 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5174 value
, strlen(value
),
5175 (time_t)0, (uint32_t)0);
5176 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5179 /* put failure limit to 1 */
5180 test_compare(MEMCACHED_SUCCESS
,
5181 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1));
5183 /* Put a retry timeout to effectively activate failure_limit effect */
5184 test_compare(MEMCACHED_SUCCESS
,
5185 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
5187 /* change behavior that triggers memcached_quit()*/
5188 test_compare(MEMCACHED_SUCCESS
,
5189 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5192 /* Check if we still are connected */
5193 string
= memcached_get(memc_clone
, key
, strlen(key
),
5194 &string_length
, &flags
, &rc
);
5196 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5199 memcached_free(memc_clone
);
5201 return TEST_SUCCESS
;
5208 * Test that ensures mget_execute does not end into recursive calls that finally fails
5210 static test_return_t
regression_bug_490486(memcached_st
*original_memc
)
5214 return TEST_SKIPPED
; // My MAC can't handle this test
5217 test_skip(TEST_SUCCESS
, pre_binary(original_memc
));
5220 * I only want to hit _one_ server so I know the number of requests I'm
5221 * sending in the pipeline.
5223 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
5226 size_t max_keys
= 20480;
5228 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5229 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5231 /* First add all of the items.. */
5232 char blob
[1024]= { 0 };
5233 for (size_t x
= 0; x
< max_keys
; ++x
)
5236 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5239 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5240 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5245 /* Try to get all of them with a large multiget */
5247 memcached_execute_function callbacks
[]= { &callback_counter
};
5248 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5249 (size_t)max_keys
, callbacks
, &counter
, 1);
5250 test_compare(MEMCACHED_SUCCESS
, rc
);
5252 char* the_value
= NULL
;
5253 char the_key
[MEMCACHED_MAX_KEY
];
5254 size_t the_key_length
;
5255 size_t the_value_length
;
5259 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5261 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5267 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5270 test_compare(MEMCACHED_END
, rc
);
5272 /* Verify that we got all of the items */
5273 test_compare(counter
, max_keys
);
5276 /* Release all allocated resources */
5277 for (size_t x
= 0; x
< max_keys
; ++x
)
5284 memcached_free(memc
);
5286 return TEST_SUCCESS
;
5289 static test_return_t
regression_bug_583031(memcached_st
*)
5291 memcached_st
*memc
= memcached_create(NULL
);
5293 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5295 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5296 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5297 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5298 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5299 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5300 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5302 memcached_return_t rc
;
5306 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5310 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5312 memcached_free(memc
);
5314 return TEST_SUCCESS
;
5317 static test_return_t
regression_bug_581030(memcached_st
*)
5320 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5321 test_false(local_stat
);
5323 memcached_stat_free(NULL
, NULL
);
5326 return TEST_SUCCESS
;
5329 #define regression_bug_655423_COUNT 6000
5330 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5332 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5333 memc
= NULL
; // Just to make sure it is not used
5338 return TEST_SKIPPED
;
5341 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5342 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5343 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5344 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5346 memset(payload
, int('x'), sizeof(payload
));
5348 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5350 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5351 snprintf(key
, sizeof(key
), "%u", x
);
5353 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5356 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5358 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5359 snprintf(key
, sizeof(key
), "%u", x
);
5361 size_t value_length
;
5362 memcached_return_t rc
;
5363 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5365 if (rc
== MEMCACHED_NOTFOUND
)
5368 test_zero(value_length
);
5372 test_compare(MEMCACHED_SUCCESS
, rc
);
5374 test_compare(100LLU, value_length
);
5378 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5379 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5380 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5382 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5383 snprintf(key
, sizeof(key
), "%u", x
);
5385 keys
[x
]= strdup(key
);
5387 key_length
[x
]= strlen(key
);
5388 test_true(key_length
[x
]);
5391 test_compare(MEMCACHED_SUCCESS
,
5392 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5395 memcached_result_st
*result
= NULL
;
5396 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5398 test_compare(size_t(100), memcached_result_length(result
));
5402 test_true(count
> 100); // If we don't get back atleast this, something is up
5404 /* Release all allocated resources */
5405 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5413 memcached_free(clone
);
5415 return TEST_SUCCESS
;
5419 * Test that ensures that buffered set to not trigger problems during io_flush
5421 #define regression_bug_490520_COUNT 200480
5422 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5424 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5425 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5426 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5427 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5428 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5430 memc
->number_of_hosts
= 1;
5432 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5433 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5435 /* First add all of the items.. */
5436 char blob
[3333] = {0};
5437 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5440 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5444 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5445 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5448 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5455 return TEST_SUCCESS
;
5459 static test_return_t
regression_bug_854604(memcached_st
*)
5463 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
5465 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
5467 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
5468 test_compare(buffer
[0], 0);
5470 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
5471 test_true(strlen(buffer
));
5473 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
5474 test_true(strlen(buffer
));
5476 return TEST_SUCCESS
;
5479 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5481 fprintf(stderr
, "Iteration #%u: ", it
);
5483 if (error
== MEMCACHED_ERRNO
)
5485 fprintf(stderr
, "system error %d from %s: %s\n",
5486 errno
, what
, strerror(errno
));
5490 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5491 memcached_strerror(mc
, error
));
5495 #define TEST_CONSTANT_CREATION 200
5497 static test_return_t
regression_bug_(memcached_st
*memc
)
5499 const char *remote_server
;
5502 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5504 return TEST_SKIPPED
;
5507 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5509 memcached_st
* mc
= memcached_create(NULL
);
5510 memcached_return rc
;
5512 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5513 if (rc
!= MEMCACHED_SUCCESS
)
5515 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5518 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5519 if (rc
!= MEMCACHED_SUCCESS
)
5521 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5524 rc
= memcached_server_add(mc
, remote_server
, 0);
5525 if (rc
!= MEMCACHED_SUCCESS
)
5527 memcached_die(mc
, rc
, "memcached_server_add", x
);
5530 const char *set_key
= "akey";
5531 const size_t set_key_len
= strlen(set_key
);
5532 const char *set_value
= "a value";
5533 const size_t set_value_len
= strlen(set_value
);
5535 if (rc
== MEMCACHED_SUCCESS
)
5539 size_t get_value_len
;
5541 uint32_t get_value_flags
;
5543 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5544 &get_value_flags
, &rc
);
5545 if (rc
!= MEMCACHED_SUCCESS
)
5547 memcached_die(mc
, rc
, "memcached_get", x
);
5553 (get_value_len
!= set_value_len
5554 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5556 fprintf(stderr
, "Values don't match?\n");
5557 rc
= MEMCACHED_FAILURE
;
5563 rc
= memcached_set(mc
,
5564 set_key
, set_key_len
,
5565 set_value
, set_value_len
,
5569 if (rc
!= MEMCACHED_SUCCESS
)
5571 memcached_die(mc
, rc
, "memcached_set", x
);
5578 if (rc
!= MEMCACHED_SUCCESS
)
5584 return TEST_SUCCESS
;
5587 /* Clean the server before beginning testing */
5589 {"util_version", true, (test_callback_fn
*)util_version_test
},
5590 {"flush", false, (test_callback_fn
*)flush_test
},
5591 {"init", false, (test_callback_fn
*)init_test
},
5592 {"allocation", false, (test_callback_fn
*)allocation_test
},
5593 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5594 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5595 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5596 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5597 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5598 {"clone_test", false, (test_callback_fn
*)clone_test
},
5599 {"connection_test", false, (test_callback_fn
*)connection_test
},
5600 {"callback_test", false, (test_callback_fn
*)callback_test
},
5601 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5602 {"set", false, (test_callback_fn
*)set_test
},
5603 {"set2", false, (test_callback_fn
*)set_test2
},
5604 {"set3", false, (test_callback_fn
*)set_test3
},
5605 {"dump", true, (test_callback_fn
*)dump_test
},
5606 {"add", true, (test_callback_fn
*)add_test
},
5607 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5608 {"replace", true, (test_callback_fn
*)replace_test
},
5609 {"delete", true, (test_callback_fn
*)delete_test
},
5610 {"get", true, (test_callback_fn
*)get_test
},
5611 {"get2", false, (test_callback_fn
*)get_test2
},
5612 {"get3", false, (test_callback_fn
*)get_test3
},
5613 {"get4", false, (test_callback_fn
*)get_test4
},
5614 {"partial mget", false, (test_callback_fn
*)get_test5
},
5615 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5616 {"increment", false, (test_callback_fn
*)increment_test
},
5617 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5618 {"decrement", false, (test_callback_fn
*)decrement_test
},
5619 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5620 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5621 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5622 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5623 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5624 {"binary_increment_with_prefix", 1, (test_callback_fn
*)binary_increment_with_prefix_test
},
5625 {"quit", false, (test_callback_fn
*)quit_test
},
5626 {"mget", true, (test_callback_fn
*)mget_test
},
5627 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5628 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5629 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5630 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5631 {"mget_end", false, (test_callback_fn
*)mget_end
},
5632 {"get_stats", false, (test_callback_fn
*)get_stats
},
5633 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5634 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5635 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5636 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
5637 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5638 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5639 {"read_through", true, (test_callback_fn
*)read_through
},
5640 {"delete_through", true, (test_callback_fn
*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER
},
5641 {"noreply", true, (test_callback_fn
*)noreply_test
},
5642 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5643 {"memcached_pool_st", true, (test_callback_fn
*)connection_pool_test
},
5644 {"memcached_pool_st #2", true, (test_callback_fn
*)connection_pool2_test
},
5645 {"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();