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
error_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, 3365377466U };
440 // You have updated the memcache_error messages but not updated docs/tests.
441 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
444 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
445 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
446 MEMCACHED_HASH_JENKINS
);
447 if (values
[rc
] != hash_val
)
449 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the error_test\n");
450 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
452 test_compare(values
[rc
], hash_val
);
454 test_compare(47, int(MEMCACHED_MAXIMUM_RETURN
));
459 static test_return_t
set_test(memcached_st
*memc
)
461 memcached_return_t rc
= memcached_set(memc
,
462 test_literal_param("foo"),
463 test_literal_param("when we sanitize"),
464 time_t(0), (uint32_t)0);
465 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
470 static test_return_t
append_test(memcached_st
*memc
)
472 memcached_return_t rc
;
473 const char *key
= "fig";
474 const char *in_value
= "we";
475 char *out_value
= NULL
;
479 rc
= memcached_flush(memc
, 0);
480 test_compare(MEMCACHED_SUCCESS
, rc
);
482 rc
= memcached_set(memc
, key
, strlen(key
),
483 in_value
, strlen(in_value
),
484 (time_t)0, (uint32_t)0);
485 test_compare(MEMCACHED_SUCCESS
, rc
);
487 rc
= memcached_append(memc
, key
, strlen(key
),
488 " the", strlen(" the"),
489 (time_t)0, (uint32_t)0);
490 test_compare(MEMCACHED_SUCCESS
, rc
);
492 rc
= memcached_append(memc
, key
, strlen(key
),
493 " people", strlen(" people"),
494 (time_t)0, (uint32_t)0);
495 test_compare(MEMCACHED_SUCCESS
, rc
);
497 out_value
= memcached_get(memc
, key
, strlen(key
),
498 &value_length
, &flags
, &rc
);
499 test_memcmp(out_value
, "we the people", strlen("we the people"));
500 test_compare(strlen("we the people"), value_length
);
501 test_compare(MEMCACHED_SUCCESS
, rc
);
507 static test_return_t
append_binary_test(memcached_st
*memc
)
509 memcached_return_t rc
;
510 const char *key
= "numbers";
511 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
517 rc
= memcached_flush(memc
, 0);
518 test_compare(MEMCACHED_SUCCESS
, rc
);
520 rc
= memcached_set(memc
,
523 (time_t)0, (uint32_t)0);
524 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
526 for (x
= 0; store_list
[x
] ; x
++)
528 rc
= memcached_append(memc
,
530 (char *)&store_list
[x
], sizeof(uint32_t),
531 (time_t)0, (uint32_t)0);
532 test_compare(MEMCACHED_SUCCESS
, rc
);
535 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
536 &value_length
, &flags
, &rc
);
537 test_compare(value_length
, sizeof(uint32_t) * x
);
538 test_compare(MEMCACHED_SUCCESS
, rc
);
540 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
542 test_compare(*ptr
, store_list
[x
- counter
]);
550 static test_return_t
cas2_test(memcached_st
*memc
)
552 memcached_return_t rc
;
553 const char *keys
[]= {"fudge", "son", "food"};
554 size_t key_length
[]= {5, 3, 4};
555 const char *value
= "we the people";
556 size_t value_length
= strlen("we the people");
557 memcached_result_st results_obj
;
558 memcached_result_st
*results
;
561 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
563 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
565 for (uint32_t x
= 0; x
< 3; x
++)
567 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
568 keys
[x
], key_length
[x
],
569 (time_t)50, (uint32_t)9);
570 test_compare(MEMCACHED_SUCCESS
, rc
);
573 rc
= memcached_mget(memc
, keys
, key_length
, 3);
575 results
= memcached_result_create(memc
, &results_obj
);
577 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
579 test_true(results
->item_cas
);
580 test_compare(MEMCACHED_SUCCESS
, rc
);
581 test_true(memcached_result_cas(results
));
583 test_memcmp(value
, "we the people", strlen("we the people"));
584 test_compare(strlen("we the people"), value_length
);
585 test_compare(MEMCACHED_SUCCESS
, rc
);
587 memcached_result_free(&results_obj
);
592 static test_return_t
cas_test(memcached_st
*memc
)
594 memcached_return_t rc
;
595 const char *key
= "fun";
596 size_t key_length
= strlen(key
);
597 const char *value
= "we the people";
598 const char* keys
[2] = { key
, NULL
};
599 size_t keylengths
[2] = { strlen(key
), 0 };
600 size_t value_length
= strlen(value
);
601 const char *value2
= "change the value";
602 size_t value2_length
= strlen(value2
);
604 memcached_result_st results_obj
;
605 memcached_result_st
*results
;
608 rc
= memcached_flush(memc
, 0);
609 test_compare(MEMCACHED_SUCCESS
, rc
);
611 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
613 rc
= memcached_set(memc
, key
, strlen(key
),
614 value
, strlen(value
),
615 (time_t)0, (uint32_t)0);
616 test_compare(MEMCACHED_SUCCESS
, rc
);
618 rc
= memcached_mget(memc
, keys
, keylengths
, 1);
620 results
= memcached_result_create(memc
, &results_obj
);
622 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
624 test_compare(MEMCACHED_SUCCESS
, rc
);
625 test_true(memcached_result_cas(results
));
626 test_memcmp(value
, memcached_result_value(results
), value_length
);
627 test_compare(strlen(memcached_result_value(results
)), value_length
);
628 test_compare(MEMCACHED_SUCCESS
, rc
);
629 uint64_t cas
= memcached_result_cas(results
);
632 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
633 test_true(rc
== MEMCACHED_END
);
634 test_true(results
== NULL
);
637 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
638 test_compare(MEMCACHED_SUCCESS
, rc
);
641 * The item will have a new cas value, so try to set it again with the old
642 * value. This should fail!
644 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
645 test_compare(MEMCACHED_DATA_EXISTS
, rc
);
647 memcached_result_free(&results_obj
);
652 static test_return_t
prepend_test(memcached_st
*memc
)
654 memcached_return_t rc
;
655 const char *key
= "fig";
656 const char *value
= "people";
657 char *out_value
= NULL
;
661 rc
= memcached_flush(memc
, 0);
662 test_compare(MEMCACHED_SUCCESS
, rc
);
664 rc
= memcached_set(memc
, key
, strlen(key
),
665 value
, strlen(value
),
666 (time_t)0, (uint32_t)0);
667 test_compare(MEMCACHED_SUCCESS
, rc
);
669 rc
= memcached_prepend(memc
, key
, strlen(key
),
670 "the ", strlen("the "),
671 (time_t)0, (uint32_t)0);
672 test_compare(MEMCACHED_SUCCESS
, rc
);
674 rc
= memcached_prepend(memc
, key
, strlen(key
),
675 "we ", strlen("we "),
676 (time_t)0, (uint32_t)0);
677 test_compare(MEMCACHED_SUCCESS
, rc
);
679 out_value
= memcached_get(memc
, key
, strlen(key
),
680 &value_length
, &flags
, &rc
);
681 test_memcmp(out_value
, "we the people", strlen("we the people"));
682 test_compare(strlen("we the people"), value_length
);
683 test_compare(MEMCACHED_SUCCESS
, rc
);
690 Set the value, then quit to make sure it is flushed.
691 Come back in and test that add fails.
693 static test_return_t
add_test(memcached_st
*memc
)
695 memcached_return_t rc
;
696 const char *key
= "foo";
697 const char *value
= "when we sanitize";
698 unsigned long long setting_value
;
700 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
702 rc
= memcached_set(memc
, key
, strlen(key
),
703 value
, strlen(value
),
704 (time_t)0, (uint32_t)0);
705 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
706 memcached_quit(memc
);
707 rc
= memcached_add(memc
, key
, strlen(key
),
708 value
, strlen(value
),
709 (time_t)0, (uint32_t)0);
711 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
714 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
718 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
725 ** There was a problem of leaking filedescriptors in the initial release
726 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
727 ** systems it seems that the kernel is slow on reclaiming the resources
728 ** because the connects starts to time out (the test doesn't do much
729 ** anyway, so just loop 10 iterations)
731 static test_return_t
add_wrapper(memcached_st
*memc
)
733 unsigned int max
= 10000;
741 for (uint32_t x
= 0; x
< max
; x
++)
747 static test_return_t
replace_test(memcached_st
*memc
)
749 memcached_return_t rc
;
750 const char *key
= "foo";
751 const char *value
= "when we sanitize";
752 const char *original
= "first we insert some data";
754 rc
= memcached_set(memc
, key
, strlen(key
),
755 original
, strlen(original
),
756 (time_t)0, (uint32_t)0);
757 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
759 test_compare(MEMCACHED_SUCCESS
,
760 memcached_replace(memc
, key
, strlen(key
),
761 value
, strlen(value
),
762 (time_t)0, (uint32_t)0));
767 static test_return_t
delete_test(memcached_st
*memc
)
769 memcached_return_t rc
;
770 const char *key
= "foo";
771 const char *value
= "when we sanitize";
773 rc
= memcached_set(memc
, key
, strlen(key
),
774 value
, strlen(value
),
775 (time_t)0, (uint32_t)0);
776 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
778 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
779 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
784 static test_return_t
flush_test(memcached_st
*memc
)
786 uint64_t query_id
= memcached_query_id(memc
);
787 test_compare(MEMCACHED_SUCCESS
,
788 memcached_flush(memc
, 0));
789 test_compare(query_id
+1, memcached_query_id(memc
));
794 static memcached_return_t
server_function(const memcached_st
*ptr
,
795 const memcached_server_st
*server
,
798 (void)ptr
; (void)server
; (void)context
;
801 return MEMCACHED_SUCCESS
;
804 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
807 strncpy(context
, "foo bad", sizeof(context
));
808 memcached_server_fn callbacks
[1];
810 callbacks
[0]= server_function
;
811 memcached_server_cursor(memc
, callbacks
, context
, 1);
815 static test_return_t
bad_key_test(memcached_st
*memc
)
817 memcached_return_t rc
;
818 const char *key
= "foo bad";
820 size_t string_length
;
822 memcached_st
*memc_clone
;
824 size_t max_keylen
= 0xffff;
826 // Just skip if we are in binary mode.
827 uint64_t query_id
= memcached_query_id(memc
);
828 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
830 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
832 memc_clone
= memcached_clone(NULL
, memc
);
833 test_true(memc_clone
);
835 query_id
= memcached_query_id(memc_clone
);
836 test_compare(MEMCACHED_SUCCESS
,
837 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
838 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
840 /* All keys are valid in the binary protocol (except for length) */
841 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
843 query_id
= memcached_query_id(memc_clone
);
844 string
= memcached_get(memc_clone
, key
, strlen(key
),
845 &string_length
, &flags
, &rc
);
846 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
847 test_zero(string_length
);
851 query_id
= memcached_query_id(memc_clone
);
852 test_compare(MEMCACHED_SUCCESS
,
853 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
854 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
855 string
= memcached_get(memc_clone
, key
, strlen(key
),
856 &string_length
, &flags
, &rc
);
857 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
858 test_zero(string_length
);
861 /* Test multi key for bad keys */
862 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
863 size_t key_lengths
[] = { 7, 7, 7 };
865 query_id
= memcached_query_id(memc_clone
);
866 test_compare(MEMCACHED_SUCCESS
,
867 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
868 test_compare(query_id
, memcached_query_id(memc_clone
));
870 query_id
= memcached_query_id(memc_clone
);
871 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
872 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
873 test_compare(query_id
+1, memcached_query_id(memc_clone
));
875 query_id
= memcached_query_id(memc_clone
);
876 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
877 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
878 test_compare(query_id
+1, memcached_query_id(memc_clone
));
882 /* The following test should be moved to the end of this function when the
883 memcached server is updated to allow max size length of the keys in the
886 test_compare(MEMCACHED_SUCCESS
,
887 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
889 char *longkey
= (char *)malloc(max_keylen
+ 1);
892 memset(longkey
, 'a', max_keylen
+ 1);
893 string
= memcached_get(memc_clone
, longkey
, max_keylen
,
894 &string_length
, &flags
, &rc
);
895 test_compare(MEMCACHED_NOTFOUND
, rc
);
896 test_zero(string_length
);
899 string
= memcached_get(memc_clone
, longkey
, max_keylen
+ 1,
900 &string_length
, &flags
, &rc
);
901 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
902 test_zero(string_length
);
909 /* Make sure zero length keys are marked as bad */
911 test_compare(MEMCACHED_SUCCESS
,
912 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, set
));
913 string
= memcached_get(memc_clone
, key
, 0,
914 &string_length
, &flags
, &rc
);
915 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
916 test_zero(string_length
);
919 memcached_free(memc_clone
);
924 #define READ_THROUGH_VALUE "set for me"
925 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
928 memcached_result_st
*result
)
930 (void)memc
;(void)key
;(void)key_length
;
931 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
934 #ifndef __INTEL_COMPILER
935 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
938 static test_return_t
read_through(memcached_st
*memc
)
940 memcached_return_t rc
;
941 const char *key
= "foo";
943 size_t string_length
;
945 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
947 string
= memcached_get(memc
, key
, strlen(key
),
948 &string_length
, &flags
, &rc
);
950 test_compare(MEMCACHED_NOTFOUND
, rc
);
951 test_false(string_length
);
954 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
);
955 test_compare(MEMCACHED_SUCCESS
, rc
);
957 string
= memcached_get(memc
, key
, strlen(key
),
958 &string_length
, &flags
, &rc
);
960 test_compare(MEMCACHED_SUCCESS
, rc
);
961 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
962 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
963 test_strcmp(READ_THROUGH_VALUE
, string
);
966 string
= memcached_get(memc
, key
, strlen(key
),
967 &string_length
, &flags
, &rc
);
969 test_compare(MEMCACHED_SUCCESS
, rc
);
971 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
972 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
973 test_strcmp(READ_THROUGH_VALUE
, string
);
979 static memcached_return_t
delete_trigger(memcached_st
*,
986 return MEMCACHED_SUCCESS
;
989 static test_return_t
delete_through(memcached_st
*memc
)
991 memcached_trigger_delete_key_fn callback
;
992 memcached_return_t rc
;
994 callback
= (memcached_trigger_delete_key_fn
)delete_trigger
;
996 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
);
997 test_compare(MEMCACHED_SUCCESS
, rc
);
1002 static test_return_t
get_test(memcached_st
*memc
)
1004 memcached_return_t rc
;
1005 const char *key
= "foo";
1007 size_t string_length
;
1010 uint64_t query_id
= memcached_query_id(memc
);
1011 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
1012 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
1013 test_compare(query_id
+1, memcached_query_id(memc
));
1015 string
= memcached_get(memc
, key
, strlen(key
),
1016 &string_length
, &flags
, &rc
);
1018 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1019 test_false(string_length
);
1022 return TEST_SUCCESS
;
1025 static test_return_t
get_test2(memcached_st
*memc
)
1027 const char *key
= "foo";
1028 const char *value
= "when we sanitize";
1030 uint64_t query_id
= memcached_query_id(memc
);
1031 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1032 value
, strlen(value
),
1033 (time_t)0, (uint32_t)0);
1034 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1035 test_compare(query_id
+1, memcached_query_id(memc
));
1037 query_id
= memcached_query_id(memc
);
1038 test_true(query_id
);
1041 size_t string_length
;
1042 char *string
= memcached_get(memc
, key
, strlen(key
),
1043 &string_length
, &flags
, &rc
);
1044 test_compare(query_id
+1, memcached_query_id(memc
));
1046 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1047 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1049 test_compare(strlen(value
), string_length
);
1050 test_memcmp(string
, value
, string_length
);
1054 return TEST_SUCCESS
;
1057 static test_return_t
set_test2(memcached_st
*memc
)
1059 const char *key
= "foo";
1060 const char *value
= "train in the brain";
1061 size_t value_length
= strlen(value
);
1063 for (uint32_t x
= 0; x
< 10; x
++)
1065 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1066 value
, value_length
,
1067 (time_t)0, (uint32_t)0);
1068 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1071 return TEST_SUCCESS
;
1074 static test_return_t
set_test3(memcached_st
*memc
)
1076 size_t value_length
= 8191;
1078 char *value
= (char*)malloc(value_length
);
1081 for (uint32_t x
= 0; x
< value_length
; x
++)
1083 value
[x
] = (char) (x
% 127);
1086 /* The dump test relies on there being at least 32 items in memcached */
1087 for (uint32_t x
= 0; x
< 32; x
++)
1091 snprintf(key
, sizeof(key
), "foo%u", x
);
1093 uint64_t query_id
= memcached_query_id(memc
);
1094 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1095 value
, value_length
,
1096 (time_t)0, (uint32_t)0);
1097 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1098 test_compare(query_id
+1, memcached_query_id(memc
));
1103 return TEST_SUCCESS
;
1106 static test_return_t
get_test3(memcached_st
*memc
)
1108 const char *key
= "foo";
1109 size_t value_length
= 8191;
1111 char *value
= (char*)malloc(value_length
);
1114 for (uint32_t x
= 0; x
< value_length
; x
++)
1116 value
[x
] = (char) (x
% 127);
1119 memcached_return_t rc
;
1120 rc
= memcached_set(memc
, key
, strlen(key
),
1121 value
, value_length
,
1122 (time_t)0, (uint32_t)0);
1123 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1125 size_t string_length
;
1127 char *string
= memcached_get(memc
, key
, strlen(key
),
1128 &string_length
, &flags
, &rc
);
1130 test_compare(MEMCACHED_SUCCESS
, rc
);
1132 test_compare(string_length
, value_length
);
1133 test_memcmp(string
, value
, string_length
);
1138 return TEST_SUCCESS
;
1141 static test_return_t
get_test4(memcached_st
*memc
)
1143 const char *key
= "foo";
1144 size_t value_length
= 8191;
1146 char *value
= (char*)malloc(value_length
);
1149 for (uint32_t x
= 0; x
< value_length
; x
++)
1151 value
[x
] = (char) (x
% 127);
1154 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1155 value
, value_length
,
1156 (time_t)0, (uint32_t)0);
1157 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1159 for (uint32_t x
= 0; x
< 10; x
++)
1162 size_t string_length
;
1163 char *string
= memcached_get(memc
, key
, strlen(key
),
1164 &string_length
, &flags
, &rc
);
1166 test_compare(MEMCACHED_SUCCESS
, rc
);
1168 test_compare(string_length
, value_length
);
1169 test_memcmp(string
, value
, string_length
);
1175 return TEST_SUCCESS
;
1179 * This test verifies that memcached_read_one_response doesn't try to
1180 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1181 * responses before you execute a storage command.
1183 static test_return_t
get_test5(memcached_st
*memc
)
1186 ** Request the same key twice, to ensure that we hash to the same server
1187 ** (so that we have multiple response values queued up) ;-)
1189 const char *keys
[]= { "key", "key" };
1190 size_t lengths
[]= { 3, 3 };
1194 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1195 keys
[0], lengths
[0], 0, 0);
1196 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1198 memcached_result_st results_obj
;
1199 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1202 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1205 memcached_result_free(&results_obj
);
1207 /* Don't read out the second result, but issue a set instead.. */
1208 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1210 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1211 &rlen
, &flags
, &rc
);
1213 test_compare(MEMCACHED_NOTFOUND
, rc
);
1214 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1216 test_compare(MEMCACHED_SUCCESS
, rc
);
1219 return TEST_SUCCESS
;
1222 static test_return_t
mget_end(memcached_st
*memc
)
1224 const char *keys
[]= { "foo", "foo2" };
1225 size_t lengths
[]= { 3, 4 };
1226 const char *values
[]= { "fjord", "41" };
1228 memcached_return_t rc
;
1231 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1233 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[x
], lengths
[x
], values
[x
], strlen(values
[x
]), (time_t)0, (uint32_t)0));
1237 size_t string_length
;
1240 // retrieve both via mget
1241 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1243 char key
[MEMCACHED_MAX_KEY
];
1246 // this should get both
1247 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1249 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1251 test_compare(MEMCACHED_SUCCESS
, rc
);
1253 if (key_length
== 4)
1258 test_compare(string_length
, strlen(values
[val
]));
1259 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1263 // this should indicate end
1264 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1265 test_compare(MEMCACHED_END
, rc
);
1268 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1269 test_compare(MEMCACHED_SUCCESS
, rc
);
1271 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1272 test_compare(key_length
, lengths
[0]);
1273 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1274 test_compare(string_length
, strlen(values
[0]));
1275 test_true(strncmp(values
[0], string
, string_length
) == 0);
1276 test_compare(MEMCACHED_SUCCESS
, rc
);
1279 // this should indicate end
1280 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1281 test_true(rc
== MEMCACHED_END
);
1283 return TEST_SUCCESS
;
1286 /* Do not copy the style of this code, I just access hosts to testthis function */
1287 static test_return_t
stats_servername_test(memcached_st
*memc
)
1289 memcached_stat_st memc_stat
;
1290 memcached_server_instance_st instance
=
1291 memcached_server_instance_by_position(memc
, 0);
1293 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1295 return TEST_SKIPPED
;
1298 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1299 memcached_server_name(instance
),
1300 memcached_server_port(instance
)));
1302 return TEST_SUCCESS
;
1305 static test_return_t
increment_test(memcached_st
*memc
)
1307 uint64_t new_number
;
1309 test_compare(MEMCACHED_SUCCESS
,
1311 test_literal_param("number"),
1312 test_literal_param("0"),
1313 (time_t)0, (uint32_t)0));
1315 test_compare(MEMCACHED_SUCCESS
,
1316 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1317 test_compare(uint64_t(1), new_number
);
1319 test_compare(MEMCACHED_SUCCESS
,
1320 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1321 test_compare(uint64_t(2), new_number
);
1323 return TEST_SUCCESS
;
1326 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1328 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1330 uint64_t new_number
;
1331 uint64_t initial
= 0;
1333 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1335 test_compare(MEMCACHED_SUCCESS
,
1336 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1337 test_compare(new_number
, initial
);
1339 test_compare(MEMCACHED_SUCCESS
,
1340 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1341 test_compare(new_number
, (initial
+1));
1343 return TEST_SUCCESS
;
1346 static test_return_t
decrement_test(memcached_st
*memc
)
1348 uint64_t new_number
;
1349 memcached_return_t rc
;
1350 const char *value
= "3";
1352 rc
= memcached_set(memc
,
1353 test_literal_param("number"),
1354 value
, strlen(value
),
1355 (time_t)0, (uint32_t)0);
1356 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1358 test_compare(MEMCACHED_SUCCESS
,
1359 memcached_decrement(memc
,
1360 test_literal_param("number"),
1362 test_compare(uint64_t(2), new_number
);
1364 test_compare(MEMCACHED_SUCCESS
,
1365 memcached_decrement(memc
,
1366 test_literal_param("number"),
1368 test_compare(uint64_t(1), new_number
);
1370 return TEST_SUCCESS
;
1373 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1375 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1377 uint64_t new_number
;
1378 uint64_t initial
= 3;
1380 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1382 test_compare(MEMCACHED_SUCCESS
,
1383 memcached_decrement_with_initial(memc
,
1384 test_literal_param("number"),
1385 1, initial
, 0, &new_number
));
1386 test_compare(new_number
, initial
);
1388 test_compare(MEMCACHED_SUCCESS
,
1389 memcached_decrement_with_initial(memc
,
1390 test_literal_param("number"),
1391 1, initial
, 0, &new_number
));
1392 test_compare(new_number
, (initial
- 1));
1394 return TEST_SUCCESS
;
1397 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1399 uint64_t new_number
;
1400 memcached_return_t rc
;
1401 const char *master_key
= "foo";
1402 const char *key
= "number";
1403 const char *value
= "0";
1405 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1407 value
, strlen(value
),
1408 (time_t)0, (uint32_t)0);
1409 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1411 test_compare(MEMCACHED_SUCCESS
,
1412 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1413 test_compare(uint64_t(1), new_number
);
1415 test_compare(MEMCACHED_SUCCESS
,
1416 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1417 test_compare(uint64_t(2), new_number
);
1419 return TEST_SUCCESS
;
1422 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1424 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1426 uint64_t new_number
;
1427 memcached_return_t rc
;
1428 const char *master_key
= "foo";
1429 const char *key
= "number";
1430 uint64_t initial
= 0;
1432 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1434 1, initial
, 0, &new_number
);
1435 test_compare(MEMCACHED_SUCCESS
, rc
);
1436 test_compare(new_number
, initial
);
1438 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1440 1, initial
, 0, &new_number
);
1441 test_compare(MEMCACHED_SUCCESS
, rc
);
1442 test_compare(new_number
, (initial
+1));
1444 return TEST_SUCCESS
;
1447 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1449 uint64_t new_number
;
1450 memcached_return_t rc
;
1451 const char *value
= "3";
1453 rc
= memcached_set_by_key(memc
,
1454 test_literal_param("foo"),
1455 test_literal_param("number"),
1456 value
, strlen(value
),
1457 (time_t)0, (uint32_t)0);
1458 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1460 test_compare(MEMCACHED_SUCCESS
,
1461 memcached_decrement_by_key(memc
,
1462 test_literal_param("foo"),
1463 test_literal_param("number"),
1465 test_compare(uint64_t(2), new_number
);
1467 test_compare(MEMCACHED_SUCCESS
,
1468 memcached_decrement_by_key(memc
,
1469 test_literal_param("foo"),
1470 test_literal_param("number"),
1472 test_compare(uint64_t(1), new_number
);
1474 return TEST_SUCCESS
;
1477 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1479 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1481 uint64_t new_number
;
1482 uint64_t initial
= 3;
1484 test_compare(MEMCACHED_SUCCESS
,
1485 memcached_decrement_with_initial_by_key(memc
,
1486 test_literal_param("foo"),
1487 test_literal_param("number"),
1488 1, initial
, 0, &new_number
));
1489 test_compare(new_number
, initial
);
1491 test_compare(MEMCACHED_SUCCESS
,
1492 memcached_decrement_with_initial_by_key(memc
,
1493 test_literal_param("foo"),
1494 test_literal_param("number"),
1495 1, initial
, 0, &new_number
));
1496 test_compare(new_number
, (initial
- 1));
1498 return TEST_SUCCESS
;
1500 static test_return_t
binary_increment_with_prefix_test(memcached_st
*orig_memc
)
1502 memcached_st
*memc
= memcached_clone(NULL
, orig_memc
);
1504 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1506 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1508 memcached_return_t rc
;
1509 rc
= memcached_set(memc
,
1510 test_literal_param("number"),
1511 test_literal_param("0"),
1512 (time_t)0, (uint32_t)0);
1513 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1515 uint64_t new_number
;
1516 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1517 test_literal_param("number"),
1519 test_compare(uint64_t(1), new_number
);
1521 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1522 test_literal_param("number"),
1524 test_compare(uint64_t(2), new_number
);
1526 return TEST_SUCCESS
;
1529 static test_return_t
quit_test(memcached_st
*memc
)
1531 memcached_return_t rc
;
1532 const char *key
= "fudge";
1533 const char *value
= "sanford and sun";
1535 rc
= memcached_set(memc
, key
, strlen(key
),
1536 value
, strlen(value
),
1537 (time_t)10, (uint32_t)3);
1538 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1539 memcached_quit(memc
);
1541 rc
= memcached_set(memc
, key
, strlen(key
),
1542 value
, strlen(value
),
1543 (time_t)50, (uint32_t)9);
1544 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1546 return TEST_SUCCESS
;
1549 static test_return_t
mget_result_test(memcached_st
*memc
)
1551 const char *keys
[]= {"fudge", "son", "food"};
1552 size_t key_length
[]= {5, 3, 4};
1554 memcached_result_st results_obj
;
1555 memcached_result_st
*results
;
1557 results
= memcached_result_create(memc
, &results_obj
);
1559 test_true(&results_obj
== results
);
1561 /* We need to empty the server before continueing test */
1562 test_compare(MEMCACHED_SUCCESS
,
1563 memcached_flush(memc
, 0));
1565 test_compare(MEMCACHED_SUCCESS
,
1566 memcached_mget(memc
, keys
, key_length
, 3));
1568 memcached_return_t rc
;
1569 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1574 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1575 test_false(results
);
1576 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1578 for (uint32_t x
= 0; x
< 3; x
++)
1580 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1581 keys
[x
], key_length
[x
],
1582 (time_t)50, (uint32_t)9);
1583 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1586 test_compare(MEMCACHED_SUCCESS
,
1587 memcached_mget(memc
, keys
, key_length
, 3));
1589 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1592 test_true(&results_obj
== results
);
1593 test_compare(MEMCACHED_SUCCESS
, rc
);
1594 test_memcmp(memcached_result_key_value(results
),
1595 memcached_result_value(results
),
1596 memcached_result_length(results
));
1597 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1600 memcached_result_free(&results_obj
);
1602 return TEST_SUCCESS
;
1605 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1607 const char *keys
[]= {"fudge", "son", "food"};
1608 size_t key_length
[]= {5, 3, 4};
1610 memcached_result_st
*results
;
1612 /* We need to empty the server before continueing test */
1613 test_compare(MEMCACHED_SUCCESS
,
1614 memcached_flush(memc
, 0));
1616 test_compare(MEMCACHED_SUCCESS
,
1617 memcached_mget(memc
, keys
, key_length
, 3));
1619 memcached_return_t rc
;
1620 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1624 test_false(results
);
1625 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1627 for (uint32_t x
= 0; x
< 3; x
++)
1629 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1630 keys
[x
], key_length
[x
],
1631 (time_t)50, (uint32_t)9);
1632 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1635 test_compare(MEMCACHED_SUCCESS
,
1636 memcached_mget(memc
, keys
, key_length
, 3));
1639 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1642 test_compare(MEMCACHED_SUCCESS
, rc
);
1643 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1644 test_memcmp(memcached_result_key_value(results
),
1645 memcached_result_value(results
),
1646 memcached_result_length(results
));
1647 memcached_result_free(results
);
1651 return TEST_SUCCESS
;
1654 /* Count the results */
1655 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1657 size_t *counter
= (size_t *)context
;
1659 *counter
= *counter
+ 1;
1661 return MEMCACHED_SUCCESS
;
1664 static test_return_t
mget_result_function(memcached_st
*memc
)
1666 const char *keys
[]= {"fudge", "son", "food"};
1667 size_t key_length
[]= {5, 3, 4};
1669 memcached_execute_fn callbacks
[1];
1671 /* We need to empty the server before continueing test */
1672 test_compare(MEMCACHED_SUCCESS
,
1673 memcached_flush(memc
, 0));
1674 for (uint32_t x
= 0; x
< 3; x
++)
1676 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1677 keys
[x
], key_length
[x
],
1678 (time_t)50, (uint32_t)9);
1679 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1682 test_compare(MEMCACHED_SUCCESS
,
1683 memcached_mget(memc
, keys
, key_length
, 3));
1685 callbacks
[0]= &callback_counter
;
1688 test_compare(MEMCACHED_SUCCESS
,
1689 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1691 test_compare(size_t(3), counter
);
1693 return TEST_SUCCESS
;
1696 static test_return_t
mget_test(memcached_st
*memc
)
1698 const char *keys
[]= {"fudge", "son", "food"};
1699 size_t key_length
[]= {5, 3, 4};
1701 char return_key
[MEMCACHED_MAX_KEY
];
1702 size_t return_key_length
;
1704 size_t return_value_length
;
1706 /* We need to empty the server before continueing test */
1707 test_compare(MEMCACHED_SUCCESS
,
1708 memcached_flush(memc
, 0));
1710 test_compare(MEMCACHED_SUCCESS
,
1711 memcached_mget(memc
, keys
, key_length
, 3));
1714 memcached_return_t rc
;
1715 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1716 &return_value_length
, &flags
, &rc
)))
1718 test_true(return_value
);
1720 test_false(return_value
);
1721 test_zero(return_value_length
);
1722 test_compare(MEMCACHED_NOTFOUND
, rc
);
1724 for (uint32_t x
= 0; x
< 3; x
++)
1726 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1727 keys
[x
], key_length
[x
],
1728 (time_t)50, (uint32_t)9);
1729 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1731 test_compare(MEMCACHED_SUCCESS
,
1732 memcached_mget(memc
, keys
, key_length
, 3));
1735 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1736 &return_value_length
, &flags
, &rc
)))
1738 test_true(return_value
);
1739 test_compare(MEMCACHED_SUCCESS
, rc
);
1740 if (not memc
->_namespace
)
1742 test_compare(return_key_length
, return_value_length
);
1743 test_memcmp(return_value
, return_key
, return_value_length
);
1749 return TEST_SUCCESS
;
1752 static test_return_t
mget_execute(memcached_st
*memc
)
1756 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1760 * I only want to hit _one_ server so I know the number of requests I'm
1761 * sending in the pipeline.
1763 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1764 memc
->number_of_hosts
= 1;
1766 size_t max_keys
= 20480;
1769 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1770 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1772 /* First add all of the items.. */
1773 char blob
[1024] = {0};
1774 memcached_return_t rc
;
1776 for (size_t x
= 0; x
< max_keys
; ++x
)
1780 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1782 test_true(keys
[x
] != NULL
);
1783 uint64_t query_id
= memcached_query_id(memc
);
1784 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1785 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1786 test_compare(query_id
+1, memcached_query_id(memc
));
1789 /* Try to get all of them with a large multiget */
1791 memcached_execute_fn callbacks
[]= { &callback_counter
};
1792 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1793 max_keys
, callbacks
, &counter
, 1);
1795 if (memcached_success(rc
))
1798 uint64_t query_id
= memcached_query_id(memc
);
1799 test_compare(MEMCACHED_SUCCESS
,
1800 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1801 test_compare(query_id
, memcached_query_id(memc
));
1803 /* Verify that we got all of the items */
1804 test_true(counter
== max_keys
);
1806 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1808 test_true(counter
== 0);
1812 test_fail("note: this test functions differently when in binary mode");
1815 /* Release all allocated resources */
1816 for (size_t x
= 0; x
< max_keys
; ++x
)
1823 memc
->number_of_hosts
= number_of_hosts
;
1824 return TEST_SUCCESS
;
1827 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1829 static test_return_t
key_setup(memcached_st
*memc
)
1831 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1833 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1835 return TEST_SUCCESS
;
1838 static test_return_t
key_teardown(memcached_st
*memc
)
1841 pairs_free(global_pairs
);
1843 return TEST_SUCCESS
;
1846 static test_return_t
block_add_regression(memcached_st
*memc
)
1848 /* First add all of the items.. */
1849 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1851 memcached_return_t rc
;
1852 char blob
[1024] = {0};
1854 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1855 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1858 return TEST_SUCCESS
;
1861 static test_return_t
binary_add_regression(memcached_st
*memc
)
1863 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1864 test_return_t rc
= block_add_regression(memc
);
1865 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1869 static test_return_t
get_stats_keys(memcached_st
*memc
)
1873 memcached_stat_st memc_stat
;
1874 memcached_return_t rc
;
1876 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1877 test_compare(MEMCACHED_SUCCESS
, rc
);
1878 for (ptr
= stat_list
; *ptr
; ptr
++)
1883 return TEST_SUCCESS
;
1886 static test_return_t
version_string_test(memcached_st
*memc
)
1888 const char *version_string
;
1891 version_string
= memcached_lib_version();
1893 test_strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
);
1895 return TEST_SUCCESS
;
1898 static test_return_t
get_stats(memcached_st
*memc
)
1900 memcached_return_t rc
;
1902 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1903 test_compare(MEMCACHED_SUCCESS
, rc
);
1904 test_true(memc_stat
);
1906 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1908 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1909 test_compare(MEMCACHED_SUCCESS
, rc
);
1910 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1915 memcached_stat_free(NULL
, memc_stat
);
1917 return TEST_SUCCESS
;
1920 static test_return_t
add_host_test(memcached_st
*memc
)
1923 memcached_server_st
*servers
;
1924 memcached_return_t rc
;
1925 char servername
[]= "0.example.com";
1927 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1929 test_true(1 == memcached_server_list_count(servers
));
1931 for (x
= 2; x
< 20; x
++)
1933 char buffer
[SMALL_STRING_LEN
];
1935 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1936 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1938 test_compare(MEMCACHED_SUCCESS
, rc
);
1939 test_true(x
== memcached_server_list_count(servers
));
1942 rc
= memcached_server_push(memc
, servers
);
1943 test_compare(MEMCACHED_SUCCESS
, rc
);
1944 rc
= memcached_server_push(memc
, servers
);
1945 test_compare(MEMCACHED_SUCCESS
, rc
);
1947 memcached_server_list_free(servers
);
1949 return TEST_SUCCESS
;
1952 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1954 memcached_return_t rc
;
1955 const char *key
= "not_found";
1956 size_t key_len
= strlen(key
);
1958 test_compare(MEMCACHED_SUCCESS
,
1959 memcached_mget(memc
, &key
, &key_len
, 1));
1961 memcached_result_st
*result
= NULL
;
1962 result
= memcached_fetch_result(memc
, result
, &rc
);
1964 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1966 memcached_result_free(result
);
1968 return TEST_SUCCESS
;
1971 static memcached_return_t
clone_test_callback(memcached_st
*parent
, memcached_st
*memc_clone
)
1973 (void)parent
;(void)memc_clone
;
1974 return MEMCACHED_SUCCESS
;
1977 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
)
1980 return MEMCACHED_SUCCESS
;
1983 static test_return_t
callback_test(memcached_st
*memc
)
1985 /* Test User Data */
1989 memcached_return_t rc
;
1991 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1992 test_compare(MEMCACHED_SUCCESS
, rc
);
1993 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
1994 test_true(*test_ptr
== x
);
1997 /* Test Clone Callback */
1999 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2000 void *clone_cb_ptr
= *(void **)&clone_cb
;
2001 void *temp_function
= NULL
;
2002 memcached_return_t rc
;
2004 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2006 test_compare(MEMCACHED_SUCCESS
, rc
);
2007 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2008 test_true(temp_function
== clone_cb_ptr
);
2011 /* Test Cleanup Callback */
2013 memcached_cleanup_fn cleanup_cb
=
2014 (memcached_cleanup_fn
)cleanup_test_callback
;
2015 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2016 void *temp_function
= NULL
;
2017 memcached_return_t rc
;
2019 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2021 test_compare(MEMCACHED_SUCCESS
, rc
);
2022 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2023 test_true(temp_function
== cleanup_cb_ptr
);
2026 return TEST_SUCCESS
;
2029 /* We don't test the behavior itself, we test the switches */
2030 static test_return_t
behavior_test(memcached_st
*memc
)
2035 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2036 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2037 test_true(value
== 1);
2039 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2040 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2041 test_true(value
== 1);
2043 set
= MEMCACHED_HASH_MD5
;
2044 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2045 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2046 test_true(value
== MEMCACHED_HASH_MD5
);
2050 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2051 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2052 test_true(value
== 0);
2054 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2055 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2056 test_true(value
== 0);
2058 set
= MEMCACHED_HASH_DEFAULT
;
2059 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2060 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2061 test_true(value
== MEMCACHED_HASH_DEFAULT
);
2063 set
= MEMCACHED_HASH_CRC
;
2064 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2065 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2066 test_true(value
== MEMCACHED_HASH_CRC
);
2068 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2069 test_true(value
> 0);
2071 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2072 test_true(value
> 0);
2074 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2075 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
2076 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2078 return TEST_SUCCESS
;
2081 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2083 memcached_return_t rc
;
2086 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
2087 test_true(rc
== MEMCACHED_DEPRECATED
);
2089 // Platform dependent
2091 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2095 return TEST_SUCCESS
;
2099 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2101 memcached_return_t rc
;
2105 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, set
);
2106 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2108 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2110 if (rc
== MEMCACHED_SUCCESS
)
2112 test_true((bool)value
== set
);
2116 test_false((bool)value
== set
);
2119 return TEST_SUCCESS
;
2123 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2125 memcached_return_t rc
;
2129 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, set
);
2130 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2132 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2134 if (rc
== MEMCACHED_SUCCESS
)
2136 test_true((bool)value
== set
);
2140 test_false((bool)value
== set
);
2143 return TEST_SUCCESS
;
2146 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, const memcached_return_t expect
)
2148 memcached_return_t rc
;
2149 char return_key
[MEMCACHED_MAX_KEY
];
2150 size_t return_key_length
;
2152 size_t return_value_length
;
2156 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2157 &return_value_length
, &flags
, &rc
)))
2159 test_true(return_value
);
2160 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2165 if (memcached_success(expect
) and memcached_success(rc
))
2167 return TEST_SUCCESS
;
2169 else if (expect
== rc
)
2171 return TEST_SUCCESS
;
2173 fprintf(stderr
, "\n%s:%u %s(#%u)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), keys_returned
);
2175 return TEST_FAILURE
;
2178 /* Test case provided by Cal Haldenbrand */
2179 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2180 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2181 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2183 /* We just keep looking at the same values over and over */
2186 unsigned int setter
= 1;
2187 test_compare(MEMCACHED_SUCCESS
,
2188 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2189 test_compare(MEMCACHED_SUCCESS
,
2190 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2194 unsigned long long total
= 0;
2195 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2197 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2198 char randomstuff
[6 * 1024];
2199 memset(randomstuff
, 0, 6 * 1024);
2200 test_true(size
< 6 * 1024); /* Being safe here */
2202 for (uint32_t j
= 0 ; j
< size
;j
++)
2204 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2209 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2210 test_compare(MEMCACHED_SUCCESS
,
2211 memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
));
2213 test_true(total
> HALDENBRAND_KEY_COUNT
);
2215 return TEST_SUCCESS
;
2218 /* Test case provided by Cal Haldenbrand */
2219 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2221 unsigned int setter
= 1;
2223 test_compare(MEMCACHED_SUCCESS
,
2224 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2226 test_compare(MEMCACHED_SUCCESS
,
2227 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2230 setter
= 20 * 1024576;
2231 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2232 setter
= 20 * 1024576;
2233 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2234 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2235 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2237 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2240 size_t total_value_length
= 0;
2241 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2246 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2247 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2249 memcached_return_t rc
;
2250 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2251 if (memcached_failed(rc
))
2253 if (rc
== MEMCACHED_NOTFOUND
)
2264 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2266 total_value_length
+= val_len
;
2271 return TEST_SUCCESS
;
2274 /* Do a large mget() over all the keys we think exist */
2275 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2277 unsigned int setter
= 1;
2278 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2279 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2281 setter
= 20 * 1024576;
2282 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2283 setter
= 20 * 1024576;
2284 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2285 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2286 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2289 size_t key_lengths
[HALDENBRAND_KEY_COUNT
];
2290 char **keys
= static_cast<char **>(calloc(HALDENBRAND_KEY_COUNT
, sizeof(char *)));
2292 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2294 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2295 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2296 keys
[x
]= strdup(key
);
2298 key_lengths
[x
]= key_length
;
2299 test_compare(size_t(key_length
), strlen(keys
[x
]));
2302 test_compare(MEMCACHED_SUCCESS
,
2303 memcached_mget(memc
, (const char **)keys
, key_lengths
, HALDENBRAND_KEY_COUNT
));
2305 unsigned int keys_returned
;
2306 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
2307 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2309 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2315 return TEST_SUCCESS
;
2318 /* Make sure we behave properly if server list has no values */
2319 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2321 const char *keys
[]= {"fudge", "son", "food"};
2322 size_t key_length
[]= {5, 3, 4};
2324 /* Here we free everything before running a bunch of mget tests */
2325 memcached_servers_reset(memc
);
2328 /* We need to empty the server before continueing test */
2329 test_compare(MEMCACHED_NO_SERVERS
,
2330 memcached_flush(memc
, 0));
2332 test_compare(MEMCACHED_NO_SERVERS
,
2333 memcached_mget(memc
, keys
, key_length
, 3));
2335 unsigned int keys_returned
;
2336 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2337 test_zero(keys_returned
);
2339 for (uint32_t x
= 0; x
< 3; x
++)
2341 test_compare(MEMCACHED_NO_SERVERS
,
2342 memcached_set(memc
, keys
[x
], key_length
[x
],
2343 keys
[x
], key_length
[x
],
2344 (time_t)50, (uint32_t)9));
2347 test_compare(MEMCACHED_NO_SERVERS
,
2348 memcached_mget(memc
, keys
, key_length
, 3));
2352 char return_key
[MEMCACHED_MAX_KEY
];
2353 memcached_return_t rc
;
2354 size_t return_key_length
;
2355 size_t return_value_length
;
2358 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2359 &return_value_length
, &flags
, &rc
)))
2361 test_true(return_value
);
2362 test_compare(MEMCACHED_SUCCESS
, rc
);
2363 test_true(return_key_length
== return_value_length
);
2364 test_memcmp(return_value
, return_key
, return_value_length
);
2370 return TEST_SUCCESS
;
2373 #define VALUE_SIZE_BUG5 1048064
2374 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2376 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2377 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2379 size_t value_length
;
2381 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2383 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2385 insert_data
[x
]= (signed char)rand();
2388 test_compare(MEMCACHED_SUCCESS
,
2389 memcached_flush(memc
, 0));
2391 memcached_return_t rc
;
2392 value
= memcached_get(memc
, keys
[0], key_length
[0],
2393 &value_length
, &flags
, &rc
);
2395 test_compare(MEMCACHED_SUCCESS
,
2396 memcached_mget(memc
, keys
, key_length
, 4));
2399 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2402 for (uint32_t x
= 0; x
< 4; x
++)
2404 test_compare(MEMCACHED_SUCCESS
,
2405 memcached_set(memc
, keys
[x
], key_length
[x
],
2406 insert_data
, VALUE_SIZE_BUG5
,
2407 (time_t)0, (uint32_t)0));
2410 for (uint32_t x
= 0; x
< 10; x
++)
2412 value
= memcached_get(memc
, keys
[0], key_length
[0],
2413 &value_length
, &flags
, &rc
);
2414 test_compare(rc
, MEMCACHED_SUCCESS
);
2418 test_compare(MEMCACHED_SUCCESS
,
2419 memcached_mget(memc
, keys
, key_length
, 4));
2421 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2422 test_compare(4U, count
);
2424 delete [] insert_data
;
2426 return TEST_SUCCESS
;
2429 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2431 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2432 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2433 char return_key
[MEMCACHED_MAX_KEY
];
2434 size_t return_key_length
;
2436 size_t value_length
;
2438 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2440 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2442 insert_data
[x
]= (signed char)rand();
2445 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2447 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2449 // We will now confirm that memcached_mget() returns success, but we will
2450 // then check to make sure that no actual keys are returned.
2451 test_compare(MEMCACHED_SUCCESS
,
2452 memcached_mget(memc
, keys
, key_length
, 4));
2454 memcached_return_t rc
;
2456 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2457 &value_length
, &flags
, &rc
)))
2462 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2464 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2466 test_compare(MEMCACHED_SUCCESS
,
2467 memcached_set(memc
, keys
[x
], key_length
[x
],
2468 insert_data
, VALUE_SIZE_BUG5
,
2469 (time_t)0, (uint32_t)0));
2471 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2473 for (uint32_t x
= 0; x
< 2; x
++)
2475 value
= memcached_get(memc
, keys
[0], key_length
[0],
2476 &value_length
, &flags
, &rc
);
2480 test_compare(MEMCACHED_SUCCESS
,
2481 memcached_mget(memc
, keys
, key_length
, 4));
2482 /* We test for purge of partial complete fetches */
2483 for (count
= 3; count
; count
--)
2485 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2486 &value_length
, &flags
, &rc
);
2487 test_compare(MEMCACHED_SUCCESS
, rc
);
2488 test_memcmp(value
, insert_data
, value_length
);
2489 test_true(value_length
);
2493 delete [] insert_data
;
2495 return TEST_SUCCESS
;
2498 static test_return_t
user_supplied_bug8(memcached_st
*)
2500 memcached_return_t rc
;
2502 memcached_st
*memc_clone
;
2504 memcached_server_st
*servers
;
2505 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";
2507 servers
= memcached_servers_parse(server_list
);
2510 mine
= memcached_create(NULL
);
2511 rc
= memcached_server_push(mine
, servers
);
2512 test_compare(MEMCACHED_SUCCESS
, rc
);
2513 memcached_server_list_free(servers
);
2516 memc_clone
= memcached_clone(NULL
, mine
);
2518 memcached_quit(mine
);
2519 memcached_quit(memc_clone
);
2522 memcached_free(mine
);
2523 memcached_free(memc_clone
);
2525 return TEST_SUCCESS
;
2528 /* Test flag store/retrieve */
2529 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2531 const char *keys
= "036790384900";
2532 size_t key_length
= strlen(keys
);
2533 char return_key
[MEMCACHED_MAX_KEY
];
2534 size_t return_key_length
;
2536 size_t value_length
;
2538 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2540 for (unsigned int x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2541 insert_data
[x
]= (signed char)rand();
2543 memcached_flush(memc
, 0);
2546 memcached_return_t rc
= memcached_set(memc
, keys
, key_length
,
2547 insert_data
, VALUE_SIZE_BUG5
,
2549 test_compare(MEMCACHED_SUCCESS
, rc
);
2552 value
= memcached_get(memc
, keys
, key_length
,
2553 &value_length
, &flags
, &rc
);
2554 test_true(flags
== 245);
2558 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2561 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2562 &value_length
, &flags
, &rc
);
2563 test_compare(uint32_t(245), flags
);
2566 delete [] insert_data
;
2569 return TEST_SUCCESS
;
2572 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2574 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2575 size_t key_length
[3];
2579 char return_key
[MEMCACHED_MAX_KEY
];
2580 size_t return_key_length
;
2582 size_t return_value_length
;
2585 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2586 key_length
[1]= strlen("fudge&*@#");
2587 key_length
[2]= strlen("for^#@&$not");
2590 for (unsigned int x
= 0; x
< 3; x
++)
2592 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2593 keys
[x
], key_length
[x
],
2594 (time_t)50, (uint32_t)9);
2595 test_compare(MEMCACHED_SUCCESS
, rc
);
2598 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2599 test_compare(MEMCACHED_SUCCESS
, rc
);
2601 /* We need to empty the server before continueing test */
2602 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2603 &return_value_length
, &flags
, &rc
)) != NULL
)
2605 test_true(return_value
);
2609 test_compare(3U, count
);
2611 return TEST_SUCCESS
;
2614 /* We are testing with aggressive timeout to get failures */
2615 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2617 const char *key
= "foo";
2618 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
);
2626 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, (uint64_t)timeout
);
2628 char *value
= (char*)malloc(value_length
* sizeof(char));
2630 for (unsigned int x
= 0; x
< value_length
; x
++)
2632 value
[x
]= (char) (x
% 127);
2635 for (unsigned int x
= 1; x
<= 100000; ++x
)
2637 memcached_return_t rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2639 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
,
2640 memcached_strerror(NULL
, rc
));
2642 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2649 memcached_free(mclone
);
2651 return TEST_SUCCESS
;
2655 We are looking failures in the async protocol
2657 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2659 const char *key
= "foo";
2660 size_t value_length
= 512;
2662 unsigned int set
= 1;
2663 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2665 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2666 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2667 int32_t timeout
= -1;
2668 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, (size_t)timeout
);
2670 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2672 test_true(timeout
== -1);
2674 char *value
= (char*)malloc(value_length
* sizeof(char));
2676 for (unsigned int x
= 0; x
< value_length
; x
++)
2678 value
[x
]= (char) (x
% 127);
2681 for (unsigned int x
= 1; x
<= 100000; ++x
)
2683 memcached_return_t rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2688 memcached_free(mclone
);
2690 return TEST_SUCCESS
;
2694 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2696 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2698 memcached_return_t rc
;
2700 size_t value_length
;
2702 uint64_t number_value
;
2704 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2705 &value_length
, &flags
, &rc
);
2706 test_true(value
== NULL
);
2707 test_compare(MEMCACHED_NOTFOUND
, rc
);
2709 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2712 test_true(value
== NULL
);
2713 /* The binary protocol will set the key if it doesn't exist */
2714 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2716 test_compare(MEMCACHED_SUCCESS
, rc
);
2720 test_compare(MEMCACHED_NOTFOUND
, rc
);
2723 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2725 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2726 &value_length
, &flags
, &rc
);
2728 test_compare(MEMCACHED_SUCCESS
, rc
);
2731 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2733 test_true(number_value
== 2);
2734 test_compare(MEMCACHED_SUCCESS
, rc
);
2736 return TEST_SUCCESS
;
2740 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2741 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2743 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2745 char key
[] = "key34567890";
2746 memcached_return_t rc
;
2747 size_t overflowSize
;
2749 char commandFirst
[]= "set key34567890 0 0 ";
2750 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2751 size_t commandLength
;
2754 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2756 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2758 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2760 char *overflow
= new (std::nothrow
) char[testSize
];
2761 test_true(overflow
);
2763 memset(overflow
, 'x', testSize
);
2764 rc
= memcached_set(memc
, key
, strlen(key
),
2765 overflow
, testSize
, 0, 0);
2766 test_compare(MEMCACHED_SUCCESS
, rc
);
2770 return TEST_SUCCESS
;
2775 Test values of many different sizes
2776 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2777 set key34567890 0 0 8169 \r\n
2778 is sent followed by buffer of size 8169, followed by 8169
2780 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2783 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2784 memcached_return_t rc
;
2785 const char *key
= "foo";
2787 size_t value_length
= 18000;
2789 size_t string_length
;
2792 size_t current_length
;
2794 value
= (char*)malloc(value_length
);
2797 for (x
= 0; x
< value_length
; x
++)
2798 value
[x
] = (char) (x
% 127);
2800 for (current_length
= 0; current_length
< value_length
; current_length
++)
2802 rc
= memcached_set(memc
, key
, strlen(key
),
2803 value
, current_length
,
2804 (time_t)0, (uint32_t)0);
2805 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
2807 string
= memcached_get(memc
, key
, strlen(key
),
2808 &string_length
, &flags
, &rc
);
2810 test_compare(MEMCACHED_SUCCESS
, rc
);
2811 test_true(string_length
== current_length
);
2812 test_memcmp(string
, value
, string_length
);
2819 return TEST_SUCCESS
;
2823 Look for zero length value problems
2825 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2828 memcached_return_t rc
;
2829 const char *key
= "mykey";
2833 for (x
= 0; x
< 2; x
++)
2835 rc
= memcached_set(memc
, key
, strlen(key
),
2837 (time_t)0, (uint32_t)0);
2839 test_compare(MEMCACHED_SUCCESS
, rc
);
2841 char *value
= memcached_get(memc
, key
, strlen(key
),
2842 &length
, &flags
, &rc
);
2844 test_compare(MEMCACHED_SUCCESS
, rc
);
2849 value
= memcached_get(memc
, key
, strlen(key
),
2850 &length
, &flags
, &rc
);
2852 test_compare(MEMCACHED_SUCCESS
, rc
);
2853 test_true(value
== NULL
);
2854 test_true(length
== 0);
2855 test_true(flags
== 0);
2858 return TEST_SUCCESS
;
2861 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2862 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2864 memcached_return_t rc
;
2865 const char *key
= "mykey";
2870 rc
= memcached_set(memc
, key
, strlen(key
),
2872 (time_t)0, UINT32_MAX
);
2874 test_compare(MEMCACHED_SUCCESS
, rc
);
2876 value
= memcached_get(memc
, key
, strlen(key
),
2877 &length
, &flags
, &rc
);
2879 test_compare(MEMCACHED_SUCCESS
, rc
);
2880 test_true(value
== NULL
);
2881 test_true(length
== 0);
2882 test_true(flags
== UINT32_MAX
);
2884 return TEST_SUCCESS
;
2887 #if !defined(__sun) && !defined(__OpenBSD__)
2888 /* Check the validity of chinese key*/
2889 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2891 memcached_return_t rc
;
2892 const char *key
= "豆瓣";
2893 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2898 rc
= memcached_set(memc
, key
, strlen(key
),
2899 value
, strlen(value
),
2902 test_compare(MEMCACHED_SUCCESS
, rc
);
2904 value2
= memcached_get(memc
, key
, strlen(key
),
2905 &length
, &flags
, &rc
);
2907 test_true(length
==strlen(value
));
2908 test_compare(MEMCACHED_SUCCESS
, rc
);
2909 test_memcmp(value
, value2
, length
);
2912 return TEST_SUCCESS
;
2920 static test_return_t
user_supplied_bug19(memcached_st
*)
2922 memcached_return_t res
;
2924 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2926 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2929 memcached_free(memc
);
2931 return TEST_SUCCESS
;
2934 /* CAS test from Andei */
2935 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2937 memcached_return_t status
;
2938 memcached_result_st
*result
, result_obj
;
2939 const char *key
= "abc";
2940 size_t key_len
= strlen("abc");
2941 const char *value
= "foobar";
2942 size_t value_len
= strlen(value
);
2944 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
2946 status
= memcached_set(memc
, key
, key_len
, value
, value_len
, (time_t)0, (uint32_t)0);
2947 test_true(status
== MEMCACHED_SUCCESS
);
2949 status
= memcached_mget(memc
, &key
, &key_len
, 1);
2950 test_true(status
== MEMCACHED_SUCCESS
);
2952 result
= memcached_result_create(memc
, &result_obj
);
2955 memcached_result_create(memc
, &result_obj
);
2956 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2959 test_true(status
== MEMCACHED_SUCCESS
);
2961 memcached_result_free(result
);
2963 return TEST_SUCCESS
;
2966 /* Large mget() of missing keys with binary proto
2968 * If many binary quiet commands (such as getq's in an mget) fill the output
2969 * buffer and the server chooses not to respond, memcached_flush hangs. See
2970 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2973 /* sighandler_t function that always asserts false */
2974 static void fail(int)
2980 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2985 return TEST_SKIPPED
;
2987 void (*oldalarm
)(int);
2989 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2990 test_true(memc_clone
);
2992 /* only binproto uses getq for mget */
2993 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
2995 /* empty the cache to ensure misses (hence non-responses) */
2996 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2998 size_t* key_lengths
= new (std::nothrow
) size_t[key_count
];
2999 test_true(key_lengths
);
3000 char **keys
= static_cast<char **>(calloc(key_count
, sizeof(char *)));
3002 for (unsigned int x
= 0; x
< key_count
; x
++)
3006 snprintf(buffer
, 30, "%u", x
);
3007 keys
[x
]= strdup(buffer
);
3009 key_lengths
[x
]= strlen(keys
[x
]);
3012 oldalarm
= signal(SIGALRM
, fail
);
3015 test_compare_got(MEMCACHED_SUCCESS
,
3016 memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
), memcached_last_error_message(memc_clone
));
3019 signal(SIGALRM
, oldalarm
);
3021 memcached_return_t rc
;
3023 char return_key
[MEMCACHED_MAX_KEY
];
3024 size_t return_key_length
;
3026 size_t return_value_length
;
3027 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
3028 &return_value_length
, &flags
, &rc
)))
3030 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
3032 test_compare(MEMCACHED_NOTFOUND
, rc
);
3033 test_zero(return_value_length
);
3034 test_zero(return_key_length
);
3035 test_false(return_key
[0]);
3036 test_false(return_value
);
3038 for (unsigned int x
= 0; x
< key_count
; x
++)
3043 delete [] key_lengths
;
3045 memcached_free(memc_clone
);
3047 return TEST_SUCCESS
;
3051 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3053 test_return_t test_rc
;
3054 test_rc
= pre_binary(memc
);
3056 if (test_rc
!= TEST_SUCCESS
)
3059 /* should work as of r580 */
3060 test_compare(TEST_SUCCESS
,
3061 _user_supplied_bug21(memc
, 10));
3063 /* should fail as of r580 */
3064 test_compare(TEST_SUCCESS
,
3065 _user_supplied_bug21(memc
, 1000));
3067 return TEST_SUCCESS
;
3070 static test_return_t
output_ketama_weighted_keys(memcached_st
*trash
)
3074 memcached_return_t rc
;
3075 memcached_st
*memc
= memcached_create(NULL
);
3079 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3080 test_compare(MEMCACHED_SUCCESS
, rc
);
3082 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3083 test_true(value
== 1);
3085 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3086 test_compare(MEMCACHED_SUCCESS
, rc
);
3088 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3089 test_true(value
== MEMCACHED_HASH_MD5
);
3092 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3094 memcached_server_st
*server_pool
;
3095 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");
3096 memcached_server_push(memc
, server_pool
);
3098 // @todo this needs to be refactored to actually test something.
3101 if ((fp
= fopen("ketama_keys.txt", "w")))
3105 printf("cannot write to file ketama_keys.txt");
3106 return TEST_FAILURE
;
3109 for (int x
= 0; x
< 10000; x
++)
3112 snprintf(key
, sizeof(key
), "%d", x
);
3114 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3115 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3116 in_port_t port
= memc
->hosts
[server_idx
].port
;
3117 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3118 memcached_server_instance_st instance
=
3119 memcached_server_instance_by_position(memc
, host_index
);
3123 memcached_server_list_free(server_pool
);
3124 memcached_free(memc
);
3126 return TEST_SUCCESS
;
3130 static test_return_t
result_static(memcached_st
*memc
)
3132 memcached_result_st result
;
3133 memcached_result_st
*result_ptr
;
3135 result_ptr
= memcached_result_create(memc
, &result
);
3136 test_true(result
.options
.is_allocated
== false);
3137 test_true(memcached_is_initialized(&result
) == true);
3138 test_true(result_ptr
);
3139 test_true(result_ptr
== &result
);
3141 memcached_result_free(&result
);
3143 test_true(result
.options
.is_allocated
== false);
3144 test_true(memcached_is_initialized(&result
) == false);
3146 return TEST_SUCCESS
;
3149 static test_return_t
result_alloc(memcached_st
*memc
)
3151 memcached_result_st
*result_ptr
;
3153 result_ptr
= memcached_result_create(memc
, NULL
);
3154 test_true(result_ptr
);
3155 test_true(result_ptr
->options
.is_allocated
== true);
3156 test_true(memcached_is_initialized(result_ptr
) == true);
3157 memcached_result_free(result_ptr
);
3159 return TEST_SUCCESS
;
3162 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3165 pairs_free(global_pairs
);
3167 return TEST_SUCCESS
;
3170 static test_return_t
generate_pairs(memcached_st
*memc
)
3173 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3174 global_count
= GLOBAL_COUNT
;
3176 for (size_t x
= 0; x
< global_count
; x
++)
3178 global_keys
[x
]= global_pairs
[x
].key
;
3179 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3182 return TEST_SUCCESS
;
3185 static test_return_t
generate_large_pairs(memcached_st
*)
3187 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3188 global_count
= GLOBAL2_COUNT
;
3190 for (size_t x
= 0; x
< global_count
; x
++)
3192 global_keys
[x
]= global_pairs
[x
].key
;
3193 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3196 return TEST_SUCCESS
;
3199 static test_return_t
generate_data(memcached_st
*memc
)
3201 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3203 test_compare(check_execute
, global_count
);
3205 return TEST_SUCCESS
;
3208 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3210 uint32_t host_index
= 0;
3211 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3213 test_true(check_execute
== global_count
);
3215 // @todo hosts used size stats
3216 memcached_return_t rc
;
3217 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3220 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3222 /* This test was changes so that "make test" would work properlly */
3224 memcached_server_instance_st instance
=
3225 memcached_server_instance_by_position(memc
, host_index
);
3227 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3229 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3232 memcached_stat_free(NULL
, stat_p
);
3234 return TEST_SUCCESS
;
3236 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3241 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3242 generate_data(memc
);
3244 return TEST_SUCCESS
;
3247 static test_return_t
get_read_count(memcached_st
*memc
)
3249 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3250 test_true(memc_clone
);
3252 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3256 size_t return_value_length
;
3260 for (size_t x
= count
= 0; x
< global_count
; x
++)
3262 memcached_return_t rc
;
3263 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3264 &return_value_length
, &flags
, &rc
);
3265 if (rc
== MEMCACHED_SUCCESS
)
3276 memcached_free(memc_clone
);
3278 return TEST_SUCCESS
;
3281 static test_return_t
get_read(memcached_st
*memc
)
3283 for (size_t x
= 0; x
< global_count
; x
++)
3285 size_t return_value_length
;
3287 memcached_return_t rc
;
3288 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3289 &return_value_length
, &flags
, &rc
);
3291 test_true(return_value);
3292 test_compare(MEMCACHED_SUCCESS, rc);
3294 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3300 return TEST_SUCCESS
;
3303 static test_return_t
mget_read(memcached_st
*memc
)
3306 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3308 test_compare(MEMCACHED_SUCCESS
,
3309 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3311 // Go fetch the keys and test to see if all of them were returned
3313 unsigned int keys_returned
;
3314 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3315 test_true(keys_returned
> 0);
3316 test_compare_got(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3319 return TEST_SUCCESS
;
3322 static test_return_t
mget_read_result(memcached_st
*memc
)
3325 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3327 test_compare(MEMCACHED_SUCCESS
,
3328 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3330 /* Turn this into a help function */
3332 memcached_result_st results_obj
;
3333 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3335 memcached_return_t rc
;
3336 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3338 if (rc
== MEMCACHED_IN_PROGRESS
)
3344 test_compare(MEMCACHED_SUCCESS
, rc
);
3346 test_compare(MEMCACHED_END
, rc
);
3348 memcached_result_free(&results_obj
);
3351 return TEST_SUCCESS
;
3354 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3357 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3359 test_compare(MEMCACHED_SUCCESS
,
3360 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3362 memcached_result_st
*results
= NULL
;
3363 memcached_return_t rc
;
3364 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3367 test_compare(MEMCACHED_SUCCESS
, rc
);
3369 test_compare(MEMCACHED_END
, rc
);
3371 memcached_result_free(results
);
3374 return TEST_SUCCESS
;
3377 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3380 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3382 test_compare(MEMCACHED_SUCCESS
,
3383 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3385 // We will scan for just one key
3387 memcached_result_st results_obj
;
3388 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3390 memcached_return_t rc
;
3391 results
= memcached_fetch_result(memc
, results
, &rc
);
3393 test_compare(MEMCACHED_SUCCESS
, rc
);
3395 memcached_result_free(&results_obj
);
3398 // We already have a read happening, lets start up another one.
3399 test_compare(MEMCACHED_SUCCESS
,
3400 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3402 memcached_result_st results_obj
;
3403 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3405 memcached_return_t rc
;
3406 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3409 test_compare(MEMCACHED_SUCCESS
, rc
);
3411 test_compare(MEMCACHED_END
, rc
);
3413 memcached_result_free(&results_obj
);
3416 return TEST_SUCCESS
;
3419 static test_return_t
mget_read_function(memcached_st
*memc
)
3421 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3423 test_compare(MEMCACHED_SUCCESS
,
3424 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3426 memcached_execute_fn callbacks
[]= { &callback_counter
};
3428 test_compare(MEMCACHED_SUCCESS
,
3429 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3431 return TEST_SUCCESS
;
3434 static test_return_t
delete_generate(memcached_st
*memc
)
3436 for (size_t x
= 0; x
< global_count
; x
++)
3438 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3441 return TEST_SUCCESS
;
3444 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3447 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, latch
);
3449 for (size_t x
= 0; x
< global_count
; x
++)
3451 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3454 return TEST_SUCCESS
;
3457 static test_return_t
add_host_test1(memcached_st
*memc
)
3459 memcached_return_t rc
;
3460 char servername
[]= "0.example.com";
3462 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3464 test_compare(1U, memcached_server_list_count(servers
));
3466 for (uint32_t x
= 2; x
< 20; x
++)
3468 char buffer
[SMALL_STRING_LEN
];
3470 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3471 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3473 test_compare(MEMCACHED_SUCCESS
, rc
);
3474 test_compare(x
, memcached_server_list_count(servers
));
3477 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3478 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3480 memcached_server_list_free(servers
);
3482 return TEST_SUCCESS
;
3485 static test_return_t
pre_nonblock(memcached_st
*memc
)
3487 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3489 return TEST_SUCCESS
;
3492 static test_return_t
pre_cork(memcached_st
*memc
)
3495 return TEST_SKIPPED
;
3498 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3499 return TEST_SUCCESS
;
3501 return TEST_SKIPPED
;
3504 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3507 return TEST_SKIPPED
;
3509 test_return_t test_rc
;
3510 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3513 return pre_nonblock(memc
);
3516 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3518 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3519 test_true(memc_clone
);
3521 // The memcached_version needs to be done on a clone, because the server
3522 // will not toggle protocol on an connection.
3523 memcached_version(memc_clone
);
3525 memcached_return_t rc
= MEMCACHED_FAILURE
;
3526 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3528 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3529 test_compare(MEMCACHED_SUCCESS
,
3530 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3531 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3535 memcached_free(memc_clone
);
3536 return TEST_SKIPPED
;
3539 memcached_free(memc_clone
);
3541 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3544 static test_return_t
pre_murmur(memcached_st
*memc
)
3546 #ifdef HAVE_MURMUR_HASH
3547 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3548 return TEST_SUCCESS
;
3551 return TEST_SKIPPED
;
3555 static test_return_t
pre_jenkins(memcached_st
*memc
)
3557 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3559 return TEST_SUCCESS
;
3563 static test_return_t
pre_md5(memcached_st
*memc
)
3565 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3567 return TEST_SUCCESS
;
3570 static test_return_t
pre_crc(memcached_st
*memc
)
3572 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3574 return TEST_SUCCESS
;
3577 static test_return_t
pre_hsieh(memcached_st
*memc
)
3579 #ifdef HAVE_HSIEH_HASH
3580 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
);
3581 return TEST_SUCCESS
;
3584 return TEST_SKIPPED
;
3588 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3590 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
);
3592 return TEST_SUCCESS
;
3595 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3597 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
);
3599 return TEST_SUCCESS
;
3602 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3604 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3606 return TEST_SUCCESS
;
3609 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3611 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3613 return TEST_SUCCESS
;
3616 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3618 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3619 test_compare(MEMCACHED_SUCCESS
, rc
);
3621 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3622 test_true(value
== 1);
3624 return TEST_SUCCESS
;
3627 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3629 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3630 test_compare(MEMCACHED_SUCCESS
, rc
);
3632 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3633 test_true(value
== 1);
3635 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
);
3636 test_compare(MEMCACHED_SUCCESS
, rc
);
3638 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3639 test_true(value
== MEMCACHED_HASH_MD5
);
3641 return TEST_SUCCESS
;
3645 @note This should be testing to see if the server really supports the binary protocol.
3647 static test_return_t
pre_binary(memcached_st
*memc
)
3649 memcached_return_t rc
= MEMCACHED_FAILURE
;
3651 if (libmemcached_util_version_check(memc
, 1, 4, 4))
3653 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3654 test_compare(MEMCACHED_SUCCESS
, rc
);
3655 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3658 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3661 static test_return_t
pre_replication(memcached_st
*memc
)
3663 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3666 * Make sure that we store the item on all servers
3667 * (master + replicas == number of servers)
3669 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3670 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3672 return TEST_SUCCESS
;
3676 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3678 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3680 return pre_nonblock(memc
);
3684 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3688 #ifdef HARD_MALLOC_TESTS
3689 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3697 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3701 #ifdef HARD_MALLOC_TESTS
3702 void *ret
= malloc(size
+ 8);
3705 ret
= (void*)((caddr_t
)ret
+ 8);
3708 void *ret
= malloc(size
);
3713 memset(ret
, 0xff, size
);
3720 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3722 #ifdef HARD_MALLOC_TESTS
3723 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3724 void *nmem
= realloc(real_ptr
, size
+ 8);
3729 ret
= (void*)((caddr_t
)nmem
+ 8);
3735 return realloc(mem
, size
);
3740 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3742 #ifdef HARD_MALLOC_TESTS
3743 void *mem
= my_malloc(ptr
, nelem
* size
);
3746 memset(mem
, 0, nelem
* size
);
3752 return calloc(nelem
, size
);
3756 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3758 memcached_return_t rc
;
3759 const char *key
= "mine";
3762 /* Make sure be default none exists */
3763 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3764 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3766 /* Test a clean set */
3767 test_compare(MEMCACHED_SUCCESS
,
3768 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3770 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3772 test_memcmp(value
, key
, 4);
3773 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3775 /* Test that we can turn it off */
3776 test_compare(MEMCACHED_SUCCESS
,
3777 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3779 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3781 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3783 /* Now setup for main test */
3784 test_compare(MEMCACHED_SUCCESS
,
3785 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3787 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3789 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3790 test_memcmp(value
, key
, 4);
3792 /* Set to Zero, and then Set to something too large */
3795 memset(long_key
, 0, 255);
3797 test_compare(MEMCACHED_SUCCESS
,
3798 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3800 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3802 test_true(rc
== MEMCACHED_FAILURE
);
3803 test_true(value
== NULL
);
3805 /* Test a long key for failure */
3806 /* TODO, extend test to determine based on setting, what result should be */
3807 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3808 test_compare(MEMCACHED_SUCCESS
,
3809 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3811 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3812 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3813 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3814 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3816 /* Test for a bad prefix, but with a short key */
3817 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3818 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3820 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3821 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3824 return TEST_SUCCESS
;
3827 static test_return_t
set_namespace(memcached_st
*memc
)
3829 memcached_return_t rc
;
3830 const char *key
= "mine";
3833 /* Make sure be default none exists */
3834 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3835 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3837 /* Test a clean set */
3838 test_compare(MEMCACHED_SUCCESS
,
3839 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3841 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3843 test_memcmp(value
, key
, 4);
3844 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3846 return TEST_SUCCESS
;
3849 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3851 test_return_if(pre_binary(memc
));
3852 test_return_if(set_namespace(memc
));
3854 return TEST_SUCCESS
;
3857 #ifdef MEMCACHED_ENABLE_DEPRECATED
3858 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3860 void *test_ptr
= NULL
;
3863 memcached_malloc_fn malloc_cb
=
3864 (memcached_malloc_fn
)my_malloc
;
3865 cb_ptr
= *(void **)&malloc_cb
;
3866 memcached_return_t rc
;
3868 test_compare(MEMCACHED_SUCCESS
,
3869 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3870 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3871 test_compare(MEMCACHED_SUCCESS
, rc
);
3872 test_true(test_ptr
== cb_ptr
);
3876 memcached_realloc_fn realloc_cb
=
3877 (memcached_realloc_fn
)my_realloc
;
3878 cb_ptr
= *(void **)&realloc_cb
;
3879 memcached_return_t rc
;
3881 test_compare(MEMCACHED_SUCCESS
,
3882 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3883 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3884 test_compare(MEMCACHED_SUCCESS
, rc
);
3885 test_true(test_ptr
== cb_ptr
);
3889 memcached_free_fn free_cb
=
3890 (memcached_free_fn
)my_free
;
3891 cb_ptr
= *(void **)&free_cb
;
3892 memcached_return_t rc
;
3894 test_compare(MEMCACHED_SUCCESS
,
3895 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3896 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3897 test_compare(MEMCACHED_SUCCESS
, rc
);
3898 test_true(test_ptr
== cb_ptr
);
3901 return TEST_SUCCESS
;
3906 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3908 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3909 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3910 my_realloc
, my_calloc
, NULL
));
3912 test_compare(MEMCACHED_SUCCESS
,
3913 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3914 my_realloc
, my_calloc
, NULL
));
3916 memcached_malloc_fn mem_malloc
;
3917 memcached_free_fn mem_free
;
3918 memcached_realloc_fn mem_realloc
;
3919 memcached_calloc_fn mem_calloc
;
3920 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3921 &mem_realloc
, &mem_calloc
);
3923 test_true(mem_malloc
== my_malloc
);
3924 test_true(mem_realloc
== my_realloc
);
3925 test_true(mem_calloc
== my_calloc
);
3926 test_true(mem_free
== my_free
);
3928 return TEST_SUCCESS
;
3931 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3934 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3935 memcached_hash_t hash
;
3936 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3937 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3940 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3941 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3943 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3945 if (hash
!= MEMCACHED_HASH_CRC
)
3946 return TEST_SKIPPED
;
3948 return TEST_SUCCESS
;
3951 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3954 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3955 memcached_hash_t hash
;
3956 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3957 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3960 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3961 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3963 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3965 if (hash
!= MEMCACHED_HASH_HSIEH
)
3966 return TEST_SKIPPED
;
3969 return TEST_SUCCESS
;
3972 static test_return_t
enable_cas(memcached_st
*memc
)
3974 unsigned int set
= 1;
3976 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3978 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3980 return TEST_SUCCESS
;
3983 return TEST_SKIPPED
;
3986 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3988 memcached_version(memc
);
3990 memcached_server_instance_st instance
=
3991 memcached_server_instance_by_position(memc
, 0);
3993 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3994 or instance
->minor_version
> 2)
3996 return TEST_SUCCESS
;
3999 return TEST_SKIPPED
;
4002 static test_return_t
pre_unix_socket(memcached_st
*memc
)
4006 memcached_servers_reset(memc
);
4007 const char *socket_file
= default_socket();
4009 test_skip(0, stat(socket_file
, &buf
));
4011 test_compare(MEMCACHED_SUCCESS
,
4012 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
4014 return TEST_SUCCESS
;
4017 static test_return_t
pre_nodelay(memcached_st
*memc
)
4019 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
4020 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
4022 return TEST_SUCCESS
;
4025 static test_return_t
pre_settimer(memcached_st
*memc
)
4027 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4028 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4030 return TEST_SUCCESS
;
4033 static test_return_t
poll_timeout(memcached_st
*memc
)
4035 const uint64_t timeout
= 100; // Not using, just checking that it sets
4037 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4040 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
4042 return TEST_SUCCESS
;
4045 static test_return_t
noreply_test(memcached_st
*memc
)
4047 memcached_return_t ret
;
4048 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1);
4049 test_true(ret
== MEMCACHED_SUCCESS
);
4050 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4051 test_true(ret
== MEMCACHED_SUCCESS
);
4052 ret
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1);
4053 test_true(ret
== MEMCACHED_SUCCESS
);
4054 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
) == 1);
4055 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
) == 1);
4056 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
) == 1);
4058 for (int count
=0; count
< 5; ++count
)
4060 for (size_t x
= 0; x
< 100; ++x
)
4063 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4064 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4066 size_t len
= (size_t)check_length
;
4071 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4074 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4077 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4080 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4083 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4089 test_true(ret
== MEMCACHED_SUCCESS
|| ret
== MEMCACHED_BUFFERED
);
4093 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4094 ** API and is _ONLY_ done this way to verify that the library works the
4095 ** way it is supposed to do!!!!
4098 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4100 memcached_server_instance_st instance
=
4101 memcached_server_instance_by_position(memc
, x
);
4102 no_msg
+=(int)(instance
->cursor_active
);
4105 test_true(no_msg
== 0);
4106 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4109 ** Now validate that all items was set properly!
4111 for (size_t x
= 0; x
< 100; ++x
)
4115 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4117 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4119 size_t len
= (size_t)check_length
;
4122 char* value
=memcached_get(memc
, key
, strlen(key
),
4123 &length
, &flags
, &ret
);
4124 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4127 case 0: /* FALLTHROUGH */
4128 case 1: /* FALLTHROUGH */
4130 test_true(strncmp(value
, key
, len
) == 0);
4131 test_true(len
== length
);
4134 test_true(length
== len
* 2);
4137 test_true(length
== len
* 3);
4147 /* Try setting an illegal cas value (should not return an error to
4148 * the caller (because we don't expect a return message from the server)
4150 const char* keys
[]= {"0"};
4151 size_t lengths
[]= {1};
4154 memcached_result_st results_obj
;
4155 memcached_result_st
*results
;
4156 ret
= memcached_mget(memc
, keys
, lengths
, 1);
4157 test_true(ret
== MEMCACHED_SUCCESS
);
4159 results
= memcached_result_create(memc
, &results_obj
);
4161 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4163 test_true(ret
== MEMCACHED_SUCCESS
);
4164 uint64_t cas
= memcached_result_cas(results
);
4165 memcached_result_free(&results_obj
);
4167 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4168 test_true(ret
== MEMCACHED_SUCCESS
);
4171 * The item will have a new cas value, so try to set it again with the old
4172 * value. This should fail!
4174 ret
= memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
);
4175 test_true(ret
== MEMCACHED_SUCCESS
);
4176 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4177 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4178 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4181 return TEST_SUCCESS
;
4184 static test_return_t
analyzer_test(memcached_st
*memc
)
4186 memcached_return_t rc
;
4187 memcached_stat_st
*memc_stat
;
4188 memcached_analysis_st
*report
;
4190 memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4191 test_compare(MEMCACHED_SUCCESS
, rc
);
4192 test_true(memc_stat
);
4194 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4195 test_compare(MEMCACHED_SUCCESS
, rc
);
4199 memcached_stat_free(NULL
, memc_stat
);
4201 return TEST_SUCCESS
;
4204 /* Count the objects */
4206 static test_return_t
dump_test(memcached_st
*memc
)
4208 /* No support for Binary protocol yet */
4209 test_skip(false, memc
->flags
.binary_protocol
);
4211 test_compare(TEST_SUCCESS
, set_test3(memc
));
4213 // confirm_key_count() call dump
4214 size_t counter
= confirm_key_count(memc
);
4216 /* We may have more then 32 if our previous flush has not completed */
4217 test_true(counter
>= 32);
4219 return TEST_SUCCESS
;
4222 struct test_pool_context_st
{
4223 memcached_pool_st
* pool
;
4227 static void* connection_release(void *arg
)
4229 test_pool_context_st
*resource
= static_cast<test_pool_context_st
*>(arg
);
4232 // Release all of the memc we are holding
4233 assert(memcached_success(memcached_pool_push(resource
->pool
, resource
->mmc
)));
4237 #define POOL_SIZE 10
4238 static test_return_t
connection_pool_test(memcached_st
*memc
)
4240 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4241 test_true(pool
!= NULL
);
4242 memcached_st
*mmc
[POOL_SIZE
];
4243 memcached_return_t rc
;
4245 // Fill up our array that we will store the memc that are in the pool
4246 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4248 mmc
[x
]= memcached_pool_pop(pool
, false, &rc
);
4249 test_true(mmc
[x
] != NULL
);
4250 test_compare(MEMCACHED_SUCCESS
, rc
);
4253 // All memc should be gone
4254 test_true(memcached_pool_pop(pool
, false, &rc
) == NULL
);
4255 test_compare(MEMCACHED_SUCCESS
, rc
);
4258 test_pool_context_st item
= { pool
, mmc
[9] };
4260 pthread_create(&tid
, NULL
, connection_release
, &item
);
4261 mmc
[9]= memcached_pool_pop(pool
, true, &rc
);
4262 test_compare(MEMCACHED_SUCCESS
, rc
);
4263 pthread_join(tid
, NULL
);
4265 const char *key
= "key";
4266 size_t keylen
= strlen(key
);
4268 // verify that I can do ops with all connections
4269 test_compare(MEMCACHED_SUCCESS
,
4270 memcached_set(mmc
[0], key
, keylen
, "0", 1, 0, 0));
4272 for (uint64_t x
= 0; x
< POOL_SIZE
; ++x
)
4274 uint64_t number_value
;
4275 test_compare(MEMCACHED_SUCCESS
,
4276 memcached_increment(mmc
[x
], key
, keylen
, 1, &number_value
));
4277 test_compare(number_value
, (x
+1));
4281 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4283 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[x
]));
4287 /* verify that I can set behaviors on the pool when I don't have all
4288 * of the connections in the pool. It should however be enabled
4289 * when I push the item into the pool
4291 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4294 rc
= memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999);
4295 test_compare(MEMCACHED_SUCCESS
, rc
);
4297 mmc
[1]= memcached_pool_pop(pool
, false, &rc
);
4300 test_compare(UINT64_C(9999), memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4301 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[1]));
4302 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4304 mmc
[0]= memcached_pool_pop(pool
, false, &rc
);
4305 test_compare(UINT64_C(9999), memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4306 test_compare(MEMCACHED_SUCCESS
, memcached_pool_push(pool
, mmc
[0]));
4308 test_true(memcached_pool_destroy(pool
) == memc
);
4310 return TEST_SUCCESS
;
4313 static test_return_t
util_version_test(memcached_st
*memc
)
4315 bool if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4316 test_true(if_successful
);
4318 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4320 // We expect failure
4323 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4324 fprintf(stderr
, "\nDumping Server Information\n\n");
4325 memcached_server_fn callbacks
[1];
4327 callbacks
[0]= dump_server_information
;
4328 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4329 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4331 test_true(if_successful
== false);
4333 memcached_server_instance_st instance
=
4334 memcached_server_instance_by_position(memc
, 0);
4336 memcached_version(memc
);
4338 // We only use one binary when we test, so this should be just fine.
4339 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4340 test_true(if_successful
== true);
4342 if (instance
->micro_version
> 0)
4343 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4344 else if (instance
->minor_version
> 0)
4345 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4346 else if (instance
->major_version
> 0)
4347 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4349 test_true(if_successful
== true);
4351 if (instance
->micro_version
> 0)
4352 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4353 else if (instance
->minor_version
> 0)
4354 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4355 else if (instance
->major_version
> 0)
4356 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4358 test_true(if_successful
== false);
4360 return TEST_SUCCESS
;
4363 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4365 memcached_return_t rc
;
4366 memcached_server_instance_st instance
=
4367 memcached_server_instance_by_position(memc
, 0);
4369 // Test both the version that returns a code, and the one that does not.
4370 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4371 memcached_server_port(instance
) -1, NULL
) == -1);
4373 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4374 memcached_server_port(instance
) -1, &rc
) == -1);
4375 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4377 return TEST_SUCCESS
;
4381 static test_return_t
getpid_test(memcached_st
*memc
)
4383 memcached_return_t rc
;
4384 memcached_server_instance_st instance
=
4385 memcached_server_instance_by_position(memc
, 0);
4387 // Test both the version that returns a code, and the one that does not.
4388 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4389 memcached_server_port(instance
), NULL
) > -1);
4391 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4392 memcached_server_port(instance
), &rc
) > -1);
4393 test_compare(MEMCACHED_SUCCESS
, rc
);
4395 return TEST_SUCCESS
;
4398 static test_return_t
ping_test(memcached_st
*memc
)
4400 memcached_return_t rc
;
4401 memcached_server_instance_st instance
=
4402 memcached_server_instance_by_position(memc
, 0);
4404 // Test both the version that returns a code, and the one that does not.
4405 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4406 memcached_server_port(instance
), NULL
));
4408 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4409 memcached_server_port(instance
), &rc
));
4411 test_compare(MEMCACHED_SUCCESS
, rc
);
4413 return TEST_SUCCESS
;
4418 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4422 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4423 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4424 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4425 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4426 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4427 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4428 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4429 #ifdef HAVE_HSIEH_HASH
4430 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4432 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4433 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4434 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4436 return TEST_SUCCESS
;
4440 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4442 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4443 #ifdef HAVE_HSIEH_HASH
4444 expected_rc
= MEMCACHED_SUCCESS
;
4446 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4447 (uint64_t)MEMCACHED_HASH_HSIEH
);
4448 test_true(rc
== expected_rc
);
4450 return TEST_SUCCESS
;
4453 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4455 memcached_return_t expected_rc
= MEMCACHED_INVALID_ARGUMENTS
;
4456 #ifdef HAVE_MURMUR_HASH
4457 expected_rc
= MEMCACHED_SUCCESS
;
4459 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4460 (uint64_t)MEMCACHED_HASH_MURMUR
);
4461 test_true(rc
== expected_rc
);
4463 return TEST_SUCCESS
;
4466 static test_return_t
one_at_a_time_run (memcached_st
*)
4471 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4475 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
);
4476 test_true(one_at_a_time_values
[x
] == hash_val
);
4479 return TEST_SUCCESS
;
4482 static test_return_t
md5_run (memcached_st
*)
4487 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4491 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
);
4492 test_true(md5_values
[x
] == hash_val
);
4495 return TEST_SUCCESS
;
4498 static test_return_t
crc_run (memcached_st
*)
4503 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4507 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
);
4508 test_true(crc_values
[x
] == hash_val
);
4511 return TEST_SUCCESS
;
4514 static test_return_t
fnv1_64_run (memcached_st
*)
4519 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4523 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
);
4524 test_true(fnv1_64_values
[x
] == hash_val
);
4527 return TEST_SUCCESS
;
4530 static test_return_t
fnv1a_64_run (memcached_st
*)
4535 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4539 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
);
4540 test_true(fnv1a_64_values
[x
] == hash_val
);
4543 return TEST_SUCCESS
;
4546 static test_return_t
fnv1_32_run (memcached_st
*)
4551 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4555 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
);
4556 test_true(fnv1_32_values
[x
] == hash_val
);
4559 return TEST_SUCCESS
;
4562 static test_return_t
fnv1a_32_run (memcached_st
*)
4567 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4571 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
);
4572 test_true(fnv1a_32_values
[x
] == hash_val
);
4575 return TEST_SUCCESS
;
4578 static test_return_t
hsieh_run (memcached_st
*)
4583 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4587 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
);
4588 test_true(hsieh_values
[x
] == hash_val
);
4591 return TEST_SUCCESS
;
4594 static test_return_t
murmur_run (memcached_st
*)
4596 #ifdef WORDS_BIGENDIAN
4597 (void)murmur_values
;
4598 return TEST_SKIPPED
;
4603 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4607 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
);
4608 test_true(murmur_values
[x
] == hash_val
);
4611 return TEST_SUCCESS
;
4615 static test_return_t
jenkins_run (memcached_st
*)
4620 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4624 hash_val
= memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
);
4625 test_true(jenkins_values
[x
] == hash_val
);
4628 return TEST_SUCCESS
;
4631 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *context
)
4634 return libhashkit_md5(string
, string_length
);
4637 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *context
)
4640 return libhashkit_crc32(string
, string_length
);
4643 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4649 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5"));
4651 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};
4652 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};
4654 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4656 hashkit_clone(&new_kit
, kit
);
4657 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4659 memcached_set_hashkit(memc
, &new_kit
);
4662 Verify Setting the hash.
4664 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4668 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4669 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4674 Now check memcached_st.
4676 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4680 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4681 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4684 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4686 memcached_set_hashkit(memc
, &new_kit
);
4689 Verify Setting the hash.
4691 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4695 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4696 test_true(crc_values
[x
] == hash_val
);
4699 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4703 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4704 test_compare(crc_hosts
[x
], hash_val
);
4707 memcached_free(memc
);
4709 return TEST_SUCCESS
;
4713 Test case adapted from John Gorman <johngorman2@gmail.com>
4715 We are testing the error condition when we connect to a server via memcached_get()
4716 but find that the server is not available.
4718 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4720 const char *key
= "MemcachedLives";
4723 memcached_return rc
;
4726 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4728 // See if memcached is reachable.
4729 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4733 test_true(memcached_failed(rc
));
4735 memcached_free(tl_memc_h
);
4737 return TEST_SUCCESS
;
4741 We connect to a server which exists, but search for a key that does not exist.
4743 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4745 const char *key
= "MemcachedKeyNotEXIST";
4748 memcached_return rc
;
4751 // See if memcached is reachable.
4752 value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4756 test_compare(MEMCACHED_NOTFOUND
, rc
);
4758 return TEST_SUCCESS
;
4762 Test case adapted from John Gorman <johngorman2@gmail.com>
4764 We are testing the error condition when we connect to a server via memcached_get_by_key()
4765 but find that the server is not available.
4767 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4770 memcached_st
*tl_memc_h
;
4771 memcached_server_st
*servers
;
4773 const char *key
= "MemcachedLives";
4776 memcached_return rc
;
4780 tl_memc_h
= memcached_create(NULL
);
4781 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4782 memcached_server_push(tl_memc_h
, servers
);
4783 memcached_server_list_free(servers
);
4785 // See if memcached is reachable.
4786 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4790 test_true(memcached_failed(rc
));
4792 memcached_free(tl_memc_h
);
4794 return TEST_SUCCESS
;
4798 We connect to a server which exists, but search for a key that does not exist.
4800 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4802 const char *key
= "MemcachedKeyNotEXIST";
4805 memcached_return rc
;
4808 // See if memcached is reachable.
4809 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4813 test_compare(MEMCACHED_NOTFOUND
, rc
);
4815 return TEST_SUCCESS
;
4818 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4820 test_return_t test_rc
;
4821 test_rc
= pre_binary(memc
);
4823 if (test_rc
!= TEST_SUCCESS
)
4826 const char *key
= "regression_bug_434484";
4827 size_t keylen
= strlen(key
);
4829 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4830 test_compare(MEMCACHED_NOTSTORED
, ret
);
4832 size_t size
= 2048 * 1024;
4833 char *data
= (char*)calloc(1, size
);
4835 test_compare(MEMCACHED_E2BIG
,
4836 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4839 return TEST_SUCCESS
;
4842 static test_return_t
regression_bug_434843(memcached_st
*memc
)
4844 test_return_t test_rc
;
4845 test_rc
= pre_binary(memc
);
4847 if (test_rc
!= TEST_SUCCESS
)
4850 memcached_return_t rc
;
4852 memcached_execute_fn callbacks
[]= { &callback_counter
};
4855 * I only want to hit only _one_ server so I know the number of requests I'm
4856 * sending in the pipleine to the server. Let's try to do a multiget of
4857 * 1024 (that should satisfy most users don't you think?). Future versions
4858 * will include a mget_execute function call if you need a higher number.
4860 uint32_t number_of_hosts
= memcached_server_count(memc
);
4861 memc
->number_of_hosts
= 1;
4862 const size_t max_keys
= 1024;
4863 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4864 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4866 for (size_t x
= 0; x
< max_keys
; ++x
)
4870 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4876 * Run two times.. the first time we should have 100% cache miss,
4877 * and the second time we should have 100% cache hits
4879 for (size_t y
= 0; y
< 2; y
++)
4881 test_compare(MEMCACHED_SUCCESS
,
4882 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4884 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4885 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4889 /* The first iteration should give me a 100% cache miss. verify that*/
4890 char blob
[1024]= { 0 };
4892 test_false(counter
);
4894 for (size_t x
= 0; x
< max_keys
; ++x
)
4896 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4897 blob
, sizeof(blob
), 0, 0);
4898 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4903 /* Verify that we received all of the key/value pairs */
4904 test_compare(counter
, max_keys
);
4908 /* Release allocated resources */
4909 for (size_t x
= 0; x
< max_keys
; ++x
)
4916 memc
->number_of_hosts
= number_of_hosts
;
4918 return TEST_SUCCESS
;
4921 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
4923 memcached_return_t rc
;
4924 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
4925 test_compare(MEMCACHED_SUCCESS
, rc
);
4927 return regression_bug_434843(memc
);
4930 static test_return_t
regression_bug_421108(memcached_st
*memc
)
4932 memcached_return_t rc
;
4933 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4934 test_compare(MEMCACHED_SUCCESS
, rc
);
4936 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
4937 test_compare(MEMCACHED_SUCCESS
, rc
);
4938 test_true(bytes_str
);
4939 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
4941 test_compare(MEMCACHED_SUCCESS
, rc
);
4942 test_true(bytes_read_str
);
4944 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
4945 "bytes_written", &rc
);
4946 test_compare(MEMCACHED_SUCCESS
, rc
);
4947 test_true(bytes_written_str
);
4949 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
4950 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
4951 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
4953 test_true(bytes
!= bytes_read
);
4954 test_true(bytes
!= bytes_written
);
4956 /* Release allocated resources */
4958 free(bytes_read_str
);
4959 free(bytes_written_str
);
4960 memcached_stat_free(NULL
, memc_stat
);
4962 return TEST_SUCCESS
;
4966 * The test case isn't obvious so I should probably document why
4967 * it works the way it does. Bug 442914 was caused by a bug
4968 * in the logic in memcached_purge (it did not handle the case
4969 * where the number of bytes sent was equal to the watermark).
4970 * In this test case, create messages so that we hit that case
4971 * and then disable noreply mode and issue a new command to
4972 * verify that it isn't stuck. If we change the format for the
4973 * delete command or the watermarks, we need to update this
4976 static test_return_t
regression_bug_442914(memcached_st
*memc
)
4978 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4979 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
4981 uint32_t number_of_hosts
= memcached_server_count(memc
);
4982 memc
->number_of_hosts
= 1;
4987 for (uint32_t x
= 0; x
< 250; ++x
)
4989 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
4990 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4991 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
4994 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
4997 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
4998 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5000 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5001 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
5003 memc
->number_of_hosts
= number_of_hosts
;
5005 return TEST_SUCCESS
;
5008 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5010 memcached_server_instance_st instance_one
;
5011 memcached_server_instance_st instance_two
;
5013 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
5014 return TEST_SKIPPED
;
5016 test_compare(MEMCACHED_SUCCESS
,
5017 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
5019 const unsigned int max_keys
= 100;
5020 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
5021 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5023 for (unsigned int x
= 0; x
< max_keys
; ++x
)
5027 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5030 test_compare(MEMCACHED_SUCCESS
,
5031 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
5035 ** We are using the quiet commands to store the replicas, so we need
5036 ** to ensure that all of them are processed before we can continue.
5037 ** In the test we go directly from storing the object to trying to
5038 ** receive the object from all of the different servers, so we
5039 ** could end up in a race condition (the memcached server hasn't yet
5040 ** processed the quiet command from the replication set when it process
5041 ** the request from the other client (created by the clone)). As a
5042 ** workaround for that we call memcached_quit to send the quit command
5043 ** to the server and wait for the response ;-) If you use the test code
5044 ** as an example for your own code, please note that you shouldn't need
5047 memcached_quit(memc
);
5049 /* Verify that all messages are stored, and we didn't stuff too much
5052 test_compare(MEMCACHED_SUCCESS
,
5053 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5055 unsigned int counter
= 0;
5056 memcached_execute_fn callbacks
[]= { &callback_counter
};
5057 test_compare(MEMCACHED_SUCCESS
,
5058 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5060 /* Verify that we received all of the key/value pairs */
5061 test_compare(counter
, max_keys
);
5063 memcached_quit(memc
);
5065 * Don't do the following in your code. I am abusing the internal details
5066 * within the library, and this is not a supported interface.
5067 * This is to verify correct behavior in the library. Fake that two servers
5070 instance_one
= memcached_server_instance_by_position(memc
, 0);
5071 instance_two
= memcached_server_instance_by_position(memc
, 2);
5072 in_port_t port0
= instance_one
->port
;
5073 in_port_t port2
= instance_two
->port
;
5075 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5076 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5078 test_compare(MEMCACHED_SUCCESS
,
5079 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5082 test_compare(MEMCACHED_SUCCESS
,
5083 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5084 test_compare(counter
, (unsigned int)max_keys
);
5086 /* restore the memc handle */
5087 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5088 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5090 memcached_quit(memc
);
5092 /* Remove half of the objects */
5093 for (size_t x
= 0; x
< max_keys
; ++x
)
5097 test_compare(MEMCACHED_SUCCESS
,
5098 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
5102 memcached_quit(memc
);
5103 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5104 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5106 /* now retry the command, this time we should have cache misses */
5107 test_compare(MEMCACHED_SUCCESS
,
5108 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5111 test_compare(MEMCACHED_SUCCESS
,
5112 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5113 test_compare(counter
, (unsigned int)(max_keys
>> 1));
5115 /* Release allocated resources */
5116 for (size_t x
= 0; x
< max_keys
; ++x
)
5123 /* restore the memc handle */
5124 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5125 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5127 return TEST_SUCCESS
;
5130 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5132 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5133 test_true(memc_clone
);
5134 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5136 memcached_server_instance_st instance
=
5137 memcached_server_instance_by_position(memc_clone
, 0);
5139 if (instance
->major_version
> 1 ||
5140 (instance
->major_version
== 1 &&
5141 instance
->minor_version
> 2))
5143 /* Binary protocol doesn't support deferred delete */
5144 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5145 test_true(bin_clone
);
5146 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5147 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
5148 memcached_free(bin_clone
);
5150 memcached_quit(memc_clone
);
5152 /* If we know the server version, deferred delete should fail
5153 * with invalid arguments */
5154 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
5156 /* If we don't know the server version, we should get a protocol error */
5157 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5159 /* but there is a bug in some of the memcached servers (1.4) that treats
5160 * the counter as noreply so it doesn't send the proper error message
5162 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5164 /* And buffered mode should be disabled and we should get protocol error */
5165 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5166 rc
= memcached_delete(memc
, "foo", 3, 1);
5167 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5169 /* Same goes for noreply... */
5170 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5171 rc
= memcached_delete(memc
, "foo", 3, 1);
5172 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5174 /* but a normal request should go through (and be buffered) */
5175 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
5176 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
5178 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
5179 /* unbuffered noreply should be success */
5180 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
5181 /* unbuffered with reply should be not found... */
5182 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5183 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
5186 memcached_free(memc_clone
);
5187 return TEST_SUCCESS
;
5191 /* Test memcached_server_get_last_disconnect
5192 * For a working server set, shall be NULL
5193 * For a set of non existing server, shall not be NULL
5195 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5197 memcached_return_t rc
;
5198 memcached_server_instance_st disconnected_server
;
5200 /* With the working set of server */
5201 const char *key
= "marmotte";
5202 const char *value
= "milka";
5204 memcached_reset_last_disconnected_server(memc
);
5205 test_false(memc
->last_disconnected_server
);
5206 rc
= memcached_set(memc
, key
, strlen(key
),
5207 value
, strlen(value
),
5208 (time_t)0, (uint32_t)0);
5209 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5211 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5212 test_false(disconnected_server
);
5214 /* With a non existing server */
5216 memcached_server_st
*servers
;
5218 const char *server_list
= "localhost:9";
5220 servers
= memcached_servers_parse(server_list
);
5222 mine
= memcached_create(NULL
);
5223 rc
= memcached_server_push(mine
, servers
);
5224 test_compare(MEMCACHED_SUCCESS
, rc
);
5225 memcached_server_list_free(servers
);
5228 rc
= memcached_set(mine
, key
, strlen(key
),
5229 value
, strlen(value
),
5230 (time_t)0, (uint32_t)0);
5231 test_true(memcached_failed(rc
));
5233 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5234 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5235 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5236 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5238 memcached_quit(mine
);
5239 memcached_free(mine
);
5241 return TEST_SUCCESS
;
5244 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5246 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5247 char buffer
[BUFSIZ
];
5249 test_compare(MEMCACHED_SUCCESS
,
5250 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5252 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5255 // We will just use the error strings as our keys
5256 uint32_t counter
= 100;
5259 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5261 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5262 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5263 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, ret
, memcached_last_error_message(memc
));
5265 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5266 test_true(disconnected_server
);
5267 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5268 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5272 memcached_reset_last_disconnected_server(memc
);
5277 memcached_free(memc
);
5279 return TEST_SUCCESS
;
5282 static test_return_t
test_verbosity(memcached_st
*memc
)
5284 memcached_verbosity(memc
, 3);
5286 return TEST_SUCCESS
;
5289 static test_return_t
test_server_failure(memcached_st
*memc
)
5291 if (memcached_server_count(memc
) < 2)
5292 return TEST_SKIPPED
;
5294 memcached_server_instance_st instance
= memcached_server_instance_by_position(memc
, 0);
5296 memcached_st
*local_memc
= memcached_create(NULL
);
5298 memcached_server_add(local_memc
, memcached_server_name(instance
), memcached_server_port(instance
));
5299 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 2);
5301 uint32_t server_count
= memcached_server_count(local_memc
);
5302 test_compare(1U, server_count
);
5304 // Disable the server
5305 instance
= memcached_server_instance_by_position(local_memc
, 0);
5306 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 2;
5308 memcached_return_t rc
;
5309 test_compare_got(MEMCACHED_SERVER_MARKED_DEAD
,
5310 rc
= memcached_set(local_memc
, "foo", strlen("foo"), NULL
, 0, (time_t)0, (uint32_t)0),
5311 memcached_last_error_message(local_memc
));
5313 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5314 test_compare(MEMCACHED_SUCCESS
,
5315 memcached_set(local_memc
, "foo", strlen("foo"), NULL
, 0, (time_t)0, (uint32_t)0));
5317 memcached_last_error_message(local_memc
));
5321 memcached_free(local_memc
);
5323 return TEST_SUCCESS
;
5326 static test_return_t
test_cull_servers(memcached_st
*memc
)
5328 uint32_t count
= memcached_server_count(memc
);
5332 return TEST_SKIPPED
;
5335 // Do not do this in your code, it is not supported.
5336 memc
->servers
[1].options
.is_dead
= true;
5337 memc
->state
.is_time_for_rebuild
= true;
5339 uint32_t new_count
= memcached_server_count(memc
);
5340 test_compare(count
, new_count
);
5343 test_true(count
== new_count
+ 1 );
5346 return TEST_SUCCESS
;
5350 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5351 const char *key
, size_t key_length
,
5352 const char *value
, size_t value_length
,
5362 return MEMCACHED_SUCCESS
;
5365 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5367 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5368 test_compare(MEMCACHED_SUCCESS
, rc
);
5370 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5371 test_compare(MEMCACHED_SUCCESS
, rc
);
5373 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5374 test_compare(MEMCACHED_SUCCESS
, rc
);
5376 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5377 test_compare(MEMCACHED_SUCCESS
, rc
);
5379 return TEST_SUCCESS
;
5383 * This test ensures that the failure counter isn't incremented during
5384 * normal termination of the memcached instance.
5386 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5388 memcached_return_t rc
;
5389 memcached_server_instance_st instance
;
5391 /* Set value to force connection to the server */
5392 const char *key
= "marmotte";
5393 const char *value
= "milka";
5396 * Please note that I'm abusing the internal structures in libmemcached
5397 * in a non-portable way and you shouldn't be doing this. I'm only
5398 * doing this in order to verify that the library works the way it should
5400 uint32_t number_of_hosts
= memcached_server_count(memc
);
5401 memc
->number_of_hosts
= 1;
5403 /* Ensure that we are connected to the server by setting a value */
5404 rc
= memcached_set(memc
, key
, strlen(key
),
5405 value
, strlen(value
),
5406 (time_t)0, (uint32_t)0);
5407 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5410 instance
= memcached_server_instance_by_position(memc
, 0);
5411 /* The test is to see that the memcached_quit doesn't increase the
5412 * the server failure conter, so let's ensure that it is zero
5413 * before sending quit
5415 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5417 memcached_quit(memc
);
5419 /* Verify that it memcached_quit didn't increment the failure counter
5420 * Please note that this isn't bullet proof, because an error could
5423 test_zero(instance
->server_failure_counter
);
5425 /* restore the instance */
5426 memc
->number_of_hosts
= number_of_hosts
;
5428 return TEST_SUCCESS
;
5432 * This tests ensures expected disconnections (for some behavior changes
5433 * for instance) do not wrongly increase failure counter
5435 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5437 memcached_return rc
;
5439 memcached_st
*memc_clone
;
5440 memc_clone
= memcached_clone(NULL
, memc
);
5441 test_true(memc_clone
);
5443 /* Set value to force connection to the server */
5444 const char *key
= "marmotte";
5445 const char *value
= "milka";
5446 char *string
= NULL
;
5447 size_t string_length
;
5450 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5451 value
, strlen(value
),
5452 (time_t)0, (uint32_t)0);
5453 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5456 /* put failure limit to 1 */
5457 test_compare(MEMCACHED_SUCCESS
,
5458 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1));
5460 /* Put a retry timeout to effectively activate failure_limit effect */
5461 test_compare(MEMCACHED_SUCCESS
,
5462 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
5464 /* change behavior that triggers memcached_quit()*/
5465 test_compare(MEMCACHED_SUCCESS
,
5466 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5469 /* Check if we still are connected */
5470 string
= memcached_get(memc_clone
, key
, strlen(key
),
5471 &string_length
, &flags
, &rc
);
5473 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5476 memcached_free(memc_clone
);
5478 return TEST_SUCCESS
;
5485 * Test that ensures mget_execute does not end into recursive calls that finally fails
5487 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5489 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5490 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5491 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5492 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5493 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5496 return TEST_SKIPPED
; // My MAC can't handle this test
5500 * I only want to hit _one_ server so I know the number of requests I'm
5501 * sending in the pipeline.
5503 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5504 memc
->number_of_hosts
= 1;
5505 size_t max_keys
= 20480;
5508 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5509 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5511 /* First add all of the items.. */
5512 char blob
[1024]= { 0 };
5513 for (size_t x
= 0; x
< max_keys
; ++x
)
5516 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5519 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5520 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5525 /* Try to get all of them with a large multiget */
5527 memcached_execute_function callbacks
[]= { &callback_counter
};
5528 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5529 (size_t)max_keys
, callbacks
, &counter
, 1);
5530 test_compare(MEMCACHED_SUCCESS
, rc
);
5532 char* the_value
= NULL
;
5533 char the_key
[MEMCACHED_MAX_KEY
];
5534 size_t the_key_length
;
5535 size_t the_value_length
;
5539 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5541 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5547 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5550 test_compare(MEMCACHED_END
, rc
);
5552 /* Verify that we got all of the items */
5553 test_compare(counter
, max_keys
);
5556 /* Release all allocated resources */
5557 for (size_t x
= 0; x
< max_keys
; ++x
)
5564 memc
->number_of_hosts
= number_of_hosts
;
5566 return TEST_SUCCESS
;
5569 static test_return_t
regression_bug_583031(memcached_st
*)
5571 memcached_st
*memc
= memcached_create(NULL
);
5573 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5575 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5576 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5577 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5578 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5579 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5580 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5582 memcached_return_t rc
;
5586 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5590 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5592 memcached_free(memc
);
5594 return TEST_SUCCESS
;
5597 static test_return_t
regression_bug_581030(memcached_st
*)
5600 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5601 test_false(local_stat
);
5603 memcached_stat_free(NULL
, NULL
);
5606 return TEST_SUCCESS
;
5609 #define regression_bug_655423_COUNT 6000
5610 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5612 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5613 memc
= NULL
; // Just to make sure it is not used
5618 return TEST_SKIPPED
;
5621 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5622 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5623 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5624 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5626 memset(payload
, int('x'), sizeof(payload
));
5628 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5630 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5631 snprintf(key
, sizeof(key
), "%u", x
);
5633 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5636 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5638 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5639 snprintf(key
, sizeof(key
), "%u", x
);
5641 size_t value_length
;
5642 memcached_return_t rc
;
5643 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5645 if (rc
== MEMCACHED_NOTFOUND
)
5648 test_zero(value_length
);
5652 test_compare(MEMCACHED_SUCCESS
, rc
);
5654 test_compare(100UL, value_length
);
5658 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5659 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5660 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5662 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5663 snprintf(key
, sizeof(key
), "%u", x
);
5665 keys
[x
]= strdup(key
);
5667 key_length
[x
]= strlen(key
);
5668 test_true(key_length
[x
]);
5671 test_compare(MEMCACHED_SUCCESS
,
5672 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5675 memcached_result_st
*result
= NULL
;
5676 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5678 test_compare(size_t(100), memcached_result_length(result
));
5682 test_true(count
> 100); // If we don't get back atleast this, something is up
5684 /* Release all allocated resources */
5685 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5693 memcached_free(clone
);
5695 return TEST_SUCCESS
;
5699 * Test that ensures that buffered set to not trigger problems during io_flush
5701 #define regression_bug_490520_COUNT 200480
5702 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5704 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5705 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5706 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5707 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5708 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5710 memc
->number_of_hosts
= 1;
5712 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5713 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5715 /* First add all of the items.. */
5716 char blob
[3333] = {0};
5717 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5720 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5724 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5725 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5728 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5735 return TEST_SUCCESS
;
5738 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5740 fprintf(stderr
, "Iteration #%u: ", it
);
5742 if (error
== MEMCACHED_ERRNO
)
5744 fprintf(stderr
, "system error %d from %s: %s\n",
5745 errno
, what
, strerror(errno
));
5749 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5750 memcached_strerror(mc
, error
));
5754 #define TEST_CONSTANT_CREATION 200
5756 static test_return_t
regression_bug_(memcached_st
*memc
)
5758 const char *remote_server
;
5761 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5763 return TEST_SKIPPED
;
5766 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5768 memcached_st
* mc
= memcached_create(NULL
);
5769 memcached_return rc
;
5771 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5772 if (rc
!= MEMCACHED_SUCCESS
)
5774 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5777 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5778 if (rc
!= MEMCACHED_SUCCESS
)
5780 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5783 rc
= memcached_server_add(mc
, remote_server
, 0);
5784 if (rc
!= MEMCACHED_SUCCESS
)
5786 memcached_die(mc
, rc
, "memcached_server_add", x
);
5789 const char *set_key
= "akey";
5790 const size_t set_key_len
= strlen(set_key
);
5791 const char *set_value
= "a value";
5792 const size_t set_value_len
= strlen(set_value
);
5794 if (rc
== MEMCACHED_SUCCESS
)
5798 size_t get_value_len
;
5800 uint32_t get_value_flags
;
5802 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5803 &get_value_flags
, &rc
);
5804 if (rc
!= MEMCACHED_SUCCESS
)
5806 memcached_die(mc
, rc
, "memcached_get", x
);
5812 (get_value_len
!= set_value_len
5813 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5815 fprintf(stderr
, "Values don't match?\n");
5816 rc
= MEMCACHED_FAILURE
;
5822 rc
= memcached_set(mc
,
5823 set_key
, set_key_len
,
5824 set_value
, set_value_len
,
5828 if (rc
!= MEMCACHED_SUCCESS
)
5830 memcached_die(mc
, rc
, "memcached_set", x
);
5837 if (rc
!= MEMCACHED_SUCCESS
)
5843 return TEST_SUCCESS
;
5846 /* Clean the server before beginning testing */
5848 {"util_version", true, (test_callback_fn
*)util_version_test
},
5849 {"flush", false, (test_callback_fn
*)flush_test
},
5850 {"init", false, (test_callback_fn
*)init_test
},
5851 {"allocation", false, (test_callback_fn
*)allocation_test
},
5852 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5853 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5854 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5855 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5856 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5857 {"clone_test", false, (test_callback_fn
*)clone_test
},
5858 {"connection_test", false, (test_callback_fn
*)connection_test
},
5859 {"callback_test", false, (test_callback_fn
*)callback_test
},
5860 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5861 {"error", false, (test_callback_fn
*)error_test
},
5862 {"set", false, (test_callback_fn
*)set_test
},
5863 {"set2", false, (test_callback_fn
*)set_test2
},
5864 {"set3", false, (test_callback_fn
*)set_test3
},
5865 {"dump", true, (test_callback_fn
*)dump_test
},
5866 {"add", true, (test_callback_fn
*)add_test
},
5867 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5868 {"replace", true, (test_callback_fn
*)replace_test
},
5869 {"delete", true, (test_callback_fn
*)delete_test
},
5870 {"get", true, (test_callback_fn
*)get_test
},
5871 {"get2", false, (test_callback_fn
*)get_test2
},
5872 {"get3", false, (test_callback_fn
*)get_test3
},
5873 {"get4", false, (test_callback_fn
*)get_test4
},
5874 {"partial mget", false, (test_callback_fn
*)get_test5
},
5875 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5876 {"increment", false, (test_callback_fn
*)increment_test
},
5877 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5878 {"decrement", false, (test_callback_fn
*)decrement_test
},
5879 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5880 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5881 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5882 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5883 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5884 {"binary_increment_with_prefix", 1, (test_callback_fn
*)binary_increment_with_prefix_test
},
5885 {"quit", false, (test_callback_fn
*)quit_test
},
5886 {"mget", true, (test_callback_fn
*)mget_test
},
5887 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5888 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5889 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5890 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5891 {"mget_end", false, (test_callback_fn
*)mget_end
},
5892 {"get_stats", false, (test_callback_fn
*)get_stats
},
5893 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5894 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5895 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5896 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
5897 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5898 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5899 {"read_through", true, (test_callback_fn
*)read_through
},
5900 {"delete_through", true, (test_callback_fn
*)delete_through
},
5901 {"noreply", true, (test_callback_fn
*)noreply_test
},
5902 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5903 {"connectionpool", true, (test_callback_fn
*)connection_pool_test
},
5904 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
5905 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
5906 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
5907 {"test_server_failure", true, (test_callback_fn
*)test_server_failure
},
5908 {"cull_servers", true, (test_callback_fn
*)test_cull_servers
},
5909 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
5913 test_st behavior_tests
[] ={
5914 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5915 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5916 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5917 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5918 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5919 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5923 test_st libmemcachedutil_tests
[] ={
5924 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5925 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5926 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5930 test_st basic_tests
[] ={
5931 {"init", true, (test_callback_fn
*)basic_init_test
},
5932 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5933 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5934 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5935 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5936 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5940 test_st regression_binary_vs_block
[] ={
5941 {"block add", true, (test_callback_fn
*)block_add_regression
},
5942 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
5946 test_st async_tests
[] ={
5947 {"add", true, (test_callback_fn
*)add_wrapper
},
5951 test_st memcached_server_get_last_disconnect_tests
[] ={
5952 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
5953 {0, 0, (test_callback_fn
*)0}
5957 test_st result_tests
[] ={
5958 {"result static", false, (test_callback_fn
*)result_static
},
5959 {"result alloc", false, (test_callback_fn
*)result_alloc
},
5960 {0, 0, (test_callback_fn
*)0}
5963 test_st version_1_2_3
[] ={
5964 {"append", false, (test_callback_fn
*)append_test
},
5965 {"prepend", false, (test_callback_fn
*)prepend_test
},
5966 {"cas", false, (test_callback_fn
*)cas_test
},
5967 {"cas2", false, (test_callback_fn
*)cas2_test
},
5968 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
5969 {0, 0, (test_callback_fn
*)0}
5972 test_st haldenbrand_tests
[] ={
5973 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
5974 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
5975 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
5976 {0, 0, (test_callback_fn
*)0}
5979 test_st user_tests
[] ={
5980 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
5981 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
5982 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
5983 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
5984 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
5985 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
5986 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
5987 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
5988 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
5989 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
5990 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
5991 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
5992 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
5993 #if !defined(__sun) && !defined(__OpenBSD__)
5995 ** It seems to be something weird with the character sets..
5996 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
5997 ** guess I need to find out how this is supposed to work.. Perhaps I need
5998 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
5999 ** so just disable the code for now...).
6001 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
6003 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
6004 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
6005 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
6006 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
6007 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
6008 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
6009 {0, 0, (test_callback_fn
*)0}
6012 test_st replication_tests
[]= {
6013 {"set", true, (test_callback_fn
*)replication_set_test
},
6014 {"get", false, (test_callback_fn
*)replication_get_test
},
6015 {"mget", false, (test_callback_fn
*)replication_mget_test
},
6016 {"delete", true, (test_callback_fn
*)replication_delete_test
},
6017 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
6018 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
6019 {0, 0, (test_callback_fn
*)0}
6023 * The following test suite is used to verify that we don't introduce
6024 * regression bugs. If you want more information about the bug / test,
6025 * you should look in the bug report at
6026 * http://bugs.launchpad.net/libmemcached
6028 test_st regression_tests
[]= {
6029 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
6030 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
6031 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
6032 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
6033 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
6034 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
6035 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
6036 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
6037 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
6038 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
6039 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
6040 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
6041 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
6042 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
6043 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
6044 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
6045 {0, false, (test_callback_fn
*)0}
6048 test_st ketama_compatibility
[]= {
6049 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
6050 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
6051 {0, 0, (test_callback_fn
*)0}
6054 test_st generate_tests
[] ={
6055 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6056 {"generate_data", true, (test_callback_fn
*)generate_data
},
6057 {"get_read", false, (test_callback_fn
*)get_read
},
6058 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
6059 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
6060 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
6061 {"generate_data", true, (test_callback_fn
*)generate_data
},
6062 {"mget_read", false, (test_callback_fn
*)mget_read
},
6063 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
6064 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
6065 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
6066 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
6067 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6068 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
6069 {"generate_data", true, (test_callback_fn
*)generate_data
},
6070 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
6071 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6072 {0, 0, (test_callback_fn
*)0}
6075 test_st consistent_tests
[] ={
6076 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6077 {"generate_data", true, (test_callback_fn
*)generate_data
},
6078 {"get_read", 0, (test_callback_fn
*)get_read_count
},
6079 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6080 {0, 0, (test_callback_fn
*)0}
6083 test_st consistent_weighted_tests
[] ={
6084 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6085 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
6086 {"get_read", false, (test_callback_fn
*)get_read_count
},
6087 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6088 {0, 0, (test_callback_fn
*)0}
6091 test_st hsieh_availability
[] ={
6092 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
6093 {0, 0, (test_callback_fn
*)0}
6096 test_st murmur_availability
[] ={
6097 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
6098 {0, 0, (test_callback_fn
*)0}
6102 test_st hash_sanity
[] ={
6103 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
6104 {0, 0, (test_callback_fn
*)0}
6108 test_st ketama_auto_eject_hosts
[] ={
6109 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
6110 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
6111 {0, 0, (test_callback_fn
*)0}
6114 test_st hash_tests
[] ={
6115 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
6116 {"md5", false, (test_callback_fn
*)md5_run
},
6117 {"crc", false, (test_callback_fn
*)crc_run
},
6118 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
6119 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
6120 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
6121 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
6122 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
6123 {"murmur", false, (test_callback_fn
*)murmur_run
},
6124 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
6125 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
6126 {0, 0, (test_callback_fn
*)0}
6129 test_st error_conditions
[] ={
6130 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
6131 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
6132 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
6133 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6134 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6135 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
6136 {0, 0, (test_callback_fn
*)0}
6140 test_st parser_tests
[] ={
6141 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
6142 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
6143 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
6144 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
6145 {"hash", false, (test_callback_fn
*)parser_hash_test
},
6146 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
6147 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
6148 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
6149 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
6150 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
6151 {"server", false, (test_callback_fn
*)server_test
},
6152 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
6153 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
6154 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
6155 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
6156 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
6157 {0, 0, (test_callback_fn
*)0}
6160 test_st virtual_bucket_tests
[] ={
6161 {"basic", false, (test_callback_fn
*)virtual_back_map
},
6162 {0, 0, (test_callback_fn
*)0}
6165 test_st memcached_server_add_tests
[] ={
6166 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
6167 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
6168 {0, 0, (test_callback_fn
*)0}
6171 test_st namespace_tests
[] ={
6172 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
6173 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
6174 {0, 0, (test_callback_fn
*)0}
6177 collection_st collection
[] ={
6179 {"hash_sanity", 0, 0, hash_sanity
},
6181 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
6182 {"basic", 0, 0, basic_tests
},
6183 {"hsieh_availability", 0, 0, hsieh_availability
},
6184 {"murmur_availability", 0, 0, murmur_availability
},
6185 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
6186 {"block", 0, 0, tests
},
6187 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
6188 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
6189 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6190 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
6191 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
6192 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
6193 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
6194 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
6195 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
6196 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
6197 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
6198 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
6199 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
6200 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6201 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
6202 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6203 {"poll_timeout", (test_callback_fn
*)poll_timeout
, 0, tests
},
6204 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
6205 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
6206 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
6207 #ifdef MEMCACHED_ENABLE_DEPRECATED
6208 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
6210 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
6211 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
6212 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
6213 {"specific namespace", 0, 0, namespace_tests
},
6214 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
6215 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
6216 {"result", 0, 0, result_tests
},
6217 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
6218 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
6219 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
6220 {"user", 0, 0, user_tests
},
6221 {"generate", 0, 0, generate_tests
},
6222 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
6223 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
6224 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
6225 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
6226 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
6227 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
6228 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
6230 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
6231 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
6232 {"consistent_not", 0, 0, consistent_tests
},
6233 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
6234 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6235 {"ketama_compat", 0, 0, ketama_compatibility
},
6236 {"test_hashes", 0, 0, hash_tests
},
6237 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6238 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6239 {"regression", 0, 0, regression_tests
},
6240 {"behaviors", 0, 0, behavior_tests
},
6241 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6242 {"error_conditions", 0, 0, error_conditions
},
6243 {"parser", 0, 0, parser_tests
},
6244 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6245 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6249 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
6251 #include "tests/libmemcached_world.h"
6253 void get_world(Framework
*world
)
6255 world
->collections
= collection
;
6257 world
->_create
= (test_callback_create_fn
*)world_create
;
6258 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6260 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6261 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6262 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6263 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6264 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6266 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6267 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6269 world
->set_runner(&defualt_libmemcached_runner
);
6271 world
->set_socket();