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>
55 #include <semaphore.h>
59 #include <sys/types.h>
64 #include <libtest/server.h>
66 #include "clients/generator.h"
67 #include "clients/execute.h"
69 #define SMALL_STRING_LEN 1024
71 #include <libtest/test.hpp>
73 #include "tests/basic.h"
74 #include "tests/debug.h"
75 #include "tests/deprecated.h"
76 #include "tests/error_conditions.h"
77 #include "tests/exist.h"
78 #include "tests/ketama.h"
79 #include "tests/namespace.h"
80 #include "tests/parser.h"
81 #include "tests/pool.h"
82 #include "tests/print.h"
83 #include "tests/replication.h"
84 #include "tests/server_add.h"
85 #include "tests/virtual_buckets.h"
87 using namespace libtest
;
89 #include <libmemcached/memcached_util.h>
91 #include "hash_results.h"
93 #define GLOBAL_COUNT 10000
94 #define GLOBAL2_COUNT 100
95 #define SERVERS_TO_CREATE 5
96 static uint32_t global_count
;
98 static pairs_st
*global_pairs
;
99 static const char *global_keys
[GLOBAL_COUNT
];
100 static size_t global_keys_length
[GLOBAL_COUNT
];
103 static test_return_t
pre_binary(memcached_st
*memc
);
106 static test_return_t
init_test(memcached_st
*not_used
)
111 (void)memcached_create(&memc
);
112 memcached_free(&memc
);
117 #define TEST_PORT_COUNT 7
118 in_port_t test_ports
[TEST_PORT_COUNT
];
120 static memcached_return_t
server_display_function(const memcached_st
*ptr
,
121 const memcached_server_st
*server
,
125 size_t bigger
= *((size_t *)(context
));
127 assert(bigger
<= memcached_server_port(server
));
128 *((size_t *)(context
))= memcached_server_port(server
);
130 return MEMCACHED_SUCCESS
;
133 static memcached_return_t
dump_server_information(const memcached_st
*ptr
,
134 const memcached_server_st
*instance
,
138 FILE *stream
= (FILE *)context
;
141 fprintf(stream
, "Memcached Server: %s %u Version %u.%u.%u\n",
142 memcached_server_name(instance
),
143 memcached_server_port(instance
),
144 instance
->major_version
,
145 instance
->minor_version
,
146 instance
->micro_version
);
148 return MEMCACHED_SUCCESS
;
151 static test_return_t
server_sort_test(memcached_st
*ptr
)
153 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
155 memcached_return_t rc
;
156 memcached_server_fn callbacks
[1];
157 memcached_st
*local_memc
;
160 local_memc
= memcached_create(NULL
);
161 test_true(local_memc
);
162 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
164 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
166 test_ports
[x
]= (in_port_t
)random() % 64000;
167 rc
= memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0);
168 test_compare(memcached_server_count(local_memc
), x
+1);
170 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
172 test_compare(MEMCACHED_SUCCESS
, rc
);
175 callbacks
[0]= server_display_function
;
176 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
179 memcached_free(local_memc
);
184 static test_return_t
server_sort2_test(memcached_st
*ptr
)
186 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
187 memcached_server_fn callbacks
[1];
188 memcached_st
*local_memc
;
189 memcached_server_instance_st instance
;
192 local_memc
= memcached_create(NULL
);
193 test_true(local_memc
);
194 test_compare(MEMCACHED_SUCCESS
,
195 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1));
197 test_compare(MEMCACHED_SUCCESS
,
198 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
199 instance
= memcached_server_instance_by_position(local_memc
, 0);
200 test_compare(in_port_t(43043), memcached_server_port(instance
));
202 test_compare(MEMCACHED_SUCCESS
,
203 memcached_server_add_with_weight(local_memc
, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
205 instance
= memcached_server_instance_by_position(local_memc
, 0);
206 test_compare(in_port_t(43042), memcached_server_port(instance
));
208 instance
= memcached_server_instance_by_position(local_memc
, 1);
209 test_compare(in_port_t(43043), memcached_server_port(instance
));
211 callbacks
[0]= server_display_function
;
212 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
215 memcached_free(local_memc
);
220 static test_return_t
memcached_server_remove_test(memcached_st
*)
222 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";
225 test_compare(MEMCACHED_SUCCESS
,
226 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
227 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
230 memcached_server_fn callbacks
[1];
231 callbacks
[0]= server_print_callback
;
232 memcached_server_cursor(memc
, callbacks
, NULL
, 1);
234 memcached_free(memc
);
239 static memcached_return_t
server_display_unsort_function(const memcached_st
*,
240 const memcached_server_st
*server
,
244 uint32_t x
= *((uint32_t *)(context
));
246 if (! (test_ports
[x
] == server
->port
))
248 fprintf(stderr
, "%lu -> %lu\n", (unsigned long)test_ports
[x
], (unsigned long)server
->port
);
249 return MEMCACHED_FAILURE
;
252 *((uint32_t *)(context
))= ++x
;
254 return MEMCACHED_SUCCESS
;
257 static test_return_t
server_unsort_test(memcached_st
*ptr
)
259 size_t counter
= 0; /* Prime the value for the test_true in server_display_function */
260 size_t bigger
= 0; /* Prime the value for the test_true in server_display_function */
261 memcached_server_fn callbacks
[1];
262 memcached_st
*local_memc
;
265 local_memc
= memcached_create(NULL
);
266 test_true(local_memc
);
268 for (uint32_t x
= 0; x
< TEST_PORT_COUNT
; x
++)
270 test_ports
[x
]= (in_port_t
)(random() % 64000);
271 test_compare(MEMCACHED_SUCCESS
,
272 memcached_server_add_with_weight(local_memc
, "localhost", test_ports
[x
], 0));
273 test_compare(memcached_server_count(local_memc
), x
+1);
275 test_true(memcached_server_list_count(memcached_server_list(local_memc
)) == x
+1);
279 callbacks
[0]= server_display_unsort_function
;
280 memcached_server_cursor(local_memc
, callbacks
, (void *)&counter
, 1);
282 /* Now we sort old data! */
283 memcached_behavior_set(local_memc
, MEMCACHED_BEHAVIOR_SORT_HOSTS
, 1);
284 callbacks
[0]= server_display_function
;
285 memcached_server_cursor(local_memc
, callbacks
, (void *)&bigger
, 1);
288 memcached_free(local_memc
);
293 static test_return_t
allocation_test(memcached_st
*not_used
)
297 memc
= memcached_create(NULL
);
299 memcached_free(memc
);
304 static test_return_t
clone_test(memcached_st
*memc
)
308 memcached_st
*memc_clone
;
309 memc_clone
= memcached_clone(NULL
, NULL
);
310 test_true(memc_clone
);
311 memcached_free(memc_clone
);
314 /* Can we init from null? */
316 memcached_st
*memc_clone
;
317 memc_clone
= memcached_clone(NULL
, memc
);
318 test_true(memc_clone
);
321 test_true(memc_clone
->allocators
.free
== memc
->allocators
.free
);
322 test_true(memc_clone
->allocators
.malloc
== memc
->allocators
.malloc
);
323 test_true(memc_clone
->allocators
.realloc
== memc
->allocators
.realloc
);
324 test_true(memc_clone
->allocators
.calloc
== memc
->allocators
.calloc
);
327 test_true(memc_clone
->connect_timeout
== memc
->connect_timeout
);
328 test_true(memc_clone
->delete_trigger
== memc
->delete_trigger
);
329 test_true(memc_clone
->distribution
== memc
->distribution
);
330 { // Test all of the flags
331 test_true(memc_clone
->flags
.no_block
== memc
->flags
.no_block
);
332 test_true(memc_clone
->flags
.tcp_nodelay
== memc
->flags
.tcp_nodelay
);
333 test_true(memc_clone
->flags
.support_cas
== memc
->flags
.support_cas
);
334 test_true(memc_clone
->flags
.buffer_requests
== memc
->flags
.buffer_requests
);
335 test_true(memc_clone
->flags
.use_sort_hosts
== memc
->flags
.use_sort_hosts
);
336 test_true(memc_clone
->flags
.verify_key
== memc
->flags
.verify_key
);
337 test_true(memc_clone
->ketama
.weighted
== memc
->ketama
.weighted
);
338 test_true(memc_clone
->flags
.binary_protocol
== memc
->flags
.binary_protocol
);
339 test_true(memc_clone
->flags
.hash_with_namespace
== memc
->flags
.hash_with_namespace
);
340 test_true(memc_clone
->flags
.no_reply
== memc
->flags
.no_reply
);
341 test_true(memc_clone
->flags
.use_udp
== memc
->flags
.use_udp
);
342 test_true(memc_clone
->flags
.auto_eject_hosts
== memc
->flags
.auto_eject_hosts
);
343 test_true(memc_clone
->flags
.randomize_replica_read
== memc
->flags
.randomize_replica_read
);
345 test_true(memc_clone
->get_key_failure
== memc
->get_key_failure
);
346 test_true(hashkit_compare(&memc_clone
->hashkit
, &memc
->hashkit
));
347 test_true(memc_clone
->io_bytes_watermark
== memc
->io_bytes_watermark
);
348 test_true(memc_clone
->io_msg_watermark
== memc
->io_msg_watermark
);
349 test_true(memc_clone
->io_key_prefetch
== memc
->io_key_prefetch
);
350 test_true(memc_clone
->on_cleanup
== memc
->on_cleanup
);
351 test_true(memc_clone
->on_clone
== memc
->on_clone
);
352 test_true(memc_clone
->poll_timeout
== memc
->poll_timeout
);
353 test_true(memc_clone
->rcv_timeout
== memc
->rcv_timeout
);
354 test_true(memc_clone
->recv_size
== memc
->recv_size
);
355 test_true(memc_clone
->retry_timeout
== memc
->retry_timeout
);
356 test_true(memc_clone
->send_size
== memc
->send_size
);
357 test_true(memc_clone
->server_failure_limit
== memc
->server_failure_limit
);
358 test_true(memc_clone
->snd_timeout
== memc
->snd_timeout
);
359 test_true(memc_clone
->user_data
== memc
->user_data
);
361 memcached_free(memc_clone
);
364 /* Can we init from struct? */
366 memcached_st declared_clone
;
367 memcached_st
*memc_clone
;
368 memset(&declared_clone
, 0 , sizeof(memcached_st
));
369 memc_clone
= memcached_clone(&declared_clone
, NULL
);
370 test_true(memc_clone
);
371 memcached_free(memc_clone
);
374 /* Can we init from struct? */
376 memcached_st declared_clone
;
377 memcached_st
*memc_clone
;
378 memset(&declared_clone
, 0 , sizeof(memcached_st
));
379 memc_clone
= memcached_clone(&declared_clone
, memc
);
380 test_true(memc_clone
);
381 memcached_free(memc_clone
);
387 static test_return_t
userdata_test(memcached_st
*memc
)
390 test_false(memcached_set_user_data(memc
, foo
));
391 test_true(memcached_get_user_data(memc
) == foo
);
392 test_true(memcached_set_user_data(memc
, NULL
) == foo
);
397 static test_return_t
connection_test(memcached_st
*memc
)
399 test_compare(MEMCACHED_SUCCESS
,
400 memcached_server_add_with_weight(memc
, "localhost", 0, 0));
405 static test_return_t
libmemcached_string_behavior_test(memcached_st
*)
407 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
409 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
411 test_compare(36, int(MEMCACHED_BEHAVIOR_MAX
));
416 static test_return_t
libmemcached_string_distribution_test(memcached_st
*)
418 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
420 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
422 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
427 static test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
429 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
430 982370485U, 1263635348U, 4242906218U, 3829656100U,
431 1891735253U, 334139633U, 2257084983U, 3088286104U,
432 13199785U, 2542027183U, 1097051614U, 199566778U,
433 2748246961U, 2465192557U, 1664094137U, 2405439045U,
434 1842224848U, 692413798U, 3479807801U, 919913813U,
435 4269430871U, 610793021U, 527273862U, 1437122909U,
436 2300930706U, 2943759320U, 674306647U, 2400528935U,
437 54481931U, 4186304426U, 1741088401U, 2979625118U,
438 4159057246U, 3425930182U, 2593724503U, 1868899624U,
439 1769812374U, 2302537950U, 1110330676U, 3365377466U,
440 1336171666U, 3021258493U, 2334992265U, 3861994737U,
443 // You have updated the memcache_error messages but not updated docs/tests.
444 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
447 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
448 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
449 MEMCACHED_HASH_JENKINS
);
450 if (values
[rc
] != hash_val
)
452 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
453 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
455 test_compare(values
[rc
], hash_val
);
457 test_compare(48, int(MEMCACHED_MAXIMUM_RETURN
));
462 static test_return_t
set_test(memcached_st
*memc
)
464 memcached_return_t rc
= memcached_set(memc
,
465 test_literal_param("foo"),
466 test_literal_param("when we sanitize"),
467 time_t(0), (uint32_t)0);
468 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
473 static test_return_t
append_test(memcached_st
*memc
)
475 memcached_return_t rc
;
476 const char *key
= "fig";
477 const char *in_value
= "we";
478 char *out_value
= NULL
;
482 rc
= memcached_flush(memc
, 0);
483 test_compare(MEMCACHED_SUCCESS
, rc
);
485 rc
= memcached_set(memc
, key
, strlen(key
),
486 in_value
, strlen(in_value
),
487 (time_t)0, (uint32_t)0);
488 test_compare(MEMCACHED_SUCCESS
, rc
);
490 rc
= memcached_append(memc
, key
, strlen(key
),
491 " the", strlen(" the"),
492 (time_t)0, (uint32_t)0);
493 test_compare(MEMCACHED_SUCCESS
, rc
);
495 rc
= memcached_append(memc
, key
, strlen(key
),
496 " people", strlen(" people"),
497 (time_t)0, (uint32_t)0);
498 test_compare(MEMCACHED_SUCCESS
, rc
);
500 out_value
= memcached_get(memc
, key
, strlen(key
),
501 &value_length
, &flags
, &rc
);
502 test_memcmp(out_value
, "we the people", strlen("we the people"));
503 test_compare(strlen("we the people"), value_length
);
504 test_compare(MEMCACHED_SUCCESS
, rc
);
510 static test_return_t
append_binary_test(memcached_st
*memc
)
512 memcached_return_t rc
;
513 const char *key
= "numbers";
514 uint32_t store_list
[] = { 23, 56, 499, 98, 32847, 0 };
520 rc
= memcached_flush(memc
, 0);
521 test_compare(MEMCACHED_SUCCESS
, rc
);
523 rc
= memcached_set(memc
,
526 (time_t)0, (uint32_t)0);
527 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
529 for (x
= 0; store_list
[x
] ; x
++)
531 rc
= memcached_append(memc
,
533 (char *)&store_list
[x
], sizeof(uint32_t),
534 (time_t)0, (uint32_t)0);
535 test_compare(MEMCACHED_SUCCESS
, rc
);
538 value
= (uint32_t *)memcached_get(memc
, key
, strlen(key
),
539 &value_length
, &flags
, &rc
);
540 test_compare(value_length
, sizeof(uint32_t) * x
);
541 test_compare(MEMCACHED_SUCCESS
, rc
);
543 for (uint32_t counter
= x
, *ptr
= value
; counter
; counter
--)
545 test_compare(*ptr
, store_list
[x
- counter
]);
553 static test_return_t
cas2_test(memcached_st
*memc
)
555 memcached_return_t rc
;
556 const char *keys
[]= {"fudge", "son", "food"};
557 size_t key_length
[]= {5, 3, 4};
558 const char *value
= "we the people";
559 size_t value_length
= strlen("we the people");
560 memcached_result_st results_obj
;
561 memcached_result_st
*results
;
564 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
566 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
568 for (uint32_t x
= 0; x
< 3; x
++)
570 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
571 keys
[x
], key_length
[x
],
572 (time_t)50, (uint32_t)9);
573 test_compare(MEMCACHED_SUCCESS
, rc
);
576 test_compare(MEMCACHED_SUCCESS
,
577 memcached_mget(memc
, keys
, key_length
, 3));
579 results
= memcached_result_create(memc
, &results_obj
);
582 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
584 test_true(results
->item_cas
);
585 test_compare(MEMCACHED_SUCCESS
, rc
);
586 test_true(memcached_result_cas(results
));
588 test_memcmp(value
, "we the people", strlen("we the people"));
589 test_compare(strlen("we the people"), value_length
);
590 test_compare(MEMCACHED_SUCCESS
, rc
);
592 memcached_result_free(&results_obj
);
597 static test_return_t
cas_test(memcached_st
*memc
)
599 memcached_return_t rc
;
600 const char *key
= "fun";
601 size_t key_length
= strlen(key
);
602 const char *value
= "we the people";
603 const char* keys
[2] = { key
, NULL
};
604 size_t keylengths
[2] = { strlen(key
), 0 };
605 size_t value_length
= strlen(value
);
606 const char *value2
= "change the value";
607 size_t value2_length
= strlen(value2
);
609 memcached_result_st results_obj
;
610 memcached_result_st
*results
;
613 rc
= memcached_flush(memc
, 0);
614 test_compare(MEMCACHED_SUCCESS
, rc
);
616 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
618 rc
= memcached_set(memc
, key
, strlen(key
),
619 value
, strlen(value
),
620 (time_t)0, (uint32_t)0);
621 test_compare(MEMCACHED_SUCCESS
, rc
);
623 test_compare(MEMCACHED_SUCCESS
,
624 memcached_mget(memc
, keys
, keylengths
, 1));
626 results
= memcached_result_create(memc
, &results_obj
);
629 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
631 test_compare(MEMCACHED_SUCCESS
, rc
);
632 test_true(memcached_result_cas(results
));
633 test_memcmp(value
, memcached_result_value(results
), value_length
);
634 test_compare(strlen(memcached_result_value(results
)), value_length
);
635 test_compare(MEMCACHED_SUCCESS
, rc
);
636 uint64_t cas
= memcached_result_cas(results
);
639 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
640 test_true(rc
== MEMCACHED_END
);
641 test_true(results
== NULL
);
644 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
645 test_compare(MEMCACHED_SUCCESS
, rc
);
648 * The item will have a new cas value, so try to set it again with the old
649 * value. This should fail!
651 rc
= memcached_cas(memc
, key
, key_length
, value2
, value2_length
, 0, 0, cas
);
652 test_compare(MEMCACHED_DATA_EXISTS
, rc
);
654 memcached_result_free(&results_obj
);
659 static test_return_t
prepend_test(memcached_st
*memc
)
661 memcached_return_t rc
;
662 const char *key
= "fig";
663 const char *value
= "people";
664 char *out_value
= NULL
;
668 rc
= memcached_flush(memc
, 0);
669 test_compare(MEMCACHED_SUCCESS
, rc
);
671 rc
= memcached_set(memc
, key
, strlen(key
),
672 value
, strlen(value
),
673 (time_t)0, (uint32_t)0);
674 test_compare(MEMCACHED_SUCCESS
, rc
);
676 rc
= memcached_prepend(memc
, key
, strlen(key
),
677 "the ", strlen("the "),
678 (time_t)0, (uint32_t)0);
679 test_compare(MEMCACHED_SUCCESS
, rc
);
681 rc
= memcached_prepend(memc
, key
, strlen(key
),
682 "we ", strlen("we "),
683 (time_t)0, (uint32_t)0);
684 test_compare(MEMCACHED_SUCCESS
, rc
);
686 out_value
= memcached_get(memc
, key
, strlen(key
),
687 &value_length
, &flags
, &rc
);
688 test_memcmp(out_value
, "we the people", strlen("we the people"));
689 test_compare(strlen("we the people"), value_length
);
690 test_compare(MEMCACHED_SUCCESS
, rc
);
697 Set the value, then quit to make sure it is flushed.
698 Come back in and test that add fails.
700 static test_return_t
add_test(memcached_st
*memc
)
702 memcached_return_t rc
;
703 const char *key
= "foo";
704 const char *value
= "when we sanitize";
705 unsigned long long setting_value
;
707 setting_value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
709 rc
= memcached_set(memc
, key
, strlen(key
),
710 value
, strlen(value
),
711 (time_t)0, (uint32_t)0);
712 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
713 memcached_quit(memc
);
714 rc
= memcached_add(memc
, key
, strlen(key
),
715 value
, strlen(value
),
716 (time_t)0, (uint32_t)0);
718 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
721 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_STORED
);
725 test_true(rc
== MEMCACHED_NOTSTORED
|| rc
== MEMCACHED_DATA_EXISTS
);
732 ** There was a problem of leaking filedescriptors in the initial release
733 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
734 ** systems it seems that the kernel is slow on reclaiming the resources
735 ** because the connects starts to time out (the test doesn't do much
736 ** anyway, so just loop 10 iterations)
738 static test_return_t
add_wrapper(memcached_st
*memc
)
740 unsigned int max
= 10000;
748 for (uint32_t x
= 0; x
< max
; x
++)
754 static test_return_t
replace_test(memcached_st
*memc
)
756 memcached_return_t rc
;
757 const char *key
= "foo";
758 const char *value
= "when we sanitize";
759 const char *original
= "first we insert some data";
761 rc
= memcached_set(memc
, key
, strlen(key
),
762 original
, strlen(original
),
763 (time_t)0, (uint32_t)0);
764 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
766 test_compare(MEMCACHED_SUCCESS
,
767 memcached_replace(memc
, key
, strlen(key
),
768 value
, strlen(value
),
769 (time_t)0, (uint32_t)0));
774 static test_return_t
delete_test(memcached_st
*memc
)
776 memcached_return_t rc
;
777 const char *key
= "foo";
778 const char *value
= "when we sanitize";
780 rc
= memcached_set(memc
, key
, strlen(key
),
781 value
, strlen(value
),
782 (time_t)0, (uint32_t)0);
783 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
785 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
786 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
791 static test_return_t
flush_test(memcached_st
*memc
)
793 uint64_t query_id
= memcached_query_id(memc
);
794 test_compare(MEMCACHED_SUCCESS
,
795 memcached_flush(memc
, 0));
796 test_compare(query_id
+1, memcached_query_id(memc
));
801 static memcached_return_t
server_function(const memcached_st
*ptr
,
802 const memcached_server_st
*server
,
805 (void)ptr
; (void)server
; (void)context
;
808 return MEMCACHED_SUCCESS
;
811 static test_return_t
memcached_server_cursor_test(memcached_st
*memc
)
814 strncpy(context
, "foo bad", sizeof(context
));
815 memcached_server_fn callbacks
[1];
817 callbacks
[0]= server_function
;
818 memcached_server_cursor(memc
, callbacks
, context
, 1);
822 static test_return_t
bad_key_test(memcached_st
*memc
)
824 memcached_return_t rc
;
825 const char *key
= "foo bad";
827 memcached_st
*memc_clone
;
829 uint64_t query_id
= memcached_query_id(memc
);
831 // Just skip if we are in binary mode.
832 test_skip(false, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
834 test_compare(query_id
, memcached_query_id(memc
)); // We should not increase the query_id for memcached_behavior_get()
836 memc_clone
= memcached_clone(NULL
, memc
);
837 test_true(memc_clone
);
839 query_id
= memcached_query_id(memc_clone
);
840 test_compare(MEMCACHED_SUCCESS
,
841 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
842 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
844 /* All keys are valid in the binary protocol (except for length) */
845 if (not memcached_behavior_get(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
))
847 uint64_t before_query_id
= memcached_query_id(memc_clone
);
849 size_t string_length
;
850 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
851 &string_length
, &flags
, &rc
);
852 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
853 test_zero(string_length
);
856 test_compare(before_query_id
+1, memcached_query_id(memc_clone
));
858 query_id
= memcached_query_id(memc_clone
);
859 test_compare(MEMCACHED_SUCCESS
,
860 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, false));
861 test_compare(query_id
, memcached_query_id(memc_clone
)); // We should not increase the query_id for memcached_behavior_set()
863 size_t string_length
;
864 char *string
= memcached_get(memc_clone
, key
, strlen(key
),
865 &string_length
, &flags
, &rc
);
866 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
867 test_zero(string_length
);
871 /* Test multi key for bad keys */
872 const char *keys
[] = { "GoodKey", "Bad Key", "NotMine" };
873 size_t key_lengths
[] = { 7, 7, 7 };
874 query_id
= memcached_query_id(memc_clone
);
875 test_compare(MEMCACHED_SUCCESS
,
876 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
877 test_compare(query_id
, memcached_query_id(memc_clone
));
879 query_id
= memcached_query_id(memc_clone
);
880 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
881 memcached_mget(memc_clone
, keys
, key_lengths
, 3));
882 test_compare(query_id
+1, memcached_query_id(memc_clone
));
884 query_id
= memcached_query_id(memc_clone
);
885 test_compare(MEMCACHED_BAD_KEY_PROVIDED
,
886 memcached_mget_by_key(memc_clone
, "foo daddy", 9, keys
, key_lengths
, 1));
887 test_compare(query_id
+1, memcached_query_id(memc_clone
));
889 /* The following test should be moved to the end of this function when the
890 memcached server is updated to allow max size length of the keys in the
893 test_compare(MEMCACHED_SUCCESS
,
894 memcached_callback_set(memc_clone
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
896 std::vector
<char> longkey
;
897 longkey
.insert(longkey
.end(), MEMCACHED_MAX_KEY
, 'a');
898 test_compare(longkey
.size(), size_t(MEMCACHED_MAX_KEY
));
900 size_t string_length
;
902 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size() -1, &string_length
, &flags
, &rc
));
903 test_compare(MEMCACHED_NOTFOUND
, rc
);
904 test_zero(string_length
);
906 test_null(memcached_get(memc_clone
, &longkey
[0], longkey
.size(), &string_length
, &flags
, &rc
));
907 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
908 test_zero(string_length
);
912 /* Make sure zero length keys are marked as bad */
914 test_compare(MEMCACHED_SUCCESS
,
915 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
916 size_t string_length
;
917 char *string
= memcached_get(memc_clone
, key
, 0,
918 &string_length
, &flags
, &rc
);
919 test_compare(MEMCACHED_BAD_KEY_PROVIDED
, rc
);
920 test_zero(string_length
);
924 memcached_free(memc_clone
);
929 #define READ_THROUGH_VALUE "set for me"
930 static memcached_return_t
read_through_trigger(memcached_st
*memc
,
933 memcached_result_st
*result
)
935 (void)memc
;(void)key
;(void)key_length
;
936 return memcached_result_set_value(result
, READ_THROUGH_VALUE
, strlen(READ_THROUGH_VALUE
));
939 #ifndef __INTEL_COMPILER
940 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
943 static test_return_t
read_through(memcached_st
*memc
)
945 memcached_return_t rc
;
946 const char *key
= "foo";
948 size_t string_length
;
950 memcached_trigger_key_fn cb
= (memcached_trigger_key_fn
)read_through_trigger
;
952 string
= memcached_get(memc
, key
, strlen(key
),
953 &string_length
, &flags
, &rc
);
955 test_compare(MEMCACHED_NOTFOUND
, rc
);
956 test_false(string_length
);
959 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_GET_FAILURE
, *(void **)&cb
);
960 test_compare(MEMCACHED_SUCCESS
, rc
);
962 string
= memcached_get(memc
, key
, strlen(key
),
963 &string_length
, &flags
, &rc
);
965 test_compare(MEMCACHED_SUCCESS
, rc
);
966 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
967 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
968 test_strcmp(READ_THROUGH_VALUE
, string
);
971 string
= memcached_get(memc
, key
, strlen(key
),
972 &string_length
, &flags
, &rc
);
974 test_compare(MEMCACHED_SUCCESS
, rc
);
976 test_compare(string_length
, sizeof(READ_THROUGH_VALUE
) -1);
977 test_true(string
[sizeof(READ_THROUGH_VALUE
) -1] == 0);
978 test_strcmp(READ_THROUGH_VALUE
, string
);
984 static memcached_return_t
delete_trigger(memcached_st
*,
991 return MEMCACHED_SUCCESS
;
994 static test_return_t
delete_through(memcached_st
*memc
)
996 memcached_trigger_delete_key_fn callback
;
998 callback
= (memcached_trigger_delete_key_fn
)delete_trigger
;
1000 test_compare(MEMCACHED_SUCCESS
,
1001 memcached_callback_set(memc
, MEMCACHED_CALLBACK_DELETE_TRIGGER
, *(void**)&callback
));
1003 return TEST_SUCCESS
;
1006 static test_return_t
get_test(memcached_st
*memc
)
1008 memcached_return_t rc
;
1009 const char *key
= "foo";
1011 size_t string_length
;
1014 uint64_t query_id
= memcached_query_id(memc
);
1015 rc
= memcached_delete(memc
, key
, strlen(key
), (time_t)0);
1016 test_true(rc
== MEMCACHED_BUFFERED
|| rc
== MEMCACHED_NOTFOUND
);
1017 test_compare(query_id
+1, memcached_query_id(memc
));
1019 string
= memcached_get(memc
, key
, strlen(key
),
1020 &string_length
, &flags
, &rc
);
1022 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1023 test_false(string_length
);
1026 return TEST_SUCCESS
;
1029 static test_return_t
get_test2(memcached_st
*memc
)
1031 const char *key
= "foo";
1032 const char *value
= "when we sanitize";
1034 uint64_t query_id
= memcached_query_id(memc
);
1035 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1036 value
, strlen(value
),
1037 (time_t)0, (uint32_t)0);
1038 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1039 test_compare(query_id
+1, memcached_query_id(memc
));
1041 query_id
= memcached_query_id(memc
);
1042 test_true(query_id
);
1045 size_t string_length
;
1046 char *string
= memcached_get(memc
, key
, strlen(key
),
1047 &string_length
, &flags
, &rc
);
1048 test_compare(query_id
+1, memcached_query_id(memc
));
1050 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1051 test_compare_got(MEMCACHED_SUCCESS
, memcached_last_error(memc
), memcached_last_error_message(memc
));
1053 test_compare(strlen(value
), string_length
);
1054 test_memcmp(string
, value
, string_length
);
1058 return TEST_SUCCESS
;
1061 static test_return_t
set_test2(memcached_st
*memc
)
1063 const char *key
= "foo";
1064 const char *value
= "train in the brain";
1065 size_t value_length
= strlen(value
);
1067 for (uint32_t x
= 0; x
< 10; x
++)
1069 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1070 value
, value_length
,
1071 (time_t)0, (uint32_t)0);
1072 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1075 return TEST_SUCCESS
;
1078 static test_return_t
set_test3(memcached_st
*memc
)
1080 size_t value_length
= 8191;
1082 char *value
= (char*)malloc(value_length
);
1085 for (uint32_t x
= 0; x
< value_length
; x
++)
1087 value
[x
] = (char) (x
% 127);
1090 /* The dump test relies on there being at least 32 items in memcached */
1091 for (uint32_t x
= 0; x
< 32; x
++)
1095 snprintf(key
, sizeof(key
), "foo%u", x
);
1097 uint64_t query_id
= memcached_query_id(memc
);
1098 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1099 value
, value_length
,
1100 (time_t)0, (uint32_t)0);
1101 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1102 test_compare(query_id
+1, memcached_query_id(memc
));
1107 return TEST_SUCCESS
;
1110 static test_return_t
get_test3(memcached_st
*memc
)
1112 const char *key
= "foo";
1113 size_t value_length
= 8191;
1115 char *value
= (char*)malloc(value_length
);
1118 for (uint32_t x
= 0; x
< value_length
; x
++)
1120 value
[x
] = (char) (x
% 127);
1123 memcached_return_t rc
;
1124 rc
= memcached_set(memc
, key
, strlen(key
),
1125 value
, value_length
,
1126 (time_t)0, (uint32_t)0);
1127 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1129 size_t string_length
;
1131 char *string
= memcached_get(memc
, key
, strlen(key
),
1132 &string_length
, &flags
, &rc
);
1134 test_compare(MEMCACHED_SUCCESS
, rc
);
1136 test_compare(string_length
, value_length
);
1137 test_memcmp(string
, value
, string_length
);
1142 return TEST_SUCCESS
;
1145 static test_return_t
get_test4(memcached_st
*memc
)
1147 const char *key
= "foo";
1148 size_t value_length
= 8191;
1150 char *value
= (char*)malloc(value_length
);
1153 for (uint32_t x
= 0; x
< value_length
; x
++)
1155 value
[x
] = (char) (x
% 127);
1158 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1159 value
, value_length
,
1160 (time_t)0, (uint32_t)0);
1161 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1163 for (uint32_t x
= 0; x
< 10; x
++)
1166 size_t string_length
;
1167 char *string
= memcached_get(memc
, key
, strlen(key
),
1168 &string_length
, &flags
, &rc
);
1170 test_compare(MEMCACHED_SUCCESS
, rc
);
1172 test_compare(string_length
, value_length
);
1173 test_memcmp(string
, value
, string_length
);
1179 return TEST_SUCCESS
;
1183 * This test verifies that memcached_read_one_response doesn't try to
1184 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1185 * responses before you execute a storage command.
1187 static test_return_t
get_test5(memcached_st
*memc
)
1190 ** Request the same key twice, to ensure that we hash to the same server
1191 ** (so that we have multiple response values queued up) ;-)
1193 const char *keys
[]= { "key", "key" };
1194 size_t lengths
[]= { 3, 3 };
1198 memcached_return_t rc
= memcached_set(memc
, keys
[0], lengths
[0],
1199 keys
[0], lengths
[0], 0, 0);
1200 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1202 memcached_result_st results_obj
;
1203 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
1206 results
= memcached_fetch_result(memc
, &results_obj
, &rc
);
1209 memcached_result_free(&results_obj
);
1211 /* Don't read out the second result, but issue a set instead.. */
1212 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0));
1214 char *val
= memcached_get_by_key(memc
, keys
[0], lengths
[0], "yek", 3,
1215 &rlen
, &flags
, &rc
);
1217 test_compare(MEMCACHED_NOTFOUND
, rc
);
1218 val
= memcached_get(memc
, keys
[0], lengths
[0], &rlen
, &flags
, &rc
);
1220 test_compare(MEMCACHED_SUCCESS
, rc
);
1223 return TEST_SUCCESS
;
1226 static test_return_t
mget_end(memcached_st
*memc
)
1228 const char *keys
[]= { "foo", "foo2" };
1229 size_t lengths
[]= { 3, 4 };
1230 const char *values
[]= { "fjord", "41" };
1232 memcached_return_t rc
;
1235 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1237 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
[x
], lengths
[x
], values
[x
], strlen(values
[x
]), (time_t)0, (uint32_t)0));
1241 size_t string_length
;
1244 // retrieve both via mget
1245 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, keys
, lengths
, test_array_length(keys
)));
1247 char key
[MEMCACHED_MAX_KEY
];
1250 // this should get both
1251 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
1253 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
1255 test_compare(MEMCACHED_SUCCESS
, rc
);
1257 if (key_length
== 4)
1262 test_compare(string_length
, strlen(values
[val
]));
1263 test_true(strncmp(values
[val
], string
, string_length
) == 0);
1267 // this should indicate end
1268 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1269 test_compare(MEMCACHED_END
, rc
);
1273 rc
= memcached_mget(memc
, keys
, lengths
, 1);
1274 test_compare(MEMCACHED_SUCCESS
, rc
);
1276 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1277 test_compare(key_length
, lengths
[0]);
1278 test_true(strncmp(keys
[0], key
, key_length
) == 0);
1279 test_compare(string_length
, strlen(values
[0]));
1280 test_true(strncmp(values
[0], string
, string_length
) == 0);
1281 test_compare(MEMCACHED_SUCCESS
, rc
);
1284 // this should indicate end
1285 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
1286 test_compare(MEMCACHED_END
, rc
);
1289 return TEST_SUCCESS
;
1292 /* Do not copy the style of this code, I just access hosts to testthis function */
1293 static test_return_t
stats_servername_test(memcached_st
*memc
)
1295 memcached_stat_st memc_stat
;
1296 memcached_server_instance_st instance
=
1297 memcached_server_instance_by_position(memc
, 0);
1299 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and memcached_get_sasl_callbacks(memc
))
1301 return TEST_SKIPPED
;
1304 test_compare(MEMCACHED_SUCCESS
, memcached_stat_servername(&memc_stat
, NULL
,
1305 memcached_server_name(instance
),
1306 memcached_server_port(instance
)));
1308 return TEST_SUCCESS
;
1311 static test_return_t
increment_test(memcached_st
*memc
)
1313 uint64_t new_number
;
1315 test_compare(MEMCACHED_SUCCESS
,
1317 test_literal_param("number"),
1318 test_literal_param("0"),
1319 (time_t)0, (uint32_t)0));
1321 test_compare(MEMCACHED_SUCCESS
,
1322 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1323 test_compare(uint64_t(1), new_number
);
1325 test_compare(MEMCACHED_SUCCESS
,
1326 memcached_increment(memc
, test_literal_param("number"), 1, &new_number
));
1327 test_compare(uint64_t(2), new_number
);
1329 return TEST_SUCCESS
;
1332 static test_return_t
increment_with_initial_test(memcached_st
*memc
)
1334 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1336 uint64_t new_number
;
1337 uint64_t initial
= 0;
1339 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
1341 test_compare(MEMCACHED_SUCCESS
,
1342 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1343 test_compare(new_number
, initial
);
1345 test_compare(MEMCACHED_SUCCESS
,
1346 memcached_increment_with_initial(memc
, test_literal_param("number"), 1, initial
, 0, &new_number
));
1347 test_compare(new_number
, (initial
+1));
1349 return TEST_SUCCESS
;
1352 static test_return_t
decrement_test(memcached_st
*memc
)
1354 uint64_t new_number
;
1355 memcached_return_t rc
;
1356 const char *value
= "3";
1358 rc
= memcached_set(memc
,
1359 test_literal_param("number"),
1360 value
, strlen(value
),
1361 (time_t)0, (uint32_t)0);
1362 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1364 test_compare(MEMCACHED_SUCCESS
,
1365 memcached_decrement(memc
,
1366 test_literal_param("number"),
1368 test_compare(uint64_t(2), new_number
);
1370 test_compare(MEMCACHED_SUCCESS
,
1371 memcached_decrement(memc
,
1372 test_literal_param("number"),
1374 test_compare(uint64_t(1), new_number
);
1376 return TEST_SUCCESS
;
1379 static test_return_t
decrement_with_initial_test(memcached_st
*memc
)
1381 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1383 uint64_t new_number
;
1384 uint64_t initial
= 3;
1386 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
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
);
1394 test_compare(MEMCACHED_SUCCESS
,
1395 memcached_decrement_with_initial(memc
,
1396 test_literal_param("number"),
1397 1, initial
, 0, &new_number
));
1398 test_compare(new_number
, (initial
- 1));
1400 return TEST_SUCCESS
;
1403 static test_return_t
increment_by_key_test(memcached_st
*memc
)
1405 uint64_t new_number
;
1406 memcached_return_t rc
;
1407 const char *master_key
= "foo";
1408 const char *key
= "number";
1409 const char *value
= "0";
1411 rc
= memcached_set_by_key(memc
, master_key
, strlen(master_key
),
1413 value
, strlen(value
),
1414 (time_t)0, (uint32_t)0);
1415 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1417 test_compare(MEMCACHED_SUCCESS
,
1418 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1419 test_compare(uint64_t(1), new_number
);
1421 test_compare(MEMCACHED_SUCCESS
,
1422 memcached_increment_by_key(memc
, master_key
, strlen(master_key
), key
, strlen(key
), 1, &new_number
));
1423 test_compare(uint64_t(2), new_number
);
1425 return TEST_SUCCESS
;
1428 static test_return_t
increment_with_initial_by_key_test(memcached_st
*memc
)
1430 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1432 uint64_t new_number
;
1433 memcached_return_t rc
;
1434 const char *master_key
= "foo";
1435 const char *key
= "number";
1436 uint64_t initial
= 0;
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
);
1444 rc
= memcached_increment_with_initial_by_key(memc
, master_key
, strlen(master_key
),
1446 1, initial
, 0, &new_number
);
1447 test_compare(MEMCACHED_SUCCESS
, rc
);
1448 test_compare(new_number
, (initial
+1));
1450 return TEST_SUCCESS
;
1453 static test_return_t
decrement_by_key_test(memcached_st
*memc
)
1455 uint64_t new_number
;
1456 memcached_return_t rc
;
1457 const char *value
= "3";
1459 rc
= memcached_set_by_key(memc
,
1460 test_literal_param("foo"),
1461 test_literal_param("number"),
1462 value
, strlen(value
),
1463 (time_t)0, (uint32_t)0);
1464 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1466 test_compare(MEMCACHED_SUCCESS
,
1467 memcached_decrement_by_key(memc
,
1468 test_literal_param("foo"),
1469 test_literal_param("number"),
1471 test_compare(uint64_t(2), new_number
);
1473 test_compare(MEMCACHED_SUCCESS
,
1474 memcached_decrement_by_key(memc
,
1475 test_literal_param("foo"),
1476 test_literal_param("number"),
1478 test_compare(uint64_t(1), new_number
);
1480 return TEST_SUCCESS
;
1483 static test_return_t
decrement_with_initial_by_key_test(memcached_st
*memc
)
1485 test_skip(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
1487 uint64_t new_number
;
1488 uint64_t initial
= 3;
1490 test_compare(MEMCACHED_SUCCESS
,
1491 memcached_decrement_with_initial_by_key(memc
,
1492 test_literal_param("foo"),
1493 test_literal_param("number"),
1494 1, initial
, 0, &new_number
));
1495 test_compare(new_number
, initial
);
1497 test_compare(MEMCACHED_SUCCESS
,
1498 memcached_decrement_with_initial_by_key(memc
,
1499 test_literal_param("foo"),
1500 test_literal_param("number"),
1501 1, initial
, 0, &new_number
));
1502 test_compare(new_number
, (initial
- 1));
1504 return TEST_SUCCESS
;
1506 static test_return_t
binary_increment_with_prefix_test(memcached_st
*orig_memc
)
1508 memcached_st
*memc
= memcached_clone(NULL
, orig_memc
);
1510 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1512 test_compare(MEMCACHED_SUCCESS
, memcached_callback_set(memc
, MEMCACHED_CALLBACK_PREFIX_KEY
, (void *)"namespace:"));
1514 memcached_return_t rc
;
1515 rc
= memcached_set(memc
,
1516 test_literal_param("number"),
1517 test_literal_param("0"),
1518 (time_t)0, (uint32_t)0);
1519 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1521 uint64_t new_number
;
1522 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1523 test_literal_param("number"),
1525 test_compare(uint64_t(1), new_number
);
1527 test_compare(MEMCACHED_SUCCESS
, memcached_increment(memc
,
1528 test_literal_param("number"),
1530 test_compare(uint64_t(2), new_number
);
1531 memcached_free(memc
);
1533 return TEST_SUCCESS
;
1536 static test_return_t
quit_test(memcached_st
*memc
)
1538 memcached_return_t rc
;
1539 const char *key
= "fudge";
1540 const char *value
= "sanford and sun";
1542 rc
= memcached_set(memc
, key
, strlen(key
),
1543 value
, strlen(value
),
1544 (time_t)10, (uint32_t)3);
1545 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1546 memcached_quit(memc
);
1548 rc
= memcached_set(memc
, key
, strlen(key
),
1549 value
, strlen(value
),
1550 (time_t)50, (uint32_t)9);
1551 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1553 return TEST_SUCCESS
;
1556 static test_return_t
mget_result_test(memcached_st
*memc
)
1558 const char *keys
[]= {"fudge", "son", "food"};
1559 size_t key_length
[]= {5, 3, 4};
1561 memcached_result_st results_obj
;
1562 memcached_result_st
*results
;
1564 results
= memcached_result_create(memc
, &results_obj
);
1566 test_true(&results_obj
== results
);
1568 /* We need to empty the server before continueing test */
1569 test_compare(MEMCACHED_SUCCESS
,
1570 memcached_flush(memc
, 0));
1572 test_compare(MEMCACHED_SUCCESS
,
1573 memcached_mget(memc
, keys
, key_length
, 3));
1575 memcached_return_t rc
;
1576 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1581 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
1582 test_false(results
);
1583 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1585 for (uint32_t x
= 0; x
< 3; x
++)
1587 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1588 keys
[x
], key_length
[x
],
1589 (time_t)50, (uint32_t)9);
1590 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1593 test_compare(MEMCACHED_SUCCESS
,
1594 memcached_mget(memc
, keys
, key_length
, 3));
1596 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
1599 test_true(&results_obj
== results
);
1600 test_compare(MEMCACHED_SUCCESS
, rc
);
1601 test_memcmp(memcached_result_key_value(results
),
1602 memcached_result_value(results
),
1603 memcached_result_length(results
));
1604 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1607 memcached_result_free(&results_obj
);
1609 return TEST_SUCCESS
;
1612 static test_return_t
mget_result_alloc_test(memcached_st
*memc
)
1614 const char *keys
[]= {"fudge", "son", "food"};
1615 size_t key_length
[]= {5, 3, 4};
1617 memcached_result_st
*results
;
1619 /* We need to empty the server before continueing test */
1620 test_compare(MEMCACHED_SUCCESS
,
1621 memcached_flush(memc
, 0));
1623 test_compare(MEMCACHED_SUCCESS
,
1624 memcached_mget(memc
, keys
, key_length
, 3));
1626 memcached_return_t rc
;
1627 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1631 test_false(results
);
1632 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1634 for (uint32_t x
= 0; x
< 3; x
++)
1636 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1637 keys
[x
], key_length
[x
],
1638 (time_t)50, (uint32_t)9);
1639 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1642 test_compare(MEMCACHED_SUCCESS
,
1643 memcached_mget(memc
, keys
, key_length
, 3));
1646 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
1649 test_compare(MEMCACHED_SUCCESS
, rc
);
1650 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
1651 test_memcmp(memcached_result_key_value(results
),
1652 memcached_result_value(results
),
1653 memcached_result_length(results
));
1654 memcached_result_free(results
);
1658 return TEST_SUCCESS
;
1661 /* Count the results */
1662 static memcached_return_t
callback_counter(const memcached_st
*, memcached_result_st
*, void *context
)
1664 size_t *counter
= (size_t *)context
;
1666 *counter
= *counter
+ 1;
1668 return MEMCACHED_SUCCESS
;
1671 static test_return_t
mget_result_function(memcached_st
*memc
)
1673 const char *keys
[]= {"fudge", "son", "food"};
1674 size_t key_length
[]= {5, 3, 4};
1676 memcached_execute_fn callbacks
[1];
1678 /* We need to empty the server before continueing test */
1679 test_compare(MEMCACHED_SUCCESS
,
1680 memcached_flush(memc
, 0));
1681 for (uint32_t x
= 0; x
< 3; x
++)
1683 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1684 keys
[x
], key_length
[x
],
1685 (time_t)50, (uint32_t)9);
1686 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1689 test_compare(MEMCACHED_SUCCESS
,
1690 memcached_mget(memc
, keys
, key_length
, 3));
1692 callbacks
[0]= &callback_counter
;
1695 test_compare(MEMCACHED_SUCCESS
,
1696 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1698 test_compare(size_t(3), counter
);
1700 return TEST_SUCCESS
;
1703 static test_return_t
mget_test(memcached_st
*memc
)
1705 const char *keys
[]= {"fudge", "son", "food"};
1706 size_t key_length
[]= {5, 3, 4};
1708 char return_key
[MEMCACHED_MAX_KEY
];
1709 size_t return_key_length
;
1711 size_t return_value_length
;
1713 /* We need to empty the server before continueing test */
1714 test_compare(MEMCACHED_SUCCESS
,
1715 memcached_flush(memc
, 0));
1717 test_compare(MEMCACHED_SUCCESS
,
1718 memcached_mget(memc
, keys
, key_length
, 3));
1721 memcached_return_t rc
;
1722 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1723 &return_value_length
, &flags
, &rc
)))
1725 test_true(return_value
);
1727 test_false(return_value
);
1728 test_zero(return_value_length
);
1729 test_compare(MEMCACHED_NOTFOUND
, rc
);
1731 for (uint32_t x
= 0; x
< 3; x
++)
1733 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
1734 keys
[x
], key_length
[x
],
1735 (time_t)50, (uint32_t)9);
1736 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1738 test_compare(MEMCACHED_SUCCESS
,
1739 memcached_mget(memc
, keys
, key_length
, 3));
1742 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1743 &return_value_length
, &flags
, &rc
)))
1745 test_true(return_value
);
1746 test_compare(MEMCACHED_SUCCESS
, rc
);
1747 if (not memc
->_namespace
)
1749 test_compare(return_key_length
, return_value_length
);
1750 test_memcmp(return_value
, return_key
, return_value_length
);
1756 return TEST_SUCCESS
;
1759 static test_return_t
mget_execute(memcached_st
*memc
)
1763 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) != 0)
1767 * I only want to hit _one_ server so I know the number of requests I'm
1768 * sending in the pipeline.
1770 uint32_t number_of_hosts
= memc
->number_of_hosts
;
1771 memc
->number_of_hosts
= 1;
1773 size_t max_keys
= 20480;
1776 char **keys
= static_cast<char **>(calloc(max_keys
, sizeof(char*)));
1777 size_t *key_length
=static_cast<size_t *>(calloc(max_keys
, sizeof(size_t)));
1779 /* First add all of the items.. */
1780 char blob
[1024] = {0};
1781 memcached_return_t rc
;
1783 for (size_t x
= 0; x
< max_keys
; ++x
)
1787 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
1789 test_true(keys
[x
] != NULL
);
1790 uint64_t query_id
= memcached_query_id(memc
);
1791 rc
= memcached_add(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
1792 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
1793 test_compare(query_id
+1, memcached_query_id(memc
));
1796 /* Try to get all of them with a large multiget */
1798 memcached_execute_fn callbacks
[]= { &callback_counter
};
1799 rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
1800 max_keys
, callbacks
, &counter
, 1);
1802 if (memcached_success(rc
))
1805 uint64_t query_id
= memcached_query_id(memc
);
1806 test_compare(MEMCACHED_SUCCESS
,
1807 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
1808 test_compare(query_id
, memcached_query_id(memc
));
1810 /* Verify that we got all of the items */
1811 test_true(counter
== max_keys
);
1813 else if (rc
== MEMCACHED_NOT_SUPPORTED
)
1815 test_true(counter
== 0);
1819 test_fail("note: this test functions differently when in binary mode");
1822 /* Release all allocated resources */
1823 for (size_t x
= 0; x
< max_keys
; ++x
)
1830 memc
->number_of_hosts
= number_of_hosts
;
1831 return TEST_SUCCESS
;
1834 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1836 static test_return_t
key_setup(memcached_st
*memc
)
1838 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1840 global_pairs
= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT
, 0);
1842 return TEST_SUCCESS
;
1845 static test_return_t
key_teardown(memcached_st
*memc
)
1848 pairs_free(global_pairs
);
1850 return TEST_SUCCESS
;
1853 static test_return_t
block_add_regression(memcached_st
*memc
)
1855 /* First add all of the items.. */
1856 for (size_t x
= 0; x
< REGRESSION_BINARY_VS_BLOCK_COUNT
; ++x
)
1858 memcached_return_t rc
;
1859 char blob
[1024] = {0};
1861 rc
= memcached_add_by_key(memc
, "bob", 3, global_pairs
[x
].key
, global_pairs
[x
].key_length
, blob
, sizeof(blob
), 0, 0);
1862 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1865 return TEST_SUCCESS
;
1868 static test_return_t
binary_add_regression(memcached_st
*memc
)
1870 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
1871 test_return_t rc
= block_add_regression(memc
);
1872 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 0);
1876 static test_return_t
get_stats_keys(memcached_st
*memc
)
1880 memcached_stat_st memc_stat
;
1881 memcached_return_t rc
;
1883 stat_list
= memcached_stat_get_keys(memc
, &memc_stat
, &rc
);
1884 test_compare(MEMCACHED_SUCCESS
, rc
);
1885 for (ptr
= stat_list
; *ptr
; ptr
++)
1890 return TEST_SUCCESS
;
1893 static test_return_t
version_string_test(memcached_st
*memc
)
1895 const char *version_string
;
1898 version_string
= memcached_lib_version();
1900 test_strcmp(version_string
, LIBMEMCACHED_VERSION_STRING
);
1902 return TEST_SUCCESS
;
1905 static test_return_t
get_stats(memcached_st
*memc
)
1907 memcached_return_t rc
;
1909 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1910 test_compare(MEMCACHED_SUCCESS
, rc
);
1911 test_true(memc_stat
);
1913 for (uint32_t x
= 0; x
< memcached_server_count(memc
); x
++)
1915 char **stat_list
= memcached_stat_get_keys(memc
, memc_stat
+x
, &rc
);
1916 test_compare(MEMCACHED_SUCCESS
, rc
);
1917 for (char **ptr
= stat_list
; *ptr
; ptr
++) {};
1922 memcached_stat_free(NULL
, memc_stat
);
1924 return TEST_SUCCESS
;
1927 static test_return_t
add_host_test(memcached_st
*memc
)
1930 memcached_server_st
*servers
;
1931 memcached_return_t rc
;
1932 char servername
[]= "0.example.com";
1934 servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
1936 test_true(1 == memcached_server_list_count(servers
));
1938 for (x
= 2; x
< 20; x
++)
1940 char buffer
[SMALL_STRING_LEN
];
1942 snprintf(buffer
, SMALL_STRING_LEN
, "%u.example.com", 400+x
);
1943 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
1945 test_compare(MEMCACHED_SUCCESS
, rc
);
1946 test_true(x
== memcached_server_list_count(servers
));
1949 rc
= memcached_server_push(memc
, servers
);
1950 test_compare(MEMCACHED_SUCCESS
, rc
);
1951 rc
= memcached_server_push(memc
, servers
);
1952 test_compare(MEMCACHED_SUCCESS
, rc
);
1954 memcached_server_list_free(servers
);
1956 return TEST_SUCCESS
;
1959 static test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
1961 memcached_return_t rc
;
1962 const char *key
= "not_found";
1963 size_t key_len
= strlen(key
);
1965 test_compare(MEMCACHED_SUCCESS
,
1966 memcached_mget(memc
, &key
, &key_len
, 1));
1968 memcached_result_st
*result
= NULL
;
1969 result
= memcached_fetch_result(memc
, result
, &rc
);
1971 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
1973 memcached_result_free(result
);
1975 return TEST_SUCCESS
;
1978 static memcached_return_t
clone_test_callback(memcached_st
*parent
, memcached_st
*memc_clone
)
1980 (void)parent
;(void)memc_clone
;
1981 return MEMCACHED_SUCCESS
;
1984 static memcached_return_t
cleanup_test_callback(memcached_st
*ptr
)
1987 return MEMCACHED_SUCCESS
;
1990 static test_return_t
callback_test(memcached_st
*memc
)
1992 /* Test User Data */
1996 memcached_return_t rc
;
1998 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_USER_DATA
, &x
);
1999 test_compare(MEMCACHED_SUCCESS
, rc
);
2000 test_ptr
= (int *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_USER_DATA
, &rc
);
2001 test_true(*test_ptr
== x
);
2004 /* Test Clone Callback */
2006 memcached_clone_fn clone_cb
= (memcached_clone_fn
)clone_test_callback
;
2007 void *clone_cb_ptr
= *(void **)&clone_cb
;
2008 void *temp_function
= NULL
;
2009 memcached_return_t rc
;
2011 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2013 test_compare(MEMCACHED_SUCCESS
, rc
);
2014 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2015 test_true(temp_function
== clone_cb_ptr
);
2018 /* Test Cleanup Callback */
2020 memcached_cleanup_fn cleanup_cb
=
2021 (memcached_cleanup_fn
)cleanup_test_callback
;
2022 void *cleanup_cb_ptr
= *(void **)&cleanup_cb
;
2023 void *temp_function
= NULL
;
2024 memcached_return_t rc
;
2026 rc
= memcached_callback_set(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
,
2028 test_compare(MEMCACHED_SUCCESS
, rc
);
2029 temp_function
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_CLONE_FUNCTION
, &rc
);
2030 test_true(temp_function
== cleanup_cb_ptr
);
2033 return TEST_SUCCESS
;
2036 /* We don't test the behavior itself, we test the switches */
2037 static test_return_t
behavior_test(memcached_st
*memc
)
2042 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2043 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2044 test_true(value
== 1);
2046 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2047 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2048 test_true(value
== 1);
2050 set
= MEMCACHED_HASH_MD5
;
2051 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2052 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2053 test_true(value
== MEMCACHED_HASH_MD5
);
2057 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2058 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
);
2059 test_true(value
== 0);
2061 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2062 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
);
2063 test_true(value
== 0);
2065 set
= MEMCACHED_HASH_DEFAULT
;
2066 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2067 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2068 test_true(value
== MEMCACHED_HASH_DEFAULT
);
2070 set
= MEMCACHED_HASH_CRC
;
2071 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, set
);
2072 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
2073 test_true(value
== MEMCACHED_HASH_CRC
);
2075 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2076 test_true(value
> 0);
2078 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2079 test_true(value
> 0);
2081 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
2082 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+ 1);
2083 test_true((value
+ 1) == memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
2085 return TEST_SUCCESS
;
2088 static test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
2090 memcached_return_t rc
;
2093 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
);
2094 test_true(rc
== MEMCACHED_DEPRECATED
);
2096 // Platform dependent
2098 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
2102 return TEST_SUCCESS
;
2106 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
2108 memcached_return_t rc
;
2112 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, set
);
2113 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2115 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
2117 if (rc
== MEMCACHED_SUCCESS
)
2119 test_true((bool)value
== set
);
2123 test_false((bool)value
== set
);
2126 return TEST_SUCCESS
;
2130 static test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
2132 memcached_return_t rc
;
2136 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, set
);
2137 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
2139 value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
2141 if (rc
== MEMCACHED_SUCCESS
)
2143 test_true((bool)value
== set
);
2147 test_false((bool)value
== set
);
2150 return TEST_SUCCESS
;
2153 static test_return_t
fetch_all_results(memcached_st
*memc
, unsigned int &keys_returned
, const memcached_return_t expect
)
2155 memcached_return_t rc
;
2156 char return_key
[MEMCACHED_MAX_KEY
];
2157 size_t return_key_length
;
2159 size_t return_value_length
;
2163 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2164 &return_value_length
, &flags
, &rc
)))
2166 test_true(return_value
);
2167 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
2172 if (memcached_success(expect
) and memcached_success(rc
))
2174 return TEST_SUCCESS
;
2176 else if (expect
== rc
)
2178 return TEST_SUCCESS
;
2180 fprintf(stderr
, "\n%s:%u %s(#%u)\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
), keys_returned
);
2182 return TEST_FAILURE
;
2185 /* Test case provided by Cal Haldenbrand */
2186 #define HALDENBRAND_KEY_COUNT 3000U // * 1024576
2187 #define HALDENBRAND_FLAG_KEY 99 // * 1024576
2188 static test_return_t
user_supplied_bug1(memcached_st
*memc
)
2190 /* We just keep looking at the same values over and over */
2193 unsigned int setter
= 1;
2194 test_compare(MEMCACHED_SUCCESS
,
2195 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2196 test_compare(MEMCACHED_SUCCESS
,
2197 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2201 unsigned long long total
= 0;
2202 for (uint32_t x
= 0 ; total
< 20 * 1024576 ; x
++ )
2204 uint32_t size
= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2205 char randomstuff
[6 * 1024];
2206 memset(randomstuff
, 0, 6 * 1024);
2207 test_true(size
< 6 * 1024); /* Being safe here */
2209 for (uint32_t j
= 0 ; j
< size
;j
++)
2211 randomstuff
[j
] = (signed char) ((rand() % 26) + 97);
2216 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2217 test_compare(MEMCACHED_SUCCESS
,
2218 memcached_set(memc
, key
, key_length
, randomstuff
, strlen(randomstuff
), time_t(0), HALDENBRAND_FLAG_KEY
));
2220 test_true(total
> HALDENBRAND_KEY_COUNT
);
2222 return TEST_SUCCESS
;
2225 /* Test case provided by Cal Haldenbrand */
2226 static test_return_t
user_supplied_bug2(memcached_st
*memc
)
2228 unsigned int setter
= 1;
2230 test_compare(MEMCACHED_SUCCESS
,
2231 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
));
2233 test_compare(MEMCACHED_SUCCESS
,
2234 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
));
2237 setter
= 20 * 1024576;
2238 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2239 setter
= 20 * 1024576;
2240 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2241 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2242 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2244 for (x
= 0, errors
= 0; total
< 20 * 1024576 ; x
++)
2247 size_t total_value_length
= 0;
2248 for (uint32_t x
= 0, errors
= 0; total_value_length
< 24576 ; x
++)
2253 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2254 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2256 memcached_return_t rc
;
2257 char *getval
= memcached_get(memc
, key
, key_length
, &val_len
, &flags
, &rc
);
2258 if (memcached_failed(rc
))
2260 if (rc
== MEMCACHED_NOTFOUND
)
2271 test_compare(uint32_t(HALDENBRAND_FLAG_KEY
), flags
);
2273 total_value_length
+= val_len
;
2278 return TEST_SUCCESS
;
2281 /* Do a large mget() over all the keys we think exist */
2282 static test_return_t
user_supplied_bug3(memcached_st
*memc
)
2284 unsigned int setter
= 1;
2285 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, setter
);
2286 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, setter
);
2288 setter
= 20 * 1024576;
2289 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
, setter
);
2290 setter
= 20 * 1024576;
2291 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
, setter
);
2292 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
);
2293 getter
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
);
2296 size_t key_lengths
[HALDENBRAND_KEY_COUNT
];
2297 char **keys
= static_cast<char **>(calloc(HALDENBRAND_KEY_COUNT
, sizeof(char *)));
2299 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2301 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
2302 int key_length
= snprintf(key
, sizeof(key
), "%u", x
);
2303 keys
[x
]= strdup(key
);
2305 key_lengths
[x
]= key_length
;
2306 test_compare(size_t(key_length
), strlen(keys
[x
]));
2309 test_compare(MEMCACHED_SUCCESS
,
2310 memcached_mget(memc
, (const char **)keys
, key_lengths
, HALDENBRAND_KEY_COUNT
));
2312 unsigned int keys_returned
;
2313 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
2314 test_compare(HALDENBRAND_KEY_COUNT
, keys_returned
);
2316 for (uint32_t x
= 0; x
< HALDENBRAND_KEY_COUNT
; x
++)
2322 return TEST_SUCCESS
;
2325 /* Make sure we behave properly if server list has no values */
2326 static test_return_t
user_supplied_bug4(memcached_st
*memc
)
2328 const char *keys
[]= {"fudge", "son", "food"};
2329 size_t key_length
[]= {5, 3, 4};
2331 /* Here we free everything before running a bunch of mget tests */
2332 memcached_servers_reset(memc
);
2335 /* We need to empty the server before continueing test */
2336 test_compare(MEMCACHED_NO_SERVERS
,
2337 memcached_flush(memc
, 0));
2339 test_compare(MEMCACHED_NO_SERVERS
,
2340 memcached_mget(memc
, keys
, key_length
, 3));
2342 unsigned int keys_returned
;
2343 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_NOTFOUND
));
2344 test_zero(keys_returned
);
2346 for (uint32_t x
= 0; x
< 3; x
++)
2348 test_compare(MEMCACHED_NO_SERVERS
,
2349 memcached_set(memc
, keys
[x
], key_length
[x
],
2350 keys
[x
], key_length
[x
],
2351 (time_t)50, (uint32_t)9));
2354 test_compare(MEMCACHED_NO_SERVERS
,
2355 memcached_mget(memc
, keys
, key_length
, 3));
2359 char return_key
[MEMCACHED_MAX_KEY
];
2360 memcached_return_t rc
;
2361 size_t return_key_length
;
2362 size_t return_value_length
;
2365 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2366 &return_value_length
, &flags
, &rc
)))
2368 test_true(return_value
);
2369 test_compare(MEMCACHED_SUCCESS
, rc
);
2370 test_true(return_key_length
== return_value_length
);
2371 test_memcmp(return_value
, return_key
, return_value_length
);
2377 return TEST_SUCCESS
;
2380 #define VALUE_SIZE_BUG5 1048064
2381 static test_return_t
user_supplied_bug5(memcached_st
*memc
)
2383 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2384 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2386 size_t value_length
;
2388 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2390 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2392 insert_data
[x
]= (signed char)rand();
2395 test_compare(MEMCACHED_SUCCESS
,
2396 memcached_flush(memc
, 0));
2398 memcached_return_t rc
;
2399 value
= memcached_get(memc
, keys
[0], key_length
[0],
2400 &value_length
, &flags
, &rc
);
2402 test_compare(MEMCACHED_SUCCESS
,
2403 memcached_mget(memc
, keys
, key_length
, 4));
2406 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_NOTFOUND
));
2409 for (uint32_t x
= 0; x
< 4; x
++)
2411 test_compare(MEMCACHED_SUCCESS
,
2412 memcached_set(memc
, keys
[x
], key_length
[x
],
2413 insert_data
, VALUE_SIZE_BUG5
,
2414 (time_t)0, (uint32_t)0));
2417 for (uint32_t x
= 0; x
< 10; x
++)
2419 value
= memcached_get(memc
, keys
[0], key_length
[0],
2420 &value_length
, &flags
, &rc
);
2421 test_compare(rc
, MEMCACHED_SUCCESS
);
2425 test_compare(MEMCACHED_SUCCESS
,
2426 memcached_mget(memc
, keys
, key_length
, 4));
2428 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, MEMCACHED_SUCCESS
));
2429 test_compare(4U, count
);
2431 delete [] insert_data
;
2433 return TEST_SUCCESS
;
2436 static test_return_t
user_supplied_bug6(memcached_st
*memc
)
2438 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2439 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2440 char return_key
[MEMCACHED_MAX_KEY
];
2441 size_t return_key_length
;
2443 size_t value_length
;
2445 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2447 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2449 insert_data
[x
]= (signed char)rand();
2452 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
2454 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
2456 // We will now confirm that memcached_mget() returns success, but we will
2457 // then check to make sure that no actual keys are returned.
2458 test_compare(MEMCACHED_SUCCESS
,
2459 memcached_mget(memc
, keys
, key_length
, 4));
2461 memcached_return_t rc
;
2463 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2464 &value_length
, &flags
, &rc
)))
2469 test_compare_got(MEMCACHED_NOTFOUND
, rc
, memcached_strerror(NULL
, rc
));
2471 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
2473 test_compare(MEMCACHED_SUCCESS
,
2474 memcached_set(memc
, keys
[x
], key_length
[x
],
2475 insert_data
, VALUE_SIZE_BUG5
,
2476 (time_t)0, (uint32_t)0));
2478 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
2480 for (uint32_t x
= 0; x
< 2; x
++)
2482 value
= memcached_get(memc
, keys
[0], key_length
[0],
2483 &value_length
, &flags
, &rc
);
2487 test_compare(MEMCACHED_SUCCESS
,
2488 memcached_mget(memc
, keys
, key_length
, 4));
2489 /* We test for purge of partial complete fetches */
2490 for (count
= 3; count
; count
--)
2492 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2493 &value_length
, &flags
, &rc
);
2494 test_compare(MEMCACHED_SUCCESS
, rc
);
2495 test_memcmp(value
, insert_data
, value_length
);
2496 test_true(value_length
);
2500 delete [] insert_data
;
2502 return TEST_SUCCESS
;
2505 static test_return_t
user_supplied_bug8(memcached_st
*)
2507 memcached_return_t rc
;
2509 memcached_st
*memc_clone
;
2511 memcached_server_st
*servers
;
2512 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";
2514 servers
= memcached_servers_parse(server_list
);
2517 mine
= memcached_create(NULL
);
2518 rc
= memcached_server_push(mine
, servers
);
2519 test_compare(MEMCACHED_SUCCESS
, rc
);
2520 memcached_server_list_free(servers
);
2523 memc_clone
= memcached_clone(NULL
, mine
);
2525 memcached_quit(mine
);
2526 memcached_quit(memc_clone
);
2529 memcached_free(mine
);
2530 memcached_free(memc_clone
);
2532 return TEST_SUCCESS
;
2535 /* Test flag store/retrieve */
2536 static test_return_t
user_supplied_bug7(memcached_st
*memc
)
2538 const char *keys
= "036790384900";
2539 size_t key_length
= strlen(keys
);
2540 char return_key
[MEMCACHED_MAX_KEY
];
2541 size_t return_key_length
;
2543 size_t value_length
;
2545 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
2547 for (unsigned int x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
2548 insert_data
[x
]= (signed char)rand();
2550 memcached_flush(memc
, 0);
2553 memcached_return_t rc
= memcached_set(memc
, keys
, key_length
,
2554 insert_data
, VALUE_SIZE_BUG5
,
2556 test_compare(MEMCACHED_SUCCESS
, rc
);
2559 value
= memcached_get(memc
, keys
, key_length
,
2560 &value_length
, &flags
, &rc
);
2561 test_true(flags
== 245);
2565 rc
= memcached_mget(memc
, &keys
, &key_length
, 1);
2568 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2569 &value_length
, &flags
, &rc
);
2570 test_compare(uint32_t(245), flags
);
2573 delete [] insert_data
;
2576 return TEST_SUCCESS
;
2579 static test_return_t
user_supplied_bug9(memcached_st
*memc
)
2581 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2582 size_t key_length
[3];
2586 char return_key
[MEMCACHED_MAX_KEY
];
2587 size_t return_key_length
;
2589 size_t return_value_length
;
2592 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
2593 key_length
[1]= strlen("fudge&*@#");
2594 key_length
[2]= strlen("for^#@&$not");
2597 for (unsigned int x
= 0; x
< 3; x
++)
2599 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
2600 keys
[x
], key_length
[x
],
2601 (time_t)50, (uint32_t)9);
2602 test_compare(MEMCACHED_SUCCESS
, rc
);
2605 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
2606 test_compare(MEMCACHED_SUCCESS
, rc
);
2608 /* We need to empty the server before continueing test */
2609 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
2610 &return_value_length
, &flags
, &rc
)) != NULL
)
2612 test_true(return_value
);
2616 test_compare(3U, count
);
2618 return TEST_SUCCESS
;
2621 /* We are testing with aggressive timeout to get failures */
2622 static test_return_t
user_supplied_bug10(memcached_st
*memc
)
2624 size_t value_length
= 512;
2625 unsigned int set
= 1;
2626 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2628 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2629 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2630 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
2632 char *value
= (char*)malloc(value_length
* sizeof(char));
2634 for (unsigned int x
= 0; x
< value_length
; x
++)
2636 value
[x
]= (char) (x
% 127);
2639 for (unsigned int x
= 1; x
<= 100000; ++x
)
2641 memcached_return_t rc
= memcached_set(mclone
,
2642 test_literal_param("foo"),
2643 value
, value_length
, 0, 0);
2645 test_true_got((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
2646 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
),
2647 memcached_strerror(NULL
, rc
));
2649 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
2656 memcached_free(mclone
);
2658 return TEST_SUCCESS
;
2662 We are looking failures in the async protocol
2664 static test_return_t
user_supplied_bug11(memcached_st
*memc
)
2666 const char *key
= "foo";
2667 size_t value_length
= 512;
2669 unsigned int set
= 1;
2670 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
2672 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
2673 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
2674 int32_t timeout
= -1;
2675 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, (size_t)timeout
);
2677 timeout
= (int32_t)memcached_behavior_get(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
);
2679 test_true(timeout
== -1);
2681 char *value
= (char*)malloc(value_length
* sizeof(char));
2683 for (unsigned int x
= 0; x
< value_length
; x
++)
2685 value
[x
]= (char) (x
% 127);
2688 for (unsigned int x
= 1; x
<= 100000; ++x
)
2690 memcached_return_t rc
= memcached_set(mclone
, key
, key_len
,value
, value_length
, 0, 0);
2695 memcached_free(mclone
);
2697 return TEST_SUCCESS
;
2701 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2703 static test_return_t
user_supplied_bug12(memcached_st
*memc
)
2705 memcached_return_t rc
;
2707 size_t value_length
;
2709 uint64_t number_value
;
2711 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2712 &value_length
, &flags
, &rc
);
2713 test_true(value
== NULL
);
2714 test_compare(MEMCACHED_NOTFOUND
, rc
);
2716 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2719 test_true(value
== NULL
);
2720 /* The binary protocol will set the key if it doesn't exist */
2721 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
2723 test_compare(MEMCACHED_SUCCESS
, rc
);
2727 test_compare(MEMCACHED_NOTFOUND
, rc
);
2730 rc
= memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2732 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
2733 &value_length
, &flags
, &rc
);
2735 test_compare(MEMCACHED_SUCCESS
, rc
);
2738 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
2740 test_true(number_value
== 2);
2741 test_compare(MEMCACHED_SUCCESS
, rc
);
2743 return TEST_SUCCESS
;
2747 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2748 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2750 static test_return_t
user_supplied_bug13(memcached_st
*memc
)
2752 char key
[] = "key34567890";
2753 memcached_return_t rc
;
2754 size_t overflowSize
;
2756 char commandFirst
[]= "set key34567890 0 0 ";
2757 char commandLast
[] = " \r\n"; /* first line of command sent to server */
2758 size_t commandLength
;
2761 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
2763 overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
2765 for (testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
2767 char *overflow
= new (std::nothrow
) char[testSize
];
2768 test_true(overflow
);
2770 memset(overflow
, 'x', testSize
);
2771 rc
= memcached_set(memc
, key
, strlen(key
),
2772 overflow
, testSize
, 0, 0);
2773 test_compare(MEMCACHED_SUCCESS
, rc
);
2777 return TEST_SUCCESS
;
2782 Test values of many different sizes
2783 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2784 set key34567890 0 0 8169 \r\n
2785 is sent followed by buffer of size 8169, followed by 8169
2787 static test_return_t
user_supplied_bug14(memcached_st
*memc
)
2789 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
2791 std::vector
<char> value
;
2792 for (size_t x
= 0; x
< 18000; x
++)
2794 value
.push_back((char) (x
% 127));
2797 for (size_t current_length
= 0; current_length
< value
.size(); current_length
++)
2799 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
2800 &value
[0], current_length
,
2801 (time_t)0, (uint32_t)0);
2802 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
2804 size_t string_length
;
2806 char *string
= memcached_get(memc
, test_literal_param("foo"),
2807 &string_length
, &flags
, &rc
);
2809 test_compare(MEMCACHED_SUCCESS
, rc
);
2810 test_compare(string_length
, current_length
);
2811 test_memcmp(string
, &value
[0], string_length
);
2816 return TEST_SUCCESS
;
2820 Look for zero length value problems
2822 static test_return_t
user_supplied_bug15(memcached_st
*memc
)
2824 for (uint32_t x
= 0; x
< 2; x
++)
2826 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2828 (time_t)0, (uint32_t)0);
2830 test_compare(MEMCACHED_SUCCESS
, rc
);
2834 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2835 &length
, &flags
, &rc
);
2837 test_compare(MEMCACHED_SUCCESS
, rc
);
2842 value
= memcached_get(memc
, test_literal_param("mykey"),
2843 &length
, &flags
, &rc
);
2845 test_compare(MEMCACHED_SUCCESS
, rc
);
2846 test_true(value
== NULL
);
2851 return TEST_SUCCESS
;
2854 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2855 static test_return_t
user_supplied_bug16(memcached_st
*memc
)
2857 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
2859 (time_t)0, UINT32_MAX
);
2861 test_compare(MEMCACHED_SUCCESS
, rc
);
2865 char *value
= memcached_get(memc
, test_literal_param("mykey"),
2866 &length
, &flags
, &rc
);
2868 test_compare(MEMCACHED_SUCCESS
, rc
);
2869 test_true(value
== NULL
);
2871 test_compare(flags
, UINT32_MAX
);
2873 return TEST_SUCCESS
;
2876 #if !defined(__sun) && !defined(__OpenBSD__)
2877 /* Check the validity of chinese key*/
2878 static test_return_t
user_supplied_bug17(memcached_st
*memc
)
2880 const char *key
= "豆瓣";
2881 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
2882 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
2883 value
, strlen(value
),
2886 test_compare(MEMCACHED_SUCCESS
, rc
);
2890 char *value2
= memcached_get(memc
, key
, strlen(key
),
2891 &length
, &flags
, &rc
);
2893 test_true(length
==strlen(value
));
2894 test_compare(MEMCACHED_SUCCESS
, rc
);
2895 test_memcmp(value
, value2
, length
);
2898 return TEST_SUCCESS
;
2906 static test_return_t
user_supplied_bug19(memcached_st
*)
2908 memcached_return_t res
;
2910 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2912 const memcached_server_st
*server
= memcached_server_by_key(memc
, "a", 1, &res
);
2915 memcached_free(memc
);
2917 return TEST_SUCCESS
;
2920 /* CAS test from Andei */
2921 static test_return_t
user_supplied_bug20(memcached_st
*memc
)
2923 const char *key
= "abc";
2924 size_t key_len
= strlen("abc");
2926 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
2928 test_compare(MEMCACHED_SUCCESS
,
2930 test_literal_param("abc"),
2931 test_literal_param("foobar"),
2932 (time_t)0, (uint32_t)0));
2934 test_compare(MEMCACHED_SUCCESS
,
2935 memcached_mget(memc
, &key
, &key_len
, 1));
2937 memcached_result_st result_obj
;
2938 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
2941 memcached_result_create(memc
, &result_obj
);
2942 memcached_return_t status
;
2943 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
2946 test_compare(MEMCACHED_SUCCESS
, status
);
2948 memcached_result_free(result
);
2950 return TEST_SUCCESS
;
2953 /* Large mget() of missing keys with binary proto
2955 * If many binary quiet commands (such as getq's in an mget) fill the output
2956 * buffer and the server chooses not to respond, memcached_flush hangs. See
2957 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2960 /* sighandler_t function that always asserts false */
2961 static void fail(int)
2967 static test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
2972 return TEST_SKIPPED
;
2974 void (*oldalarm
)(int);
2976 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
2977 test_true(memc_clone
);
2979 /* only binproto uses getq for mget */
2980 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
2982 /* empty the cache to ensure misses (hence non-responses) */
2983 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
2985 size_t* key_lengths
= new (std::nothrow
) size_t[key_count
];
2986 test_true(key_lengths
);
2987 char **keys
= static_cast<char **>(calloc(key_count
, sizeof(char *)));
2989 for (unsigned int x
= 0; x
< key_count
; x
++)
2993 snprintf(buffer
, 30, "%u", x
);
2994 keys
[x
]= strdup(buffer
);
2996 key_lengths
[x
]= strlen(keys
[x
]);
2999 oldalarm
= signal(SIGALRM
, fail
);
3002 test_compare_got(MEMCACHED_SUCCESS
,
3003 memcached_mget(memc_clone
, (const char **)keys
, key_lengths
, key_count
), memcached_last_error_message(memc_clone
));
3006 signal(SIGALRM
, oldalarm
);
3008 memcached_return_t rc
;
3010 char return_key
[MEMCACHED_MAX_KEY
];
3011 size_t return_key_length
;
3013 size_t return_value_length
;
3014 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
3015 &return_value_length
, &flags
, &rc
)))
3017 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
3019 test_compare(MEMCACHED_NOTFOUND
, rc
);
3020 test_zero(return_value_length
);
3021 test_zero(return_key_length
);
3022 test_false(return_key
[0]);
3023 test_false(return_value
);
3025 for (unsigned int x
= 0; x
< key_count
; x
++)
3030 delete [] key_lengths
;
3032 memcached_free(memc_clone
);
3034 return TEST_SUCCESS
;
3038 static test_return_t
user_supplied_bug21(memcached_st
*memc
)
3040 test_return_t test_rc
;
3041 test_rc
= pre_binary(memc
);
3043 if (test_rc
!= TEST_SUCCESS
)
3048 /* should work as of r580 */
3049 test_compare(TEST_SUCCESS
,
3050 _user_supplied_bug21(memc
, 10));
3052 /* should fail as of r580 */
3053 test_compare(TEST_SUCCESS
,
3054 _user_supplied_bug21(memc
, 1000));
3056 return TEST_SUCCESS
;
3059 static test_return_t
output_ketama_weighted_keys(memcached_st
*)
3061 memcached_st
*memc
= memcached_create(NULL
);
3065 test_compare(MEMCACHED_SUCCESS
,
3066 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, true));
3068 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3069 test_compare(value
, uint64_t(1));
3071 test_compare(MEMCACHED_SUCCESS
,
3072 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3074 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3075 test_true(value
== MEMCACHED_HASH_MD5
);
3078 test_true(memcached_behavior_set_distribution(memc
, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
) == MEMCACHED_SUCCESS
);
3080 memcached_server_st
*server_pool
;
3081 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");
3082 memcached_server_push(memc
, server_pool
);
3084 // @todo this needs to be refactored to actually test something.
3087 if ((fp
= fopen("ketama_keys.txt", "w")))
3091 printf("cannot write to file ketama_keys.txt");
3092 return TEST_FAILURE
;
3095 for (int x
= 0; x
< 10000; x
++)
3098 snprintf(key
, sizeof(key
), "%d", x
);
3100 uint32_t server_idx
= memcached_generate_hash(memc
, key
, strlen(key
));
3101 char *hostname
= memc
->hosts
[server_idx
].hostname
;
3102 in_port_t port
= memc
->hosts
[server_idx
].port
;
3103 fprintf(fp
, "key %s is on host /%s:%u\n", key
, hostname
, port
);
3104 memcached_server_instance_st instance
=
3105 memcached_server_instance_by_position(memc
, host_index
);
3109 memcached_server_list_free(server_pool
);
3110 memcached_free(memc
);
3112 return TEST_SUCCESS
;
3116 static test_return_t
result_static(memcached_st
*memc
)
3118 memcached_result_st result
;
3119 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
3120 test_false(result
.options
.is_allocated
);
3121 test_true(memcached_is_initialized(&result
));
3122 test_true(result_ptr
);
3123 test_true(result_ptr
== &result
);
3125 memcached_result_free(&result
);
3127 test_false(result
.options
.is_allocated
);
3128 test_false(memcached_is_initialized(&result
));
3130 return TEST_SUCCESS
;
3133 static test_return_t
result_alloc(memcached_st
*memc
)
3135 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
3136 test_true(result_ptr
);
3137 test_true(result_ptr
->options
.is_allocated
);
3138 test_true(memcached_is_initialized(result_ptr
));
3139 memcached_result_free(result_ptr
);
3141 return TEST_SUCCESS
;
3144 static test_return_t
cleanup_pairs(memcached_st
*memc
)
3147 pairs_free(global_pairs
);
3149 return TEST_SUCCESS
;
3152 static test_return_t
generate_pairs(memcached_st
*)
3154 global_pairs
= pairs_generate(GLOBAL_COUNT
, 400);
3155 global_count
= GLOBAL_COUNT
;
3157 for (size_t x
= 0; x
< global_count
; x
++)
3159 global_keys
[x
]= global_pairs
[x
].key
;
3160 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3163 return TEST_SUCCESS
;
3166 static test_return_t
generate_large_pairs(memcached_st
*)
3168 global_pairs
= pairs_generate(GLOBAL2_COUNT
, MEMCACHED_MAX_BUFFER
+10);
3169 global_count
= GLOBAL2_COUNT
;
3171 for (size_t x
= 0; x
< global_count
; x
++)
3173 global_keys
[x
]= global_pairs
[x
].key
;
3174 global_keys_length
[x
]= global_pairs
[x
].key_length
;
3177 return TEST_SUCCESS
;
3180 static test_return_t
generate_data(memcached_st
*memc
)
3182 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3184 test_compare(check_execute
, global_count
);
3186 return TEST_SUCCESS
;
3189 static test_return_t
generate_data_with_stats(memcached_st
*memc
)
3191 uint32_t host_index
= 0;
3192 unsigned int check_execute
= execute_set(memc
, global_pairs
, global_count
);
3194 test_true(check_execute
== global_count
);
3196 // @todo hosts used size stats
3197 memcached_return_t rc
;
3198 memcached_stat_st
*stat_p
= memcached_stat(memc
, NULL
, &rc
);
3201 for (host_index
= 0; host_index
< SERVERS_TO_CREATE
; host_index
++)
3203 /* This test was changes so that "make test" would work properlly */
3206 memcached_server_instance_st instance
=
3207 memcached_server_instance_by_position(memc
, host_index
);
3209 printf("\nserver %u|%s|%u bytes: %llu\n", host_index
, instance
->hostname
, instance
->port
, (unsigned long long)(stat_p
+ host_index
)->bytes
);
3211 test_true((unsigned long long)(stat_p
+ host_index
)->bytes
);
3214 memcached_stat_free(NULL
, stat_p
);
3216 return TEST_SUCCESS
;
3218 static test_return_t
generate_buffer_data(memcached_st
*memc
)
3220 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3221 generate_data(memc
);
3223 return TEST_SUCCESS
;
3226 static test_return_t
get_read_count(memcached_st
*memc
)
3228 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3229 test_true(memc_clone
);
3231 memcached_server_add_with_weight(memc_clone
, "localhost", 6666, 0);
3235 size_t return_value_length
;
3239 for (size_t x
= count
= 0; x
< global_count
; x
++)
3241 memcached_return_t rc
;
3242 return_value
= memcached_get(memc_clone
, global_keys
[x
], global_keys_length
[x
],
3243 &return_value_length
, &flags
, &rc
);
3244 if (rc
== MEMCACHED_SUCCESS
)
3255 memcached_free(memc_clone
);
3257 return TEST_SUCCESS
;
3260 static test_return_t
get_read(memcached_st
*memc
)
3262 for (size_t x
= 0; x
< global_count
; x
++)
3264 size_t return_value_length
;
3266 memcached_return_t rc
;
3267 char *return_value
= memcached_get(memc
, global_keys
[x
], global_keys_length
[x
],
3268 &return_value_length
, &flags
, &rc
);
3270 test_true(return_value);
3271 test_compare(MEMCACHED_SUCCESS, rc);
3273 if (rc
== MEMCACHED_SUCCESS
&& return_value
)
3279 return TEST_SUCCESS
;
3282 static test_return_t
mget_read(memcached_st
*memc
)
3285 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3287 test_compare(MEMCACHED_SUCCESS
,
3288 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3290 // Go fetch the keys and test to see if all of them were returned
3292 unsigned int keys_returned
;
3293 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, MEMCACHED_SUCCESS
));
3294 test_true(keys_returned
> 0);
3295 test_compare_warn_hint(global_count
, keys_returned
, "Possible false, positive, memcached may have ejected key/value based on memory needs");
3298 return TEST_SUCCESS
;
3301 static test_return_t
mget_read_result(memcached_st
*memc
)
3304 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3306 test_compare(MEMCACHED_SUCCESS
,
3307 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3309 /* Turn this into a help function */
3311 memcached_result_st results_obj
;
3312 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3315 memcached_return_t rc
;
3316 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3318 if (rc
== MEMCACHED_IN_PROGRESS
)
3324 test_compare(MEMCACHED_SUCCESS
, rc
);
3326 test_compare(MEMCACHED_END
, rc
);
3328 memcached_result_free(&results_obj
);
3331 return TEST_SUCCESS
;
3334 static test_return_t
mget_read_internal_result(memcached_st
*memc
)
3337 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3339 test_compare(MEMCACHED_SUCCESS
,
3340 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3342 memcached_result_st
*results
= NULL
;
3343 memcached_return_t rc
;
3344 while ((results
= memcached_fetch_result(memc
, results
, &rc
)))
3347 test_compare(MEMCACHED_SUCCESS
, rc
);
3349 test_compare(MEMCACHED_END
, rc
);
3351 memcached_result_free(results
);
3354 return TEST_SUCCESS
;
3357 static test_return_t
mget_read_partial_result(memcached_st
*memc
)
3360 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3362 test_compare(MEMCACHED_SUCCESS
,
3363 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3365 // We will scan for just one key
3367 memcached_result_st results_obj
;
3368 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3370 memcached_return_t rc
;
3371 results
= memcached_fetch_result(memc
, results
, &rc
);
3373 test_compare(MEMCACHED_SUCCESS
, rc
);
3375 memcached_result_free(&results_obj
);
3378 // We already have a read happening, lets start up another one.
3379 test_compare(MEMCACHED_SUCCESS
,
3380 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3382 memcached_result_st results_obj
;
3383 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
3385 test_false(memcached_is_allocated(results
));
3387 memcached_return_t rc
;
3388 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
3391 test_compare(MEMCACHED_SUCCESS
, rc
);
3393 test_compare(MEMCACHED_END
, rc
);
3395 memcached_result_free(&results_obj
);
3398 return TEST_SUCCESS
;
3401 static test_return_t
mget_read_function(memcached_st
*memc
)
3403 test_skip(true, bool(libmemcached_util_version_check(memc
, 1, 4, 4)));
3405 test_compare(MEMCACHED_SUCCESS
,
3406 memcached_mget(memc
, global_keys
, global_keys_length
, global_count
));
3408 memcached_execute_fn callbacks
[]= { &callback_counter
};
3410 test_compare(MEMCACHED_SUCCESS
,
3411 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
3413 return TEST_SUCCESS
;
3416 static test_return_t
delete_generate(memcached_st
*memc
)
3418 for (size_t x
= 0; x
< global_count
; x
++)
3420 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3423 return TEST_SUCCESS
;
3426 static test_return_t
delete_buffer_generate(memcached_st
*memc
)
3428 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, true);
3430 for (size_t x
= 0; x
< global_count
; x
++)
3432 (void)memcached_delete(memc
, global_keys
[x
], global_keys_length
[x
], (time_t)0);
3435 return TEST_SUCCESS
;
3438 static test_return_t
add_host_test1(memcached_st
*memc
)
3440 memcached_return_t rc
;
3441 char servername
[]= "0.example.com";
3443 memcached_server_st
*servers
= memcached_server_list_append_with_weight(NULL
, servername
, 400, 0, &rc
);
3445 test_compare(1U, memcached_server_list_count(servers
));
3447 for (uint32_t x
= 2; x
< 20; x
++)
3449 char buffer
[SMALL_STRING_LEN
];
3451 snprintf(buffer
, SMALL_STRING_LEN
, "%lu.example.com", (unsigned long)(400 +x
));
3452 servers
= memcached_server_list_append_with_weight(servers
, buffer
, 401, 0,
3454 test_compare(MEMCACHED_SUCCESS
, rc
);
3455 test_compare(x
, memcached_server_list_count(servers
));
3458 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3459 test_compare(MEMCACHED_SUCCESS
, memcached_server_push(memc
, servers
));
3461 memcached_server_list_free(servers
);
3463 return TEST_SUCCESS
;
3466 static test_return_t
pre_nonblock(memcached_st
*memc
)
3468 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3470 return TEST_SUCCESS
;
3473 static test_return_t
pre_cork(memcached_st
*memc
)
3476 return TEST_SKIPPED
;
3479 if (memcached_success(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, set
)))
3480 return TEST_SUCCESS
;
3482 return TEST_SKIPPED
;
3485 static test_return_t
pre_cork_and_nonblock(memcached_st
*memc
)
3488 return TEST_SKIPPED
;
3490 test_return_t test_rc
;
3491 if ((test_rc
= pre_cork(memc
)) != TEST_SUCCESS
)
3494 return pre_nonblock(memc
);
3497 static test_return_t
pre_nonblock_binary(memcached_st
*memc
)
3499 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
3500 test_true(memc_clone
);
3502 // The memcached_version needs to be done on a clone, because the server
3503 // will not toggle protocol on an connection.
3504 memcached_version(memc_clone
);
3506 memcached_return_t rc
= MEMCACHED_FAILURE
;
3507 if (libmemcached_util_version_check(memc_clone
, 1, 4, 4))
3509 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3510 test_compare(MEMCACHED_SUCCESS
,
3511 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
3512 test_compare(uint64_t(1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
3516 memcached_free(memc_clone
);
3517 return TEST_SKIPPED
;
3520 memcached_free(memc_clone
);
3522 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3525 static test_return_t
pre_murmur(memcached_st
*memc
)
3527 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3528 return TEST_SUCCESS
;
3531 static test_return_t
pre_jenkins(memcached_st
*memc
)
3533 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_JENKINS
);
3535 return TEST_SUCCESS
;
3539 static test_return_t
pre_md5(memcached_st
*memc
)
3541 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MD5
);
3543 return TEST_SUCCESS
;
3546 static test_return_t
pre_crc(memcached_st
*memc
)
3548 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_CRC
);
3550 return TEST_SUCCESS
;
3553 static test_return_t
pre_hsieh(memcached_st
*memc
)
3555 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_HSIEH
));
3556 return TEST_SUCCESS
;
3559 static test_return_t
pre_hash_fnv1_64(memcached_st
*memc
)
3561 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
3563 return TEST_SUCCESS
;
3566 static test_return_t
pre_hash_fnv1a_64(memcached_st
*memc
)
3568 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_64
));
3570 return TEST_SUCCESS
;
3573 static test_return_t
pre_hash_fnv1_32(memcached_st
*memc
)
3575 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1_32
);
3577 return TEST_SUCCESS
;
3580 static test_return_t
pre_hash_fnv1a_32(memcached_st
*memc
)
3582 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_FNV1A_32
);
3584 return TEST_SUCCESS
;
3587 static test_return_t
pre_behavior_ketama(memcached_st
*memc
)
3589 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, 1);
3590 test_compare(MEMCACHED_SUCCESS
, rc
);
3592 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA
);
3593 test_compare(value
, uint64_t(1));
3595 return TEST_SUCCESS
;
3598 static test_return_t
pre_behavior_ketama_weighted(memcached_st
*memc
)
3600 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
, 1);
3601 test_compare(MEMCACHED_SUCCESS
, rc
);
3603 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
);
3604 test_compare(value
, uint64_t(1));
3606 test_compare(MEMCACHED_SUCCESS
,
3607 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
, MEMCACHED_HASH_MD5
));
3609 value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_HASH
);
3610 test_compare(MEMCACHED_HASH_MD5
, memcached_hash_t(value
));
3612 return TEST_SUCCESS
;
3616 @note This should be testing to see if the server really supports the binary protocol.
3618 static test_return_t
pre_binary(memcached_st
*memc
)
3620 memcached_return_t rc
= MEMCACHED_FAILURE
;
3622 if (libmemcached_util_version_check(memc
, 1, 4, 4))
3624 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
3625 test_compare(MEMCACHED_SUCCESS
, rc
);
3626 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1);
3629 return rc
== MEMCACHED_SUCCESS
? TEST_SUCCESS
: TEST_SKIPPED
;
3632 static test_return_t
pre_replication(memcached_st
*memc
)
3634 test_skip(TEST_SUCCESS
, pre_binary(memc
));
3637 * Make sure that we store the item on all servers
3638 * (master + replicas == number of servers)
3640 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, memcached_server_count(memc
) - 1));
3641 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
), uint64_t(memcached_server_count(memc
) - 1));
3643 return TEST_SUCCESS
;
3647 static test_return_t
pre_replication_noblock(memcached_st
*memc
)
3649 test_skip(TEST_SUCCESS
, pre_replication(memc
));
3651 return pre_nonblock(memc
);
3655 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
3659 #ifdef HARD_MALLOC_TESTS
3660 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
3668 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
3672 #ifdef HARD_MALLOC_TESTS
3673 void *ret
= malloc(size
+ 8);
3676 ret
= (void*)((caddr_t
)ret
+ 8);
3679 void *ret
= malloc(size
);
3684 memset(ret
, 0xff, size
);
3691 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
3693 #ifdef HARD_MALLOC_TESTS
3694 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
3695 void *nmem
= realloc(real_ptr
, size
+ 8);
3700 ret
= (void*)((caddr_t
)nmem
+ 8);
3706 return realloc(mem
, size
);
3711 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
3713 #ifdef HARD_MALLOC_TESTS
3714 void *mem
= my_malloc(ptr
, nelem
* size
);
3717 memset(mem
, 0, nelem
* size
);
3723 return calloc(nelem
, size
);
3727 static test_return_t
selection_of_namespace_tests(memcached_st
*memc
)
3729 memcached_return_t rc
;
3730 const char *key
= "mine";
3733 /* Make sure be default none exists */
3734 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3736 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3738 /* Test a clean set */
3739 test_compare(MEMCACHED_SUCCESS
,
3740 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3742 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3744 test_memcmp(value
, key
, 4);
3745 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3747 /* Test that we can turn it off */
3748 test_compare(MEMCACHED_SUCCESS
,
3749 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3751 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3753 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3755 /* Now setup for main test */
3756 test_compare(MEMCACHED_SUCCESS
,
3757 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3759 value
= (char *)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3761 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3762 test_memcmp(value
, key
, 4);
3764 /* Set to Zero, and then Set to something too large */
3767 memset(long_key
, 0, 255);
3769 test_compare(MEMCACHED_SUCCESS
,
3770 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, NULL
));
3772 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3774 test_true(rc
== MEMCACHED_FAILURE
);
3775 test_true(value
== NULL
);
3777 /* Test a long key for failure */
3778 /* TODO, extend test to determine based on setting, what result should be */
3779 strncpy(long_key
, "Thisismorethentheallottednumberofcharacters", sizeof(long_key
));
3780 test_compare(MEMCACHED_SUCCESS
,
3781 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3783 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3784 strncpy(long_key
, "This is more then the allotted number of characters", sizeof(long_key
));
3785 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3786 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, long_key
));
3788 /* Test for a bad prefix, but with a short key */
3789 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_INVALID_ARGUMENTS
: MEMCACHED_SUCCESS
,
3790 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_VERIFY_KEY
, 1));
3792 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) ? MEMCACHED_SUCCESS
: MEMCACHED_BAD_KEY_PROVIDED
,
3793 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, "dog cat"));
3796 return TEST_SUCCESS
;
3799 static test_return_t
set_namespace(memcached_st
*memc
)
3801 memcached_return_t rc
;
3802 const char *key
= "mine";
3805 /* Make sure be default none exists */
3806 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3808 test_compare_got(MEMCACHED_FAILURE
, rc
, memcached_strerror(NULL
, rc
));
3810 /* Test a clean set */
3811 test_compare(MEMCACHED_SUCCESS
,
3812 memcached_callback_set(memc
, MEMCACHED_CALLBACK_NAMESPACE
, (void *)key
));
3814 value
= (char*)memcached_callback_get(memc
, MEMCACHED_CALLBACK_NAMESPACE
, &rc
);
3816 test_memcmp(value
, key
, 4);
3817 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
3819 return TEST_SUCCESS
;
3822 static test_return_t
set_namespace_and_binary(memcached_st
*memc
)
3824 test_return_if(pre_binary(memc
));
3825 test_return_if(set_namespace(memc
));
3827 return TEST_SUCCESS
;
3830 #ifdef MEMCACHED_ENABLE_DEPRECATED
3831 static test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
3833 void *test_ptr
= NULL
;
3836 memcached_malloc_fn malloc_cb
=
3837 (memcached_malloc_fn
)my_malloc
;
3838 cb_ptr
= *(void **)&malloc_cb
;
3839 memcached_return_t rc
;
3841 test_compare(MEMCACHED_SUCCESS
,
3842 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
3843 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
3844 test_compare(MEMCACHED_SUCCESS
, rc
);
3845 test_true(test_ptr
== cb_ptr
);
3849 memcached_realloc_fn realloc_cb
=
3850 (memcached_realloc_fn
)my_realloc
;
3851 cb_ptr
= *(void **)&realloc_cb
;
3852 memcached_return_t rc
;
3854 test_compare(MEMCACHED_SUCCESS
,
3855 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
3856 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
3857 test_compare(MEMCACHED_SUCCESS
, rc
);
3858 test_true(test_ptr
== cb_ptr
);
3862 memcached_free_fn free_cb
=
3863 (memcached_free_fn
)my_free
;
3864 cb_ptr
= *(void **)&free_cb
;
3865 memcached_return_t rc
;
3867 test_compare(MEMCACHED_SUCCESS
,
3868 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
3869 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
3870 test_compare(MEMCACHED_SUCCESS
, rc
);
3871 test_true(test_ptr
== cb_ptr
);
3874 return TEST_SUCCESS
;
3879 static test_return_t
set_memory_alloc(memcached_st
*memc
)
3881 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
3882 memcached_set_memory_allocators(memc
, NULL
, my_free
,
3883 my_realloc
, my_calloc
, NULL
));
3885 test_compare(MEMCACHED_SUCCESS
,
3886 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
3887 my_realloc
, my_calloc
, NULL
));
3889 memcached_malloc_fn mem_malloc
;
3890 memcached_free_fn mem_free
;
3891 memcached_realloc_fn mem_realloc
;
3892 memcached_calloc_fn mem_calloc
;
3893 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
3894 &mem_realloc
, &mem_calloc
);
3896 test_true(mem_malloc
== my_malloc
);
3897 test_true(mem_realloc
== my_realloc
);
3898 test_true(mem_calloc
== my_calloc
);
3899 test_true(mem_free
== my_free
);
3901 return TEST_SUCCESS
;
3904 static test_return_t
enable_consistent_crc(memcached_st
*memc
)
3907 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3908 memcached_hash_t hash
;
3909 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3910 if ((rc
= pre_crc(memc
)) != TEST_SUCCESS
)
3913 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3914 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3916 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3918 if (hash
!= MEMCACHED_HASH_CRC
)
3919 return TEST_SKIPPED
;
3921 return TEST_SUCCESS
;
3924 static test_return_t
enable_consistent_hsieh(memcached_st
*memc
)
3927 memcached_server_distribution_t value
= MEMCACHED_DISTRIBUTION_CONSISTENT
;
3928 memcached_hash_t hash
;
3929 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
, value
);
3930 if ((rc
= pre_hsieh(memc
)) != TEST_SUCCESS
)
3935 value
= (memcached_server_distribution_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_DISTRIBUTION
);
3936 test_true(value
== MEMCACHED_DISTRIBUTION_CONSISTENT
);
3938 hash
= (memcached_hash_t
)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
);
3940 if (hash
!= MEMCACHED_HASH_HSIEH
)
3941 return TEST_SKIPPED
;
3944 return TEST_SUCCESS
;
3947 static test_return_t
enable_cas(memcached_st
*memc
)
3949 unsigned int set
= 1;
3951 if (libmemcached_util_version_check(memc
, 1, 2, 4))
3953 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, set
);
3955 return TEST_SUCCESS
;
3958 return TEST_SKIPPED
;
3961 static test_return_t
check_for_1_2_3(memcached_st
*memc
)
3963 memcached_version(memc
);
3965 memcached_server_instance_st instance
=
3966 memcached_server_instance_by_position(memc
, 0);
3968 if ((instance
->major_version
>= 1 && (instance
->minor_version
== 2 && instance
->micro_version
>= 4))
3969 or instance
->minor_version
> 2)
3971 return TEST_SUCCESS
;
3974 return TEST_SKIPPED
;
3977 static test_return_t
pre_unix_socket(memcached_st
*memc
)
3981 memcached_servers_reset(memc
);
3982 const char *socket_file
= default_socket();
3984 test_skip(0, stat(socket_file
, &buf
));
3986 test_compare(MEMCACHED_SUCCESS
,
3987 memcached_server_add_unix_socket_with_weight(memc
, socket_file
, 0));
3989 return TEST_SUCCESS
;
3992 static test_return_t
pre_nodelay(memcached_st
*memc
)
3994 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
3995 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
3997 return TEST_SUCCESS
;
4000 static test_return_t
pre_settimer(memcached_st
*memc
)
4002 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
4003 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
4005 return TEST_SUCCESS
;
4008 static test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
4010 const uint64_t timeout
= 100; // Not using, just checking that it sets
4012 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
4014 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
4016 return TEST_SUCCESS
;
4019 static test_return_t
noreply_test(memcached_st
*memc
)
4021 test_compare(MEMCACHED_SUCCESS
,
4022 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
4023 test_compare(MEMCACHED_SUCCESS
,
4024 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1));
4025 test_compare(MEMCACHED_SUCCESS
,
4026 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
4027 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NOREPLY
));
4028 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
));
4029 test_compare(1LLU, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
));
4031 memcached_return_t ret
;
4032 for (int count
= 0; count
< 5; ++count
)
4034 for (size_t x
= 0; x
< 100; ++x
)
4037 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4038 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4040 size_t len
= (size_t)check_length
;
4045 ret
= memcached_add(memc
, key
, len
, key
, len
, 0, 0);
4048 ret
= memcached_replace(memc
, key
, len
, key
, len
, 0, 0);
4051 ret
= memcached_set(memc
, key
, len
, key
, len
, 0, 0);
4054 ret
= memcached_append(memc
, key
, len
, key
, len
, 0, 0);
4057 ret
= memcached_prepend(memc
, key
, len
, key
, len
, 0, 0);
4063 test_true_got(ret
== MEMCACHED_SUCCESS
or ret
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, ret
));
4067 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4068 ** API and is _ONLY_ done this way to verify that the library works the
4069 ** way it is supposed to do!!!!
4072 for (uint32_t x
= 0; x
< memcached_server_count(memc
); ++x
)
4074 memcached_server_instance_st instance
=
4075 memcached_server_instance_by_position(memc
, x
);
4076 no_msg
+=(int)(instance
->cursor_active
);
4079 test_true(no_msg
== 0);
4080 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
4083 ** Now validate that all items was set properly!
4085 for (size_t x
= 0; x
< 100; ++x
)
4089 int check_length
= (size_t)snprintf(key
, sizeof(key
), "%lu", (unsigned long)x
);
4091 test_false((size_t)check_length
>= sizeof(key
) || check_length
< 0);
4093 size_t len
= (size_t)check_length
;
4096 char* value
=memcached_get(memc
, key
, strlen(key
),
4097 &length
, &flags
, &ret
);
4098 test_true_got(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
, memcached_strerror(NULL
, ret
));
4101 case 0: /* FALLTHROUGH */
4102 case 1: /* FALLTHROUGH */
4104 test_true(strncmp(value
, key
, len
) == 0);
4105 test_true(len
== length
);
4108 test_true(length
== len
* 2);
4111 test_true(length
== len
* 3);
4121 /* Try setting an illegal cas value (should not return an error to
4122 * the caller (because we don't expect a return message from the server)
4124 const char* keys
[]= {"0"};
4125 size_t lengths
[]= {1};
4128 memcached_result_st results_obj
;
4129 memcached_result_st
*results
;
4130 test_compare(MEMCACHED_SUCCESS
,
4131 memcached_mget(memc
, keys
, lengths
, 1));
4133 results
= memcached_result_create(memc
, &results_obj
);
4135 results
= memcached_fetch_result(memc
, &results_obj
, &ret
);
4137 test_compare(MEMCACHED_SUCCESS
, ret
);
4138 uint64_t cas
= memcached_result_cas(results
);
4139 memcached_result_free(&results_obj
);
4141 test_compare(MEMCACHED_SUCCESS
,
4142 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4145 * The item will have a new cas value, so try to set it again with the old
4146 * value. This should fail!
4148 test_compare(MEMCACHED_SUCCESS
,
4149 memcached_cas(memc
, keys
[0], lengths
[0], keys
[0], lengths
[0], 0, 0, cas
));
4150 test_true(memcached_flush_buffers(memc
) == MEMCACHED_SUCCESS
);
4151 char* value
=memcached_get(memc
, keys
[0], lengths
[0], &length
, &flags
, &ret
);
4152 test_true(ret
== MEMCACHED_SUCCESS
&& value
!= NULL
);
4155 return TEST_SUCCESS
;
4158 static test_return_t
analyzer_test(memcached_st
*memc
)
4160 memcached_return_t rc
;
4161 memcached_analysis_st
*report
;
4163 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
4164 test_compare(MEMCACHED_SUCCESS
, rc
);
4165 test_true(memc_stat
);
4167 report
= memcached_analyze(memc
, memc_stat
, &rc
);
4168 test_compare(MEMCACHED_SUCCESS
, rc
);
4172 memcached_stat_free(NULL
, memc_stat
);
4174 return TEST_SUCCESS
;
4177 /* Count the objects */
4179 static test_return_t
dump_test(memcached_st
*memc
)
4181 /* No support for Binary protocol yet */
4182 test_skip(false, memc
->flags
.binary_protocol
);
4184 test_compare(TEST_SUCCESS
, set_test3(memc
));
4186 // confirm_key_count() call dump
4187 size_t counter
= confirm_key_count(memc
);
4189 /* We may have more then 32 if our previous flush has not completed */
4190 test_true(counter
>= 32);
4192 return TEST_SUCCESS
;
4196 #define POOL_SIZE 10
4197 static test_return_t
connection_pool_test(memcached_st
*memc
)
4199 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4201 memcached_st
*mmc
[POOL_SIZE
];
4203 // Fill up our array that we will store the memc that are in the pool
4204 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4206 memcached_return_t rc
;
4207 mmc
[x
]= memcached_pool_fetch(pool
, NULL
, &rc
);
4208 test_compare(MEMCACHED_SUCCESS
, rc
);
4212 // All memc should be gone
4214 memcached_return_t rc
;
4215 test_null(memcached_pool_fetch(pool
, NULL
, &rc
));
4216 test_compare(MEMCACHED_NOTFOUND
, rc
);
4220 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4224 test_compare(MEMCACHED_SUCCESS
, memcached_pool_release(pool
, mmc
[x
]));
4227 test_true(memcached_pool_destroy(pool
) == memc
);
4229 return TEST_SUCCESS
;
4232 static test_return_t
connection_pool2_test(memcached_st
*memc
)
4234 memcached_pool_st
* pool
= memcached_pool_create(memc
, 5, POOL_SIZE
);
4236 memcached_st
*mmc
[POOL_SIZE
];
4238 // Fill up our array that we will store the memc that are in the pool
4239 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4241 memcached_return_t rc
;
4242 mmc
[x
]= memcached_pool_fetch(pool
, NULL
, &rc
);
4243 test_compare(MEMCACHED_SUCCESS
, rc
);
4247 // All memc should be gone
4249 memcached_return_t rc
;
4250 test_null(memcached_pool_fetch(pool
, NULL
, &rc
));
4251 test_compare(MEMCACHED_NOTFOUND
, rc
);
4254 // verify that I can do ops with all connections
4255 test_compare(MEMCACHED_SUCCESS
,
4256 memcached_set(mmc
[0],
4257 test_literal_param("key"),
4260 for (uint64_t x
= 0; x
< POOL_SIZE
; ++x
)
4262 uint64_t number_value
;
4263 test_compare(MEMCACHED_SUCCESS
,
4264 memcached_increment(mmc
[x
],
4265 test_literal_param("key"),
4267 test_compare(number_value
, (x
+1));
4271 for (size_t x
= 0; x
< POOL_SIZE
; ++x
)
4273 test_compare(MEMCACHED_SUCCESS
, memcached_pool_release(pool
, mmc
[x
]));
4277 /* verify that I can set behaviors on the pool when I don't have all
4278 * of the connections in the pool. It should however be enabled
4279 * when I push the item into the pool
4281 mmc
[0]= memcached_pool_fetch(pool
, NULL
, NULL
);
4284 test_compare(MEMCACHED_SUCCESS
,
4285 memcached_pool_behavior_set(pool
, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
, 9999));
4288 memcached_return_t rc
;
4289 mmc
[1]= memcached_pool_fetch(pool
, NULL
, &rc
);
4291 test_compare(MEMCACHED_SUCCESS
, rc
);
4294 test_compare(UINT64_C(9999), memcached_behavior_get(mmc
[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4295 test_compare(MEMCACHED_SUCCESS
, memcached_pool_release(pool
, mmc
[1]));
4296 test_compare(MEMCACHED_SUCCESS
, memcached_pool_release(pool
, mmc
[0]));
4299 memcached_return_t rc
;
4300 mmc
[0]= memcached_pool_fetch(pool
, NULL
, &rc
);
4302 test_compare(MEMCACHED_SUCCESS
, rc
);
4305 test_compare(UINT64_C(9999), memcached_behavior_get(mmc
[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK
));
4306 test_compare(MEMCACHED_SUCCESS
, memcached_pool_release(pool
, mmc
[0]));
4308 test_true(memcached_pool_destroy(pool
) == memc
);
4310 return TEST_SUCCESS
;
4313 struct test_pool_context_st
{
4314 volatile memcached_return_t rc
;
4315 memcached_pool_st
* pool
;
4319 test_pool_context_st(memcached_pool_st
*pool_arg
, memcached_st
*memc_arg
):
4320 rc(MEMCACHED_FAILURE
),
4324 sem_init(&_lock
, 0, 0);
4337 ~test_pool_context_st()
4339 sem_destroy(&_lock
);
4343 static void* connection_release(void *arg
)
4345 test_pool_context_st
*resource
= static_cast<test_pool_context_st
*>(arg
);
4347 if (resource
== NULL
)
4352 // Release all of the memc we are holding
4353 resource
->rc
= memcached_pool_release(resource
->pool
, resource
->mmc
);
4354 resource
->release();
4359 static test_return_t
connection_pool3_test(memcached_st
*memc
)
4361 memcached_pool_st
* pool
= memcached_pool_create(memc
, 1, 1);
4364 memcached_st
*pool_memc
;
4366 memcached_return_t rc
;
4367 pool_memc
= memcached_pool_fetch(pool
, NULL
, &rc
);
4368 test_compare(MEMCACHED_SUCCESS
, rc
);
4369 test_true(pool_memc
);
4373 @note This comment was written to describe what was believed to be the original authors intent.
4375 This portion of the test creates a thread that will wait until told to free a memcached_st
4376 that will be grabbed by the main thread.
4378 It is believed that this tests whether or not we are handling ownership correctly.
4381 test_pool_context_st
item(pool
, pool_memc
);
4383 test_zero(pthread_create(&tid
, NULL
, connection_release
, &item
));
4386 memcached_return_t rc
;
4387 memcached_st
*pop_memc
;
4391 struct timespec relative_time
= { 0, 0 };
4392 pop_memc
= memcached_pool_fetch(pool
, &relative_time
, &rc
);
4394 if (memcached_failed(rc
))
4396 test_null(pop_memc
);
4398 } while (rc
== MEMCACHED_TIMEOUT
and --counter
);
4400 if (memcached_failed(rc
)) // Cleanup thread since we will exit once we test.
4402 pthread_join(tid
, NULL
);
4403 test_compare(MEMCACHED_SUCCESS
, rc
);
4407 int pthread_ret
= pthread_join(tid
, NULL
);
4408 test_true(pthread_ret
== 0 or pthread_ret
== ESRCH
);
4410 test_compare(MEMCACHED_SUCCESS
, rc
);
4411 test_true(pool_memc
== pop_memc
);
4413 test_true(memcached_pool_destroy(pool
) == memc
);
4415 return TEST_SUCCESS
;
4418 static test_return_t
util_version_test(memcached_st
*memc
)
4420 bool if_successful
= libmemcached_util_version_check(memc
, 0, 0, 0);
4421 test_true(if_successful
);
4423 if_successful
= libmemcached_util_version_check(memc
, 9, 9, 9);
4425 // We expect failure
4428 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4429 fprintf(stderr
, "\nDumping Server Information\n\n");
4430 memcached_server_fn callbacks
[1];
4432 callbacks
[0]= dump_server_information
;
4433 memcached_server_cursor(memc
, callbacks
, (void *)stderr
, 1);
4434 fprintf(stderr
, "\n----------------------------------------------------------------------\n");
4436 test_true(if_successful
== false);
4438 memcached_server_instance_st instance
=
4439 memcached_server_instance_by_position(memc
, 0);
4441 memcached_version(memc
);
4443 // We only use one binary when we test, so this should be just fine.
4444 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, instance
->micro_version
);
4445 test_true(if_successful
== true);
4447 if (instance
->micro_version
> 0)
4449 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
-1));
4451 else if (instance
->minor_version
> 0)
4453 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
- 1), instance
->micro_version
);
4455 else if (instance
->major_version
> 0)
4457 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
-1), instance
->minor_version
, instance
->micro_version
);
4460 test_true(if_successful
== true);
4462 if (instance
->micro_version
> 0)
4464 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, instance
->minor_version
, (uint8_t)(instance
->micro_version
+1));
4466 else if (instance
->minor_version
> 0)
4468 if_successful
= libmemcached_util_version_check(memc
, instance
->major_version
, (uint8_t)(instance
->minor_version
+1), instance
->micro_version
);
4470 else if (instance
->major_version
> 0)
4472 if_successful
= libmemcached_util_version_check(memc
, (uint8_t)(instance
->major_version
+1), instance
->minor_version
, instance
->micro_version
);
4475 test_true(if_successful
== false);
4477 return TEST_SUCCESS
;
4480 static test_return_t
getpid_connection_failure_test(memcached_st
*memc
)
4482 memcached_return_t rc
;
4483 memcached_server_instance_st instance
=
4484 memcached_server_instance_by_position(memc
, 0);
4486 // Test both the version that returns a code, and the one that does not.
4487 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4488 memcached_server_port(instance
) -1, NULL
) == -1);
4490 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4491 memcached_server_port(instance
) -1, &rc
) == -1);
4492 test_compare_got(MEMCACHED_CONNECTION_FAILURE
, rc
, memcached_strerror(memc
, rc
));
4494 return TEST_SUCCESS
;
4498 static test_return_t
getpid_test(memcached_st
*memc
)
4500 memcached_return_t rc
;
4501 memcached_server_instance_st instance
=
4502 memcached_server_instance_by_position(memc
, 0);
4504 // Test both the version that returns a code, and the one that does not.
4505 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4506 memcached_server_port(instance
), NULL
) > -1);
4508 test_true(libmemcached_util_getpid(memcached_server_name(instance
),
4509 memcached_server_port(instance
), &rc
) > -1);
4510 test_compare(MEMCACHED_SUCCESS
, rc
);
4512 return TEST_SUCCESS
;
4515 static test_return_t
ping_test(memcached_st
*memc
)
4517 memcached_return_t rc
;
4518 memcached_server_instance_st instance
=
4519 memcached_server_instance_by_position(memc
, 0);
4521 // Test both the version that returns a code, and the one that does not.
4522 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4523 memcached_server_port(instance
), NULL
));
4525 test_true(libmemcached_util_ping(memcached_server_name(instance
),
4526 memcached_server_port(instance
), &rc
));
4528 test_compare(MEMCACHED_SUCCESS
, rc
);
4530 return TEST_SUCCESS
;
4535 static test_return_t
hash_sanity_test (memcached_st
*memc
)
4539 assert(MEMCACHED_HASH_DEFAULT
== MEMCACHED_HASH_DEFAULT
);
4540 assert(MEMCACHED_HASH_MD5
== MEMCACHED_HASH_MD5
);
4541 assert(MEMCACHED_HASH_CRC
== MEMCACHED_HASH_CRC
);
4542 assert(MEMCACHED_HASH_FNV1_64
== MEMCACHED_HASH_FNV1_64
);
4543 assert(MEMCACHED_HASH_FNV1A_64
== MEMCACHED_HASH_FNV1A_64
);
4544 assert(MEMCACHED_HASH_FNV1_32
== MEMCACHED_HASH_FNV1_32
);
4545 assert(MEMCACHED_HASH_FNV1A_32
== MEMCACHED_HASH_FNV1A_32
);
4546 #ifdef HAVE_HSIEH_HASH
4547 assert(MEMCACHED_HASH_HSIEH
== MEMCACHED_HASH_HSIEH
);
4549 assert(MEMCACHED_HASH_MURMUR
== MEMCACHED_HASH_MURMUR
);
4550 assert(MEMCACHED_HASH_JENKINS
== MEMCACHED_HASH_JENKINS
);
4551 assert(MEMCACHED_HASH_MAX
== MEMCACHED_HASH_MAX
);
4553 return TEST_SUCCESS
;
4557 static test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
4559 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4561 test_compare(MEMCACHED_SUCCESS
,
4562 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
4563 (uint64_t)MEMCACHED_HASH_HSIEH
));
4565 return TEST_SUCCESS
;
4568 static test_return_t
murmur_avaibility_test (memcached_st
*memc
)
4570 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4572 test_compare(MEMCACHED_SUCCESS
,
4573 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
4575 return TEST_SUCCESS
;
4578 static test_return_t
one_at_a_time_run (memcached_st
*)
4583 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4585 test_compare(one_at_a_time_values
[x
],
4586 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_DEFAULT
));
4589 return TEST_SUCCESS
;
4592 static test_return_t
md5_run (memcached_st
*)
4597 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4599 test_compare(md5_values
[x
],
4600 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MD5
));
4603 return TEST_SUCCESS
;
4606 static test_return_t
crc_run (memcached_st
*)
4611 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4613 test_compare(crc_values
[x
],
4614 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_CRC
));
4617 return TEST_SUCCESS
;
4620 static test_return_t
fnv1_64_run (memcached_st
*)
4622 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64
));
4627 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4629 test_compare(fnv1_64_values
[x
],
4630 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_64
));
4633 return TEST_SUCCESS
;
4636 static test_return_t
fnv1a_64_run (memcached_st
*)
4638 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64
));
4643 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4645 test_compare(fnv1a_64_values
[x
],
4646 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_64
));
4649 return TEST_SUCCESS
;
4652 static test_return_t
fnv1_32_run (memcached_st
*)
4657 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4659 test_compare(fnv1_32_values
[x
],
4660 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1_32
));
4663 return TEST_SUCCESS
;
4666 static test_return_t
fnv1a_32_run (memcached_st
*)
4671 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4673 test_compare(fnv1a_32_values
[x
],
4674 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_FNV1A_32
));
4677 return TEST_SUCCESS
;
4680 static test_return_t
hsieh_run (memcached_st
*)
4682 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
4687 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4689 test_compare(hsieh_values
[x
],
4690 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_HSIEH
));
4693 return TEST_SUCCESS
;
4696 static test_return_t
murmur_run (memcached_st
*)
4698 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
4700 #ifdef WORDS_BIGENDIAN
4701 (void)murmur_values
;
4702 return TEST_SKIPPED
;
4707 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4709 test_compare(murmur_values
[x
],
4710 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_MURMUR
));
4713 return TEST_SUCCESS
;
4717 static test_return_t
jenkins_run (memcached_st
*)
4722 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4724 test_compare(jenkins_values
[x
],
4725 memcached_generate_hash_value(*ptr
, strlen(*ptr
), MEMCACHED_HASH_JENKINS
));
4728 return TEST_SUCCESS
;
4731 static uint32_t hash_md5_test_function(const char *string
, size_t string_length
, void *)
4733 return libhashkit_md5(string
, string_length
);
4736 static uint32_t hash_crc_test_function(const char *string
, size_t string_length
, void *)
4738 return libhashkit_crc32(string
, string_length
);
4741 static test_return_t
memcached_get_hashkit_test (memcached_st
*)
4747 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5"));
4749 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};
4750 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};
4752 const hashkit_st
*kit
= memcached_get_hashkit(memc
);
4754 hashkit_clone(&new_kit
, kit
);
4755 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_md5_test_function
, NULL
));
4757 memcached_set_hashkit(memc
, &new_kit
);
4760 Verify Setting the hash.
4762 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4766 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4767 test_compare_got(md5_values
[x
], hash_val
, *ptr
);
4772 Now check memcached_st.
4774 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4778 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4779 test_compare_got(md5_hosts
[x
], hash_val
, *ptr
);
4782 test_compare(HASHKIT_SUCCESS
, hashkit_set_custom_function(&new_kit
, hash_crc_test_function
, NULL
));
4784 memcached_set_hashkit(memc
, &new_kit
);
4787 Verify Setting the hash.
4789 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4793 hash_val
= hashkit_digest(kit
, *ptr
, strlen(*ptr
));
4794 test_true(crc_values
[x
] == hash_val
);
4797 for (ptr
= list_to_hash
, x
= 0; *ptr
; ptr
++, x
++)
4801 hash_val
= memcached_generate_hash(memc
, *ptr
, strlen(*ptr
));
4802 test_compare(crc_hosts
[x
], hash_val
);
4805 memcached_free(memc
);
4807 return TEST_SUCCESS
;
4811 Test case adapted from John Gorman <johngorman2@gmail.com>
4813 We are testing the error condition when we connect to a server via memcached_get()
4814 but find that the server is not available.
4816 static test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
4818 const char *key
= "MemcachedLives";
4821 memcached_return rc
;
4824 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
4826 // See if memcached is reachable.
4827 char *value
= memcached_get(tl_memc_h
, key
, strlen(key
), &len
, &flags
, &rc
);
4831 test_true(memcached_failed(rc
));
4833 memcached_free(tl_memc_h
);
4835 return TEST_SUCCESS
;
4839 We connect to a server which exists, but search for a key that does not exist.
4841 static test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4843 const char *key
= "MemcachedKeyNotEXIST";
4846 memcached_return rc
;
4848 // See if memcached is reachable.
4849 char *value
= memcached_get(memc
, key
, strlen(key
), &len
, &flags
, &rc
);
4853 test_compare(MEMCACHED_NOTFOUND
, rc
);
4855 return TEST_SUCCESS
;
4859 Test case adapted from John Gorman <johngorman2@gmail.com>
4861 We are testing the error condition when we connect to a server via memcached_get_by_key()
4862 but find that the server is not available.
4864 static test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*memc
)
4867 memcached_st
*tl_memc_h
;
4868 memcached_server_st
*servers
;
4870 const char *key
= "MemcachedLives";
4873 memcached_return rc
;
4877 tl_memc_h
= memcached_create(NULL
);
4878 servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4879 memcached_server_push(tl_memc_h
, servers
);
4880 memcached_server_list_free(servers
);
4882 // See if memcached is reachable.
4883 value
= memcached_get_by_key(tl_memc_h
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4887 test_true(memcached_failed(rc
));
4889 memcached_free(tl_memc_h
);
4891 return TEST_SUCCESS
;
4895 We connect to a server which exists, but search for a key that does not exist.
4897 static test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
4899 const char *key
= "MemcachedKeyNotEXIST";
4902 memcached_return rc
;
4905 // See if memcached is reachable.
4906 value
= memcached_get_by_key(memc
, key
, strlen(key
), key
, strlen(key
), &len
, &flags
, &rc
);
4910 test_compare(MEMCACHED_NOTFOUND
, rc
);
4912 return TEST_SUCCESS
;
4915 static test_return_t
regression_bug_434484(memcached_st
*memc
)
4917 test_return_t test_rc
;
4918 test_rc
= pre_binary(memc
);
4920 if (test_rc
!= TEST_SUCCESS
)
4923 const char *key
= "regression_bug_434484";
4924 size_t keylen
= strlen(key
);
4926 memcached_return_t ret
= memcached_append(memc
, key
, keylen
, key
, keylen
, 0, 0);
4927 test_compare(MEMCACHED_NOTSTORED
, ret
);
4929 size_t size
= 2048 * 1024;
4930 char *data
= (char*)calloc(1, size
);
4932 test_compare(MEMCACHED_E2BIG
,
4933 memcached_set(memc
, key
, keylen
, data
, size
, 0, 0));
4936 return TEST_SUCCESS
;
4939 static test_return_t
regression_bug_434843(memcached_st
*memc
)
4941 test_return_t test_rc
;
4942 test_rc
= pre_binary(memc
);
4944 if (test_rc
!= TEST_SUCCESS
)
4947 memcached_return_t rc
;
4949 memcached_execute_fn callbacks
[]= { &callback_counter
};
4952 * I only want to hit only _one_ server so I know the number of requests I'm
4953 * sending in the pipleine to the server. Let's try to do a multiget of
4954 * 1024 (that should satisfy most users don't you think?). Future versions
4955 * will include a mget_execute function call if you need a higher number.
4957 uint32_t number_of_hosts
= memcached_server_count(memc
);
4958 memc
->number_of_hosts
= 1;
4959 const size_t max_keys
= 1024;
4960 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
4961 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
4963 for (size_t x
= 0; x
< max_keys
; ++x
)
4967 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
4973 * Run two times.. the first time we should have 100% cache miss,
4974 * and the second time we should have 100% cache hits
4976 for (size_t y
= 0; y
< 2; y
++)
4978 test_compare(MEMCACHED_SUCCESS
,
4979 memcached_mget(memc
, (const char**)keys
, key_length
, max_keys
));
4981 test_compare(y
? MEMCACHED_SUCCESS
: MEMCACHED_NOTFOUND
,
4982 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
4986 /* The first iteration should give me a 100% cache miss. verify that*/
4987 char blob
[1024]= { 0 };
4989 test_false(counter
);
4991 for (size_t x
= 0; x
< max_keys
; ++x
)
4993 rc
= memcached_add(memc
, keys
[x
], key_length
[x
],
4994 blob
, sizeof(blob
), 0, 0);
4995 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5000 /* Verify that we received all of the key/value pairs */
5001 test_compare(counter
, max_keys
);
5005 /* Release allocated resources */
5006 for (size_t x
= 0; x
< max_keys
; ++x
)
5013 memc
->number_of_hosts
= number_of_hosts
;
5015 return TEST_SUCCESS
;
5018 static test_return_t
regression_bug_434843_buffered(memcached_st
*memc
)
5020 memcached_return_t rc
;
5021 rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1);
5022 test_compare(MEMCACHED_SUCCESS
, rc
);
5024 return regression_bug_434843(memc
);
5027 static test_return_t
regression_bug_421108(memcached_st
*memc
)
5029 memcached_return_t rc
;
5030 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
5031 test_compare(MEMCACHED_SUCCESS
, rc
);
5033 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
5034 test_compare(MEMCACHED_SUCCESS
, rc
);
5035 test_true(bytes_str
);
5036 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
5038 test_compare(MEMCACHED_SUCCESS
, rc
);
5039 test_true(bytes_read_str
);
5041 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
5042 "bytes_written", &rc
);
5043 test_compare(MEMCACHED_SUCCESS
, rc
);
5044 test_true(bytes_written_str
);
5046 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
5047 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
5048 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
5050 test_true(bytes
!= bytes_read
);
5051 test_true(bytes
!= bytes_written
);
5053 /* Release allocated resources */
5055 free(bytes_read_str
);
5056 free(bytes_written_str
);
5057 memcached_stat_free(NULL
, memc_stat
);
5059 return TEST_SUCCESS
;
5063 * The test case isn't obvious so I should probably document why
5064 * it works the way it does. Bug 442914 was caused by a bug
5065 * in the logic in memcached_purge (it did not handle the case
5066 * where the number of bytes sent was equal to the watermark).
5067 * In this test case, create messages so that we hit that case
5068 * and then disable noreply mode and issue a new command to
5069 * verify that it isn't stuck. If we change the format for the
5070 * delete command or the watermarks, we need to update this
5073 static test_return_t
regression_bug_442914(memcached_st
*memc
)
5075 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5076 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
5078 uint32_t number_of_hosts
= memcached_server_count(memc
);
5079 memc
->number_of_hosts
= 1;
5084 for (uint32_t x
= 0; x
< 250; ++x
)
5086 len
= (size_t)snprintf(k
, sizeof(k
), "%0250u", x
);
5087 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
5088 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5091 (void)snprintf(k
, sizeof(k
), "%037u", 251U);
5094 memcached_return_t rc
= memcached_delete(memc
, k
, len
, 0);
5095 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5097 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5098 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, k
, len
, 0));
5100 memc
->number_of_hosts
= number_of_hosts
;
5102 return TEST_SUCCESS
;
5105 static test_return_t
regression_bug_447342(memcached_st
*memc
)
5107 memcached_server_instance_st instance_one
;
5108 memcached_server_instance_st instance_two
;
5110 if (memcached_server_count(memc
) < 3 or pre_replication(memc
) != TEST_SUCCESS
)
5111 return TEST_SKIPPED
;
5113 test_compare(MEMCACHED_SUCCESS
,
5114 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, 2));
5116 const unsigned int max_keys
= 100;
5117 char **keys
= (char**)calloc(max_keys
, sizeof(char*));
5118 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5120 for (unsigned int x
= 0; x
< max_keys
; ++x
)
5124 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5127 test_compare(MEMCACHED_SUCCESS
,
5128 memcached_set(memc
, k
, key_length
[x
], k
, key_length
[x
], 0, 0));
5132 ** We are using the quiet commands to store the replicas, so we need
5133 ** to ensure that all of them are processed before we can continue.
5134 ** In the test we go directly from storing the object to trying to
5135 ** receive the object from all of the different servers, so we
5136 ** could end up in a race condition (the memcached server hasn't yet
5137 ** processed the quiet command from the replication set when it process
5138 ** the request from the other client (created by the clone)). As a
5139 ** workaround for that we call memcached_quit to send the quit command
5140 ** to the server and wait for the response ;-) If you use the test code
5141 ** as an example for your own code, please note that you shouldn't need
5144 memcached_quit(memc
);
5146 /* Verify that all messages are stored, and we didn't stuff too much
5149 test_compare(MEMCACHED_SUCCESS
,
5150 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5152 unsigned int counter
= 0;
5153 memcached_execute_fn callbacks
[]= { &callback_counter
};
5154 test_compare(MEMCACHED_SUCCESS
,
5155 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5157 /* Verify that we received all of the key/value pairs */
5158 test_compare(counter
, max_keys
);
5160 memcached_quit(memc
);
5162 * Don't do the following in your code. I am abusing the internal details
5163 * within the library, and this is not a supported interface.
5164 * This is to verify correct behavior in the library. Fake that two servers
5167 instance_one
= memcached_server_instance_by_position(memc
, 0);
5168 instance_two
= memcached_server_instance_by_position(memc
, 2);
5169 in_port_t port0
= instance_one
->port
;
5170 in_port_t port2
= instance_two
->port
;
5172 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5173 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5175 test_compare(MEMCACHED_SUCCESS
,
5176 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5179 test_compare(MEMCACHED_SUCCESS
,
5180 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5181 test_compare(counter
, (unsigned int)max_keys
);
5183 /* restore the memc handle */
5184 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5185 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5187 memcached_quit(memc
);
5189 /* Remove half of the objects */
5190 for (size_t x
= 0; x
< max_keys
; ++x
)
5194 test_compare(MEMCACHED_SUCCESS
,
5195 memcached_delete(memc
, keys
[x
], key_length
[x
], 0));
5199 memcached_quit(memc
);
5200 ((memcached_server_write_instance_st
)instance_one
)->port
= 0;
5201 ((memcached_server_write_instance_st
)instance_two
)->port
= 0;
5203 /* now retry the command, this time we should have cache misses */
5204 test_compare(MEMCACHED_SUCCESS
,
5205 memcached_mget(memc
, (const char* const *)keys
, key_length
, max_keys
));
5208 test_compare(MEMCACHED_SUCCESS
,
5209 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
5210 test_compare(counter
, (unsigned int)(max_keys
>> 1));
5212 /* Release allocated resources */
5213 for (size_t x
= 0; x
< max_keys
; ++x
)
5220 /* restore the memc handle */
5221 ((memcached_server_write_instance_st
)instance_one
)->port
= port0
;
5222 ((memcached_server_write_instance_st
)instance_two
)->port
= port2
;
5224 return TEST_SUCCESS
;
5227 static test_return_t
regression_bug_463297(memcached_st
*memc
)
5229 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
5230 test_true(memc_clone
);
5231 test_true(memcached_version(memc_clone
) == MEMCACHED_SUCCESS
);
5233 memcached_server_instance_st instance
=
5234 memcached_server_instance_by_position(memc_clone
, 0);
5236 if (instance
->major_version
> 1 ||
5237 (instance
->major_version
== 1 &&
5238 instance
->minor_version
> 2))
5240 /* Binary protocol doesn't support deferred delete */
5241 memcached_st
*bin_clone
= memcached_clone(NULL
, memc
);
5242 test_true(bin_clone
);
5243 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(bin_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5244 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(bin_clone
, "foo", 3, 1));
5245 memcached_free(bin_clone
);
5247 memcached_quit(memc_clone
);
5249 /* If we know the server version, deferred delete should fail
5250 * with invalid arguments */
5251 test_compare(MEMCACHED_INVALID_ARGUMENTS
, memcached_delete(memc_clone
, "foo", 3, 1));
5253 /* If we don't know the server version, we should get a protocol error */
5254 memcached_return_t rc
= memcached_delete(memc
, "foo", 3, 1);
5256 /* but there is a bug in some of the memcached servers (1.4) that treats
5257 * the counter as noreply so it doesn't send the proper error message
5259 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5261 /* And buffered mode should be disabled and we should get protocol error */
5262 test_true(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 1) == MEMCACHED_SUCCESS
);
5263 rc
= memcached_delete(memc
, "foo", 3, 1);
5264 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5266 /* Same goes for noreply... */
5267 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 1));
5268 rc
= memcached_delete(memc
, "foo", 3, 1);
5269 test_true_got(rc
== MEMCACHED_PROTOCOL_ERROR
|| rc
== MEMCACHED_NOTFOUND
|| rc
== MEMCACHED_CLIENT_ERROR
|| rc
== MEMCACHED_INVALID_ARGUMENTS
, memcached_strerror(NULL
, rc
));
5271 /* but a normal request should go through (and be buffered) */
5272 test_compare(MEMCACHED_BUFFERED
, (rc
= memcached_delete(memc
, "foo", 3, 0)));
5273 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
5275 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
, 0));
5276 /* unbuffered noreply should be success */
5277 test_compare(MEMCACHED_SUCCESS
, memcached_delete(memc
, "foo", 3, 0));
5278 /* unbuffered with reply should be not found... */
5279 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NOREPLY
, 0));
5280 test_compare(MEMCACHED_NOTFOUND
, memcached_delete(memc
, "foo", 3, 0));
5283 memcached_free(memc_clone
);
5284 return TEST_SUCCESS
;
5288 /* Test memcached_server_get_last_disconnect
5289 * For a working server set, shall be NULL
5290 * For a set of non existing server, shall not be NULL
5292 static test_return_t
test_get_last_disconnect(memcached_st
*memc
)
5294 memcached_return_t rc
;
5295 memcached_server_instance_st disconnected_server
;
5297 /* With the working set of server */
5298 const char *key
= "marmotte";
5299 const char *value
= "milka";
5301 memcached_reset_last_disconnected_server(memc
);
5302 test_false(memc
->last_disconnected_server
);
5303 rc
= memcached_set(memc
, key
, strlen(key
),
5304 value
, strlen(value
),
5305 (time_t)0, (uint32_t)0);
5306 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5308 disconnected_server
= memcached_server_get_last_disconnect(memc
);
5309 test_false(disconnected_server
);
5311 /* With a non existing server */
5313 memcached_server_st
*servers
;
5315 const char *server_list
= "localhost:9";
5317 servers
= memcached_servers_parse(server_list
);
5319 mine
= memcached_create(NULL
);
5320 rc
= memcached_server_push(mine
, servers
);
5321 test_compare(MEMCACHED_SUCCESS
, rc
);
5322 memcached_server_list_free(servers
);
5325 rc
= memcached_set(mine
, key
, strlen(key
),
5326 value
, strlen(value
),
5327 (time_t)0, (uint32_t)0);
5328 test_true(memcached_failed(rc
));
5330 disconnected_server
= memcached_server_get_last_disconnect(mine
);
5331 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
5332 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
5333 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
5335 memcached_quit(mine
);
5336 memcached_free(mine
);
5338 return TEST_SUCCESS
;
5341 static test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
5343 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
5344 char buffer
[BUFSIZ
];
5346 test_compare(MEMCACHED_SUCCESS
,
5347 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
5349 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
5352 // We will just use the error strings as our keys
5353 uint32_t counter
= 100;
5356 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
5358 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
5359 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
5360 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
5362 memcached_server_instance_st disconnected_server
= memcached_server_get_last_disconnect(memc
);
5363 test_true(disconnected_server
);
5364 test_strcmp("localhost", memcached_server_name(disconnected_server
));
5365 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
5369 memcached_reset_last_disconnected_server(memc
);
5374 memcached_free(memc
);
5376 return TEST_SUCCESS
;
5379 static test_return_t
test_verbosity(memcached_st
*memc
)
5381 memcached_verbosity(memc
, 3);
5383 return TEST_SUCCESS
;
5387 static memcached_return_t
stat_printer(memcached_server_instance_st server
,
5388 const char *key
, size_t key_length
,
5389 const char *value
, size_t value_length
,
5399 return MEMCACHED_SUCCESS
;
5402 static test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
5404 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
5405 test_compare(MEMCACHED_SUCCESS
, rc
);
5407 rc
= memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
);
5408 test_compare(MEMCACHED_SUCCESS
, rc
);
5410 rc
= memcached_stat_execute(memc
, "items", stat_printer
, NULL
);
5411 test_compare(MEMCACHED_SUCCESS
, rc
);
5413 rc
= memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
);
5414 test_compare(MEMCACHED_SUCCESS
, rc
);
5416 return TEST_SUCCESS
;
5420 * This test ensures that the failure counter isn't incremented during
5421 * normal termination of the memcached instance.
5423 static test_return_t
wrong_failure_counter_test(memcached_st
*memc
)
5425 memcached_return_t rc
;
5426 memcached_server_instance_st instance
;
5428 /* Set value to force connection to the server */
5429 const char *key
= "marmotte";
5430 const char *value
= "milka";
5433 * Please note that I'm abusing the internal structures in libmemcached
5434 * in a non-portable way and you shouldn't be doing this. I'm only
5435 * doing this in order to verify that the library works the way it should
5437 uint32_t number_of_hosts
= memcached_server_count(memc
);
5438 memc
->number_of_hosts
= 1;
5440 /* Ensure that we are connected to the server by setting a value */
5441 rc
= memcached_set(memc
, key
, strlen(key
),
5442 value
, strlen(value
),
5443 (time_t)0, (uint32_t)0);
5444 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
5447 instance
= memcached_server_instance_by_position(memc
, 0);
5448 /* The test is to see that the memcached_quit doesn't increase the
5449 * the server failure conter, so let's ensure that it is zero
5450 * before sending quit
5452 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
5454 memcached_quit(memc
);
5456 /* Verify that it memcached_quit didn't increment the failure counter
5457 * Please note that this isn't bullet proof, because an error could
5460 test_zero(instance
->server_failure_counter
);
5462 /* restore the instance */
5463 memc
->number_of_hosts
= number_of_hosts
;
5465 return TEST_SUCCESS
;
5469 * This tests ensures expected disconnections (for some behavior changes
5470 * for instance) do not wrongly increase failure counter
5472 static test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
5474 memcached_return rc
;
5476 memcached_st
*memc_clone
;
5477 memc_clone
= memcached_clone(NULL
, memc
);
5478 test_true(memc_clone
);
5480 /* Set value to force connection to the server */
5481 const char *key
= "marmotte";
5482 const char *value
= "milka";
5483 char *string
= NULL
;
5484 size_t string_length
;
5487 rc
= memcached_set(memc_clone
, key
, strlen(key
),
5488 value
, strlen(value
),
5489 (time_t)0, (uint32_t)0);
5490 test_true_got(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
, memcached_strerror(NULL
, rc
));
5493 /* put failure limit to 1 */
5494 test_compare(MEMCACHED_SUCCESS
,
5495 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1));
5497 /* Put a retry timeout to effectively activate failure_limit effect */
5498 test_compare(MEMCACHED_SUCCESS
,
5499 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
5501 /* change behavior that triggers memcached_quit()*/
5502 test_compare(MEMCACHED_SUCCESS
,
5503 memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5506 /* Check if we still are connected */
5507 string
= memcached_get(memc_clone
, key
, strlen(key
),
5508 &string_length
, &flags
, &rc
);
5510 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
5513 memcached_free(memc_clone
);
5515 return TEST_SUCCESS
;
5522 * Test that ensures mget_execute does not end into recursive calls that finally fails
5524 static test_return_t
regression_bug_490486(memcached_st
*memc
)
5526 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5527 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
5528 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5529 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 1);
5530 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5533 return TEST_SKIPPED
; // My MAC can't handle this test
5537 * I only want to hit _one_ server so I know the number of requests I'm
5538 * sending in the pipeline.
5540 uint32_t number_of_hosts
= memc
->number_of_hosts
;
5541 memc
->number_of_hosts
= 1;
5542 size_t max_keys
= 20480;
5545 char **keys
= (char **)calloc(max_keys
, sizeof(char*));
5546 size_t *key_length
= (size_t *)calloc(max_keys
, sizeof(size_t));
5548 /* First add all of the items.. */
5549 char blob
[1024]= { 0 };
5550 for (size_t x
= 0; x
< max_keys
; ++x
)
5553 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%lu", (unsigned long)x
);
5556 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5557 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
5562 /* Try to get all of them with a large multiget */
5564 memcached_execute_function callbacks
[]= { &callback_counter
};
5565 memcached_return_t rc
= memcached_mget_execute(memc
, (const char**)keys
, key_length
,
5566 (size_t)max_keys
, callbacks
, &counter
, 1);
5567 test_compare(MEMCACHED_SUCCESS
, rc
);
5569 char* the_value
= NULL
;
5570 char the_key
[MEMCACHED_MAX_KEY
];
5571 size_t the_key_length
;
5572 size_t the_value_length
;
5576 the_value
= memcached_fetch(memc
, the_key
, &the_key_length
, &the_value_length
, &the_flags
, &rc
);
5578 if ((the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
))
5584 } while ( (the_value
!= NULL
) && (rc
== MEMCACHED_SUCCESS
));
5587 test_compare(MEMCACHED_END
, rc
);
5589 /* Verify that we got all of the items */
5590 test_compare(counter
, max_keys
);
5593 /* Release all allocated resources */
5594 for (size_t x
= 0; x
< max_keys
; ++x
)
5601 memc
->number_of_hosts
= number_of_hosts
;
5603 return TEST_SUCCESS
;
5606 static test_return_t
regression_bug_583031(memcached_st
*)
5608 memcached_st
*memc
= memcached_create(NULL
);
5610 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.3.4", 11211));
5612 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 1000);
5613 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
5614 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
5615 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
5616 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5617 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
5619 memcached_return_t rc
;
5623 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
5627 test_compare_got(MEMCACHED_TIMEOUT
, rc
, memcached_last_error_message(memc
));
5629 memcached_free(memc
);
5631 return TEST_SUCCESS
;
5634 static test_return_t
regression_bug_581030(memcached_st
*)
5637 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
5638 test_false(local_stat
);
5640 memcached_stat_free(NULL
, NULL
);
5643 return TEST_SUCCESS
;
5646 #define regression_bug_655423_COUNT 6000
5647 static test_return_t
regression_bug_655423(memcached_st
*memc
)
5649 memcached_st
*clone
= memcached_clone(NULL
, memc
);
5650 memc
= NULL
; // Just to make sure it is not used
5655 return TEST_SKIPPED
;
5658 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
5659 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
5660 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
5661 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
5663 memset(payload
, int('x'), sizeof(payload
));
5665 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5667 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5668 snprintf(key
, sizeof(key
), "%u", x
);
5670 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
, key
, strlen(key
), payload
, sizeof(payload
), 0, 0));
5673 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5675 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5676 snprintf(key
, sizeof(key
), "%u", x
);
5678 size_t value_length
;
5679 memcached_return_t rc
;
5680 char *value
= memcached_get(clone
, key
, strlen(key
), &value_length
, NULL
, &rc
);
5682 if (rc
== MEMCACHED_NOTFOUND
)
5685 test_zero(value_length
);
5689 test_compare(MEMCACHED_SUCCESS
, rc
);
5691 test_compare(100LLU, value_length
);
5695 char **keys
= (char**)calloc(regression_bug_655423_COUNT
, sizeof(char*));
5696 size_t *key_length
= (size_t *)calloc(regression_bug_655423_COUNT
, sizeof(size_t));
5697 for (uint32_t x
= 0; x
< regression_bug_655423_COUNT
; x
++)
5699 char key
[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH
+1];
5700 snprintf(key
, sizeof(key
), "%u", x
);
5702 keys
[x
]= strdup(key
);
5704 key_length
[x
]= strlen(key
);
5705 test_true(key_length
[x
]);
5708 test_compare(MEMCACHED_SUCCESS
,
5709 memcached_mget(clone
, (const char* const *)keys
, key_length
, regression_bug_655423_COUNT
));
5712 memcached_result_st
*result
= NULL
;
5713 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
5715 test_compare(size_t(100), memcached_result_length(result
));
5719 test_true(count
> 100); // If we don't get back atleast this, something is up
5721 /* Release all allocated resources */
5722 for (size_t x
= 0; x
< regression_bug_655423_COUNT
; ++x
)
5730 memcached_free(clone
);
5732 return TEST_SUCCESS
;
5736 * Test that ensures that buffered set to not trigger problems during io_flush
5738 #define regression_bug_490520_COUNT 200480
5739 static test_return_t
regression_bug_490520(memcached_st
*memc
)
5741 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
5742 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
5743 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
5744 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
5745 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
5747 memc
->number_of_hosts
= 1;
5749 char **keys
= (char **)calloc(regression_bug_490520_COUNT
, sizeof(char*));
5750 size_t *key_length
= (size_t *)calloc(regression_bug_490520_COUNT
, sizeof(size_t));
5752 /* First add all of the items.. */
5753 char blob
[3333] = {0};
5754 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5757 key_length
[x
]= (size_t)snprintf(k
, sizeof(k
), "0200%u", x
);
5761 memcached_return rc
= memcached_set(memc
, keys
[x
], key_length
[x
], blob
, sizeof(blob
), 0, 0);
5762 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
5765 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
5772 return TEST_SUCCESS
;
5776 static test_return_t
regression_bug_854604(memcached_st
*)
5780 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
5782 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
5784 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
5785 test_compare(buffer
[0], 0);
5787 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
5788 test_true(strlen(buffer
));
5790 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
5791 test_true(strlen(buffer
));
5793 return TEST_SUCCESS
;
5796 static void memcached_die(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
5798 fprintf(stderr
, "Iteration #%u: ", it
);
5800 if (error
== MEMCACHED_ERRNO
)
5802 fprintf(stderr
, "system error %d from %s: %s\n",
5803 errno
, what
, strerror(errno
));
5807 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
5808 memcached_strerror(mc
, error
));
5812 #define TEST_CONSTANT_CREATION 200
5814 static test_return_t
regression_bug_(memcached_st
*memc
)
5816 const char *remote_server
;
5819 if (! (remote_server
= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5821 return TEST_SKIPPED
;
5824 for (uint32_t x
= 0; x
< TEST_CONSTANT_CREATION
; x
++)
5826 memcached_st
* mc
= memcached_create(NULL
);
5827 memcached_return rc
;
5829 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1);
5830 if (rc
!= MEMCACHED_SUCCESS
)
5832 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5835 rc
= memcached_behavior_set(mc
, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS
, 1);
5836 if (rc
!= MEMCACHED_SUCCESS
)
5838 memcached_die(mc
, rc
, "memcached_behavior_set", x
);
5841 rc
= memcached_server_add(mc
, remote_server
, 0);
5842 if (rc
!= MEMCACHED_SUCCESS
)
5844 memcached_die(mc
, rc
, "memcached_server_add", x
);
5847 const char *set_key
= "akey";
5848 const size_t set_key_len
= strlen(set_key
);
5849 const char *set_value
= "a value";
5850 const size_t set_value_len
= strlen(set_value
);
5852 if (rc
== MEMCACHED_SUCCESS
)
5856 size_t get_value_len
;
5858 uint32_t get_value_flags
;
5860 get_value
= memcached_get(mc
, set_key
, set_key_len
, &get_value_len
,
5861 &get_value_flags
, &rc
);
5862 if (rc
!= MEMCACHED_SUCCESS
)
5864 memcached_die(mc
, rc
, "memcached_get", x
);
5870 (get_value_len
!= set_value_len
5871 || 0!=strncmp(get_value
, set_value
, get_value_len
)))
5873 fprintf(stderr
, "Values don't match?\n");
5874 rc
= MEMCACHED_FAILURE
;
5880 rc
= memcached_set(mc
,
5881 set_key
, set_key_len
,
5882 set_value
, set_value_len
,
5886 if (rc
!= MEMCACHED_SUCCESS
)
5888 memcached_die(mc
, rc
, "memcached_set", x
);
5895 if (rc
!= MEMCACHED_SUCCESS
)
5901 return TEST_SUCCESS
;
5904 /* Clean the server before beginning testing */
5906 {"util_version", true, (test_callback_fn
*)util_version_test
},
5907 {"flush", false, (test_callback_fn
*)flush_test
},
5908 {"init", false, (test_callback_fn
*)init_test
},
5909 {"allocation", false, (test_callback_fn
*)allocation_test
},
5910 {"server_list_null_test", false, (test_callback_fn
*)server_list_null_test
},
5911 {"server_unsort", false, (test_callback_fn
*)server_unsort_test
},
5912 {"server_sort", false, (test_callback_fn
*)server_sort_test
},
5913 {"server_sort2", false, (test_callback_fn
*)server_sort2_test
},
5914 {"memcached_server_remove", false, (test_callback_fn
*)memcached_server_remove_test
},
5915 {"clone_test", false, (test_callback_fn
*)clone_test
},
5916 {"connection_test", false, (test_callback_fn
*)connection_test
},
5917 {"callback_test", false, (test_callback_fn
*)callback_test
},
5918 {"userdata_test", false, (test_callback_fn
*)userdata_test
},
5919 {"set", false, (test_callback_fn
*)set_test
},
5920 {"set2", false, (test_callback_fn
*)set_test2
},
5921 {"set3", false, (test_callback_fn
*)set_test3
},
5922 {"dump", true, (test_callback_fn
*)dump_test
},
5923 {"add", true, (test_callback_fn
*)add_test
},
5924 {"memcached_fetch_result(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_fetch_result_NOT_FOUND
},
5925 {"replace", true, (test_callback_fn
*)replace_test
},
5926 {"delete", true, (test_callback_fn
*)delete_test
},
5927 {"get", true, (test_callback_fn
*)get_test
},
5928 {"get2", false, (test_callback_fn
*)get_test2
},
5929 {"get3", false, (test_callback_fn
*)get_test3
},
5930 {"get4", false, (test_callback_fn
*)get_test4
},
5931 {"partial mget", false, (test_callback_fn
*)get_test5
},
5932 {"stats_servername", false, (test_callback_fn
*)stats_servername_test
},
5933 {"increment", false, (test_callback_fn
*)increment_test
},
5934 {"increment_with_initial", true, (test_callback_fn
*)increment_with_initial_test
},
5935 {"decrement", false, (test_callback_fn
*)decrement_test
},
5936 {"decrement_with_initial", true, (test_callback_fn
*)decrement_with_initial_test
},
5937 {"increment_by_key", false, (test_callback_fn
*)increment_by_key_test
},
5938 {"increment_with_initial_by_key", true, (test_callback_fn
*)increment_with_initial_by_key_test
},
5939 {"decrement_by_key", false, (test_callback_fn
*)decrement_by_key_test
},
5940 {"decrement_with_initial_by_key", true, (test_callback_fn
*)decrement_with_initial_by_key_test
},
5941 {"binary_increment_with_prefix", 1, (test_callback_fn
*)binary_increment_with_prefix_test
},
5942 {"quit", false, (test_callback_fn
*)quit_test
},
5943 {"mget", true, (test_callback_fn
*)mget_test
},
5944 {"mget_result", true, (test_callback_fn
*)mget_result_test
},
5945 {"mget_result_alloc", true, (test_callback_fn
*)mget_result_alloc_test
},
5946 {"mget_result_function", true, (test_callback_fn
*)mget_result_function
},
5947 {"mget_execute", true, (test_callback_fn
*)mget_execute
},
5948 {"mget_end", false, (test_callback_fn
*)mget_end
},
5949 {"get_stats", false, (test_callback_fn
*)get_stats
},
5950 {"add_host_test", false, (test_callback_fn
*)add_host_test
},
5951 {"add_host_test_1", false, (test_callback_fn
*)add_host_test1
},
5952 {"get_stats_keys", false, (test_callback_fn
*)get_stats_keys
},
5953 {"version_string_test", false, (test_callback_fn
*)version_string_test
},
5954 {"bad_key", true, (test_callback_fn
*)bad_key_test
},
5955 {"memcached_server_cursor", true, (test_callback_fn
*)memcached_server_cursor_test
},
5956 {"read_through", true, (test_callback_fn
*)read_through
},
5957 {"delete_through", true, (test_callback_fn
*)delete_through
},
5958 {"noreply", true, (test_callback_fn
*)noreply_test
},
5959 {"analyzer", true, (test_callback_fn
*)analyzer_test
},
5960 {"memcached_pool_st", true, (test_callback_fn
*)connection_pool_test
},
5961 {"memcached_pool_st #2", true, (test_callback_fn
*)connection_pool2_test
},
5962 {"memcached_pool_st #3", true, (test_callback_fn
*)connection_pool3_test
},
5963 {"memcached_pool_test", true, (test_callback_fn
*)memcached_pool_test
},
5964 {"test_get_last_disconnect", true, (test_callback_fn
*)test_get_last_disconnect
},
5965 {"verbosity", true, (test_callback_fn
*)test_verbosity
},
5966 {"memcached_stat_execute", true, (test_callback_fn
*)memcached_stat_execute_test
},
5967 {"memcached_exist(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_NOTFOUND
},
5968 {"memcached_exist(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_SUCCESS
},
5969 {"memcached_exist_by_key(MEMCACHED_NOTFOUND)", true, (test_callback_fn
*)memcached_exist_by_key_NOTFOUND
},
5970 {"memcached_exist_by_key(MEMCACHED_SUCCESS)", true, (test_callback_fn
*)memcached_exist_by_key_SUCCESS
},
5974 test_st behavior_tests
[] ={
5975 {"libmemcached_string_behavior()", false, (test_callback_fn
*)libmemcached_string_behavior_test
},
5976 {"libmemcached_string_distribution()", false, (test_callback_fn
*)libmemcached_string_distribution_test
},
5977 {"behavior_test", false, (test_callback_fn
*)behavior_test
},
5978 {"MEMCACHED_BEHAVIOR_CORK", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_CORK_test
},
5979 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test
},
5980 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test
},
5981 {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn
*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test
},
5985 test_st libmemcachedutil_tests
[] ={
5986 {"libmemcached_util_ping()", true, (test_callback_fn
*)ping_test
},
5987 {"libmemcached_util_getpid()", true, (test_callback_fn
*)getpid_test
},
5988 {"libmemcached_util_getpid(MEMCACHED_CONNECTION_FAILURE)", true, (test_callback_fn
*)getpid_connection_failure_test
},
5992 test_st basic_tests
[] ={
5993 {"init", true, (test_callback_fn
*)basic_init_test
},
5994 {"clone", true, (test_callback_fn
*)basic_clone_test
},
5995 {"reset", true, (test_callback_fn
*)basic_reset_stack_test
},
5996 {"reset heap", true, (test_callback_fn
*)basic_reset_heap_test
},
5997 {"reset stack clone", true, (test_callback_fn
*)basic_reset_stack_clone_test
},
5998 {"reset heap clone", true, (test_callback_fn
*)basic_reset_heap_clone_test
},
5999 {"memcached_return_t", false, (test_callback_fn
*)memcached_return_t_TEST
},
6003 test_st regression_binary_vs_block
[] ={
6004 {"block add", true, (test_callback_fn
*)block_add_regression
},
6005 {"binary add", true, (test_callback_fn
*)binary_add_regression
},
6009 test_st async_tests
[] ={
6010 {"add", true, (test_callback_fn
*)add_wrapper
},
6014 test_st memcached_server_get_last_disconnect_tests
[] ={
6015 {"memcached_server_get_last_disconnect()", false, (test_callback_fn
*)test_multiple_get_last_disconnect
},
6016 {0, 0, (test_callback_fn
*)0}
6020 test_st result_tests
[] ={
6021 {"result static", false, (test_callback_fn
*)result_static
},
6022 {"result alloc", false, (test_callback_fn
*)result_alloc
},
6023 {0, 0, (test_callback_fn
*)0}
6026 test_st version_1_2_3
[] ={
6027 {"append", false, (test_callback_fn
*)append_test
},
6028 {"prepend", false, (test_callback_fn
*)prepend_test
},
6029 {"cas", false, (test_callback_fn
*)cas_test
},
6030 {"cas2", false, (test_callback_fn
*)cas2_test
},
6031 {"append_binary", false, (test_callback_fn
*)append_binary_test
},
6032 {0, 0, (test_callback_fn
*)0}
6035 test_st haldenbrand_tests
[] ={
6036 {"memcached_set", false, (test_callback_fn
*)user_supplied_bug1
},
6037 {"memcached_get()", false, (test_callback_fn
*)user_supplied_bug2
},
6038 {"memcached_mget()", false, (test_callback_fn
*)user_supplied_bug3
},
6039 {0, 0, (test_callback_fn
*)0}
6042 test_st user_tests
[] ={
6043 {"user_supplied_bug4", true, (test_callback_fn
*)user_supplied_bug4
},
6044 {"user_supplied_bug5", true, (test_callback_fn
*)user_supplied_bug5
},
6045 {"user_supplied_bug6", true, (test_callback_fn
*)user_supplied_bug6
},
6046 {"user_supplied_bug7", true, (test_callback_fn
*)user_supplied_bug7
},
6047 {"user_supplied_bug8", true, (test_callback_fn
*)user_supplied_bug8
},
6048 {"user_supplied_bug9", true, (test_callback_fn
*)user_supplied_bug9
},
6049 {"user_supplied_bug10", true, (test_callback_fn
*)user_supplied_bug10
},
6050 {"user_supplied_bug11", true, (test_callback_fn
*)user_supplied_bug11
},
6051 {"user_supplied_bug12", true, (test_callback_fn
*)user_supplied_bug12
},
6052 {"user_supplied_bug13", true, (test_callback_fn
*)user_supplied_bug13
},
6053 {"user_supplied_bug14", true, (test_callback_fn
*)user_supplied_bug14
},
6054 {"user_supplied_bug15", true, (test_callback_fn
*)user_supplied_bug15
},
6055 {"user_supplied_bug16", true, (test_callback_fn
*)user_supplied_bug16
},
6056 #if !defined(__sun) && !defined(__OpenBSD__)
6058 ** It seems to be something weird with the character sets..
6059 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6060 ** guess I need to find out how this is supposed to work.. Perhaps I need
6061 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6062 ** so just disable the code for now...).
6064 {"user_supplied_bug17", true, (test_callback_fn
*)user_supplied_bug17
},
6066 {"user_supplied_bug18", true, (test_callback_fn
*)user_supplied_bug18
},
6067 {"user_supplied_bug19", true, (test_callback_fn
*)user_supplied_bug19
},
6068 {"user_supplied_bug20", true, (test_callback_fn
*)user_supplied_bug20
},
6069 {"user_supplied_bug21", true, (test_callback_fn
*)user_supplied_bug21
},
6070 {"wrong_failure_counter_test", true, (test_callback_fn
*)wrong_failure_counter_test
},
6071 {"wrong_failure_counter_two_test", true, (test_callback_fn
*)wrong_failure_counter_two_test
},
6072 {0, 0, (test_callback_fn
*)0}
6075 test_st replication_tests
[]= {
6076 {"set", true, (test_callback_fn
*)replication_set_test
},
6077 {"get", false, (test_callback_fn
*)replication_get_test
},
6078 {"mget", false, (test_callback_fn
*)replication_mget_test
},
6079 {"delete", true, (test_callback_fn
*)replication_delete_test
},
6080 {"rand_mget", false, (test_callback_fn
*)replication_randomize_mget_test
},
6081 {"fail", false, (test_callback_fn
*)replication_randomize_mget_fail_test
},
6082 {0, 0, (test_callback_fn
*)0}
6086 * The following test suite is used to verify that we don't introduce
6087 * regression bugs. If you want more information about the bug / test,
6088 * you should look in the bug report at
6089 * http://bugs.launchpad.net/libmemcached
6091 test_st regression_tests
[]= {
6092 {"lp:434484", true, (test_callback_fn
*)regression_bug_434484
},
6093 {"lp:434843", true, (test_callback_fn
*)regression_bug_434843
},
6094 {"lp:434843-buffered", true, (test_callback_fn
*)regression_bug_434843_buffered
},
6095 {"lp:421108", true, (test_callback_fn
*)regression_bug_421108
},
6096 {"lp:442914", true, (test_callback_fn
*)regression_bug_442914
},
6097 {"lp:447342", true, (test_callback_fn
*)regression_bug_447342
},
6098 {"lp:463297", true, (test_callback_fn
*)regression_bug_463297
},
6099 {"lp:490486", true, (test_callback_fn
*)regression_bug_490486
},
6100 {"lp:583031", true, (test_callback_fn
*)regression_bug_583031
},
6101 {"lp:?", true, (test_callback_fn
*)regression_bug_
},
6102 {"lp:728286", true, (test_callback_fn
*)regression_bug_728286
},
6103 {"lp:581030", true, (test_callback_fn
*)regression_bug_581030
},
6104 {"lp:71231153 connect()", true, (test_callback_fn
*)regression_bug_71231153_connect
},
6105 {"lp:71231153 poll()", true, (test_callback_fn
*)regression_bug_71231153_poll
},
6106 {"lp:655423", true, (test_callback_fn
*)regression_bug_655423
},
6107 {"lp:490520", true, (test_callback_fn
*)regression_bug_490520
},
6108 {"lp:854604", true, (test_callback_fn
*)regression_bug_854604
},
6109 {0, false, (test_callback_fn
*)0}
6112 test_st ketama_compatibility
[]= {
6113 {"libmemcached", true, (test_callback_fn
*)ketama_compatibility_libmemcached
},
6114 {"spymemcached", true, (test_callback_fn
*)ketama_compatibility_spymemcached
},
6115 {0, 0, (test_callback_fn
*)0}
6118 test_st generate_tests
[] ={
6119 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6120 {"generate_data", true, (test_callback_fn
*)generate_data
},
6121 {"get_read", false, (test_callback_fn
*)get_read
},
6122 {"delete_generate", false, (test_callback_fn
*)delete_generate
},
6123 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
6124 {"delete_buffer", false, (test_callback_fn
*)delete_buffer_generate
},
6125 {"generate_data", true, (test_callback_fn
*)generate_data
},
6126 {"mget_read", false, (test_callback_fn
*)mget_read
},
6127 {"mget_read_result", false, (test_callback_fn
*)mget_read_result
},
6128 {"memcached_fetch_result() use internal result", false, (test_callback_fn
*)mget_read_internal_result
},
6129 {"memcached_fetch_result() partial read", false, (test_callback_fn
*)mget_read_partial_result
},
6130 {"mget_read_function", false, (test_callback_fn
*)mget_read_function
},
6131 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6132 {"generate_large_pairs", true, (test_callback_fn
*)generate_large_pairs
},
6133 {"generate_data", true, (test_callback_fn
*)generate_data
},
6134 {"generate_buffer_data", true, (test_callback_fn
*)generate_buffer_data
},
6135 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6136 {0, 0, (test_callback_fn
*)0}
6139 test_st consistent_tests
[] ={
6140 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6141 {"generate_data", true, (test_callback_fn
*)generate_data
},
6142 {"get_read", 0, (test_callback_fn
*)get_read_count
},
6143 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6144 {0, 0, (test_callback_fn
*)0}
6147 test_st consistent_weighted_tests
[] ={
6148 {"generate_pairs", true, (test_callback_fn
*)generate_pairs
},
6149 {"generate_data", true, (test_callback_fn
*)generate_data_with_stats
},
6150 {"get_read", false, (test_callback_fn
*)get_read_count
},
6151 {"cleanup", true, (test_callback_fn
*)cleanup_pairs
},
6152 {0, 0, (test_callback_fn
*)0}
6155 test_st hsieh_availability
[] ={
6156 {"hsieh_avaibility_test", false, (test_callback_fn
*)hsieh_avaibility_test
},
6157 {0, 0, (test_callback_fn
*)0}
6160 test_st murmur_availability
[] ={
6161 {"murmur_avaibility_test", false, (test_callback_fn
*)murmur_avaibility_test
},
6162 {0, 0, (test_callback_fn
*)0}
6166 test_st hash_sanity
[] ={
6167 {"hash sanity", 0, (test_callback_fn
*)hash_sanity_test
},
6168 {0, 0, (test_callback_fn
*)0}
6172 test_st ketama_auto_eject_hosts
[] ={
6173 {"auto_eject_hosts", true, (test_callback_fn
*)auto_eject_hosts
},
6174 {"output_ketama_weighted_keys", true, (test_callback_fn
*)output_ketama_weighted_keys
},
6175 {0, 0, (test_callback_fn
*)0}
6178 test_st hash_tests
[] ={
6179 {"one_at_a_time_run", false, (test_callback_fn
*)one_at_a_time_run
},
6180 {"md5", false, (test_callback_fn
*)md5_run
},
6181 {"crc", false, (test_callback_fn
*)crc_run
},
6182 {"fnv1_64", false, (test_callback_fn
*)fnv1_64_run
},
6183 {"fnv1a_64", false, (test_callback_fn
*)fnv1a_64_run
},
6184 {"fnv1_32", false, (test_callback_fn
*)fnv1_32_run
},
6185 {"fnv1a_32", false, (test_callback_fn
*)fnv1a_32_run
},
6186 {"hsieh", false, (test_callback_fn
*)hsieh_run
},
6187 {"murmur", false, (test_callback_fn
*)murmur_run
},
6188 {"jenkis", false, (test_callback_fn
*)jenkins_run
},
6189 {"memcached_get_hashkit", false, (test_callback_fn
*)memcached_get_hashkit_test
},
6190 {0, 0, (test_callback_fn
*)0}
6193 test_st error_conditions
[] ={
6194 {"memcached_get(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_MEMCACHED_ERRNO
},
6195 {"memcached_get(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_MEMCACHED_NOTFOUND
},
6196 {"memcached_get_by_key(MEMCACHED_ERRNO)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_ERRNO
},
6197 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6198 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", false, (test_callback_fn
*)memcached_get_by_key_MEMCACHED_NOTFOUND
},
6199 {"memcached_increment(MEMCACHED_NO_SERVERS)", false, (test_callback_fn
*)memcached_increment_MEMCACHED_NO_SERVERS
},
6200 {0, 0, (test_callback_fn
*)0}
6204 test_st parser_tests
[] ={
6205 {"behavior", false, (test_callback_fn
*)behavior_parser_test
},
6206 {"boolean_options", false, (test_callback_fn
*)parser_boolean_options_test
},
6207 {"configure_file", false, (test_callback_fn
*)memcached_create_with_options_with_filename
},
6208 {"distribtions", false, (test_callback_fn
*)parser_distribution_test
},
6209 {"hash", false, (test_callback_fn
*)parser_hash_test
},
6210 {"libmemcached_check_configuration", false, (test_callback_fn
*)libmemcached_check_configuration_test
},
6211 {"libmemcached_check_configuration_with_filename", false, (test_callback_fn
*)libmemcached_check_configuration_with_filename_test
},
6212 {"number_options", false, (test_callback_fn
*)parser_number_options_test
},
6213 {"randomly generated options", false, (test_callback_fn
*)random_statement_build_test
},
6214 {"namespace", false, (test_callback_fn
*)parser_key_prefix_test
},
6215 {"server", false, (test_callback_fn
*)server_test
},
6216 {"bad server strings", false, (test_callback_fn
*)servers_bad_test
},
6217 {"server with weights", false, (test_callback_fn
*)server_with_weight_test
},
6218 {"parsing servername, port, and weight", false, (test_callback_fn
*)test_hostname_port_weight
},
6219 {"--socket=", false, (test_callback_fn
*)test_parse_socket
},
6220 {"--namespace=", false, (test_callback_fn
*)test_namespace_keyword
},
6221 {0, 0, (test_callback_fn
*)0}
6224 test_st virtual_bucket_tests
[] ={
6225 {"basic", false, (test_callback_fn
*)virtual_back_map
},
6226 {0, 0, (test_callback_fn
*)0}
6229 test_st memcached_server_add_tests
[] ={
6230 {"memcached_server_add(\"\")", false, (test_callback_fn
*)memcached_server_add_empty_test
},
6231 {"memcached_server_add(NULL)", false, (test_callback_fn
*)memcached_server_add_null_test
},
6232 {0, 0, (test_callback_fn
*)0}
6235 test_st namespace_tests
[] ={
6236 {"basic tests", true, (test_callback_fn
*)selection_of_namespace_tests
},
6237 {"increment", true, (test_callback_fn
*)memcached_increment_namespace
},
6238 {0, 0, (test_callback_fn
*)0}
6241 collection_st collection
[] ={
6243 {"hash_sanity", 0, 0, hash_sanity
},
6245 {"libmemcachedutil", 0, 0, libmemcachedutil_tests
},
6246 {"basic", 0, 0, basic_tests
},
6247 {"hsieh_availability", 0, 0, hsieh_availability
},
6248 {"murmur_availability", 0, 0, murmur_availability
},
6249 {"memcached_server_add", 0, 0, memcached_server_add_tests
},
6250 {"block", 0, 0, tests
},
6251 {"binary", (test_callback_fn
*)pre_binary
, 0, tests
},
6252 {"nonblock", (test_callback_fn
*)pre_nonblock
, 0, tests
},
6253 {"nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6254 {"settimer", (test_callback_fn
*)pre_settimer
, 0, tests
},
6255 {"md5", (test_callback_fn
*)pre_md5
, 0, tests
},
6256 {"crc", (test_callback_fn
*)pre_crc
, 0, tests
},
6257 {"hsieh", (test_callback_fn
*)pre_hsieh
, 0, tests
},
6258 {"jenkins", (test_callback_fn
*)pre_jenkins
, 0, tests
},
6259 {"fnv1_64", (test_callback_fn
*)pre_hash_fnv1_64
, 0, tests
},
6260 {"fnv1a_64", (test_callback_fn
*)pre_hash_fnv1a_64
, 0, tests
},
6261 {"fnv1_32", (test_callback_fn
*)pre_hash_fnv1_32
, 0, tests
},
6262 {"fnv1a_32", (test_callback_fn
*)pre_hash_fnv1a_32
, 0, tests
},
6263 {"ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, tests
},
6264 {"ketama_auto_eject_hosts", (test_callback_fn
*)pre_behavior_ketama
, 0, ketama_auto_eject_hosts
},
6265 {"unix_socket", (test_callback_fn
*)pre_unix_socket
, 0, tests
},
6266 {"unix_socket_nodelay", (test_callback_fn
*)pre_nodelay
, 0, tests
},
6267 {"gets", (test_callback_fn
*)enable_cas
, 0, tests
},
6268 {"consistent_crc", (test_callback_fn
*)enable_consistent_crc
, 0, tests
},
6269 {"consistent_hsieh", (test_callback_fn
*)enable_consistent_hsieh
, 0, tests
},
6270 #ifdef MEMCACHED_ENABLE_DEPRECATED
6271 {"deprecated_memory_allocators", (test_callback_fn
*)deprecated_set_memory_alloc
, 0, tests
},
6273 {"memory_allocators", (test_callback_fn
*)set_memory_alloc
, 0, tests
},
6274 {"namespace", (test_callback_fn
*)set_namespace
, 0, tests
},
6275 {"namespace(BINARY)", (test_callback_fn
*)set_namespace_and_binary
, 0, tests
},
6276 {"specific namespace", 0, 0, namespace_tests
},
6277 {"specific namespace(BINARY)", (test_callback_fn
*)pre_binary
, 0, namespace_tests
},
6278 {"version_1_2_3", (test_callback_fn
*)check_for_1_2_3
, 0, version_1_2_3
},
6279 {"result", 0, 0, result_tests
},
6280 {"async", (test_callback_fn
*)pre_nonblock
, 0, async_tests
},
6281 {"async(BINARY)", (test_callback_fn
*)pre_nonblock_binary
, 0, async_tests
},
6282 {"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests
},
6283 {"user written tests", 0, 0, user_tests
},
6284 {"generate", 0, 0, generate_tests
},
6285 {"generate_hsieh", (test_callback_fn
*)pre_hsieh
, 0, generate_tests
},
6286 {"generate_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, generate_tests
},
6287 {"generate_hsieh_consistent", (test_callback_fn
*)enable_consistent_hsieh
, 0, generate_tests
},
6288 {"generate_md5", (test_callback_fn
*)pre_md5
, 0, generate_tests
},
6289 {"generate_murmur", (test_callback_fn
*)pre_murmur
, 0, generate_tests
},
6290 {"generate_jenkins", (test_callback_fn
*)pre_jenkins
, 0, generate_tests
},
6291 {"generate_nonblock", (test_callback_fn
*)pre_nonblock
, 0, generate_tests
},
6293 {"generate_corked", (test_callback_fn
*)pre_cork
, 0, generate_tests
},
6294 {"generate_corked_and_nonblock", (test_callback_fn
*)pre_cork_and_nonblock
, 0, generate_tests
},
6295 {"consistent_not", 0, 0, consistent_tests
},
6296 {"consistent_ketama", (test_callback_fn
*)pre_behavior_ketama
, 0, consistent_tests
},
6297 {"consistent_ketama_weighted", (test_callback_fn
*)pre_behavior_ketama_weighted
, 0, consistent_weighted_tests
},
6298 {"ketama_compat", 0, 0, ketama_compatibility
},
6299 {"test_hashes", 0, 0, hash_tests
},
6300 {"replication", (test_callback_fn
*)pre_replication
, 0, replication_tests
},
6301 {"replication_noblock", (test_callback_fn
*)pre_replication_noblock
, 0, replication_tests
},
6302 {"regression", 0, 0, regression_tests
},
6303 {"behaviors", 0, 0, behavior_tests
},
6304 {"regression_binary_vs_block", (test_callback_fn
*)key_setup
, (test_callback_fn
*)key_teardown
, regression_binary_vs_block
},
6305 {"error_conditions", 0, 0, error_conditions
},
6306 {"parser", 0, 0, parser_tests
},
6307 {"virtual buckets", 0, 0, virtual_bucket_tests
},
6308 {"memcached_server_get_last_disconnect", 0, 0, memcached_server_get_last_disconnect_tests
},
6312 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
6314 #include "tests/libmemcached_world.h"
6316 void get_world(Framework
*world
)
6318 world
->collections
= collection
;
6320 world
->_create
= (test_callback_create_fn
*)world_create
;
6321 world
->_destroy
= (test_callback_destroy_fn
*)world_destroy
;
6323 world
->item
._startup
= (test_callback_fn
*)world_test_startup
;
6324 world
->item
.set_pre((test_callback_fn
*)world_pre_run
);
6325 world
->item
.set_flush((test_callback_fn
*)world_flush
);
6326 world
->item
.set_post((test_callback_fn
*)world_post_run
);
6327 world
->_on_error
= (test_callback_error_fn
*)world_on_error
;
6329 world
->collection_startup
= (test_callback_fn
*)world_container_startup
;
6330 world
->collection_shutdown
= (test_callback_fn
*)world_container_shutdown
;
6332 world
->set_runner(&defualt_libmemcached_runner
);
6334 world
->set_socket();