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/memcached.h>
46 #include <libmemcached/is.h>
47 #include <libmemcached/server_instance.h>
49 #include <libhashkit/hashkit.h>
58 #include <sys/types.h>
63 #include <libtest/server.h>
65 #include "clients/generator.h"
66 #include "clients/execute.h"
68 #define SMALL_STRING_LEN 1024
70 #include <libtest/test.hpp>
72 #include "tests/basic.h"
73 #include "tests/debug.h"
74 #include "tests/deprecated.h"
75 #include "tests/error_conditions.h"
76 #include "tests/ketama.h"
77 #include "tests/namespace.h"
78 #include "tests/parser.h"
79 #include "tests/pool.h"
80 #include "tests/print.h"
81 #include "tests/replication.h"
82 #include "tests/server_add.h"
83 #include "tests/virtual_buckets.h"
85 using namespace libtest
;
87 #include <libmemcached/memcached_util.h>
89 #include "hash_results.h"
91 #define GLOBAL_COUNT 10000
92 #define GLOBAL2_COUNT 100
93 #define SERVERS_TO_CREATE 5
94 static uint32_t global_count
;
96 static pairs_st
*global_pairs
;
97 static const char *global_keys
[GLOBAL_COUNT
];
98 static size_t global_keys_length
[GLOBAL_COUNT
];
101 static test_return_t
pre_binary(memcached_st
*memc
);
104 static test_return_t
init_test(memcached_st
*not_used
)
109 (void)memcached_create(&memc
);
110 memcached_free(&memc
);
115 #define TEST_PORT_COUNT 7
116 in_port_t test_ports
[TEST_PORT_COUNT
];
118 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
119 const memcached_server_st
*server
,
123 size_t bigger
= *((size_t *)(context
));
125 assert(bigger
<= memcached_server_port(server
));
126 *((size_t *)(context
))= memcached_server_port(server
);
128 return MEMCACHED_SUCCESS
;
131 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
132 const memcached_server_st
*instance
,
136 FILE *stream
= (FILE *)context
;
139 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
140 memcached_server_name(instance
),
141 memcached_server_port(instance
),
142 instance
->major_version
,
143 instance
->minor_version
,
144 instance
->micro_version
);
146 return MEMCACHED_SUCCESS
;
149 static test_return_t
server_sort_test(memcached_st
*ptr
)
151 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
153 memcached_return_t rc
;
154 memcached_server_fn callbacks
[1];
155 memcached_st
*local_memc
;
158 local_memc
= memcached_create(NULL
);
159 test_true(local_memc
);
160 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
162 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
164 test_ports
[x
]= (in_port_t
)random() % 64000;
165 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
166 test_compare(memcached_server_count(local_memc
), x
+1);
168 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
170 test_compare(MEMCACHED_SUCCESS
, rc
);
173 callbacks
[0]= server_display_function
;
174 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
177 memcached_free(local_memc
);
182 static test_return_t
server_sort2_test(memcached_st
*ptr
)
184 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
185 memcached_server_fn callbacks
[1];
186 memcached_st
*local_memc
;
187 memcached_server_instance_st instance
;
190 local_memc
= memcached_create(NULL
);
191 test_true(local_memc
);
192 test_compare(MEMCACHED_SUCCESS
,
193 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
195 test_compare(MEMCACHED_SUCCESS
,
196 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
197 instance
= memcached_server_instance_by_position(local_memc
, 0);
198 test_compare(in_port_t(43043), memcached_server_port(instance
));
200 test_compare(MEMCACHED_SUCCESS
,
201 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
203 instance
= memcached_server_instance_by_position(local_memc
, 0);
204 test_compare(in_port_t(43042), memcached_server_port(instance
));
206 instance
= memcached_server_instance_by_position(local_memc
, 1);
207 test_compare(in_port_t(43043), memcached_server_port(instance
));
209 callbacks
[0]= server_display_function
;
210 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
213 memcached_free(local_memc
);
218 static test_return_t
memcached_server_remove_test(memcached_st
*)
220 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";
223 test_compare(MEMCACHED_SUCCESS
,
224 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
225 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
228 memcached_server_fn callbacks
[1];
229 callbacks
[0]= server_print_callback
;
230 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
232 memcached_free(memc
);
237 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
238 const memcached_server_st
*server
,
242 uint32_t x
= *((uint32_t *)(context
));
244 if (! (test_ports
[x
] == server
->port
))
246 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
247 return MEMCACHED_FAILURE
;
250 *((uint32_t *)(context
))= ++x
;
252 return MEMCACHED_SUCCESS
;
255 static test_return_t
server_unsort_test(memcached_st
*ptr
)
257 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
258 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
259 memcached_server_fn callbacks
[1];
260 memcached_st
*local_memc
;
263 local_memc
= memcached_create(NULL
);
264 test_true(local_memc
);
266 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
268 test_ports
[x
]= (in_port_t
)(random() % 64000);
269 test_compare(MEMCACHED_SUCCESS
,
270 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
271 test_compare(memcached_server_count(local_memc
), x
+1);
273 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
277 callbacks
[0]= server_display_unsort_function
;
278 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
280 /* Now we sort old data! */
281 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
282 callbacks
[0]= server_display_function
;
283 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
286 memcached_free(local_memc
);
291 static test_return_t
allocation_test(memcached_st
*not_used
)
295 memc
= memcached_create(NULL
);
297 memcached_free(memc
);
302 static test_return_t
clone_test(memcached_st
*memc
)
306 memcached_st
*memc_clone
;
307 memc_clone
= memcached_clone(NULL
, NULL
);
308 test_true(memc_clone
);
309 memcached_free(memc_clone
);
312 /* Can we init from null? */
314 memcached_st
*memc_clone
;
315 memc_clone
= memcached_clone(NULL
, memc
);
316 test_true(memc_clone
);
319 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
320 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
321 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
322 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
325 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
326 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
327 test_true(memc_clone
->distribution
== memc
->distribution
);
328 { // Test all of the flags
329 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
330 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
331 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
332 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
333 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
334 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
335 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
336 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
337 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
338 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
339 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
340 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
341 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
343 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
344 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
345 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
346 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
347 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
348 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
349 test_true(memc_clone
->on_clone
== memc
->on_clone
);
350 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
351 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
352 test_true(memc_clone
->recv_size
== memc
->recv_size
);
353 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
354 test_true(memc_clone
->send_size
== memc
->send_size
);
355 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
356 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
357 test_true(memc_clone
->user_data
== memc
->user_data
);
359 memcached_free(memc_clone
);
362 /* Can we init from struct? */
364 memcached_st declared_clone
;
365 memcached_st
*memc_clone
;
366 memset(&declared_clone
, 0 , sizeof(memcached_st
));
367 memc_clone
= memcached_clone(&declared_clone
, NULL
);
368 test_true(memc_clone
);
369 memcached_free(memc_clone
);
372 /* Can we init from struct? */
374 memcached_st declared_clone
;
375 memcached_st
*memc_clone
;
376 memset(&declared_clone
, 0 , sizeof(memcached_st
));
377 memc_clone
= memcached_clone(&declared_clone
, memc
);
378 test_true(memc_clone
);
379 memcached_free(memc_clone
);
385 static test_return_t
userdata_test(memcached_st
*memc
)
388 test_false(memcached_set_user_data(memc
, foo
));
389 test_true(memcached_get_user_data(memc
) == foo
);
390 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
395 static test_return_t
connection_test(memcached_st
*memc
)
397 test_compare(MEMCACHED_SUCCESS
,
398 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
403 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
405 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
407 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
409 test_compare(36, int(MEMCACHED_BEHAVIOR_MAX
));
414 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
416 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
418 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
420 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
425 static test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
427 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
428 982370485U, 1263635348U, 4242906218U, 3829656100U,
429 1891735253U, 334139633U, 2257084983U, 3088286104U,
430 13199785U, 2542027183U, 1097051614U, 199566778U,
431 2748246961U, 2465192557U, 1664094137U, 2405439045U,
432 1842224848U, 692413798U, 3479807801U, 919913813U,
433 4269430871U, 610793021U, 527273862U, 1437122909U,
434 2300930706U, 2943759320U, 674306647U, 2400528935U,
435 54481931U, 4186304426U, 1741088401U, 2979625118U,
436 4159057246U, 3425930182U, 2593724503U, 1868899624U,
437 1769812374U, 2302537950U, 1110330676U, 3365377466U,
438 1336171666U, 3021258493U, 2334992265U, 3861994737U,
441 // You have updated the memcache_error messages but not updated docs/tests.
442 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
445 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
446 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
447 MEMCACHED_HASH_JENKINS
);
448 if (values
[rc
] != hash_val
)
450 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
451 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
453 test_compare(values
[rc
], hash_val
);
455 test_compare(48, int(MEMCACHED_MAXIMUM_RETURN
));
460 static test_return_t
set_test(memcached_st
*memc
)
462 memcached_return_t rc
= memcached_set(memc
,
463 test_literal_param("foo"),
464 test_literal_param("when we sanitize"),
465 time_t(0), (uint32_t)0);
466 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
471 static test_return_t
append_test(memcached_st
*memc
)
473 memcached_return_t rc
;
474 const char *key
= "fig";
475 const char *in_value
= "we";
476 char *out_value
= NULL
;
480 rc
= memcached_flush(memc
, 0);
481 test_compare(MEMCACHED_SUCCESS
, rc
);
483 rc
= memcached_set(memc
, key
, strlen(key
),
484 in_value
, strlen(in_value
),
485 (time_t)0, (uint32_t)0);
486 test_compare(MEMCACHED_SUCCESS
, rc
);
488 rc
= memcached_append(memc
, key
, strlen(key
),
489 " the", strlen(" the"),
490 (time_t)0, (uint32_t)0);
491 test_compare(MEMCACHED_SUCCESS
, rc
);
493 rc
= memcached_append(memc
, key
, strlen(key
),
494 " people", strlen(" people"),
495 (time_t)0, (uint32_t)0);
496 test_compare(MEMCACHED_SUCCESS
, rc
);
498 out_value
= memcached_get(memc
, key
, strlen(key
),
499 &value_length
, &flags
, &rc
);
500 test_memcmp(out_value
, "we the people", strlen("we the people"));
501 test_compare(strlen("we the people"), value_length
);
502 test_compare(MEMCACHED_SUCCESS
, rc
);
508 static test_return_t
append_binary_test(memcached_st
*memc
)
510 memcached_return_t rc
;
511 const char *key
= "numbers";
512 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
518 rc
= memcached_flush(memc
, 0);
519 test_compare(MEMCACHED_SUCCESS
, rc
);
521 rc
= memcached_set(memc
,
524 (time_t)0, (uint32_t)0);
525 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
527 for (x
= 0; store_list
[x
] ; x
++)
529 rc
= memcached_append(memc
,
531 (char *)&store_list
[x
], sizeof(uint32_t),
532 (time_t)0, (uint32_t)0);
533 test_compare(MEMCACHED_SUCCESS
, rc
);
536 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
537 &value_length
, &flags
, &rc
);
538 test_compare(value_length
, sizeof(uint32_t) * x
);
539 test_compare(MEMCACHED_SUCCESS
, rc
);
541 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
543 test_compare(*ptr
, store_list
[x
- counter
]);
551 static test_return_t
cas2_test(memcached_st
*memc
)
553 memcached_return_t rc
;
554 const char *keys
[]= {"fudge", "son", "food"};
555 size_t key_length
[]= {5, 3, 4};
556 const char *value
= "we the people";
557 size_t value_length
= strlen("we the people");
558 memcached_result_st results_obj
;
559 memcached_result_st
*results
;
562 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
564 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
566 for (uint32_t x
= 0; x
< 3; x
++)
568 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
569 keys
[x
], key_length
[x
],
570 (time_t)50, (uint32_t)9);
571 test_compare(MEMCACHED_SUCCESS
, rc
);
574 rc
= memcached_mget(memc
, keys
, key_length
, 3);
576 results
= memcached_result_create(memc
, &results_obj
);
578 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
580 test_true(results
->item_cas
);
581 test_compare(MEMCACHED_SUCCESS
, rc
);
582 test_true(memcached_result_cas(results
));
584 test_memcmp(value
, "we the people", strlen("we the people"));
585 test_compare(strlen("we the people"), value_length
);
586 test_compare(MEMCACHED_SUCCESS
, rc
);
588 memcached_result_free(&results_obj
);
593 static test_return_t
cas_test(memcached_st
*memc
)
595 memcached_return_t rc
;
596 const char *key
= "fun";
597 size_t key_length
= strlen(key
);
598 const char *value
= "we the people";
599 const char* keys
[2] = { key
, NULL
};
600 size_t keylengths
[2] = { strlen(key
), 0 };
601 size_t value_length
= strlen(value
);
602 const char *value2
= "change the value";
603 size_t value2_length
= strlen(value2
);
605 memcached_result_st results_obj
;
606 memcached_result_st
*results
;
609 rc
= memcached_flush(memc
, 0);
610 test_compare(MEMCACHED_SUCCESS
, rc
);
612 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
614 rc
= memcached_set(memc
, key
, strlen(key
),
615 value
, strlen(value
),
616 (time_t)0, (uint32_t)0);
617 test_compare(MEMCACHED_SUCCESS
, rc
);
619 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
621 results
= memcached_result_create(memc
, &results_obj
);
623 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
625 test_compare(MEMCACHED_SUCCESS
, rc
);
626 test_true(memcached_result_cas(results
));
627 test_memcmp(value
, memcached_result_value(results
), value_length
);
628 test_compare(strlen(memcached_result_value(results
)), value_length
);
629 test_compare(MEMCACHED_SUCCESS
, rc
);
630 uint64_t cas
= memcached_result_cas(results
);
633 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
634 test_true(rc
== MEMCACHED_END
);
635 test_true(results
== NULL
);
638 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
639 test_compare(MEMCACHED_SUCCESS
, rc
);
642 * The item will have a new cas value, so try to set it again with the old
643 * value. This should fail!
645 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
646 test_compare(MEMCACHED_DATA_EXISTS
, rc
);
648 memcached_result_free(&results_obj
);
653 static test_return_t
prepend_test(memcached_st
*memc
)
655 memcached_return_t rc
;
656 const char *key
= "fig";
657 const char *value
= "people";
658 char *out_value
= NULL
;
662 rc
= memcached_flush(memc
, 0);
663 test_compare(MEMCACHED_SUCCESS
, rc
);
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 rc
= memcached_prepend(memc
, key
, strlen(key
),
671 "the ", strlen("the "),
672 (time_t)0, (uint32_t)0);
673 test_compare(MEMCACHED_SUCCESS
, rc
);
675 rc
= memcached_prepend(memc
, key
, strlen(key
),
676 "we ", strlen("we "),
677 (time_t)0, (uint32_t)0);
678 test_compare(MEMCACHED_SUCCESS
, rc
);
680 out_value
= memcached_get(memc
, key
, strlen(key
),
681 &value_length
, &flags
, &rc
);
682 test_memcmp(out_value
, "we the people", strlen("we the people"));
683 test_compare(strlen("we the people"), value_length
);
684 test_compare(MEMCACHED_SUCCESS
, rc
);
691 Set the value, then quit to make sure it is flushed.
692 Come back in and test that add fails.
694 static test_return_t
add_test(memcached_st
*memc
)
696 memcached_return_t rc
;
697 const char *key
= "foo";
698 const char *value
= "when we sanitize";
699 unsigned long long setting_value
;
701 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
703 rc
= memcached_set(memc
, key
, strlen(key
),
704 value
, strlen(value
),
705 (time_t)0, (uint32_t)0);
706 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
707 memcached_quit(memc
);
708 rc
= memcached_add(memc
, key
, strlen(key
),
709 value
, strlen(value
),
710 (time_t)0, (uint32_t)0);
712 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
715 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
719 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
726 ** There was a problem of leaking filedescriptors in the initial release
727 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
728 ** systems it seems that the kernel is slow on reclaiming the resources
729 ** because the connects starts to time out (the test doesn't do much
730 ** anyway, so just loop 10 iterations)
732 static test_return_t
add_wrapper(memcached_st
*memc
)
734 unsigned int max
= 10000;
742 for (uint32_t x
= 0; x
< max
; x
++)
748 static test_return_t
replace_test(memcached_st
*memc
)
750 memcached_return_t rc
;
751 const char *key
= "foo";
752 const char *value
= "when we sanitize";
753 const char *original
= "first we insert some data";
755 rc
= memcached_set(memc
, key
, strlen(key
),
756 original
, strlen(original
),
757 (time_t)0, (uint32_t)0);
758 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
760 test_compare(MEMCACHED_SUCCESS
,
761 memcached_replace(memc
, key
, strlen(key
),
762 value
, strlen(value
),
763 (time_t)0, (uint32_t)0));
768 static test_return_t
delete_test(memcached_st
*memc
)
770 memcached_return_t rc
;
771 const char *key
= "foo";
772 const char *value
= "when we sanitize";
774 rc
= memcached_set(memc
, key
, strlen(key
),
775 value
, strlen(value
),
776 (time_t)0, (uint32_t)0);
777 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
779 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
780 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
785 static test_return_t
flush_test(memcached_st
*memc
)
787 uint64_t query_id
= memcached_query_id(memc
);
788 test_compare(MEMCACHED_SUCCESS
,
789 memcached_flush(memc
, 0));
790 test_compare(query_id
+1, memcached_query_id(memc
));
795 static memcached_return_t
server_function(const memcached_st
*ptr
,
796 const memcached_server_st
*server
,
799 (void)ptr
; (void)server
; (void)context
;
802 return MEMCACHED_SUCCESS
;
805 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
808 strncpy(context
, "foo bad", sizeof(context
));
809 memcached_server_fn callbacks
[1];
811 callbacks
[0]= server_function
;
812 memcached_server_cursor(memc
, callbacks
, context
, 1);
816 static test_return_t
bad_key_test(memcached_st
*memc
)
818 memcached_return_t rc
;
819 const char *key
= "foo bad";
821 size_t string_length
;
823 memcached_st
*memc_clone
;
825 size_t max_keylen
= 0xffff;
827 // Just skip if we are in binary mode.
828 uint64_t query_id
= memcached_query_id(memc
);
829 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
831 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
833 memc_clone
= memcached_clone(NULL
, memc
);
834 test_true(memc_clone
);
836 query_id
= memcached_query_id(memc_clone
);
837 test_compare(MEMCACHED_SUCCESS
,
838 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
839 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
841 /* All keys are valid in the binary protocol (except for length) */
842 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
844 query_id
= memcached_query_id(memc_clone
);
845 string
= memcached_get(memc_clone
, key
, strlen(key
),
846 &string_length
, &flags
, &rc
);
847 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
848 test_zero(string_length
);
852 query_id
= memcached_query_id(memc_clone
);
853 test_compare(MEMCACHED_SUCCESS
,
854 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
855 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
856 string
= memcached_get(memc_clone
, key
, strlen(key
),
857 &string_length
, &flags
, &rc
);
858 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
859 test_zero(string_length
);
862 /* Test multi key for bad keys */
863 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
864 size_t key_lengths
[] = { 7, 7, 7 };
866 query_id
= memcached_query_id(memc_clone
);
867 test_compare(MEMCACHED_SUCCESS
,
868 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
869 test_compare(query_id
, memcached_query_id(memc_clone
));
871 query_id
= memcached_query_id(memc_clone
);
872 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
873 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
874 test_compare(query_id
+1, memcached_query_id(memc_clone
));
876 query_id
= memcached_query_id(memc_clone
);
877 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
878 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
879 test_compare(query_id
+1, memcached_query_id(memc_clone
));
883 /* The following test should be moved to the end of this function when the
884 memcached server is updated to allow max size length of the keys in the
887 test_compare(MEMCACHED_SUCCESS
,
888 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
890 char *longkey
= (char *)malloc(max_keylen
+ 1);
893 memset(longkey
, 'a', max_keylen
+ 1);
894 string
= memcached_get(memc_clone
, longkey
, max_keylen
,
895 &string_length
, &flags
, &rc
);
896 test_compare(MEMCACHED_NOTFOUND
, rc
);
897 test_zero(string_length
);
900 string
= memcached_get(memc_clone
, longkey
, max_keylen
+ 1,
901 &string_length
, &flags
, &rc
);
902 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
903 test_zero(string_length
);
910 /* Make sure zero length keys are marked as bad */
912 test_compare(MEMCACHED_SUCCESS
,
913 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
914 string
= memcached_get(memc_clone
, key
, 0,
915 &string_length
, &flags
, &rc
);
916 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
917 test_zero(string_length
);
920 memcached_free(memc_clone
);
925 #define READ_THROUGH_VALUE "set for me"
926 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
929 memcached_result_st
*result
)
931 (void)memc
;(void)key
;(void)key_length
;
932 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
935 #ifndef __INTEL_COMPILER
936 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
939 static test_return_t
read_through(memcached_st
*memc
)
941 memcached_return_t rc
;
942 const char *key
= "foo";
944 size_t string_length
;
946 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
948 string
= memcached_get(memc
, key
, strlen(key
),
949 &string_length
, &flags
, &rc
);
951 test_compare(MEMCACHED_NOTFOUND
, rc
);
952 test_false(string_length
);
955 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
);
956 test_compare(MEMCACHED_SUCCESS
, rc
);
958 string
= memcached_get(memc
, key
, strlen(key
),
959 &string_length
, &flags
, &rc
);
961 test_compare(MEMCACHED_SUCCESS
, rc
);
962 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
963 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
964 test_strcmp(READ_THROUGH_VALUE
, string
);
967 string
= memcached_get(memc
, key
, strlen(key
),
968 &string_length
, &flags
, &rc
);
970 test_compare(MEMCACHED_SUCCESS
, rc
);
972 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
973 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
974 test_strcmp(READ_THROUGH_VALUE
, string
);
980 static memcached_return_t
delete_trigger(memcached_st
*,
987 return MEMCACHED_SUCCESS
;
990 static test_return_t
delete_through(memcached_st
*memc
)
992 memcached_trigger_delete_key_fn callback
;
993 memcached_return_t rc
;
995 callback
= (memcached_trigger_delete_key_fn
)delete_trigger
;
997 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
998 test_compare(MEMCACHED_SUCCESS
, rc
);
1000 return TEST_SUCCESS
;
1003 static test_return_t
get_test(memcached_st
*memc
)
1005 memcached_return_t rc
;
1006 const char *key
= "foo";
1008 size_t string_length
;
1011 uint64_t query_id
= memcached_query_id(memc
);
1012 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
1013 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
1014 test_compare(query_id
+1, memcached_query_id(memc
));
1016 string
= memcached_get(memc
, key
, strlen(key
),
1017 &string_length
, &flags
, &rc
);
1019 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1020 test_false(string_length
);
1023 return TEST_SUCCESS
;
1026 static test_return_t
get_test2(memcached_st
*memc
)
1028 const char *key
= "foo";
1029 const char *value
= "when we sanitize";
1031 uint64_t query_id
= memcached_query_id(memc
);
1032 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1033 value
, strlen(value
),
1034 (time_t)0, (uint32_t)0);
1035 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1036 test_compare(query_id
+1, memcached_query_id(memc
));
1038 query_id
= memcached_query_id(memc
);
1039 test_true(query_id
);
1042 size_t string_length
;
1043 char *string
= memcached_get(memc
, key
, strlen(key
),
1044 &string_length
, &flags
, &rc
);
1045 test_compare(query_id
+1, memcached_query_id(memc
));
1047 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1048 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1050 test_compare(strlen(value
), string_length
);
1051 test_memcmp(string
, value
, string_length
);
1055 return TEST_SUCCESS
;
1058 static test_return_t
set_test2(memcached_st
*memc
)
1060 const char *key
= "foo";
1061 const char *value
= "train in the brain";
1062 size_t value_length
= strlen(value
);
1064 for (uint32_t x
= 0; x
< 10; x
++)
1066 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1067 value
, value_length
,
1068 (time_t)0, (uint32_t)0);
1069 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1072 return TEST_SUCCESS
;
1075 static test_return_t
set_test3(memcached_st
*memc
)
1077 size_t value_length
= 8191;
1079 char *value
= (char*)malloc(value_length
);
1082 for (uint32_t x
= 0; x
< value_length
; x
++)
1084 value
[x
] = (char) (x
% 127);
1087 /* The dump test relies on there being at least 32 items in memcached */
1088 for (uint32_t x
= 0; x
< 32; x
++)
1092 snprintf(key
, sizeof(key
), "foo%u", x
);
1094 uint64_t query_id
= memcached_query_id(memc
);
1095 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1096 value
, value_length
,
1097 (time_t)0, (uint32_t)0);
1098 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1099 test_compare(query_id
+1, memcached_query_id(memc
));
1104 return TEST_SUCCESS
;
1107 static test_return_t
get_test3(memcached_st
*memc
)
1109 const char *key
= "foo";
1110 size_t value_length
= 8191;
1112 char *value
= (char*)malloc(value_length
);
1115 for (uint32_t x
= 0; x
< value_length
; x
++)
1117 value
[x
] = (char) (x
% 127);
1120 memcached_return_t rc
;
1121 rc
= memcached_set(memc
, key
, strlen(key
),
1122 value
, value_length
,
1123 (time_t)0, (uint32_t)0);
1124 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1126 size_t string_length
;
1128 char *string
= memcached_get(memc
, key
, strlen(key
),
1129 &string_length
, &flags
, &rc
);
1131 test_compare(MEMCACHED_SUCCESS
, rc
);
1133 test_compare(string_length
, value_length
);
1134 test_memcmp(string
, value
, string_length
);
1139 return TEST_SUCCESS
;
1142 static test_return_t
get_test4(memcached_st
*memc
)
1144 const char *key
= "foo";
1145 size_t value_length
= 8191;
1147 char *value
= (char*)malloc(value_length
);
1150 for (uint32_t x
= 0; x
< value_length
; x
++)
1152 value
[x
] = (char) (x
% 127);
1155 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1156 value
, value_length
,
1157 (time_t)0, (uint32_t)0);
1158 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1160 for (uint32_t x
= 0; x
< 10; x
++)
1163 size_t string_length
;
1164 char *string
= memcached_get(memc
, key
, strlen(key
),
1165 &string_length
, &flags
, &rc
);
1167 test_compare(MEMCACHED_SUCCESS
, rc
);
1169 test_compare(string_length
, value_length
);
1170 test_memcmp(string
, value
, string_length
);
1176 return TEST_SUCCESS
;
1180 * This test verifies that memcached_read_one_response doesn't try to
1181 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1182 * responses before you execute a storage command.
1184 static test_return_t
get_test5(memcached_st
*memc
)
1187 ** Request the same key twice, to ensure that we hash to the same server
1188 ** (so that we have multiple response values queued up) ;-)
1190 const char *keys
[]= { "key", "key" };
1191 size_t lengths
[]= { 3, 3 };
1195 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1196 keys
[0], lengths
[0], 0, 0);
1197 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1199 memcached_result_st results_obj
;
1200 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1203 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1206 memcached_result_free(&results_obj
);
1208 /* Don't read out the second result, but issue a set instead.. */
1209 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1211 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1212 &rlen
, &flags
, &rc
);
1214 test_compare(MEMCACHED_NOTFOUND
, rc
);
1215 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1217 test_compare(MEMCACHED_SUCCESS
, rc
);
1220 return TEST_SUCCESS
;
1223 static test_return_t
mget_end(memcached_st
*memc
)
1225 const char *keys
[]= { "foo", "foo2" };
1226 size_t lengths
[]= { 3, 4 };
1227 const char *values
[]= { "fjord", "41" };
1229 memcached_return_t rc
;
1232 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1234 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[x
], lengths
[x
], values
[x
], strlen(values
[x
]), (time_t)0, (uint32_t)0));
1238 size_t string_length
;
1241 // retrieve both via mget
1242 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1244 char key
[MEMCACHED_MAX_KEY
];
1247 // this should get both
1248 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1250 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1252 test_compare(MEMCACHED_SUCCESS
, rc
);
1254 if (key_length
== 4)
1259 test_compare(string_length
, strlen(values
[val
]));
1260 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1264 // this should indicate end
1265 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1266 test_compare(MEMCACHED_END
, rc
);
1269 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1270 test_compare(MEMCACHED_SUCCESS
, rc
);
1272 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1273 test_compare(key_length
, lengths
[0]);
1274 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1275 test_compare(string_length
, strlen(values
[0]));
1276 test_true(strncmp(values
[0], string
, string_length
) == 0);
1277 test_compare(MEMCACHED_SUCCESS
, rc
);
1280 // this should indicate end
1281 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1282 test_compare(MEMCACHED_END
, rc
);
1284 return TEST_SUCCESS
;
1287 /* Do not copy the style of this code, I just access hosts to testthis function */
1288 static test_return_t
stats_servername_test(memcached_st
*memc
)
1290 memcached_stat_st memc_stat
;
1291 memcached_server_instance_st instance
=
1292 memcached_server_instance_by_position(memc
, 0);
1294 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1296 return TEST_SKIPPED
;
1299 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1300 memcached_server_name(instance
),
1301 memcached_server_port(instance
)));
1303 return TEST_SUCCESS
;
1306 static test_return_t
increment_test(memcached_st
*memc
)
1308 uint64_t new_number
;
1310 test_compare(MEMCACHED_SUCCESS
,
1312 test_literal_param("number"),
1313 test_literal_param("0"),
1314 (time_t)0, (uint32_t)0));
1316 test_compare(MEMCACHED_SUCCESS
,
1317 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1318 test_compare(uint64_t(1), new_number
);
1320 test_compare(MEMCACHED_SUCCESS
,
1321 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1322 test_compare(uint64_t(2), new_number
);
1324 return TEST_SUCCESS
;
1327 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1329 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1331 uint64_t new_number
;
1332 uint64_t initial
= 0;
1334 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1336 test_compare(MEMCACHED_SUCCESS
,
1337 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1338 test_compare(new_number
, initial
);
1340 test_compare(MEMCACHED_SUCCESS
,
1341 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1342 test_compare(new_number
, (initial
+1));
1344 return TEST_SUCCESS
;
1347 static test_return_t
decrement_test(memcached_st
*memc
)
1349 uint64_t new_number
;
1350 memcached_return_t rc
;
1351 const char *value
= "3";
1353 rc
= memcached_set(memc
,
1354 test_literal_param("number"),
1355 value
, strlen(value
),
1356 (time_t)0, (uint32_t)0);
1357 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1359 test_compare(MEMCACHED_SUCCESS
,
1360 memcached_decrement(memc
,
1361 test_literal_param("number"),
1363 test_compare(uint64_t(2), new_number
);
1365 test_compare(MEMCACHED_SUCCESS
,
1366 memcached_decrement(memc
,
1367 test_literal_param("number"),
1369 test_compare(uint64_t(1), new_number
);
1371 return TEST_SUCCESS
;
1374 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1376 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1378 uint64_t new_number
;
1379 uint64_t initial
= 3;
1381 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1383 test_compare(MEMCACHED_SUCCESS
,
1384 memcached_decrement_with_initial(memc
,
1385 test_literal_param("number"),
1386 1, initial
, 0, &new_number
));
1387 test_compare(new_number
, initial
);
1389 test_compare(MEMCACHED_SUCCESS
,
1390 memcached_decrement_with_initial(memc
,
1391 test_literal_param("number"),
1392 1, initial
, 0, &new_number
));
1393 test_compare(new_number
, (initial
- 1));
1395 return TEST_SUCCESS
;
1398 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1400 uint64_t new_number
;
1401 memcached_return_t rc
;
1402 const char *master_key
= "foo";
1403 const char *key
= "number";
1404 const char *value
= "0";
1406 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1408 value
, strlen(value
),
1409 (time_t)0, (uint32_t)0);
1410 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1412 test_compare(MEMCACHED_SUCCESS
,
1413 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1414 test_compare(uint64_t(1), new_number
);
1416 test_compare(MEMCACHED_SUCCESS
,
1417 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1418 test_compare(uint64_t(2), new_number
);
1420 return TEST_SUCCESS
;
1423 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1425 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1427 uint64_t new_number
;
1428 memcached_return_t rc
;
1429 const char *master_key
= "foo";
1430 const char *key
= "number";
1431 uint64_t initial
= 0;
1433 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1435 1, initial
, 0, &new_number
);
1436 test_compare(MEMCACHED_SUCCESS
, rc
);
1437 test_compare(new_number
, initial
);
1439 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1441 1, initial
, 0, &new_number
);
1442 test_compare(MEMCACHED_SUCCESS
, rc
);
1443 test_compare(new_number
, (initial
+1));
1445 return TEST_SUCCESS
;
1448 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1450 uint64_t new_number
;
1451 memcached_return_t rc
;
1452 const char *value
= "3";
1454 rc
= memcached_set_by_key(memc
,
1455 test_literal_param("foo"),
1456 test_literal_param("number"),
1457 value
, strlen(value
),
1458 (time_t)0, (uint32_t)0);
1459 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1461 test_compare(MEMCACHED_SUCCESS
,
1462 memcached_decrement_by_key(memc
,
1463 test_literal_param("foo"),
1464 test_literal_param("number"),
1466 test_compare(uint64_t(2), new_number
);
1468 test_compare(MEMCACHED_SUCCESS
,
1469 memcached_decrement_by_key(memc
,
1470 test_literal_param("foo"),
1471 test_literal_param("number"),
1473 test_compare(uint64_t(1), new_number
);
1475 return TEST_SUCCESS
;
1478 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1480 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1482 uint64_t new_number
;
1483 uint64_t initial
= 3;
1485 test_compare(MEMCACHED_SUCCESS
,
1486 memcached_decrement_with_initial_by_key(memc
,
1487 test_literal_param("foo"),
1488 test_literal_param("number"),
1489 1, initial
, 0, &new_number
));
1490 test_compare(new_number
, initial
);
1492 test_compare(MEMCACHED_SUCCESS
,
1493 memcached_decrement_with_initial_by_key(memc
,
1494 test_literal_param("foo"),
1495 test_literal_param("number"),
1496 1, initial
, 0, &new_number
));
1497 test_compare(new_number
, (initial
- 1));
1499 return TEST_SUCCESS
;
1501 static test_return_t
binary_increment_with_prefix_test(memcached_st
*orig_memc
)
1503 memcached_st
*memc
= memcached_clone(NULL
, orig_memc
);
1505 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1507 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1509 memcached_return_t rc
;
1510 rc
= memcached_set(memc
,
1511 test_literal_param("number"),
1512 test_literal_param("0"),
1513 (time_t)0, (uint32_t)0);
1514 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1516 uint64_t new_number
;
1517 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1518 test_literal_param("number"),
1520 test_compare(uint64_t(1), new_number
);
1522 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1523 test_literal_param("number"),
1525 test_compare(uint64_t(2), new_number
);
1526 memcached_free(memc
);
1528 return TEST_SUCCESS
;
1531 static test_return_t
quit_test(memcached_st
*memc
)
1533 memcached_return_t rc
;
1534 const char *key
= "fudge";
1535 const char *value
= "sanford and sun";
1537 rc
= memcached_set(memc
, key
, strlen(key
),
1538 value
, strlen(value
),
1539 (time_t)10, (uint32_t)3);
1540 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1541 memcached_quit(memc
);
1543 rc
= memcached_set(memc
, key
, strlen(key
),
1544 value
, strlen(value
),
1545 (time_t)50, (uint32_t)9);
1546 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1548 return TEST_SUCCESS
;
1551 static test_return_t
mget_result_test(memcached_st
*memc
)
1553 const char *keys
[]= {"fudge", "son", "food"};
1554 size_t key_length
[]= {5, 3, 4};
1556 memcached_result_st results_obj
;
1557 memcached_result_st
*results
;
1559 results
= memcached_result_create(memc
, &results_obj
);
1561 test_true(&results_obj
== results
);
1563 /* We need to empty the server before continueing test */
1564 test_compare(MEMCACHED_SUCCESS
,
1565 memcached_flush(memc
, 0));
1567 test_compare(MEMCACHED_SUCCESS
,
1568 memcached_mget(memc
, keys
, key_length
, 3));
1570 memcached_return_t rc
;
1571 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1576 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1577 test_false(results
);
1578 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1580 for (uint32_t x
= 0; x
< 3; x
++)
1582 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1583 keys
[x
], key_length
[x
],
1584 (time_t)50, (uint32_t)9);
1585 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1588 test_compare(MEMCACHED_SUCCESS
,
1589 memcached_mget(memc
, keys
, key_length
, 3));
1591 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1594 test_true(&results_obj
== results
);
1595 test_compare(MEMCACHED_SUCCESS
, rc
);
1596 test_memcmp(memcached_result_key_value(results
),
1597 memcached_result_value(results
),
1598 memcached_result_length(results
));
1599 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1602 memcached_result_free(&results_obj
);
1604 return TEST_SUCCESS
;
1607 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1609 const char *keys
[]= {"fudge", "son", "food"};
1610 size_t key_length
[]= {5, 3, 4};
1612 memcached_result_st
*results
;
1614 /* We need to empty the server before continueing test */
1615 test_compare(MEMCACHED_SUCCESS
,
1616 memcached_flush(memc
, 0));
1618 test_compare(MEMCACHED_SUCCESS
,
1619 memcached_mget(memc
, keys
, key_length
, 3));
1621 memcached_return_t rc
;
1622 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1626 test_false(results
);
1627 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1629 for (uint32_t x
= 0; x
< 3; x
++)
1631 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1632 keys
[x
], key_length
[x
],
1633 (time_t)50, (uint32_t)9);
1634 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1637 test_compare(MEMCACHED_SUCCESS
,
1638 memcached_mget(memc
, keys
, key_length
, 3));
1641 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1644 test_compare(MEMCACHED_SUCCESS
, rc
);
1645 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1646 test_memcmp(memcached_result_key_value(results
),
1647 memcached_result_value(results
),
1648 memcached_result_length(results
));
1649 memcached_result_free(results
);
1653 return TEST_SUCCESS
;
1656 /* Count the results */
1657 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1659 size_t *counter
= (size_t *)context
;
1661 *counter
= *counter
+ 1;
1663 return MEMCACHED_SUCCESS
;
1666 static test_return_t
mget_result_function(memcached_st
*memc
)
1668 const char *keys
[]= {"fudge", "son", "food"};
1669 size_t key_length
[]= {5, 3, 4};
1671 memcached_execute_fn callbacks
[1];
1673 /* We need to empty the server before continueing test */
1674 test_compare(MEMCACHED_SUCCESS
,
1675 memcached_flush(memc
, 0));
1676 for (uint32_t x
= 0; x
< 3; x
++)
1678 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1679 keys
[x
], key_length
[x
],
1680 (time_t)50, (uint32_t)9);
1681 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1684 test_compare(MEMCACHED_SUCCESS
,
1685 memcached_mget(memc
, keys
, key_length
, 3));
1687 callbacks
[0]= &callback_counter
;
1690 test_compare(MEMCACHED_SUCCESS
,
1691 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1693 test_compare(size_t(3), counter
);
1695 return TEST_SUCCESS
;
1698 static test_return_t
mget_test(memcached_st
*memc
)
1700 const char *keys
[]= {"fudge", "son", "food"};
1701 size_t key_length
[]= {5, 3, 4};
1703 char return_key
[MEMCACHED_MAX_KEY
];
1704 size_t return_key_length
;
1706 size_t return_value_length
;
1708 /* We need to empty the server before continueing test */
1709 test_compare(MEMCACHED_SUCCESS
,
1710 memcached_flush(memc
, 0));
1712 test_compare(MEMCACHED_SUCCESS
,
1713 memcached_mget(memc
, keys
, key_length
, 3));
1716 memcached_return_t rc
;
1717 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1718 &return_value_length
, &flags
, &rc
)))
1720 test_true(return_value
);
1722 test_false(return_value
);
1723 test_zero(return_value_length
);
1724 test_compare(MEMCACHED_NOTFOUND
, rc
);
1726 for (uint32_t x
= 0; x
< 3; x
++)
1728 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1729 keys
[x
], key_length
[x
],
1730 (time_t)50, (uint32_t)9);
1731 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1733 test_compare(MEMCACHED_SUCCESS
,
1734 memcached_mget(memc
, keys
, key_length
, 3));
1737 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1738 &return_value_length
, &flags
, &rc
)))
1740 test_true(return_value
);
1741 test_compare(MEMCACHED_SUCCESS
, rc
);
1742 if (not memc
->_namespace
)
1744 test_compare(return_key_length
, return_value_length
);
1745 test_memcmp(return_value
, return_key
, return_value_length
);
1751 return TEST_SUCCESS
;
1754 static test_return_t
mget_execute(memcached_st
*memc
)
1758 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1762 * I only want to hit _one_ server so I know the number of requests I'm
1763 * sending in the pipeline.
1765 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1766 memc
->number_of_hosts
= 1;
1768 size_t max_keys
= 20480;
1771 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1772 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1774 /* First add all of the items.. */
1775 char blob
[1024] = {0};
1776 memcached_return_t rc
;
1778 for (size_t x
= 0; x
< max_keys
; ++x
)
1782 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1784 test_true(keys
[x
] != NULL
);
1785 uint64_t query_id
= memcached_query_id(memc
);
1786 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1787 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1788 test_compare(query_id
+1, memcached_query_id(memc
));
1791 /* Try to get all of them with a large multiget */
1793 memcached_execute_fn callbacks
[]= { &callback_counter
};
1794 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1795 max_keys
, callbacks
, &counter
, 1);
1797 if (memcached_success(rc
))
1800 uint64_t query_id
= memcached_query_id(memc
);
1801 test_compare(MEMCACHED_SUCCESS
,
1802 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1803 test_compare(query_id
, memcached_query_id(memc
));
1805 /* Verify that we got all of the items */
1806 test_true(counter
== max_keys
);
1808 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1810 test_true(counter
== 0);
1814 test_fail("note: this test functions differently when in binary mode");
1817 /* Release all allocated resources */
1818 for (size_t x
= 0; x
< max_keys
; ++x
)
1825 memc
->number_of_hosts
= number_of_hosts
;
1826 return TEST_SUCCESS
;
1829 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1831 static test_return_t
key_setup(memcached_st
*memc
)
1833 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1835 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1837 return TEST_SUCCESS
;
1840 static test_return_t
key_teardown(memcached_st
*memc
)
1843 pairs_free(global_pairs
);
1845 return TEST_SUCCESS
;
1848 static test_return_t
block_add_regression(memcached_st
*memc
)
1850 /* First add all of the items.. */
1851 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1853 memcached_return_t rc
;
1854 char blob
[1024] = {0};
1856 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1857 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1860 return TEST_SUCCESS
;
1863 static test_return_t
binary_add_regression(memcached_st
*memc
)
1865 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1866 test_return_t rc
= block_add_regression(memc
);
1867 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1871 static test_return_t
get_stats_keys(memcached_st
*memc
)
1875 memcached_stat_st memc_stat
;
1876 memcached_return_t rc
;
1878 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1879 test_compare(MEMCACHED_SUCCESS
, rc
);
1880 for (ptr
= stat_list
; *ptr
; ptr
++)
1885 return TEST_SUCCESS
;
1888 static test_return_t
version_string_test(memcached_st
*memc
)
1890 const char *version_string
;
1893 version_string
= memcached_lib_version();
1895 test_strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
);
1897 return TEST_SUCCESS
;
1900 static test_return_t
get_stats(memcached_st
*memc
)
1902 memcached_return_t rc
;
1904 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1905 test_compare(MEMCACHED_SUCCESS
, rc
);
1906 test_true(memc_stat
);
1908 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1910 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1911 test_compare(MEMCACHED_SUCCESS
, rc
);
1912 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1917 memcached_stat_free(NULL
, memc_stat
);
1919 return TEST_SUCCESS
;
1922 static test_return_t
add_host_test(memcached_st
*memc
)
1925 memcached_server_st
*servers
;
1926 memcached_return_t rc
;
1927 char servername
[]= "0.example.com";
1929 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1931 test_true(1 == memcached_server_list_count(servers
));
1933 for (x
= 2; x
< 20; x
++)
1935 char buffer
[SMALL_STRING_LEN
];
1937 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1938 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1940 test_compare(MEMCACHED_SUCCESS
, rc
);
1941 test_true(x
== memcached_server_list_count(servers
));
1944 rc
= memcached_server_push(memc
, servers
);
1945 test_compare(MEMCACHED_SUCCESS
, rc
);
1946 rc
= memcached_server_push(memc
, servers
);
1947 test_compare(MEMCACHED_SUCCESS
, rc
);
1949 memcached_server_list_free(servers
);
1951 return TEST_SUCCESS
;
1954 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1956 memcached_return_t rc
;
1957 const char *key
= "not_found";
1958 size_t key_len
= strlen(key
);
1960 test_compare(MEMCACHED_SUCCESS
,
1961 memcached_mget(memc
, &key
, &key_len
, 1));
1963 memcached_result_st
*result
= NULL
;
1964 result
= memcached_fetch_result(memc
, result
, &rc
);
1966 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1968 memcached_result_free(result
);
1970 return TEST_SUCCESS
;
1973 static memcached_return_t
clone_test_callback(memcached_st
*parent
, memcached_st
*memc_clone
)
1975 (void)parent
;(void)memc_clone
;
1976 return MEMCACHED_SUCCESS
;
1979 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
)
1982 return MEMCACHED_SUCCESS
;
1985 static test_return_t
callback_test(memcached_st
*memc
)
1987 /* Test User Data */
1991 memcached_return_t rc
;
1993 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1994 test_compare(MEMCACHED_SUCCESS
, rc
);
1995 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1996 test_true(*test_ptr
== x
);
1999 /* Test Clone Callback */
2001 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2002 void *clone_cb_ptr
= *(void **)&clone_cb
;
2003 void *temp_function
= NULL
;
2004 memcached_return_t rc
;
2006 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2008 test_compare(MEMCACHED_SUCCESS
, rc
);
2009 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2010 test_true(temp_function
== clone_cb_ptr
);
2013 /* Test Cleanup Callback */
2015 memcached_cleanup_fn cleanup_cb
=
2016 (memcached_cleanup_fn
)cleanup_test_callback
;
2017 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2018 void *temp_function
= NULL
;
2019 memcached_return_t rc
;
2021 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2023 test_compare(MEMCACHED_SUCCESS
, rc
);
2024 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2025 test_true(temp_function
== cleanup_cb_ptr
);
2028 return TEST_SUCCESS
;
2031 /* We don't test the behavior itself, we test the switches */
2032 static test_return_t
behavior_test(memcached_st
*memc
)
2037 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2038 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2039 test_true(value
== 1);
2041 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2042 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2043 test_true(value
== 1);
2045 set
= MEMCACHED_HASH_MD5
;
2046 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2047 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2048 test_true(value
== MEMCACHED_HASH_MD5
);
2052 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2053 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2054 test_true(value
== 0);
2056 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2057 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2058 test_true(value
== 0);
2060 set
= MEMCACHED_HASH_DEFAULT
;
2061 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2062 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2063 test_true(value
== MEMCACHED_HASH_DEFAULT
);
2065 set
= MEMCACHED_HASH_CRC
;
2066 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2067 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2068 test_true(value
== MEMCACHED_HASH_CRC
);
2070 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2071 test_true(value
> 0);
2073 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2074 test_true(value
> 0);
2076 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2077 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
2078 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2080 return TEST_SUCCESS
;
2083 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2085 memcached_return_t rc
;
2088 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
2089 test_true(rc
== MEMCACHED_DEPRECATED
);
2091 // Platform dependent
2093 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2097 return TEST_SUCCESS
;
2101 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2103 memcached_return_t rc
;
2107 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, set
);
2108 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2110 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2112 if (rc
== MEMCACHED_SUCCESS
)
2114 test_true((bool)value
== set
);
2118 test_false((bool)value
== set
);
2121 return TEST_SUCCESS
;
2125 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2127 memcached_return_t rc
;
2131 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, set
);
2132 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2134 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2136 if (rc
== MEMCACHED_SUCCESS
)
2138 test_true((bool)value
== set
);
2142 test_false((bool)value
== set
);
2145 return TEST_SUCCESS
;
2148 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, const memcached_return_t expect
)
2150 memcached_return_t rc
;
2151 char return_key
[MEMCACHED_MAX_KEY
];
2152 size_t return_key_length
;
2154 size_t return_value_length
;
2158 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2159 &return_value_length
, &flags
, &rc
)))
2161 test_true(return_value
);
2162 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2167 if (memcached_success(expect
) and memcached_success(rc
))
2169 return TEST_SUCCESS
;
2171 else if (expect
== rc
)
2173 return TEST_SUCCESS
;
2175 fprintf(stderr
, "\n%s:%u %s(#%u)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), keys_returned
);
2177 return TEST_FAILURE
;
2180 /* Test case provided by Cal Haldenbrand */
2181 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2182 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2183 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2185 /* We just keep looking at the same values over and over */
2188 unsigned int setter
= 1;
2189 test_compare(MEMCACHED_SUCCESS
,
2190 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2191 test_compare(MEMCACHED_SUCCESS
,
2192 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2196 unsigned long long total
= 0;
2197 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2199 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2200 char randomstuff
[6 * 1024];
2201 memset(randomstuff
, 0, 6 * 1024);
2202 test_true(size
< 6 * 1024); /* Being safe here */
2204 for (uint32_t j
= 0 ; j
< size
;j
++)
2206 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2211 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2212 test_compare(MEMCACHED_SUCCESS
,
2213 memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
));
2215 test_true(total
> HALDENBRAND_KEY_COUNT
);
2217 return TEST_SUCCESS
;
2220 /* Test case provided by Cal Haldenbrand */
2221 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2223 unsigned int setter
= 1;
2225 test_compare(MEMCACHED_SUCCESS
,
2226 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2228 test_compare(MEMCACHED_SUCCESS
,
2229 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2232 setter
= 20 * 1024576;
2233 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2234 setter
= 20 * 1024576;
2235 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2236 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2237 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2239 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2242 size_t total_value_length
= 0;
2243 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2248 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2249 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2251 memcached_return_t rc
;
2252 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2253 if (memcached_failed(rc
))
2255 if (rc
== MEMCACHED_NOTFOUND
)
2266 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2268 total_value_length
+= val_len
;
2273 return TEST_SUCCESS
;
2276 /* Do a large mget() over all the keys we think exist */
2277 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2279 unsigned int setter
= 1;
2280 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2281 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2283 setter
= 20 * 1024576;
2284 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2285 setter
= 20 * 1024576;
2286 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2287 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2288 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2291 size_t key_lengths
[HALDENBRAND_KEY_COUNT
];
2292 char **keys
= static_cast<char **>(calloc(HALDENBRAND_KEY_COUNT
, sizeof(char *)));
2294 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2296 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2297 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2298 keys
[x
]= strdup(key
);
2300 key_lengths
[x
]= key_length
;
2301 test_compare(size_t(key_length
), strlen(keys
[x
]));
2304 test_compare(MEMCACHED_SUCCESS
,
2305 memcached_mget(memc
, (const char **)keys
, key_lengths
, HALDENBRAND_KEY_COUNT
));
2307 unsigned int keys_returned
;
2308 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
2309 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2311 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2317 return TEST_SUCCESS
;
2320 /* Make sure we behave properly if server list has no values */
2321 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2323 const char *keys
[]= {"fudge", "son", "food"};
2324 size_t key_length
[]= {5, 3, 4};
2326 /* Here we free everything before running a bunch of mget tests */
2327 memcached_servers_reset(memc
);
2330 /* We need to empty the server before continueing test */
2331 test_compare(MEMCACHED_NO_SERVERS
,
2332 memcached_flush(memc
, 0));
2334 test_compare(MEMCACHED_NO_SERVERS
,
2335 memcached_mget(memc
, keys
, key_length
, 3));
2337 unsigned int keys_returned
;
2338 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2339 test_zero(keys_returned
);
2341 for (uint32_t x
= 0; x
< 3; x
++)
2343 test_compare(MEMCACHED_NO_SERVERS
,
2344 memcached_set(memc
, keys
[x
], key_length
[x
],
2345 keys
[x
], key_length
[x
],
2346 (time_t)50, (uint32_t)9));
2349 test_compare(MEMCACHED_NO_SERVERS
,
2350 memcached_mget(memc
, keys
, key_length
, 3));
2354 char return_key
[MEMCACHED_MAX_KEY
];
2355 memcached_return_t rc
;
2356 size_t return_key_length
;
2357 size_t return_value_length
;
2360 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2361 &return_value_length
, &flags
, &rc
)))
2363 test_true(return_value
);
2364 test_compare(MEMCACHED_SUCCESS
, rc
);
2365 test_true(return_key_length
== return_value_length
);
2366 test_memcmp(return_value
, return_key
, return_value_length
);
2372 return TEST_SUCCESS
;
2375 #define VALUE_SIZE_BUG5 1048064
2376 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2378 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2379 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2381 size_t value_length
;
2383 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2385 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2387 insert_data
[x
]= (signed char)rand();
2390 test_compare(MEMCACHED_SUCCESS
,
2391 memcached_flush(memc
, 0));
2393 memcached_return_t rc
;
2394 value
= memcached_get(memc
, keys
[0], key_length
[0],
2395 &value_length
, &flags
, &rc
);
2397 test_compare(MEMCACHED_SUCCESS
,
2398 memcached_mget(memc
, keys
, key_length
, 4));
2401 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2404 for (uint32_t x
= 0; x
< 4; x
++)
2406 test_compare(MEMCACHED_SUCCESS
,
2407 memcached_set(memc
, keys
[x
], key_length
[x
],
2408 insert_data
, VALUE_SIZE_BUG5
,
2409 (time_t)0, (uint32_t)0));
2412 for (uint32_t x
= 0; x
< 10; x
++)
2414 value
= memcached_get(memc
, keys
[0], key_length
[0],
2415 &value_length
, &flags
, &rc
);
2416 test_compare(rc
, MEMCACHED_SUCCESS
);
2420 test_compare(MEMCACHED_SUCCESS
,
2421 memcached_mget(memc
, keys
, key_length
, 4));
2423 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2424 test_compare(4U, count
);
2426 delete [] insert_data
;
2428 return TEST_SUCCESS
;
2431 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2433 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2434 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2435 char return_key
[MEMCACHED_MAX_KEY
];
2436 size_t return_key_length
;
2438 size_t value_length
;
2440 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2442 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2444 insert_data
[x
]= (signed char)rand();
2447 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2449 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2451 // We will now confirm that memcached_mget() returns success, but we will
2452 // then check to make sure that no actual keys are returned.
2453 test_compare(MEMCACHED_SUCCESS
,
2454 memcached_mget(memc
, keys
, key_length
, 4));
2456 memcached_return_t rc
;
2458 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2459 &value_length
, &flags
, &rc
)))
2464 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2466 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2468 test_compare(MEMCACHED_SUCCESS
,
2469 memcached_set(memc
, keys
[x
], key_length
[x
],
2470 insert_data
, VALUE_SIZE_BUG5
,
2471 (time_t)0, (uint32_t)0));
2473 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2475 for (uint32_t x
= 0; x
< 2; x
++)
2477 value
= memcached_get(memc
, keys
[0], key_length
[0],
2478 &value_length
, &flags
, &rc
);
2482 test_compare(MEMCACHED_SUCCESS
,
2483 memcached_mget(memc
, keys
, key_length
, 4));
2484 /* We test for purge of partial complete fetches */
2485 for (count
= 3; count
; count
--)
2487 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2488 &value_length
, &flags
, &rc
);
2489 test_compare(MEMCACHED_SUCCESS
, rc
);
2490 test_memcmp(value
, insert_data
, value_length
);
2491 test_true(value_length
);
2495 delete [] insert_data
;
2497 return TEST_SUCCESS
;
2500 static test_return_t
user_supplied_bug8(memcached_st
*)
2502 memcached_return_t rc
;
2504 memcached_st
*memc_clone
;
2506 memcached_server_st
*servers
;
2507 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";
2509 servers
= memcached_servers_parse(server_list
);
2512 mine
= memcached_create(NULL
);
2513 rc
= memcached_server_push(mine
, servers
);
2514 test_compare(MEMCACHED_SUCCESS
, rc
);
2515 memcached_server_list_free(servers
);
2518 memc_clone
= memcached_clone(NULL
, mine
);
2520 memcached_quit(mine
);
2521 memcached_quit(memc_clone
);
2524 memcached_free(mine
);
2525 memcached_free(memc_clone
);
2527 return TEST_SUCCESS
;
2530 /* Test flag store/retrieve */
2531 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2533 const char *keys
= "036790384900";
2534 size_t key_length
= strlen(keys
);
2535 char return_key
[MEMCACHED_MAX_KEY
];
2536 size_t return_key_length
;
2538 size_t value_length
;
2540 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2542 for (unsigned int x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2543 insert_data
[x
]= (signed char)rand();
2545 memcached_flush(memc
, 0);
2548 memcached_return_t rc
= memcached_set(memc
, keys
, key_length
,
2549 insert_data
, VALUE_SIZE_BUG5
,
2551 test_compare(MEMCACHED_SUCCESS
, rc
);
2554 value
= memcached_get(memc
, keys
, key_length
,
2555 &value_length
, &flags
, &rc
);
2556 test_true(flags
== 245);
2560 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2563 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2564 &value_length
, &flags
, &rc
);
2565 test_compare(uint32_t(245), flags
);
2568 delete [] insert_data
;
2571 return TEST_SUCCESS
;
2574 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2576 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2577 size_t key_length
[3];
2581 char return_key
[MEMCACHED_MAX_KEY
];
2582 size_t return_key_length
;
2584 size_t return_value_length
;
2587 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2588 key_length
[1]= strlen("fudge&*@#");
2589 key_length
[2]= strlen("for^#@&$not");
2592 for (unsigned int x
= 0; x
< 3; x
++)
2594 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2595 keys
[x
], key_length
[x
],
2596 (time_t)50, (uint32_t)9);
2597 test_compare(MEMCACHED_SUCCESS
, rc
);
2600 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2601 test_compare(MEMCACHED_SUCCESS
, rc
);
2603 /* We need to empty the server before continueing test */
2604 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2605 &return_value_length
, &flags
, &rc
)) != NULL
)
2607 test_true(return_value
);
2611 test_compare(3U, count
);
2613 return TEST_SUCCESS
;
2616 /* We are testing with aggressive timeout to get failures */
2617 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2619 size_t value_length
= 512;
2620 unsigned int set
= 1;
2621 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2623 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2624 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2625 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2627 char *value
= (char*)malloc(value_length
* sizeof(char));
2629 for (unsigned int x
= 0; x
< value_length
; x
++)
2631 value
[x
]= (char) (x
% 127);
2634 for (unsigned int x
= 1; x
<= 100000; ++x
)
2636 memcached_return_t rc
= memcached_set(mclone
,
2637 test_literal_param("foo"),
2638 value
, value_length
, 0, 0);
2640 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2641 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2642 memcached_strerror(NULL
, rc
));
2644 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2651 memcached_free(mclone
);
2653 return TEST_SUCCESS
;
2657 We are looking failures in the async protocol
2659 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2661 const char *key
= "foo";
2662 size_t value_length
= 512;
2664 unsigned int set
= 1;
2665 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2667 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2668 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2669 int32_t timeout
= -1;
2670 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, (size_t)timeout
);
2672 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2674 test_true(timeout
== -1);
2676 char *value
= (char*)malloc(value_length
* sizeof(char));
2678 for (unsigned int x
= 0; x
< value_length
; x
++)
2680 value
[x
]= (char) (x
% 127);
2683 for (unsigned int x
= 1; x
<= 100000; ++x
)
2685 memcached_return_t rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2690 memcached_free(mclone
);
2692 return TEST_SUCCESS
;
2696 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2698 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2700 memcached_return_t rc
;
2702 size_t value_length
;
2704 uint64_t number_value
;
2706 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2707 &value_length
, &flags
, &rc
);
2708 test_true(value
== NULL
);
2709 test_compare(MEMCACHED_NOTFOUND
, rc
);
2711 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2714 test_true(value
== NULL
);
2715 /* The binary protocol will set the key if it doesn't exist */
2716 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2718 test_compare(MEMCACHED_SUCCESS
, rc
);
2722 test_compare(MEMCACHED_NOTFOUND
, rc
);
2725 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2727 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2728 &value_length
, &flags
, &rc
);
2730 test_compare(MEMCACHED_SUCCESS
, rc
);
2733 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2735 test_true(number_value
== 2);
2736 test_compare(MEMCACHED_SUCCESS
, rc
);
2738 return TEST_SUCCESS
;
2742 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2743 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2745 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2747 char key
[] = "key34567890";
2748 memcached_return_t rc
;
2749 size_t overflowSize
;
2751 char commandFirst
[]= "set key34567890 0 0 ";
2752 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2753 size_t commandLength
;
2756 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2758 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2760 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2762 char *overflow
= new (std::nothrow
) char[testSize
];
2763 test_true(overflow
);
2765 memset(overflow
, 'x', testSize
);
2766 rc
= memcached_set(memc
, key
, strlen(key
),
2767 overflow
, testSize
, 0, 0);
2768 test_compare(MEMCACHED_SUCCESS
, rc
);
2772 return TEST_SUCCESS
;
2777 Test values of many different sizes
2778 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2779 set key34567890 0 0 8169 \r\n
2780 is sent followed by buffer of size 8169, followed by 8169
2782 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2785 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2786 memcached_return_t rc
;
2787 const char *key
= "foo";
2789 size_t value_length
= 18000;
2791 size_t string_length
;
2794 size_t current_length
;
2796 value
= (char*)malloc(value_length
);
2799 for (x
= 0; x
< value_length
; x
++)
2800 value
[x
] = (char) (x
% 127);
2802 for (current_length
= 0; current_length
< value_length
; current_length
++)
2804 rc
= memcached_set(memc
, key
, strlen(key
),
2805 value
, current_length
,
2806 (time_t)0, (uint32_t)0);
2807 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2809 string
= memcached_get(memc
, key
, strlen(key
),
2810 &string_length
, &flags
, &rc
);
2812 test_compare(MEMCACHED_SUCCESS
, rc
);
2813 test_true(string_length
== current_length
);
2814 test_memcmp(string
, value
, string_length
);
2821 return TEST_SUCCESS
;
2825 Look for zero length value problems
2827 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2830 memcached_return_t rc
;
2831 const char *key
= "mykey";
2835 for (x
= 0; x
< 2; x
++)
2837 rc
= memcached_set(memc
, key
, strlen(key
),
2839 (time_t)0, (uint32_t)0);
2841 test_compare(MEMCACHED_SUCCESS
, rc
);
2843 char *value
= memcached_get(memc
, key
, strlen(key
),
2844 &length
, &flags
, &rc
);
2846 test_compare(MEMCACHED_SUCCESS
, rc
);
2851 value
= memcached_get(memc
, key
, strlen(key
),
2852 &length
, &flags
, &rc
);
2854 test_compare(MEMCACHED_SUCCESS
, rc
);
2855 test_true(value
== NULL
);
2856 test_true(length
== 0);
2857 test_true(flags
== 0);
2860 return TEST_SUCCESS
;
2863 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2864 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2866 memcached_return_t rc
;
2867 const char *key
= "mykey";
2872 rc
= memcached_set(memc
, key
, strlen(key
),
2874 (time_t)0, UINT32_MAX
);
2876 test_compare(MEMCACHED_SUCCESS
, rc
);
2878 value
= memcached_get(memc
, key
, strlen(key
),
2879 &length
, &flags
, &rc
);
2881 test_compare(MEMCACHED_SUCCESS
, rc
);
2882 test_true(value
== NULL
);
2883 test_true(length
== 0);
2884 test_true(flags
== UINT32_MAX
);
2886 return TEST_SUCCESS
;
2889 #if !defined(__sun) && !defined(__OpenBSD__)
2890 /* Check the validity of chinese key*/
2891 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2893 memcached_return_t rc
;
2894 const char *key
= "豆瓣";
2895 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2900 rc
= memcached_set(memc
, key
, strlen(key
),
2901 value
, strlen(value
),
2904 test_compare(MEMCACHED_SUCCESS
, rc
);
2906 value2
= memcached_get(memc
, key
, strlen(key
),
2907 &length
, &flags
, &rc
);
2909 test_true(length
==strlen(value
));
2910 test_compare(MEMCACHED_SUCCESS
, rc
);
2911 test_memcmp(value
, value2
, length
);
2914 return TEST_SUCCESS
;
2922 static test_return_t
user_supplied_bug19(memcached_st
*)
2924 memcached_return_t res
;
2926 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2928 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2931 memcached_free(memc
);
2933 return TEST_SUCCESS
;
2936 /* CAS test from Andei */
2937 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2939 memcached_return_t status
;
2940 memcached_result_st
*result
, result_obj
;
2941 const char *key
= "abc";
2942 size_t key_len
= strlen("abc");
2943 const char *value
= "foobar";
2944 size_t value_len
= strlen(value
);
2946 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2948 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2949 test_true(status
== MEMCACHED_SUCCESS
);
2951 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2952 test_true(status
== MEMCACHED_SUCCESS
);
2954 result
= memcached_result_create(memc
, &result_obj
);
2957 memcached_result_create(memc
, &result_obj
);
2958 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2961 test_true(status
== MEMCACHED_SUCCESS
);
2963 memcached_result_free(result
);
2965 return TEST_SUCCESS
;
2968 /* Large mget() of missing keys with binary proto
2970 * If many binary quiet commands (such as getq's in an mget) fill the output
2971 * buffer and the server chooses not to respond, memcached_flush hangs. See
2972 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2975 /* sighandler_t function that always asserts false */
2976 static void fail(int)
2982 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2987 return TEST_SKIPPED
;
2989 void (*oldalarm
)(int);
2991 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2992 test_true(memc_clone
);
2994 /* only binproto uses getq for mget */
2995 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
2997 /* empty the cache to ensure misses (hence non-responses) */
2998 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
3000 size_t* key_lengths
= new (std::nothrow
) size_t[key_count
];
3001 test_true(key_lengths
);
3002 char **keys
= static_cast<char **>(calloc(key_count
, sizeof(char *)));
3004 for (unsigned int x
= 0; x
< key_count
; x
++)
3008 snprintf(buffer
, 30, "%u", x
);
3009 keys
[x
]= strdup(buffer
);
3011 key_lengths
[x
]= strlen(keys
[x
]);
3014 oldalarm
= signal(SIGALRM
, fail
);
3017 test_compare_got(MEMCACHED_SUCCESS
,
3018 memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
), memcached_last_error_message(memc_clone
));
3021 signal(SIGALRM
, oldalarm
);
3023 memcached_return_t rc
;
3025 char return_key
[MEMCACHED_MAX_KEY
];
3026 size_t return_key_length
;
3028 size_t return_value_length
;
3029 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
3030 &return_value_length
, &flags
, &rc
)))
3032 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
3034 test_compare(MEMCACHED_NOTFOUND
, rc
);
3035 test_zero(return_value_length
);
3036 test_zero(return_key_length
);
3037 test_false(return_key
[0]);
3038 test_false(return_value
);
3040 for (unsigned int x
= 0; x
< key_count
; x
++)
3045 delete [] key_lengths
;
3047 memcached_free(memc_clone
);
3049 return TEST_SUCCESS
;
3053 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3055 test_return_t test_rc
;
3056 test_rc
= pre_binary(memc
);
3058 if (test_rc
!= TEST_SUCCESS
)
3061 /* should work as of r580 */
3062 test_compare(TEST_SUCCESS
,
3063 _user_supplied_bug21(memc
, 10));
3065 /* should fail as of r580 */
3066 test_compare(TEST_SUCCESS
,
3067 _user_supplied_bug21(memc
, 1000));
3069 return TEST_SUCCESS
;
3072 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
3076 memcached_return_t rc
;
3077 memcached_st
*memc
= memcached_create(NULL
);
3081 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3082 test_compare(MEMCACHED_SUCCESS
, rc
);
3084 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3085 test_true(value
== 1);
3087 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3088 test_compare(MEMCACHED_SUCCESS
, rc
);
3090 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3091 test_true(value
== MEMCACHED_HASH_MD5
);
3094 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3096 memcached_server_st
*server_pool
;
3097 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");
3098 memcached_server_push(memc
, server_pool
);
3100 // @todo this needs to be refactored to actually test something.
3103 if ((fp
= fopen("ketama_keys.txt", "w")))
3107 printf("cannot write to file ketama_keys.txt");
3108 return TEST_FAILURE
;
3111 for (int x
= 0; x
< 10000; x
++)
3114 snprintf(key
, sizeof(key
), "%d", x
);
3116 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3117 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3118 in_port_t port
= memc
->hosts
[server_idx
].port
;
3119 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3120 memcached_server_instance_st instance
=
3121 memcached_server_instance_by_position(memc
, host_index
);
3125 memcached_server_list_free(server_pool
);
3126 memcached_free(memc
);
3128 return TEST_SUCCESS
;
3132 static test_return_t
result_static(memcached_st
*memc
)
3134 memcached_result_st result
;
3135 memcached_result_st
*result_ptr
;
3137 result_ptr
= memcached_result_create(memc
, &result
);
3138 test_true(result
.options
.is_allocated
== false);
3139 test_true(memcached_is_initialized(&result
) == true);
3140 test_true(result_ptr
);
3141 test_true(result_ptr
== &result
);
3143 memcached_result_free(&result
);
3145 test_true(result
.options
.is_allocated
== false);
3146 test_true(memcached_is_initialized(&result
) == false);
3148 return TEST_SUCCESS
;
3151 static test_return_t
result_alloc(memcached_st
*memc
)
3153 memcached_result_st
*result_ptr
;
3155 result_ptr
= memcached_result_create(memc
, NULL
);
3156 test_true(result_ptr
);
3157 test_true(result_ptr
->options
.is_allocated
== true);
3158 test_true(memcached_is_initialized(result_ptr
) == true);
3159 memcached_result_free(result_ptr
);
3161 return TEST_SUCCESS
;
3164 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3167 pairs_free(global_pairs
);
3169 return TEST_SUCCESS
;
3172 static test_return_t
generate_pairs(memcached_st
*memc
)
3175 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3176 global_count
= GLOBAL_COUNT
;
3178 for (size_t x
= 0; x
< global_count
; x
++)
3180 global_keys
[x
]= global_pairs
[x
].key
;
3181 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3184 return TEST_SUCCESS
;
3187 static test_return_t
generate_large_pairs(memcached_st
*)
3189 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3190 global_count
= GLOBAL2_COUNT
;
3192 for (size_t x
= 0; x
< global_count
; x
++)
3194 global_keys
[x
]= global_pairs
[x
].key
;
3195 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3198 return TEST_SUCCESS
;
3201 static test_return_t
generate_data(memcached_st
*memc
)
3203 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3205 test_compare(check_execute
, global_count
);
3207 return TEST_SUCCESS
;
3210 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3212 uint32_t host_index
= 0;
3213 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3215 test_true(check_execute
== global_count
);
3217 // @todo hosts used size stats
3218 memcached_return_t rc
;
3219 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3222 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3224 /* This test was changes so that "make test" would work properlly */
3227 memcached_server_instance_st instance
=
3228 memcached_server_instance_by_position(memc
, host_index
);
3230 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3232 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3235 memcached_stat_free(NULL
, stat_p
);
3237 return TEST_SUCCESS
;
3239 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3244 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3245 generate_data(memc
);
3247 return TEST_SUCCESS
;
3250 static test_return_t
get_read_count(memcached_st
*memc
)
3252 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3253 test_true(memc_clone
);
3255 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3259 size_t return_value_length
;
3263 for (size_t x
= count
= 0; x
< global_count
; x
++)
3265 memcached_return_t rc
;
3266 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3267 &return_value_length
, &flags
, &rc
);
3268 if (rc
== MEMCACHED_SUCCESS
)
3279 memcached_free(memc_clone
);
3281 return TEST_SUCCESS
;
3284 static test_return_t
get_read(memcached_st
*memc
)
3286 for (size_t x
= 0; x
< global_count
; x
++)
3288 size_t return_value_length
;
3290 memcached_return_t rc
;
3291 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3292 &return_value_length
, &flags
, &rc
);
3294 test_true(return_value);
3295 test_compare(MEMCACHED_SUCCESS, rc);
3297 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3303 return TEST_SUCCESS
;
3306 static test_return_t
mget_read(memcached_st
*memc
)
3309 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3311 test_compare(MEMCACHED_SUCCESS
,
3312 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3314 // Go fetch the keys and test to see if all of them were returned
3316 unsigned int keys_returned
;
3317 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3318 test_true(keys_returned
> 0);
3319 test_compare_got(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3322 return TEST_SUCCESS
;
3325 static test_return_t
mget_read_result(memcached_st
*memc
)
3328 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3330 test_compare(MEMCACHED_SUCCESS
,
3331 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3333 /* Turn this into a help function */
3335 memcached_result_st results_obj
;
3336 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3338 memcached_return_t rc
;
3339 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3341 if (rc
== MEMCACHED_IN_PROGRESS
)
3347 test_compare(MEMCACHED_SUCCESS
, rc
);
3349 test_compare(MEMCACHED_END
, rc
);
3351 memcached_result_free(&results_obj
);
3354 return TEST_SUCCESS
;
3357 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3360 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3362 test_compare(MEMCACHED_SUCCESS
,
3363 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3365 memcached_result_st
*results
= NULL
;
3366 memcached_return_t rc
;
3367 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3370 test_compare(MEMCACHED_SUCCESS
, rc
);
3372 test_compare(MEMCACHED_END
, rc
);
3374 memcached_result_free(results
);
3377 return TEST_SUCCESS
;
3380 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3383 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3385 test_compare(MEMCACHED_SUCCESS
,
3386 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3388 // We will scan for just one key
3390 memcached_result_st results_obj
;
3391 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3393 memcached_return_t rc
;
3394 results
= memcached_fetch_result(memc
, results
, &rc
);
3396 test_compare(MEMCACHED_SUCCESS
, rc
);
3398 memcached_result_free(&results_obj
);
3401 // We already have a read happening, lets start up another one.
3402 test_compare(MEMCACHED_SUCCESS
,
3403 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3405 memcached_result_st results_obj
;
3406 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3408 memcached_return_t rc
;
3409 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3412 test_compare(MEMCACHED_SUCCESS
, rc
);
3414 test_compare(MEMCACHED_END
, rc
);
3416 memcached_result_free(&results_obj
);
3419 return TEST_SUCCESS
;
3422 static test_return_t
mget_read_function(memcached_st
*memc
)
3424 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3426 test_compare(MEMCACHED_SUCCESS
,
3427 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3429 memcached_execute_fn callbacks
[]= { &callback_counter
};
3431 test_compare(MEMCACHED_SUCCESS
,
3432 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3434 return TEST_SUCCESS
;
3437 static test_return_t
delete_generate(memcached_st
*memc
)
3439 for (size_t x
= 0; x
< global_count
; x
++)
3441 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3444 return TEST_SUCCESS
;
3447 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3450 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3452 for (size_t x
= 0; x
< global_count
; x
++)
3454 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3457 return TEST_SUCCESS
;
3460 static test_return_t
add_host_test1(memcached_st
*memc
)
3462 memcached_return_t rc
;
3463 char servername
[]= "0.example.com";
3465 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3467 test_compare(1U, memcached_server_list_count(servers
));
3469 for (uint32_t x
= 2; x
< 20; x
++)
3471 char buffer
[SMALL_STRING_LEN
];
3473 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3474 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3476 test_compare(MEMCACHED_SUCCESS
, rc
);
3477 test_compare(x
, memcached_server_list_count(servers
));
3480 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3481 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3483 memcached_server_list_free(servers
);
3485 return TEST_SUCCESS
;
3488 static test_return_t
pre_nonblock(memcached_st
*memc
)
3490 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3492 return TEST_SUCCESS
;
3495 static test_return_t
pre_cork(memcached_st
*memc
)
3498 return TEST_SKIPPED
;
3501 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3502 return TEST_SUCCESS
;
3504 return TEST_SKIPPED
;
3507 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3510 return TEST_SKIPPED
;
3512 test_return_t test_rc
;
3513 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3516 return pre_nonblock(memc
);
3519 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3521 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3522 test_true(memc_clone
);
3524 // The memcached_version needs to be done on a clone, because the server
3525 // will not toggle protocol on an connection.
3526 memcached_version(memc_clone
);
3528 memcached_return_t rc
= MEMCACHED_FAILURE
;
3529 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3531 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3532 test_compare(MEMCACHED_SUCCESS
,
3533 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3534 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3538 memcached_free(memc_clone
);
3539 return TEST_SKIPPED
;
3542 memcached_free(memc_clone
);
3544 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3547 static test_return_t
pre_murmur(memcached_st
*memc
)
3549 #ifdef HAVE_MURMUR_HASH
3550 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3551 return TEST_SUCCESS
;
3554 return TEST_SKIPPED
;
3558 static test_return_t
pre_jenkins(memcached_st
*memc
)
3560 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3562 return TEST_SUCCESS
;
3566 static test_return_t
pre_md5(memcached_st
*memc
)
3568 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3570 return TEST_SUCCESS
;
3573 static test_return_t
pre_crc(memcached_st
*memc
)
3575 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3577 return TEST_SUCCESS
;
3580 static test_return_t
pre_hsieh(memcached_st
*memc
)
3582 #ifdef HAVE_HSIEH_HASH
3583 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3584 return TEST_SUCCESS
;
3587 return TEST_SKIPPED
;
3591 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3593 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3595 return TEST_SUCCESS
;
3598 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3600 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3602 return TEST_SUCCESS
;
3605 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3607 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3609 return TEST_SUCCESS
;
3612 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3614 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3616 return TEST_SUCCESS
;
3619 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3621 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3622 test_compare(MEMCACHED_SUCCESS
, rc
);
3624 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3625 test_true(value
== 1);
3627 return TEST_SUCCESS
;
3630 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3632 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3633 test_compare(MEMCACHED_SUCCESS
, rc
);
3635 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3636 test_true(value
== 1);
3638 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3639 test_compare(MEMCACHED_SUCCESS
, rc
);
3641 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3642 test_true(value
== MEMCACHED_HASH_MD5
);
3644 return TEST_SUCCESS
;
3648 @note This should be testing to see if the server really supports the binary protocol.
3650 static test_return_t
pre_binary(memcached_st
*memc
)
3652 memcached_return_t rc
= MEMCACHED_FAILURE
;
3654 if (libmemcached_util_version_check(memc
, 1, 4, 4))
3656 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3657 test_compare(MEMCACHED_SUCCESS
, rc
);
3658 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3661 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3664 static test_return_t
pre_replication(memcached_st
*memc
)
3666 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3669 * Make sure that we store the item on all servers
3670 * (master + replicas == number of servers)
3672 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3673 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3675 return TEST_SUCCESS
;
3679 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3681 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3683 return pre_nonblock(memc
);
3687 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3691 #ifdef HARD_MALLOC_TESTS
3692 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3700 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3704 #ifdef HARD_MALLOC_TESTS
3705 void *ret
= malloc(size
+ 8);
3708 ret
= (void*)((caddr_t
)ret
+ 8);
3711 void *ret
= malloc(size
);
3716 memset(ret
, 0xff, size
);
3723 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3725 #ifdef HARD_MALLOC_TESTS
3726 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3727 void *nmem
= realloc(real_ptr
, size
+ 8);
3732 ret
= (void*)((caddr_t
)nmem
+ 8);
3738 return realloc(mem
, size
);
3743 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3745 #ifdef HARD_MALLOC_TESTS
3746 void *mem
= my_malloc(ptr
, nelem
* size
);
3749 memset(mem
, 0, nelem
* size
);
3755 return calloc(nelem
, size
);
3759 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3761 memcached_return_t rc
;
3762 const char *key
= "mine";
3765 /* Make sure be default none exists */
3766 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3767 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3769 /* Test a clean set */
3770 test_compare(MEMCACHED_SUCCESS
,
3771 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3773 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3775 test_memcmp(value
, key
, 4);
3776 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3778 /* Test that we can turn it off */
3779 test_compare(MEMCACHED_SUCCESS
,
3780 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3782 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3784 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3786 /* Now setup for main test */
3787 test_compare(MEMCACHED_SUCCESS
,
3788 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3790 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3792 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3793 test_memcmp(value
, key
, 4);
3795 /* Set to Zero, and then Set to something too large */
3798 memset(long_key
, 0, 255);
3800 test_compare(MEMCACHED_SUCCESS
,
3801 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3803 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3805 test_true(rc
== MEMCACHED_FAILURE
);
3806 test_true(value
== NULL
);
3808 /* Test a long key for failure */
3809 /* TODO, extend test to determine based on setting, what result should be */
3810 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3811 test_compare(MEMCACHED_SUCCESS
,
3812 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3814 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3815 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3816 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3817 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3819 /* Test for a bad prefix, but with a short key */
3820 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3821 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3823 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3824 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3827 return TEST_SUCCESS
;
3830 static test_return_t
set_namespace(memcached_st
*memc
)
3832 memcached_return_t rc
;
3833 const char *key
= "mine";
3836 /* Make sure be default none exists */
3837 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3838 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3840 /* Test a clean set */
3841 test_compare(MEMCACHED_SUCCESS
,
3842 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3844 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3846 test_memcmp(value
, key
, 4);
3847 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3849 return TEST_SUCCESS
;
3852 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3854 test_return_if(pre_binary(memc
));
3855 test_return_if(set_namespace(memc
));
3857 return TEST_SUCCESS
;
3860 #ifdef MEMCACHED_ENABLE_DEPRECATED
3861 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3863 void *test_ptr
= NULL
;
3866 memcached_malloc_fn malloc_cb
=
3867 (memcached_malloc_fn
)my_malloc
;
3868 cb_ptr
= *(void **)&malloc_cb
;
3869 memcached_return_t rc
;
3871 test_compare(MEMCACHED_SUCCESS
,
3872 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3873 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3874 test_compare(MEMCACHED_SUCCESS
, rc
);
3875 test_true(test_ptr
== cb_ptr
);
3879 memcached_realloc_fn realloc_cb
=
3880 (memcached_realloc_fn
)my_realloc
;
3881 cb_ptr
= *(void **)&realloc_cb
;
3882 memcached_return_t rc
;
3884 test_compare(MEMCACHED_SUCCESS
,
3885 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3886 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3887 test_compare(MEMCACHED_SUCCESS
, rc
);
3888 test_true(test_ptr
== cb_ptr
);
3892 memcached_free_fn free_cb
=
3893 (memcached_free_fn
)my_free
;
3894 cb_ptr
= *(void **)&free_cb
;
3895 memcached_return_t rc
;
3897 test_compare(MEMCACHED_SUCCESS
,
3898 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3899 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3900 test_compare(MEMCACHED_SUCCESS
, rc
);
3901 test_true(test_ptr
== cb_ptr
);
3904 return TEST_SUCCESS
;
3909 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3911 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3912 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3913 my_realloc
, my_calloc
, NULL
));
3915 test_compare(MEMCACHED_SUCCESS
,
3916 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3917 my_realloc
, my_calloc
, NULL
));
3919 memcached_malloc_fn mem_malloc
;
3920 memcached_free_fn mem_free
;
3921 memcached_realloc_fn mem_realloc
;
3922 memcached_calloc_fn mem_calloc
;
3923 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3924 &mem_realloc
, &mem_calloc
);
3926 test_true(mem_malloc
== my_malloc
);
3927 test_true(mem_realloc
== my_realloc
);
3928 test_true(mem_calloc
== my_calloc
);
3929 test_true(mem_free
== my_free
);
3931 return TEST_SUCCESS
;
3934 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3937 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3938 memcached_hash_t hash
;
3939 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3940 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3943 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3944 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3946 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3948 if (hash
!= MEMCACHED_HASH_CRC
)
3949 return TEST_SKIPPED
;
3951 return TEST_SUCCESS
;
3954 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3957 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3958 memcached_hash_t hash
;
3959 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3960 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3963 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3964 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3966 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3968 if (hash
!= MEMCACHED_HASH_HSIEH
)
3969 return TEST_SKIPPED
;
3972 return TEST_SUCCESS
;
3975 static test_return_t
enable_cas(memcached_st
*memc
)
3977 unsigned int set
= 1;
3979 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3981 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3983 return TEST_SUCCESS
;
3986 return TEST_SKIPPED
;
3989 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3991 memcached_version(memc
);
3993 memcached_server_instance_st instance
=
3994 memcached_server_instance_by_position(memc
, 0);
3996 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3997 or instance
->minor_version
> 2)
3999 return TEST_SUCCESS
;
4002 return TEST_SKIPPED
;
4005 static test_return_t
pre_unix_socket(memcached_st
*memc
)
4009 memcached_servers_reset(memc
);
4010 const char *socket_file
= default_socket();
4012 test_skip(0, stat(socket_file
, &buf
));
4014 test_compare(MEMCACHED_SUCCESS
,
4015 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
4017 return TEST_SUCCESS
;
4020 static test_return_t
pre_nodelay(memcached_st
*memc
)
4022 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
4023 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
4025 return TEST_SUCCESS
;
4028 static test_return_t
pre_settimer(memcached_st
*memc
)
4030 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4031 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4033 return TEST_SUCCESS
;
4036 static test_return_t
poll_timeout(memcached_st
*memc
)
4038 const uint64_t timeout
= 100; // Not using, just checking that it sets
4040 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4043 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
4045 return TEST_SUCCESS
;
4048 static test_return_t
noreply_test(memcached_st
*memc
)
4050 memcached_return_t ret
;
4051 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
4052 test_true(ret
== MEMCACHED_SUCCESS
);
4053 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4054 test_true(ret
== MEMCACHED_SUCCESS
);
4055 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
4056 test_true(ret
== MEMCACHED_SUCCESS
);
4057 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
4058 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
4059 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
4061 for (int count
=0; count
< 5; ++count
)
4063 for (size_t x
= 0; x
< 100; ++x
)
4066 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4067 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4069 size_t len
= (size_t)check_length
;
4074 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4077 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4080 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4083 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4086 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4092 test_true(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
4096 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4097 ** API and is _ONLY_ done this way to verify that the library works the
4098 ** way it is supposed to do!!!!
4101 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4103 memcached_server_instance_st instance
=
4104 memcached_server_instance_by_position(memc
, x
);
4105 no_msg
+=(int)(instance
->cursor_active
);
4108 test_true(no_msg
== 0);
4109 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4112 ** Now validate that all items was set properly!
4114 for (size_t x
= 0; x
< 100; ++x
)
4118 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4120 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4122 size_t len
= (size_t)check_length
;
4125 char* value
=memcached_get(memc
, key
, strlen(key
),
4126 &length
, &flags
, &ret
);
4127 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4130 case 0: /* FALLTHROUGH */
4131 case 1: /* FALLTHROUGH */
4133 test_true(strncmp(value
, key
, len
) == 0);
4134 test_true(len
== length
);
4137 test_true(length
== len
* 2);
4140 test_true(length
== len
* 3);
4150 /* Try setting an illegal cas value (should not return an error to
4151 * the caller (because we don't expect a return message from the server)
4153 const char* keys
[]= {"0"};
4154 size_t lengths
[]= {1};
4157 memcached_result_st results_obj
;
4158 memcached_result_st
*results
;
4159 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4160 test_true(ret
== MEMCACHED_SUCCESS
);
4162 results
= memcached_result_create(memc
, &results_obj
);
4164 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4166 test_true(ret
== MEMCACHED_SUCCESS
);
4167 uint64_t cas
= memcached_result_cas(results
);
4168 memcached_result_free(&results_obj
);
4170 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4171 test_true(ret
== MEMCACHED_SUCCESS
);
4174 * The item will have a new cas value, so try to set it again with the old
4175 * value. This should fail!
4177 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4178 test_true(ret
== MEMCACHED_SUCCESS
);
4179 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4180 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4181 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4184 return TEST_SUCCESS
;
4187 static test_return_t
analyzer_test(memcached_st
*memc
)
4189 memcached_return_t rc
;
4190 memcached_stat_st
*memc_stat
;
4191 memcached_analysis_st
*report
;
4193 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4194 test_compare(MEMCACHED_SUCCESS
, rc
);
4195 test_true(memc_stat
);
4197 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4198 test_compare(MEMCACHED_SUCCESS
, rc
);
4202 memcached_stat_free(NULL
, memc_stat
);
4204 return TEST_SUCCESS
;
4207 /* Count the objects */
4209 static test_return_t
dump_test(memcached_st
*memc
)
4211 /* No support for Binary protocol yet */
4212 test_skip(false, memc
->flags
.binary_protocol
);
4214 test_compare(TEST_SUCCESS
, set_test3(memc
));
4216 // confirm_key_count() call dump
4217 size_t counter
= confirm_key_count(memc
);
4219 /* We may have more then 32 if our previous flush has not completed */
4220 test_true(counter
>= 32);
4222 return TEST_SUCCESS
;
4225 struct test_pool_context_st
{
4226 memcached_pool_st
* pool
;
4230 static void* connection_release(void *arg
)
4232 test_pool_context_st
*resource
= static_cast<test_pool_context_st
*>(arg
);
4235 // Release all of the memc we are holding
4236 assert(memcached_success(memcached_pool_push(resource
->pool
, resource
->mmc
)));
4240 #define POOL_SIZE 10
4241 static test_return_t
connection_pool_test(memcached_st
*memc
)
4243 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4244 test_true(pool
!= NULL
);
4245 memcached_st
*mmc
[POOL_SIZE
];
4246 memcached_return_t rc
;
4248 // Fill up our array that we will store the memc that are in the pool
4249 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4251 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4252 test_true(mmc
[x
] != NULL
);
4253 test_compare(MEMCACHED_SUCCESS
, rc
);
4256 // All memc should be gone
4257 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4258 test_compare(MEMCACHED_SUCCESS
, rc
);
4261 test_pool_context_st item
= { pool
, mmc
[9] };
4263 pthread_create(&tid
, NULL
, connection_release
, &item
);
4264 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4265 test_compare(MEMCACHED_SUCCESS
, rc
);
4266 pthread_join(tid
, NULL
);
4268 const char *key
= "key";
4269 size_t keylen
= strlen(key
);
4271 // verify that I can do ops with all connections
4272 test_compare(MEMCACHED_SUCCESS
,
4273 memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0));
4275 for (uint64_t x
= 0; x
< POOL_SIZE
; ++x
)
4277 uint64_t number_value
;
4278 test_compare(MEMCACHED_SUCCESS
,
4279 memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
));
4280 test_compare(number_value
, (x
+1));
4284 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4286 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[x
]));
4290 /* verify that I can set behaviors on the pool when I don't have all
4291 * of the connections in the pool. It should however be enabled
4292 * when I push the item into the pool
4294 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4297 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4298 test_compare(MEMCACHED_SUCCESS
, rc
);
4300 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4303 test_compare(UINT64_C(9999), memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4304 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[1]));
4305 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4307 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4308 test_compare(UINT64_C(9999), memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4309 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4311 test_true(memcached_pool_destroy(pool
) == memc
);
4313 return TEST_SUCCESS
;
4316 static test_return_t
util_version_test(memcached_st
*memc
)
4318 bool if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4319 test_true(if_successful
);
4321 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4323 // We expect failure
4326 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4327 fprintf(stderr
, "\nDumping Server Information\n\n");
4328 memcached_server_fn callbacks
[1];
4330 callbacks
[0]= dump_server_information
;
4331 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4332 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4334 test_true(if_successful
== false);
4336 memcached_server_instance_st instance
=
4337 memcached_server_instance_by_position(memc
, 0);
4339 memcached_version(memc
);
4341 // We only use one binary when we test, so this should be just fine.
4342 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4343 test_true(if_successful
== true);
4345 if (instance
->micro_version
> 0)
4346 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4347 else if (instance
->minor_version
> 0)
4348 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4349 else if (instance
->major_version
> 0)
4350 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4352 test_true(if_successful
== true);
4354 if (instance
->micro_version
> 0)
4355 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4356 else if (instance
->minor_version
> 0)
4357 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4358 else if (instance
->major_version
> 0)
4359 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4361 test_true(if_successful
== false);
4363 return TEST_SUCCESS
;
4366 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4368 memcached_return_t rc
;
4369 memcached_server_instance_st instance
=
4370 memcached_server_instance_by_position(memc
, 0);
4372 // Test both the version that returns a code, and the one that does not.
4373 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4374 memcached_server_port(instance
) -1, NULL
) == -1);
4376 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4377 memcached_server_port(instance
) -1, &rc
) == -1);
4378 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4380 return TEST_SUCCESS
;
4384 static test_return_t
getpid_test(memcached_st
*memc
)
4386 memcached_return_t rc
;
4387 memcached_server_instance_st instance
=
4388 memcached_server_instance_by_position(memc
, 0);
4390 // Test both the version that returns a code, and the one that does not.
4391 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4392 memcached_server_port(instance
), NULL
) > -1);
4394 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4395 memcached_server_port(instance
), &rc
) > -1);
4396 test_compare(MEMCACHED_SUCCESS
, rc
);
4398 return TEST_SUCCESS
;
4401 static test_return_t
ping_test(memcached_st
*memc
)
4403 memcached_return_t rc
;
4404 memcached_server_instance_st instance
=
4405 memcached_server_instance_by_position(memc
, 0);
4407 // Test both the version that returns a code, and the one that does not.
4408 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4409 memcached_server_port(instance
), NULL
));
4411 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4412 memcached_server_port(instance
), &rc
));
4414 test_compare(MEMCACHED_SUCCESS
, rc
);
4416 return TEST_SUCCESS
;
4421 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4425 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4426 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4427 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4428 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4429 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4430 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4431 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4432 #ifdef HAVE_HSIEH_HASH
4433 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4435 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4436 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4437 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4439 return TEST_SUCCESS
;
4443 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4445 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4446 #ifdef HAVE_HSIEH_HASH
4447 expected_rc
= MEMCACHED_SUCCESS
;
4449 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4450 (uint64_t)MEMCACHED_HASH_HSIEH
);
4451 test_true(rc
== expected_rc
);
4453 return TEST_SUCCESS
;
4456 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4458 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4459 #ifdef HAVE_MURMUR_HASH
4460 expected_rc
= MEMCACHED_SUCCESS
;
4462 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4463 (uint64_t)MEMCACHED_HASH_MURMUR
);
4464 test_true(rc
== expected_rc
);
4466 return TEST_SUCCESS
;
4469 static test_return_t
one_at_a_time_run (memcached_st
*)
4474 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4478 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
);
4479 test_true(one_at_a_time_values
[x
] == hash_val
);
4482 return TEST_SUCCESS
;
4485 static test_return_t
md5_run (memcached_st
*)
4490 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4494 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4495 test_true(md5_values
[x
] == hash_val
);
4498 return TEST_SUCCESS
;
4501 static test_return_t
crc_run (memcached_st
*)
4506 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4510 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4511 test_true(crc_values
[x
] == hash_val
);
4514 return TEST_SUCCESS
;
4517 static test_return_t
fnv1_64_run (memcached_st
*)
4522 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4526 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4527 test_true(fnv1_64_values
[x
] == hash_val
);
4530 return TEST_SUCCESS
;
4533 static test_return_t
fnv1a_64_run (memcached_st
*)
4538 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4542 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4543 test_true(fnv1a_64_values
[x
] == hash_val
);
4546 return TEST_SUCCESS
;
4549 static test_return_t
fnv1_32_run (memcached_st
*)
4554 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4558 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4559 test_true(fnv1_32_values
[x
] == hash_val
);
4562 return TEST_SUCCESS
;
4565 static test_return_t
fnv1a_32_run (memcached_st
*)
4570 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4574 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4575 test_true(fnv1a_32_values
[x
] == hash_val
);
4578 return TEST_SUCCESS
;
4581 static test_return_t
hsieh_run (memcached_st
*)
4586 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4590 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4591 test_true(hsieh_values
[x
] == hash_val
);
4594 return TEST_SUCCESS
;
4597 static test_return_t
murmur_run (memcached_st
*)
4599 #ifdef WORDS_BIGENDIAN
4600 (void)murmur_values
;
4601 return TEST_SKIPPED
;
4606 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4610 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
4611 test_true(murmur_values
[x
] == hash_val
);
4614 return TEST_SUCCESS
;
4618 static test_return_t
jenkins_run (memcached_st
*)
4623 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4627 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4628 test_true(jenkins_values
[x
] == hash_val
);
4631 return TEST_SUCCESS
;
4634 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *context
)
4637 return libhashkit_md5(string
, string_length
);
4640 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *context
)
4643 return libhashkit_crc32(string
, string_length
);
4646 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4652 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5"));
4654 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};
4655 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};
4657 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4659 hashkit_clone(&new_kit
, kit
);
4660 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4662 memcached_set_hashkit(memc
, &new_kit
);
4665 Verify Setting the hash.
4667 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4671 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4672 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4677 Now check memcached_st.
4679 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4683 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4684 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4687 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4689 memcached_set_hashkit(memc
, &new_kit
);
4692 Verify Setting the hash.
4694 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4698 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4699 test_true(crc_values
[x
] == hash_val
);
4702 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4706 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4707 test_compare(crc_hosts
[x
], hash_val
);
4710 memcached_free(memc
);
4712 return TEST_SUCCESS
;
4716 Test case adapted from John Gorman <johngorman2@gmail.com>
4718 We are testing the error condition when we connect to a server via memcached_get()
4719 but find that the server is not available.
4721 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4723 const char *key
= "MemcachedLives";
4726 memcached_return rc
;
4729 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4731 // See if memcached is reachable.
4732 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4736 test_true(memcached_failed(rc
));
4738 memcached_free(tl_memc_h
);
4740 return TEST_SUCCESS
;
4744 We connect to a server which exists, but search for a key that does not exist.
4746 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4748 const char *key
= "MemcachedKeyNotEXIST";
4751 memcached_return rc
;
4754 // See if memcached is reachable.
4755 value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4759 test_compare(MEMCACHED_NOTFOUND
, rc
);
4761 return TEST_SUCCESS
;
4765 Test case adapted from John Gorman <johngorman2@gmail.com>
4767 We are testing the error condition when we connect to a server via memcached_get_by_key()
4768 but find that the server is not available.
4770 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4773 memcached_st
*tl_memc_h
;
4774 memcached_server_st
*servers
;
4776 const char *key
= "MemcachedLives";
4779 memcached_return rc
;
4783 tl_memc_h
= memcached_create(NULL
);
4784 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4785 memcached_server_push(tl_memc_h
, servers
);
4786 memcached_server_list_free(servers
);
4788 // See if memcached is reachable.
4789 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4793 test_true(memcached_failed(rc
));
4795 memcached_free(tl_memc_h
);
4797 return TEST_SUCCESS
;
4801 We connect to a server which exists, but search for a key that does not exist.
4803 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4805 const char *key
= "MemcachedKeyNotEXIST";
4808 memcached_return rc
;
4811 // See if memcached is reachable.
4812 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4816 test_compare(MEMCACHED_NOTFOUND
, rc
);
4818 return TEST_SUCCESS
;
4821 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4823 test_return_t test_rc
;
4824 test_rc
= pre_binary(memc
);
4826 if (test_rc
!= TEST_SUCCESS
)
4829 const char *key
= "regression_bug_434484";
4830 size_t keylen
= strlen(key
);
4832 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4833 test_compare(MEMCACHED_NOTSTORED
, ret
);
4835 size_t size
= 2048 * 1024;
4836 char *data
= (char*)calloc(1, size
);
4838 test_compare(MEMCACHED_E2BIG
,
4839 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4842 return TEST_SUCCESS
;
4845 static test_return_t
regression_bug_434843(memcached_st
*memc
)
4847 test_return_t test_rc
;
4848 test_rc
= pre_binary(memc
);
4850 if (test_rc
!= TEST_SUCCESS
)
4853 memcached_return_t rc
;
4855 memcached_execute_fn callbacks
[]= { &callback_counter
};
4858 * I only want to hit only _one_ server so I know the number of requests I'm
4859 * sending in the pipleine to the server. Let's try to do a multiget of
4860 * 1024 (that should satisfy most users don't you think?). Future versions
4861 * will include a mget_execute function call if you need a higher number.
4863 uint32_t number_of_hosts
= memcached_server_count(memc
);
4864 memc
->number_of_hosts
= 1;
4865 const size_t max_keys
= 1024;
4866 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4867 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4869 for (size_t x
= 0; x
< max_keys
; ++x
)
4873 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4879 * Run two times.. the first time we should have 100% cache miss,
4880 * and the second time we should have 100% cache hits
4882 for (size_t y
= 0; y
< 2; y
++)
4884 test_compare(MEMCACHED_SUCCESS
,
4885 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4887 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4888 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4892 /* The first iteration should give me a 100% cache miss. verify that*/
4893 char blob
[1024]= { 0 };
4895 test_false(counter
);
4897 for (size_t x
= 0; x
< max_keys
; ++x
)
4899 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4900 blob
, sizeof(blob
), 0, 0);
4901 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4906 /* Verify that we received all of the key/value pairs */
4907 test_compare(counter
, max_keys
);
4911 /* Release allocated resources */
4912 for (size_t x
= 0; x
< max_keys
; ++x
)
4919 memc
->number_of_hosts
= number_of_hosts
;
4921 return TEST_SUCCESS
;
4924 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4926 memcached_return_t rc
;
4927 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4928 test_compare(MEMCACHED_SUCCESS
, rc
);
4930 return regression_bug_434843(memc
);
4933 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4935 memcached_return_t rc
;
4936 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4937 test_compare(MEMCACHED_SUCCESS
, rc
);
4939 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4940 test_compare(MEMCACHED_SUCCESS
, rc
);
4941 test_true(bytes_str
);
4942 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4944 test_compare(MEMCACHED_SUCCESS
, rc
);
4945 test_true(bytes_read_str
);
4947 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4948 "bytes_written", &rc
);
4949 test_compare(MEMCACHED_SUCCESS
, rc
);
4950 test_true(bytes_written_str
);
4952 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4953 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4954 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4956 test_true(bytes
!= bytes_read
);
4957 test_true(bytes
!= bytes_written
);
4959 /* Release allocated resources */
4961 free(bytes_read_str
);
4962 free(bytes_written_str
);
4963 memcached_stat_free(NULL
, memc_stat
);
4965 return TEST_SUCCESS
;
4969 * The test case isn't obvious so I should probably document why
4970 * it works the way it does. Bug 442914 was caused by a bug
4971 * in the logic in memcached_purge (it did not handle the case
4972 * where the number of bytes sent was equal to the watermark).
4973 * In this test case, create messages so that we hit that case
4974 * and then disable noreply mode and issue a new command to
4975 * verify that it isn't stuck. If we change the format for the
4976 * delete command or the watermarks, we need to update this
4979 static test_return_t
regression_bug_442914(memcached_st
*memc
)
4981 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4982 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4984 uint32_t number_of_hosts
= memcached_server_count(memc
);
4985 memc
->number_of_hosts
= 1;
4990 for (uint32_t x
= 0; x
< 250; ++x
)
4992 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4993 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4994 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4997 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5000 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
5001 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5003 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5004 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
5006 memc
->number_of_hosts
= number_of_hosts
;
5008 return TEST_SUCCESS
;
5011 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5013 memcached_server_instance_st instance_one
;
5014 memcached_server_instance_st instance_two
;
5016 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
5017 return TEST_SKIPPED
;
5019 test_compare(MEMCACHED_SUCCESS
,
5020 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
5022 const unsigned int max_keys
= 100;
5023 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
5024 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5026 for (unsigned int x
= 0; x
< max_keys
; ++x
)
5030 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5033 test_compare(MEMCACHED_SUCCESS
,
5034 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
5038 ** We are using the quiet commands to store the replicas, so we need
5039 ** to ensure that all of them are processed before we can continue.
5040 ** In the test we go directly from storing the object to trying to
5041 ** receive the object from all of the different servers, so we
5042 ** could end up in a race condition (the memcached server hasn't yet
5043 ** processed the quiet command from the replication set when it process
5044 ** the request from the other client (created by the clone)). As a
5045 ** workaround for that we call memcached_quit to send the quit command
5046 ** to the server and wait for the response ;-) If you use the test code
5047 ** as an example for your own code, please note that you shouldn't need
5050 memcached_quit(memc
);
5052 /* Verify that all messages are stored, and we didn't stuff too much
5055 test_compare(MEMCACHED_SUCCESS
,
5056 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5058 unsigned int counter
= 0;
5059 memcached_execute_fn callbacks
[]= { &callback_counter
};
5060 test_compare(MEMCACHED_SUCCESS
,
5061 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5063 /* Verify that we received all of the key/value pairs */
5064 test_compare(counter
, max_keys
);
5066 memcached_quit(memc
);
5068 * Don't do the following in your code. I am abusing the internal details
5069 * within the library, and this is not a supported interface.
5070 * This is to verify correct behavior in the library. Fake that two servers
5073 instance_one
= memcached_server_instance_by_position(memc
, 0);
5074 instance_two
= memcached_server_instance_by_position(memc
, 2);
5075 in_port_t port0
= instance_one
->port
;
5076 in_port_t port2
= instance_two
->port
;
5078 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5079 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5081 test_compare(MEMCACHED_SUCCESS
,
5082 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5085 test_compare(MEMCACHED_SUCCESS
,
5086 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5087 test_compare(counter
, (unsigned int)max_keys
);
5089 /* restore the memc handle */
5090 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5091 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5093 memcached_quit(memc
);
5095 /* Remove half of the objects */
5096 for (size_t x
= 0; x
< max_keys
; ++x
)
5100 test_compare(MEMCACHED_SUCCESS
,
5101 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
5105 memcached_quit(memc
);
5106 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5107 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5109 /* now retry the command, this time we should have cache misses */
5110 test_compare(MEMCACHED_SUCCESS
,
5111 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5114 test_compare(MEMCACHED_SUCCESS
,
5115 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5116 test_compare(counter
, (unsigned int)(max_keys
>> 1));
5118 /* Release allocated resources */
5119 for (size_t x
= 0; x
< max_keys
; ++x
)
5126 /* restore the memc handle */
5127 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5128 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5130 return TEST_SUCCESS
;
5133 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5135 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5136 test_true(memc_clone
);
5137 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5139 memcached_server_instance_st instance
=
5140 memcached_server_instance_by_position(memc_clone
, 0);
5142 if (instance
->major_version
> 1 ||
5143 (instance
->major_version
== 1 &&
5144 instance
->minor_version
> 2))
5146 /* Binary protocol doesn't support deferred delete */
5147 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5148 test_true(bin_clone
);
5149 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5150 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
5151 memcached_free(bin_clone
);
5153 memcached_quit(memc_clone
);
5155 /* If we know the server version, deferred delete should fail
5156 * with invalid arguments */
5157 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
5159 /* If we don't know the server version, we should get a protocol error */
5160 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5162 /* but there is a bug in some of the memcached servers (1.4) that treats
5163 * the counter as noreply so it doesn't send the proper error message
5165 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5167 /* And buffered mode should be disabled and we should get protocol error */
5168 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5169 rc
= memcached_delete(memc
, "foo", 3, 1);
5170 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5172 /* Same goes for noreply... */
5173 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5174 rc
= memcached_delete(memc
, "foo", 3, 1);
5175 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5177 /* but a normal request should go through (and be buffered) */
5178 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
5179 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
5181 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
5182 /* unbuffered noreply should be success */
5183 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
5184 /* unbuffered with reply should be not found... */
5185 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5186 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
5189 memcached_free(memc_clone
);
5190 return TEST_SUCCESS
;
5194 /* Test memcached_server_get_last_disconnect
5195 * For a working server set, shall be NULL
5196 * For a set of non existing server, shall not be NULL
5198 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5200 memcached_return_t rc
;
5201 memcached_server_instance_st disconnected_server
;
5203 /* With the working set of server */
5204 const char *key
= "marmotte";
5205 const char *value
= "milka";
5207 memcached_reset_last_disconnected_server(memc
);
5208 test_false(memc
->last_disconnected_server
);
5209 rc
= memcached_set(memc
, key
, strlen(key
),
5210 value
, strlen(value
),
5211 (time_t)0, (uint32_t)0);
5212 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5214 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5215 test_false(disconnected_server
);
5217 /* With a non existing server */
5219 memcached_server_st
*servers
;
5221 const char *server_list
= "localhost:9";
5223 servers
= memcached_servers_parse(server_list
);
5225 mine
= memcached_create(NULL
);
5226 rc
= memcached_server_push(mine
, servers
);
5227 test_compare(MEMCACHED_SUCCESS
, rc
);
5228 memcached_server_list_free(servers
);
5231 rc
= memcached_set(mine
, key
, strlen(key
),
5232 value
, strlen(value
),
5233 (time_t)0, (uint32_t)0);
5234 test_true(memcached_failed(rc
));
5236 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5237 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5238 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5239 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5241 memcached_quit(mine
);
5242 memcached_free(mine
);
5244 return TEST_SUCCESS
;
5247 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5249 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5250 char buffer
[BUFSIZ
];
5252 test_compare(MEMCACHED_SUCCESS
,
5253 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5255 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5258 // We will just use the error strings as our keys
5259 uint32_t counter
= 100;
5262 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5264 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5265 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5266 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
5268 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5269 test_true(disconnected_server
);
5270 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5271 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5275 memcached_reset_last_disconnected_server(memc
);
5280 memcached_free(memc
);
5282 return TEST_SUCCESS
;
5285 static test_return_t
test_verbosity(memcached_st
*memc
)
5287 memcached_verbosity(memc
, 3);
5289 return TEST_SUCCESS
;
5293 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5294 const char *key
, size_t key_length
,
5295 const char *value
, size_t value_length
,
5305 return MEMCACHED_SUCCESS
;
5308 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5310 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5311 test_compare(MEMCACHED_SUCCESS
, rc
);
5313 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5314 test_compare(MEMCACHED_SUCCESS
, rc
);
5316 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5317 test_compare(MEMCACHED_SUCCESS
, rc
);
5319 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5320 test_compare(MEMCACHED_SUCCESS
, rc
);
5322 return TEST_SUCCESS
;
5326 * This test ensures that the failure counter isn't incremented during
5327 * normal termination of the memcached instance.
5329 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5331 memcached_return_t rc
;
5332 memcached_server_instance_st instance
;
5334 /* Set value to force connection to the server */
5335 const char *key
= "marmotte";
5336 const char *value
= "milka";
5339 * Please note that I'm abusing the internal structures in libmemcached
5340 * in a non-portable way and you shouldn't be doing this. I'm only
5341 * doing this in order to verify that the library works the way it should
5343 uint32_t number_of_hosts
= memcached_server_count(memc
);
5344 memc
->number_of_hosts
= 1;
5346 /* Ensure that we are connected to the server by setting a value */
5347 rc
= memcached_set(memc
, key
, strlen(key
),
5348 value
, strlen(value
),
5349 (time_t)0, (uint32_t)0);
5350 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5353 instance
= memcached_server_instance_by_position(memc
, 0);
5354 /* The test is to see that the memcached_quit doesn't increase the
5355 * the server failure conter, so let's ensure that it is zero
5356 * before sending quit
5358 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5360 memcached_quit(memc
);
5362 /* Verify that it memcached_quit didn't increment the failure counter
5363 * Please note that this isn't bullet proof, because an error could
5366 test_zero(instance
->server_failure_counter
);
5368 /* restore the instance */
5369 memc
->number_of_hosts
= number_of_hosts
;
5371 return TEST_SUCCESS
;
5375 * This tests ensures expected disconnections (for some behavior changes
5376 * for instance) do not wrongly increase failure counter
5378 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5380 memcached_return rc
;
5382 memcached_st
*memc_clone
;
5383 memc_clone
= memcached_clone(NULL
, memc
);
5384 test_true(memc_clone
);
5386 /* Set value to force connection to the server */
5387 const char *key
= "marmotte";
5388 const char *value
= "milka";
5389 char *string
= NULL
;
5390 size_t string_length
;
5393 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5394 value
, strlen(value
),
5395 (time_t)0, (uint32_t)0);
5396 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5399 /* put failure limit to 1 */
5400 test_compare(MEMCACHED_SUCCESS
,
5401 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1));
5403 /* Put a retry timeout to effectively activate failure_limit effect */
5404 test_compare(MEMCACHED_SUCCESS
,
5405 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
5407 /* change behavior that triggers memcached_quit()*/
5408 test_compare(MEMCACHED_SUCCESS
,
5409 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5412 /* Check if we still are connected */
5413 string
= memcached_get(memc_clone
, key
, strlen(key
),
5414 &string_length
, &flags
, &rc
);
5416 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5419 memcached_free(memc_clone
);
5421 return TEST_SUCCESS
;
5428 * Test that ensures mget_execute does not end into recursive calls that finally fails
5430 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5432 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5433 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5434 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5435 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5436 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5439 return TEST_SKIPPED
; // My MAC can't handle this test
5443 * I only want to hit _one_ server so I know the number of requests I'm
5444 * sending in the pipeline.
5446 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5447 memc
->number_of_hosts
= 1;
5448 size_t max_keys
= 20480;
5451 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5452 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5454 /* First add all of the items.. */
5455 char blob
[1024]= { 0 };
5456 for (size_t x
= 0; x
< max_keys
; ++x
)
5459 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5462 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5463 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5468 /* Try to get all of them with a large multiget */
5470 memcached_execute_function callbacks
[]= { &callback_counter
};
5471 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5472 (size_t)max_keys
, callbacks
, &counter
, 1);
5473 test_compare(MEMCACHED_SUCCESS
, rc
);
5475 char* the_value
= NULL
;
5476 char the_key
[MEMCACHED_MAX_KEY
];
5477 size_t the_key_length
;
5478 size_t the_value_length
;
5482 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5484 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5490 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5493 test_compare(MEMCACHED_END
, rc
);
5495 /* Verify that we got all of the items */
5496 test_compare(counter
, max_keys
);
5499 /* Release all allocated resources */
5500 for (size_t x
= 0; x
< max_keys
; ++x
)
5507 memc
->number_of_hosts
= number_of_hosts
;
5509 return TEST_SUCCESS
;
5512 static test_return_t
regression_bug_583031(memcached_st
*)
5514 memcached_st
*memc
= memcached_create(NULL
);
5516 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5518 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5519 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5520 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5521 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5522 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5523 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5525 memcached_return_t rc
;
5529 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5533 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5535 memcached_free(memc
);
5537 return TEST_SUCCESS
;
5540 static test_return_t
regression_bug_581030(memcached_st
*)
5543 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5544 test_false(local_stat
);
5546 memcached_stat_free(NULL
, NULL
);
5549 return TEST_SUCCESS
;
5552 #define regression_bug_655423_COUNT 6000
5553 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5555 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5556 memc
= NULL
; // Just to make sure it is not used
5561 return TEST_SKIPPED
;
5564 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5565 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5566 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5567 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5569 memset(payload
, int('x'), sizeof(payload
));
5571 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5573 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5574 snprintf(key
, sizeof(key
), "%u", x
);
5576 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5579 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5581 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5582 snprintf(key
, sizeof(key
), "%u", x
);
5584 size_t value_length
;
5585 memcached_return_t rc
;
5586 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5588 if (rc
== MEMCACHED_NOTFOUND
)
5591 test_zero(value_length
);
5595 test_compare(MEMCACHED_SUCCESS
, rc
);
5597 test_compare(100UL, value_length
);
5601 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5602 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5603 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5605 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5606 snprintf(key
, sizeof(key
), "%u", x
);
5608 keys
[x
]= strdup(key
);
5610 key_length
[x
]= strlen(key
);
5611 test_true(key_length
[x
]);
5614 test_compare(MEMCACHED_SUCCESS
,
5615 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5618 memcached_result_st
*result
= NULL
;
5619 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5621 test_compare(size_t(100), memcached_result_length(result
));
5625 test_true(count
> 100); // If we don't get back atleast this, something is up
5627 /* Release all allocated resources */
5628 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5636 memcached_free(clone
);
5638 return TEST_SUCCESS
;
5642 * Test that ensures that buffered set to not trigger problems during io_flush
5644 #define regression_bug_490520_COUNT 200480
5645 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5647 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5648 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5649 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5650 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5651 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5653 memc
->number_of_hosts
= 1;
5655 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5656 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5658 /* First add all of the items.. */
5659 char blob
[3333] = {0};
5660 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5663 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5667 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5668 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5671 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5678 return TEST_SUCCESS
;
5681 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5683 fprintf(stderr
, "Iteration #%u: ", it
);
5685 if (error
== MEMCACHED_ERRNO
)
5687 fprintf(stderr
, "system error %d from %s: %s\n",
5688 errno
, what
, strerror(errno
));
5692 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5693 memcached_strerror(mc
, error
));
5697 #define TEST_CONSTANT_CREATION 200
5699 static test_return_t
regression_bug_(memcached_st
*memc
)
5701 const char *remote_server
;
5704 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5706 return TEST_SKIPPED
;
5709 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5711 memcached_st
* mc
= memcached_create(NULL
);
5712 memcached_return rc
;
5714 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5715 if (rc
!= MEMCACHED_SUCCESS
)
5717 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5720 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5721 if (rc
!= MEMCACHED_SUCCESS
)
5723 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5726 rc
= memcached_server_add(mc
, remote_server
, 0);
5727 if (rc
!= MEMCACHED_SUCCESS
)
5729 memcached_die(mc
, rc
, "memcached_server_add", x
);
5732 const char *set_key
= "akey";
5733 const size_t set_key_len
= strlen(set_key
);
5734 const char *set_value
= "a value";
5735 const size_t set_value_len
= strlen(set_value
);
5737 if (rc
== MEMCACHED_SUCCESS
)
5741 size_t get_value_len
;
5743 uint32_t get_value_flags
;
5745 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5746 &get_value_flags
, &rc
);
5747 if (rc
!= MEMCACHED_SUCCESS
)
5749 memcached_die(mc
, rc
, "memcached_get", x
);
5755 (get_value_len
!= set_value_len
5756 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5758 fprintf(stderr
, "Values don't match?\n");
5759 rc
= MEMCACHED_FAILURE
;
5765 rc
= memcached_set(mc
,
5766 set_key
, set_key_len
,
5767 set_value
, set_value_len
,
5771 if (rc
!= MEMCACHED_SUCCESS
)
5773 memcached_die(mc
, rc
, "memcached_set", x
);
5780 if (rc
!= MEMCACHED_SUCCESS
)
5786 return TEST_SUCCESS
;
5789 /* Clean the server before beginning testing */
5791 {"util_version", true, (test_callback_fn
*)util_version_test
},
5792 {"flush", false, (test_callback_fn
*)flush_test
},
5793 {"init", false, (test_callback_fn
*)init_test
},
5794 {"allocation", false, (test_callback_fn
*)allocation_test
},
5795 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5796 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5797 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5798 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5799 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5800 {"clone_test", false, (test_callback_fn
*)clone_test
},
5801 {"connection_test", false, (test_callback_fn
*)connection_test
},
5802 {"callback_test", false, (test_callback_fn
*)callback_test
},
5803 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5804 {"set", false, (test_callback_fn
*)set_test
},
5805 {"set2", false, (test_callback_fn
*)set_test2
},
5806 {"set3", false, (test_callback_fn
*)set_test3
},
5807 {"dump", true, (test_callback_fn
*)dump_test
},
5808 {"add", true, (test_callback_fn
*)add_test
},
5809 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5810 {"replace", true, (test_callback_fn
*)replace_test
},
5811 {"delete", true, (test_callback_fn
*)delete_test
},
5812 {"get", true, (test_callback_fn
*)get_test
},
5813 {"get2", false, (test_callback_fn
*)get_test2
},
5814 {"get3", false, (test_callback_fn
*)get_test3
},
5815 {"get4", false, (test_callback_fn
*)get_test4
},
5816 {"partial mget", false, (test_callback_fn
*)get_test5
},
5817 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5818 {"increment", false, (test_callback_fn
*)increment_test
},
5819 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5820 {"decrement", false, (test_callback_fn
*)decrement_test
},
5821 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5822 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5823 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5824 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5825 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5826 {"binary_increment_with_prefix", 1, (test_callback_fn
*)binary_increment_with_prefix_test
},
5827 {"quit", false, (test_callback_fn
*)quit_test
},
5828 {"mget", true, (test_callback_fn
*)mget_test
},
5829 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5830 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5831 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5832 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5833 {"mget_end", false, (test_callback_fn
*)mget_end
},
5834 {"get_stats", false, (test_callback_fn
*)get_stats
},
5835 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5836 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5837 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5838 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
5839 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5840 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5841 {"read_through", true, (test_callback_fn
*)read_through
},
5842 {"delete_through", true, (test_callback_fn
*)delete_through
},
5843 {"noreply", true, (test_callback_fn
*)noreply_test
},
5844 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5845 {"connectionpool", true, (test_callback_fn
*)connection_pool_test
},
5846 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
5847 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
5848 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
5849 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
5853 test_st behavior_tests
[] ={
5854 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5855 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5856 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5857 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5858 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5859 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5863 test_st libmemcachedutil_tests
[] ={
5864 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5865 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5866 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5870 test_st basic_tests
[] ={
5871 {"init", true, (test_callback_fn
*)basic_init_test
},
5872 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5873 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5874 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5875 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5876 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5877 {"memcached_return_t", false, (test_callback_fn
*)memcached_return_t_TEST
},
5881 test_st regression_binary_vs_block
[] ={
5882 {"block add", true, (test_callback_fn
*)block_add_regression
},
5883 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
5887 test_st async_tests
[] ={
5888 {"add", true, (test_callback_fn
*)add_wrapper
},
5892 test_st memcached_server_get_last_disconnect_tests
[] ={
5893 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
5894 {0, 0, (test_callback_fn
*)0}
5898 test_st result_tests
[] ={
5899 {"result static", false, (test_callback_fn
*)result_static
},
5900 {"result alloc", false, (test_callback_fn
*)result_alloc
},
5901 {0, 0, (test_callback_fn
*)0}
5904 test_st version_1_2_3
[] ={
5905 {"append", false, (test_callback_fn
*)append_test
},
5906 {"prepend", false, (test_callback_fn
*)prepend_test
},
5907 {"cas", false, (test_callback_fn
*)cas_test
},
5908 {"cas2", false, (test_callback_fn
*)cas2_test
},
5909 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
5910 {0, 0, (test_callback_fn
*)0}
5913 test_st haldenbrand_tests
[] ={
5914 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
5915 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
5916 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
5917 {0, 0, (test_callback_fn
*)0}
5920 test_st user_tests
[] ={
5921 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
5922 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
5923 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
5924 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
5925 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
5926 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
5927 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
5928 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
5929 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
5930 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
5931 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
5932 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
5933 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
5934 #if !defined(__sun) && !defined(__OpenBSD__)
5936 ** It seems to be something weird with the character sets..
5937 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5938 ** guess I need to find out how this is supposed to work.. Perhaps I need
5939 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5940 ** so just disable the code for now...).
5942 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
5944 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
5945 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
5946 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
5947 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
5948 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
5949 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
5950 {0, 0, (test_callback_fn
*)0}
5953 test_st replication_tests
[]= {
5954 {"set", true, (test_callback_fn
*)replication_set_test
},
5955 {"get", false, (test_callback_fn
*)replication_get_test
},
5956 {"mget", false, (test_callback_fn
*)replication_mget_test
},
5957 {"delete", true, (test_callback_fn
*)replication_delete_test
},
5958 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
5959 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
5960 {0, 0, (test_callback_fn
*)0}
5964 * The following test suite is used to verify that we don't introduce
5965 * regression bugs. If you want more information about the bug / test,
5966 * you should look in the bug report at
5967 * http://bugs.launchpad.net/libmemcached
5969 test_st regression_tests
[]= {
5970 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
5971 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
5972 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
5973 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
5974 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
5975 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
5976 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
5977 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
5978 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
5979 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
5980 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
5981 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
5982 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
5983 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
5984 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
5985 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
5986 {0, false, (test_callback_fn
*)0}
5989 test_st ketama_compatibility
[]= {
5990 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
5991 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
5992 {0, 0, (test_callback_fn
*)0}
5995 test_st generate_tests
[] ={
5996 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
5997 {"generate_data", true, (test_callback_fn
*)generate_data
},
5998 {"get_read", false, (test_callback_fn
*)get_read
},
5999 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
6000 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
6001 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
6002 {"generate_data", true, (test_callback_fn
*)generate_data
},
6003 {"mget_read", false, (test_callback_fn
*)mget_read
},
6004 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
6005 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
6006 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
6007 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
6008 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6009 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
6010 {"generate_data", true, (test_callback_fn
*)generate_data
},
6011 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
6012 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6013 {0, 0, (test_callback_fn
*)0}
6016 test_st consistent_tests
[] ={
6017 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6018 {"generate_data", true, (test_callback_fn
*)generate_data
},
6019 {"get_read", 0, (test_callback_fn
*)get_read_count
},
6020 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6021 {0, 0, (test_callback_fn
*)0}
6024 test_st consistent_weighted_tests
[] ={
6025 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6026 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
6027 {"get_read", false, (test_callback_fn
*)get_read_count
},
6028 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6029 {0, 0, (test_callback_fn
*)0}
6032 test_st hsieh_availability
[] ={
6033 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
6034 {0, 0, (test_callback_fn
*)0}
6037 test_st murmur_availability
[] ={
6038 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
6039 {0, 0, (test_callback_fn
*)0}
6043 test_st hash_sanity
[] ={
6044 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
6045 {0, 0, (test_callback_fn
*)0}
6049 test_st ketama_auto_eject_hosts
[] ={
6050 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
6051 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
6052 {0, 0, (test_callback_fn
*)0}
6055 test_st hash_tests
[] ={
6056 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
6057 {"md5", false, (test_callback_fn
*)md5_run
},
6058 {"crc", false, (test_callback_fn
*)crc_run
},
6059 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
6060 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
6061 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
6062 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
6063 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
6064 {"murmur", false, (test_callback_fn
*)murmur_run
},
6065 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
6066 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
6067 {0, 0, (test_callback_fn
*)0}
6070 test_st error_conditions
[] ={
6071 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
6072 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
6073 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
6074 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6075 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6076 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
6077 {0, 0, (test_callback_fn
*)0}
6081 test_st parser_tests
[] ={
6082 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
6083 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
6084 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
6085 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
6086 {"hash", false, (test_callback_fn
*)parser_hash_test
},
6087 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
6088 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
6089 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
6090 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
6091 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
6092 {"server", false, (test_callback_fn
*)server_test
},
6093 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
6094 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
6095 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
6096 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
6097 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
6098 {0, 0, (test_callback_fn
*)0}
6101 test_st virtual_bucket_tests
[] ={
6102 {"basic", false, (test_callback_fn
*)virtual_back_map
},
6103 {0, 0, (test_callback_fn
*)0}
6106 test_st memcached_server_add_tests
[] ={
6107 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
6108 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
6109 {0, 0, (test_callback_fn
*)0}
6112 test_st namespace_tests
[] ={
6113 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
6114 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
6115 {0, 0, (test_callback_fn
*)0}
6118 collection_st collection
[] ={
6120 {"hash_sanity", 0, 0, hash_sanity
},
6122 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
6123 {"basic", 0, 0, basic_tests
},
6124 {"hsieh_availability", 0, 0, hsieh_availability
},
6125 {"murmur_availability", 0, 0, murmur_availability
},
6126 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
6127 {"block", 0, 0, tests
},
6128 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
6129 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
6130 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6131 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
6132 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
6133 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
6134 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
6135 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
6136 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
6137 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
6138 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
6139 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
6140 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
6141 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6142 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
6143 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6144 {"poll_timeout", (test_callback_fn
*)poll_timeout
, 0, tests
},
6145 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
6146 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
6147 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
6148 #ifdef MEMCACHED_ENABLE_DEPRECATED
6149 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
6151 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
6152 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
6153 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
6154 {"specific namespace", 0, 0, namespace_tests
},
6155 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
6156 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
6157 {"result", 0, 0, result_tests
},
6158 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
6159 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
6160 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
6161 {"user written tests", 0, 0, user_tests
},
6162 {"generate", 0, 0, generate_tests
},
6163 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
6164 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
6165 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
6166 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
6167 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
6168 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
6169 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
6171 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
6172 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
6173 {"consistent_not", 0, 0, consistent_tests
},
6174 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
6175 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6176 {"ketama_compat", 0, 0, ketama_compatibility
},
6177 {"test_hashes", 0, 0, hash_tests
},
6178 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6179 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6180 {"regression", 0, 0, regression_tests
},
6181 {"behaviors", 0, 0, behavior_tests
},
6182 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6183 {"error_conditions", 0, 0, error_conditions
},
6184 {"parser", 0, 0, parser_tests
},
6185 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6186 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6190 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
6192 #include "tests/libmemcached_world.h"
6194 void get_world(Framework
*world
)
6196 world
->collections
= collection
;
6198 world
->_create
= (test_callback_create_fn
*)world_create
;
6199 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6201 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6202 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6203 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6204 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6205 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6207 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6208 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6210 world
->set_runner(&defualt_libmemcached_runner
);
6212 world
->set_socket();