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.
38 #include "mem_config.h"
39 #include "libtest/test.hpp"
41 #if defined(HAVE_LIBUUID) && HAVE_LIBUUID
42 # include <uuid/uuid.h>
49 #include "libmemcached-1.0/memcached.h"
50 #include "libmemcached/is.h"
51 #include "libmemcached/server_instance.h"
53 #include "libhashkit-1.0/hashkit.h"
55 #include "libtest/memcached.hpp"
60 #include <semaphore.h>
64 #include <sys/types.h>
69 #include "libtest/server.h"
71 #include "bin/generator.h"
73 #define SMALL_STRING_LEN 1024
75 #include "libtest/test.hpp"
77 using namespace libtest
;
79 #include "libmemcachedutil-1.0/util.h"
81 #include "tests/hash_results.h"
83 #include "tests/libmemcached-1.0/callback_counter.h"
84 #include "tests/libmemcached-1.0/fetch_all_results.h"
85 #include "tests/libmemcached-1.0/mem_functions.h"
86 #include "tests/libmemcached-1.0/setup_and_teardowns.h"
87 #include "tests/print.h"
88 #include "tests/debug.h"
89 #include "tests/memc.hpp"
91 #define UUID_STRING_MAXLENGTH 36
93 #include "tests/keys.hpp"
95 #include "libmemcached/instance.hpp"
98 test_return_t
mget_end(memcached_st
*memc
)
100 const char *keys
[]= { "foo", "foo2" };
101 size_t lengths
[]= { 3, 4 };
102 const char *values
[]= { "fjord", "41" };
105 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
107 test_compare(MEMCACHED_SUCCESS
,
110 values
[x
], strlen(values
[x
]),
111 time_t(0), uint32_t(0)));
115 size_t string_length
;
118 // retrieve both via mget
119 test_compare(MEMCACHED_SUCCESS
,
122 test_array_length(keys
)));
124 char key
[MEMCACHED_MAX_KEY
];
126 memcached_return_t rc
;
128 // this should get both
129 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
131 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
133 test_compare(MEMCACHED_SUCCESS
, rc
);
140 test_compare(string_length
, strlen(values
[val
]));
141 test_true(strncmp(values
[val
], string
, string_length
) == 0);
145 // this should indicate end
146 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
147 test_compare(MEMCACHED_END
, rc
);
151 test_compare(MEMCACHED_SUCCESS
,
152 memcached_mget(memc
, keys
, lengths
, 1));
154 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
155 test_compare(key_length
, lengths
[0]);
156 test_true(strncmp(keys
[0], key
, key_length
) == 0);
157 test_compare(string_length
, strlen(values
[0]));
158 test_true(strncmp(values
[0], string
, string_length
) == 0);
159 test_compare(MEMCACHED_SUCCESS
, rc
);
162 // this should indicate end
163 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
164 test_compare(MEMCACHED_END
, rc
);
170 test_return_t
mget_result_test(memcached_st
*memc
)
172 const char *keys
[]= {"fudge", "son", "food"};
173 size_t key_length
[]= {5, 3, 4};
175 memcached_result_st results_obj
;
176 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
178 test_true(&results_obj
== results
);
180 /* We need to empty the server before continueing test */
181 test_compare(MEMCACHED_SUCCESS
,
182 memcached_flush(memc
, 0));
184 test_compare(MEMCACHED_SUCCESS
,
185 memcached_mget(memc
, keys
, key_length
, 3));
187 memcached_return_t rc
;
188 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
193 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
195 test_compare(MEMCACHED_NOTFOUND
, rc
);
197 for (uint32_t x
= 0; x
< 3; x
++)
199 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
200 keys
[x
], key_length
[x
],
201 (time_t)50, (uint32_t)9);
202 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
205 test_compare(MEMCACHED_SUCCESS
,
206 memcached_mget(memc
, keys
, key_length
, 3));
208 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
211 test_true(&results_obj
== results
);
212 test_compare(MEMCACHED_SUCCESS
, rc
);
213 test_memcmp(memcached_result_key_value(results
),
214 memcached_result_value(results
),
215 memcached_result_length(results
));
216 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
219 memcached_result_free(&results_obj
);
224 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
226 const char *keys
[]= {"fudge", "son", "food"};
227 size_t key_length
[]= {5, 3, 4};
229 memcached_result_st
*results
;
231 /* We need to empty the server before continueing test */
232 test_compare(MEMCACHED_SUCCESS
,
233 memcached_flush(memc
, 0));
235 test_compare(MEMCACHED_SUCCESS
,
236 memcached_mget(memc
, keys
, key_length
, 3));
238 memcached_return_t rc
;
239 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
244 test_compare(MEMCACHED_NOTFOUND
, rc
);
246 for (uint32_t x
= 0; x
< 3; x
++)
248 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
249 keys
[x
], key_length
[x
],
250 (time_t)50, (uint32_t)9);
251 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
254 test_compare(MEMCACHED_SUCCESS
,
255 memcached_mget(memc
, keys
, key_length
, 3));
258 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
261 test_compare(MEMCACHED_SUCCESS
, rc
);
262 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
263 test_memcmp(memcached_result_key_value(results
),
264 memcached_result_value(results
),
265 memcached_result_length(results
));
266 memcached_result_free(results
);
273 test_return_t
mget_result_function(memcached_st
*memc
)
275 const char *keys
[]= {"fudge", "son", "food"};
276 size_t key_length
[]= {5, 3, 4};
278 memcached_execute_fn callbacks
[1];
280 for (uint32_t x
= 0; x
< 3; x
++)
282 test_compare(return_value_based_on_buffering(memc
),
283 memcached_set(memc
, keys
[x
], key_length
[x
],
284 keys
[x
], key_length
[x
],
285 time_t(50), uint32_t(9)));
287 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
288 memcached_quit(memc
);
290 test_compare(MEMCACHED_SUCCESS
,
291 memcached_mget(memc
, keys
, key_length
, 3));
293 callbacks
[0]= &callback_counter
;
296 test_compare(MEMCACHED_SUCCESS
,
297 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
299 test_compare(size_t(3), counter
);
304 test_return_t
mget_test(memcached_st
*memc
)
306 const char *keys
[]= {"fudge", "son", "food"};
307 size_t key_length
[]= {5, 3, 4};
309 char return_key
[MEMCACHED_MAX_KEY
];
310 size_t return_key_length
;
312 size_t return_value_length
;
314 test_compare(MEMCACHED_SUCCESS
,
315 memcached_mget(memc
, keys
, key_length
, 3));
318 memcached_return_t rc
;
319 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
320 &return_value_length
, &flags
, &rc
)))
322 test_true(return_value
);
324 test_false(return_value
);
325 test_zero(return_value_length
);
326 test_compare(MEMCACHED_NOTFOUND
, rc
);
328 for (uint32_t x
= 0; x
< 3; x
++)
330 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
331 keys
[x
], key_length
[x
],
332 (time_t)50, (uint32_t)9);
333 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
335 test_compare(MEMCACHED_SUCCESS
,
336 memcached_mget(memc
, keys
, key_length
, 3));
339 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
340 &return_value_length
, &flags
, &rc
)))
342 test_true(return_value
);
343 test_compare(MEMCACHED_SUCCESS
, rc
);
344 if (not memc
->_namespace
)
346 test_compare(return_key_length
, return_value_length
);
347 test_memcmp(return_value
, return_key
, return_value_length
);
356 test_return_t
mget_execute(memcached_st
*original_memc
)
358 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
360 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
365 /* First add all of the items.. */
366 char blob
[1024] = {0};
368 for (size_t x
= 0; x
< keys
.size(); ++x
)
370 uint64_t query_id
= memcached_query_id(memc
);
371 memcached_return_t rc
= memcached_add(memc
,
372 keys
.key_at(x
), keys
.length_at(x
),
375 ASSERT_TRUE_(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, "Returned %s", memcached_strerror(NULL
, rc
));
376 test_compare(query_id
+1, memcached_query_id(memc
));
379 /* Try to get all of them with a large multiget */
381 memcached_execute_fn callbacks
[]= { &callback_counter
};
382 test_compare(MEMCACHED_SUCCESS
,
383 memcached_mget_execute(memc
,
384 keys
.keys_ptr(), keys
.lengths_ptr(),
385 keys
.size(), callbacks
, &counter
, 1));
388 uint64_t query_id
= memcached_query_id(memc
);
389 test_compare(MEMCACHED_SUCCESS
,
390 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
391 test_compare(query_id
, memcached_query_id(memc
));
393 /* Verify that we got all of the items */
394 test_compare(keys
.size(), counter
);
397 memcached_free(memc
);
402 test_return_t
MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST(memcached_st
*original_memc
)
404 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
406 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
409 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 8));
413 /* First add all of the items.. */
414 char blob
[1024] = {0};
416 for (size_t x
= 0; x
< keys
.size(); ++x
)
418 uint64_t query_id
= memcached_query_id(memc
);
419 memcached_return_t rc
= memcached_add(memc
,
420 keys
.key_at(x
), keys
.length_at(x
),
423 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
424 test_compare(query_id
+1, memcached_query_id(memc
));
427 /* Try to get all of them with a large multiget */
429 memcached_execute_fn callbacks
[]= { &callback_counter
};
430 test_compare(MEMCACHED_SUCCESS
,
431 memcached_mget_execute(memc
,
432 keys
.keys_ptr(), keys
.lengths_ptr(),
433 keys
.size(), callbacks
, &counter
, 1));
436 uint64_t query_id
= memcached_query_id(memc
);
437 test_compare(MEMCACHED_SUCCESS
,
438 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
439 test_compare(query_id
, memcached_query_id(memc
));
441 /* Verify that we got all of the items */
442 test_compare(keys
.size(), counter
);
445 memcached_free(memc
);
450 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
452 memcached_return_t rc
;
454 const char *key
= "not_found";
455 size_t key_length
= test_literal_param_size("not_found");
457 test_compare(MEMCACHED_SUCCESS
,
458 memcached_mget(memc
, &key
, &key_length
, 1));
460 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
462 test_compare(MEMCACHED_NOTFOUND
, rc
);
464 memcached_result_free(result
);
469 /* We don't test the behavior itself, we test the switches */
470 test_return_t
behavior_test(memcached_st
*memc
)
472 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
473 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
475 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
476 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
478 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
479 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
481 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
482 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
484 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
485 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
487 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
488 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
490 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
491 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
493 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
495 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
497 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
498 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
499 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
504 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
506 test_compare(MEMCACHED_DEPRECATED
,
507 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
509 // Platform dependent
511 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
519 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
521 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
522 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
524 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
526 if (memcached_success(rc
))
539 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
541 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
542 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
544 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
546 if (memcached_success(rc
))
558 /* Make sure we behave properly if server list has no values */
559 test_return_t
user_supplied_bug4(memcached_st
*memc
)
561 const char *keys
[]= {"fudge", "son", "food"};
562 size_t key_length
[]= {5, 3, 4};
564 /* Here we free everything before running a bunch of mget tests */
565 memcached_servers_reset(memc
);
568 /* We need to empty the server before continueing test */
569 test_compare(MEMCACHED_NO_SERVERS
,
570 memcached_flush(memc
, 0));
572 test_compare(MEMCACHED_NO_SERVERS
,
573 memcached_mget(memc
, keys
, key_length
, 3));
576 unsigned int keys_returned
;
577 memcached_return_t rc
;
578 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
579 test_compare(MEMCACHED_NOTFOUND
, rc
);
580 test_zero(keys_returned
);
583 for (uint32_t x
= 0; x
< 3; x
++)
585 test_compare(MEMCACHED_NO_SERVERS
,
586 memcached_set(memc
, keys
[x
], key_length
[x
],
587 keys
[x
], key_length
[x
],
588 (time_t)50, (uint32_t)9));
591 test_compare(MEMCACHED_NO_SERVERS
,
592 memcached_mget(memc
, keys
, key_length
, 3));
596 char return_key
[MEMCACHED_MAX_KEY
];
597 memcached_return_t rc
;
598 size_t return_key_length
;
599 size_t return_value_length
;
602 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
603 &return_value_length
, &flags
, &rc
)))
605 test_true(return_value
);
606 test_compare(MEMCACHED_SUCCESS
, rc
);
607 test_true(return_key_length
== return_value_length
);
608 test_memcmp(return_value
, return_key
, return_value_length
);
617 #define VALUE_SIZE_BUG5 1048064
618 test_return_t
user_supplied_bug5(memcached_st
*memc
)
620 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
621 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
625 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
627 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
629 insert_data
[x
]= (signed char)rand();
632 test_compare(MEMCACHED_SUCCESS
,
633 memcached_flush(memc
, 0));
635 memcached_return_t rc
;
636 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
637 test_compare(MEMCACHED_SUCCESS
,
638 memcached_mget(memc
, keys
, key_length
, 4));
641 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
642 test_compare(MEMCACHED_NOTFOUND
, rc
);
645 for (uint32_t x
= 0; x
< 4; x
++)
647 test_compare(MEMCACHED_SUCCESS
,
648 memcached_set(memc
, keys
[x
], key_length
[x
],
649 insert_data
, VALUE_SIZE_BUG5
,
650 (time_t)0, (uint32_t)0));
653 for (uint32_t x
= 0; x
< 10; x
++)
655 value
= memcached_get(memc
, keys
[0], key_length
[0],
656 &value_length
, &flags
, &rc
);
657 test_compare(rc
, MEMCACHED_SUCCESS
);
661 test_compare(MEMCACHED_SUCCESS
,
662 memcached_mget(memc
, keys
, key_length
, 4));
664 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
665 test_compare(4U, count
);
667 delete [] insert_data
;
672 test_return_t
user_supplied_bug6(memcached_st
*memc
)
674 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
675 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
676 char return_key
[MEMCACHED_MAX_KEY
];
677 size_t return_key_length
;
681 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
683 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
685 insert_data
[x
]= (signed char)rand();
688 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
690 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
692 // We will now confirm that memcached_mget() returns success, but we will
693 // then check to make sure that no actual keys are returned.
694 test_compare(MEMCACHED_SUCCESS
,
695 memcached_mget(memc
, keys
, key_length
, 4));
697 memcached_return_t rc
;
699 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
700 &value_length
, &flags
, &rc
)))
705 test_compare(MEMCACHED_NOTFOUND
, rc
);
707 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
709 test_compare(MEMCACHED_SUCCESS
,
710 memcached_set(memc
, keys
[x
], key_length
[x
],
711 insert_data
, VALUE_SIZE_BUG5
,
712 (time_t)0, (uint32_t)0));
714 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
716 for (uint32_t x
= 0; x
< 2; x
++)
718 value
= memcached_get(memc
, keys
[0], key_length
[0],
719 &value_length
, &flags
, &rc
);
723 test_compare(MEMCACHED_SUCCESS
,
724 memcached_mget(memc
, keys
, key_length
, 4));
725 /* We test for purge of partial complete fetches */
726 for (count
= 3; count
; count
--)
728 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
729 &value_length
, &flags
, &rc
);
730 test_compare(MEMCACHED_SUCCESS
, rc
);
731 test_memcmp(value
, insert_data
, value_length
);
732 test_true(value_length
);
736 delete [] insert_data
;
741 test_return_t
user_supplied_bug8(memcached_st
*)
743 memcached_return_t rc
;
745 memcached_st
*memc_clone
;
747 memcached_server_st
*servers
;
748 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";
750 servers
= memcached_servers_parse(server_list
);
753 mine
= memcached_create(NULL
);
754 rc
= memcached_server_push(mine
, servers
);
755 test_compare(MEMCACHED_SUCCESS
, rc
);
756 memcached_server_list_free(servers
);
759 memc_clone
= memcached_clone(NULL
, mine
);
761 memcached_quit(mine
);
762 memcached_quit(memc_clone
);
765 memcached_free(mine
);
766 memcached_free(memc_clone
);
771 /* Test flag store/retrieve */
772 test_return_t
user_supplied_bug7(memcached_st
*memc
)
774 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
775 test_true(insert_data
);
777 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
779 insert_data
[x
]= (signed char)rand();
782 memcached_flush(memc
, 0);
784 const char *keys
= "036790384900";
785 size_t key_length
= strlen(keys
);
786 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
787 insert_data
, VALUE_SIZE_BUG5
,
790 memcached_return_t rc
;
793 char *value
= memcached_get(memc
, keys
, key_length
,
794 &value_length
, &flags
, &rc
);
795 test_compare(245U, flags
);
799 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
801 char return_key
[MEMCACHED_MAX_KEY
];
802 size_t return_key_length
;
804 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
805 &value_length
, &flags
, &rc
);
806 test_compare(uint32_t(245), flags
);
809 delete [] insert_data
;
815 test_return_t
user_supplied_bug9(memcached_st
*memc
)
817 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
818 size_t key_length
[3];
822 char return_key
[MEMCACHED_MAX_KEY
];
823 size_t return_key_length
;
825 size_t return_value_length
;
828 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
829 key_length
[1]= strlen("fudge&*@#");
830 key_length
[2]= strlen("for^#@&$not");
833 for (unsigned int x
= 0; x
< 3; x
++)
835 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
836 keys
[x
], key_length
[x
],
837 (time_t)50, (uint32_t)9);
838 test_compare(MEMCACHED_SUCCESS
, rc
);
841 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
842 test_compare(MEMCACHED_SUCCESS
, rc
);
844 /* We need to empty the server before continueing test */
845 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
846 &return_value_length
, &flags
, &rc
)) != NULL
)
848 test_true(return_value
);
852 test_compare(3U, count
);
857 /* We are testing with aggressive timeout to get failures */
858 test_return_t
user_supplied_bug10(memcached_st
*memc
)
860 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
862 size_t value_length
= 512;
864 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
866 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
867 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
868 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
870 libtest::vchar_t value
;
871 value
.reserve(value_length
);
872 for (uint32_t x
= 0; x
< value_length
; x
++)
874 value
.push_back(char(x
% 127));
877 for (unsigned int x
= 1; x
<= 100000; ++x
)
879 memcached_return_t rc
= memcached_set(mclone
,
880 test_literal_param("foo"),
881 &value
[0], value
.size(),
884 test_true((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
885 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
));
887 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
893 memcached_free(mclone
);
899 We are looking failures in the async protocol
901 test_return_t
user_supplied_bug11(memcached_st
*memc
)
905 test::Memc
mclone(memc
);
907 memcached_behavior_set(&mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
908 memcached_behavior_set(&mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
909 memcached_behavior_set(&mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
911 test_compare(-1, int32_t(memcached_behavior_get(&mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
913 libtest::vchar_t value
;
915 for (unsigned int x
= 0; x
< 512; x
++)
917 value
.push_back(char(x
% 127));
920 for (unsigned int x
= 1; x
<= 100000; ++x
)
922 memcached_return_t rc
= memcached_set(&mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
932 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
934 test_return_t
user_supplied_bug12(memcached_st
*memc
)
936 memcached_return_t rc
;
940 uint64_t number_value
;
942 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
943 &value_length
, &flags
, &rc
);
945 test_compare(MEMCACHED_NOTFOUND
, rc
);
947 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
950 /* The binary protocol will set the key if it doesn't exist */
951 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
953 test_compare(MEMCACHED_SUCCESS
, rc
);
957 test_compare(MEMCACHED_NOTFOUND
, rc
);
960 test_compare(MEMCACHED_SUCCESS
,
961 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
963 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
967 test_compare(MEMCACHED_SUCCESS
,
968 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
969 test_compare(2UL, number_value
);
975 Bug found where command total one more than MEMCACHED_MAX_BUFFER
976 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
978 test_return_t
user_supplied_bug13(memcached_st
*memc
)
980 char key
[] = "key34567890";
982 char commandFirst
[]= "set key34567890 0 0 ";
983 char commandLast
[] = " \r\n"; /* first line of command sent to server */
984 size_t commandLength
;
986 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
988 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
990 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
992 char *overflow
= new (std::nothrow
) char[testSize
];
995 memset(overflow
, 'x', testSize
);
996 test_compare(MEMCACHED_SUCCESS
,
997 memcached_set(memc
, key
, strlen(key
),
998 overflow
, testSize
, 0, 0));
1002 return TEST_SUCCESS
;
1007 Test values of many different sizes
1008 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1009 set key34567890 0 0 8169 \r\n
1010 is sent followed by buffer of size 8169, followed by 8169
1012 test_return_t
user_supplied_bug14(memcached_st
*memc
)
1014 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
1016 libtest::vchar_t value
;
1017 value
.reserve(18000);
1018 for (ptrdiff_t x
= 0; x
< 18000; x
++)
1020 value
.push_back((char) (x
% 127));
1023 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
1025 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
1026 &value
[0], current_length
,
1027 (time_t)0, (uint32_t)0);
1028 ASSERT_TRUE_(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, "Instead got %s", memcached_strerror(NULL
, rc
));
1030 size_t string_length
;
1032 char *string
= memcached_get(memc
, test_literal_param("foo"),
1033 &string_length
, &flags
, &rc
);
1035 test_compare(MEMCACHED_SUCCESS
, rc
);
1036 test_compare(string_length
, current_length
);
1038 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
1039 test_memcmp(string
, &value
[0], string_length
);
1044 return TEST_SUCCESS
;
1048 Look for zero length value problems
1050 test_return_t
user_supplied_bug15(memcached_st
*memc
)
1052 for (uint32_t x
= 0; x
< 2; x
++)
1054 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
1056 (time_t)0, (uint32_t)0);
1058 test_compare(MEMCACHED_SUCCESS
, rc
);
1062 char *value
= memcached_get(memc
, test_literal_param("mykey"),
1063 &length
, &flags
, &rc
);
1065 test_compare(MEMCACHED_SUCCESS
, rc
);
1070 value
= memcached_get(memc
, test_literal_param("mykey"),
1071 &length
, &flags
, &rc
);
1073 test_compare(MEMCACHED_SUCCESS
, rc
);
1079 return TEST_SUCCESS
;
1082 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
1083 test_return_t
user_supplied_bug16(memcached_st
*memc
)
1085 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
1087 (time_t)0, UINT32_MAX
));
1092 memcached_return_t rc
;
1093 char *value
= memcached_get(memc
, test_literal_param("mykey"),
1094 &length
, &flags
, &rc
);
1096 test_compare(MEMCACHED_SUCCESS
, rc
);
1099 test_compare(flags
, UINT32_MAX
);
1101 return TEST_SUCCESS
;
1104 #if !defined(__sun) && !defined(__OpenBSD__)
1105 /* Check the validity of chinese key*/
1106 test_return_t
user_supplied_bug17(memcached_st
*memc
)
1108 const char *key
= "豆瓣";
1109 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
1110 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1111 value
, strlen(value
),
1114 test_compare(MEMCACHED_SUCCESS
, rc
);
1118 char *value2
= memcached_get(memc
, key
, strlen(key
),
1119 &length
, &flags
, &rc
);
1121 test_compare(length
, strlen(value
));
1122 test_compare(MEMCACHED_SUCCESS
, rc
);
1123 test_memcmp(value
, value2
, length
);
1126 return TEST_SUCCESS
;
1134 test_return_t
user_supplied_bug19(memcached_st
*)
1136 memcached_return_t res
;
1138 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
1140 const memcached_instance_st
* server
= memcached_server_by_key(memc
, "a", 1, &res
);
1143 memcached_free(memc
);
1145 return TEST_SUCCESS
;
1148 /* CAS test from Andei */
1149 test_return_t
user_supplied_bug20(memcached_st
*memc
)
1151 const char *key
= "abc";
1152 size_t key_len
= strlen("abc");
1154 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
1156 test_compare(MEMCACHED_SUCCESS
,
1158 test_literal_param("abc"),
1159 test_literal_param("foobar"),
1160 (time_t)0, (uint32_t)0));
1162 test_compare(MEMCACHED_SUCCESS
,
1163 memcached_mget(memc
, &key
, &key_len
, 1));
1165 memcached_result_st result_obj
;
1166 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
1169 memcached_result_create(memc
, &result_obj
);
1170 memcached_return_t status
;
1171 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
1174 test_compare(MEMCACHED_SUCCESS
, status
);
1176 memcached_result_free(result
);
1178 return TEST_SUCCESS
;
1181 /* Large mget() of missing keys with binary proto
1183 * If many binary quiet commands (such as getq's in an mget) fill the output
1184 * buffer and the server chooses not to respond, memcached_flush hangs. See
1185 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
1188 /* sighandler_t function that always asserts false */
1189 static __attribute__((noreturn
)) void fail(int)
1195 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
1200 return TEST_SKIPPED
;
1202 void (*oldalarm
)(int);
1204 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
1205 test_true(memc_clone
);
1207 /* only binproto uses getq for mget */
1208 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1210 /* empty the cache to ensure misses (hence non-responses) */
1211 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
1213 keys_st
keys(key_count
);
1215 oldalarm
= signal(SIGALRM
, fail
);
1218 test_compare_got(MEMCACHED_SUCCESS
,
1219 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
1220 memcached_last_error_message(memc_clone
));
1223 signal(SIGALRM
, oldalarm
);
1225 memcached_return_t rc
;
1227 char return_key
[MEMCACHED_MAX_KEY
];
1228 size_t return_key_length
;
1230 size_t return_value_length
;
1231 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1232 &return_value_length
, &flags
, &rc
)))
1234 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
1236 test_compare(MEMCACHED_NOTFOUND
, rc
);
1237 test_zero(return_value_length
);
1238 test_zero(return_key_length
);
1239 test_false(return_key
[0]);
1240 test_false(return_value
);
1242 memcached_free(memc_clone
);
1244 return TEST_SUCCESS
;
1248 test_return_t
user_supplied_bug21(memcached_st
*memc
)
1250 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1252 /* should work as of r580 */
1253 test_compare(TEST_SUCCESS
,
1254 _user_supplied_bug21(memc
, 10));
1256 /* should fail as of r580 */
1257 test_compare(TEST_SUCCESS
,
1258 _user_supplied_bug21(memc
, 1000));
1260 return TEST_SUCCESS
;
1263 test_return_t
comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st
*)
1267 memcached_st
*memc
= &memc_
;
1269 ASSERT_EQ(memc
, MEMCACHED_SUCCESS
);
1270 test_compare(memc
, MEMCACHED_SUCCESS
);
1272 ASSERT_NEQ(memc
, MEMCACHED_FAILURE
);
1274 return TEST_SUCCESS
;
1277 test_return_t
result_static(memcached_st
*memc
)
1279 memcached_result_st result
;
1280 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
1281 test_false(result
.options
.is_allocated
);
1282 test_true(memcached_is_initialized(&result
));
1283 test_true(result_ptr
);
1284 test_true(result_ptr
== &result
);
1286 memcached_result_free(&result
);
1288 test_false(result
.options
.is_allocated
);
1289 test_false(memcached_is_initialized(&result
));
1291 return TEST_SUCCESS
;
1294 test_return_t
result_alloc(memcached_st
*memc
)
1296 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
1297 test_true(result_ptr
);
1298 test_true(result_ptr
->options
.is_allocated
);
1299 test_true(memcached_is_initialized(result_ptr
));
1300 memcached_result_free(result_ptr
);
1302 return TEST_SUCCESS
;
1306 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
1310 #ifdef HARD_MALLOC_TESTS
1311 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
1319 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
1323 #ifdef HARD_MALLOC_TESTS
1324 void *ret
= malloc(size
+ 8);
1327 ret
= (void*)((caddr_t
)ret
+ 8);
1330 void *ret
= malloc(size
);
1335 memset(ret
, 0xff, size
);
1342 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
1344 #ifdef HARD_MALLOC_TESTS
1345 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
1346 void *nmem
= realloc(real_ptr
, size
+ 8);
1351 ret
= (void*)((caddr_t
)nmem
+ 8);
1357 return realloc(mem
, size
);
1362 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
1364 #ifdef HARD_MALLOC_TESTS
1365 void *mem
= my_malloc(ptr
, nelem
* size
);
1368 memset(mem
, 0, nelem
* size
);
1374 return calloc(nelem
, size
);
1378 #ifdef MEMCACHED_ENABLE_DEPRECATED
1379 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
1381 void *test_ptr
= NULL
;
1384 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
1385 cb_ptr
= *(void **)&malloc_cb
;
1386 memcached_return_t rc
;
1388 test_compare(MEMCACHED_SUCCESS
,
1389 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
1390 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
1391 test_compare(MEMCACHED_SUCCESS
, rc
);
1392 test_true(test_ptr
== cb_ptr
);
1396 memcached_realloc_fn realloc_cb
=
1397 (memcached_realloc_fn
)my_realloc
;
1398 cb_ptr
= *(void **)&realloc_cb
;
1399 memcached_return_t rc
;
1401 test_compare(MEMCACHED_SUCCESS
,
1402 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
1403 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
1404 test_compare(MEMCACHED_SUCCESS
, rc
);
1405 test_true(test_ptr
== cb_ptr
);
1409 memcached_free_fn free_cb
=
1410 (memcached_free_fn
)my_free
;
1411 cb_ptr
= *(void **)&free_cb
;
1412 memcached_return_t rc
;
1414 test_compare(MEMCACHED_SUCCESS
,
1415 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
1416 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
1417 test_compare(MEMCACHED_SUCCESS
, rc
);
1418 test_true(test_ptr
== cb_ptr
);
1421 return TEST_SUCCESS
;
1426 test_return_t
set_memory_alloc(memcached_st
*memc
)
1428 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
1429 memcached_set_memory_allocators(memc
, NULL
, my_free
,
1430 my_realloc
, my_calloc
, NULL
));
1432 test_compare(MEMCACHED_SUCCESS
,
1433 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
1434 my_realloc
, my_calloc
, NULL
));
1436 memcached_malloc_fn mem_malloc
;
1437 memcached_free_fn mem_free
;
1438 memcached_realloc_fn mem_realloc
;
1439 memcached_calloc_fn mem_calloc
;
1440 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
1441 &mem_realloc
, &mem_calloc
);
1443 test_true(mem_malloc
== my_malloc
);
1444 test_true(mem_realloc
== my_realloc
);
1445 test_true(mem_calloc
== my_calloc
);
1446 test_true(mem_free
== my_free
);
1448 return TEST_SUCCESS
;
1451 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
1453 const uint64_t timeout
= 100; // Not using, just checking that it sets
1455 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
1457 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
1459 return TEST_SUCCESS
;
1462 test_return_t
analyzer_test(memcached_st
*memc
)
1464 memcached_analysis_st
*report
;
1465 memcached_return_t rc
;
1467 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1468 test_compare(MEMCACHED_SUCCESS
, rc
);
1469 test_true(memc_stat
);
1471 report
= memcached_analyze(memc
, memc_stat
, &rc
);
1472 test_compare(MEMCACHED_SUCCESS
, rc
);
1476 memcached_stat_free(NULL
, memc_stat
);
1478 return TEST_SUCCESS
;
1481 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
1483 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
1485 test_compare(MEMCACHED_SUCCESS
,
1486 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
1487 (uint64_t)MEMCACHED_HASH_HSIEH
));
1489 return TEST_SUCCESS
;
1492 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
1494 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
1496 test_compare(MEMCACHED_SUCCESS
,
1497 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
1499 return TEST_SUCCESS
;
1503 Test case adapted from John Gorman <johngorman2@gmail.com>
1505 We are testing the error condition when we connect to a server via memcached_get()
1506 but find that the server is not available.
1508 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
1512 memcached_return rc
;
1515 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
1517 // See if memcached is reachable.
1518 char *value
= memcached_get(tl_memc_h
,
1519 test_literal_param(__func__
),
1524 test_true(memcached_failed(rc
));
1526 memcached_free(tl_memc_h
);
1528 return TEST_SUCCESS
;
1532 We connect to a server which exists, but search for a key that does not exist.
1534 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
1538 memcached_return rc
;
1540 // See if memcached is reachable.
1541 char *value
= memcached_get(memc
,
1542 test_literal_param(__func__
),
1547 test_compare(MEMCACHED_NOTFOUND
, rc
);
1549 return TEST_SUCCESS
;
1553 Test case adapted from John Gorman <johngorman2@gmail.com>
1555 We are testing the error condition when we connect to a server via memcached_get_by_key()
1556 but find that the server is not available.
1558 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
1562 memcached_return rc
;
1565 memcached_st
*tl_memc_h
= memcached_create(NULL
);
1566 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
1567 memcached_server_push(tl_memc_h
, servers
);
1568 memcached_server_list_free(servers
);
1570 // See if memcached is reachable.
1571 char *value
= memcached_get_by_key(tl_memc_h
,
1572 test_literal_param(__func__
), // Key
1573 test_literal_param(__func__
), // Value
1578 test_true(memcached_failed(rc
));
1580 memcached_free(tl_memc_h
);
1582 return TEST_SUCCESS
;
1586 We connect to a server which exists, but search for a key that does not exist.
1588 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
1592 memcached_return rc
;
1594 // See if memcached is reachable.
1595 char *value
= memcached_get_by_key(memc
,
1596 test_literal_param(__func__
), // Key
1597 test_literal_param(__func__
), // Value
1602 test_compare(MEMCACHED_NOTFOUND
, rc
);
1604 return TEST_SUCCESS
;
1607 test_return_t
regression_bug_421108(memcached_st
*memc
)
1609 memcached_return_t rc
;
1610 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1611 test_compare(MEMCACHED_SUCCESS
, rc
);
1613 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
1614 test_compare(MEMCACHED_SUCCESS
, rc
);
1615 test_true(bytes_str
);
1616 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
1618 test_compare(MEMCACHED_SUCCESS
, rc
);
1619 test_true(bytes_read_str
);
1621 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
1622 "bytes_written", &rc
);
1623 test_compare(MEMCACHED_SUCCESS
, rc
);
1624 test_true(bytes_written_str
);
1626 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
1627 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
1628 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
1630 test_true(bytes
!= bytes_read
);
1631 test_true(bytes
!= bytes_written
);
1633 /* Release allocated resources */
1635 free(bytes_read_str
);
1636 free(bytes_written_str
);
1637 memcached_stat_free(NULL
, memc_stat
);
1639 return TEST_SUCCESS
;
1643 /* Test memcached_server_get_last_disconnect
1644 * For a working server set, shall be NULL
1645 * For a set of non existing server, shall not be NULL
1647 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
1649 memcached_return_t rc
;
1650 const memcached_instance_st
* disconnected_server
;
1652 /* With the working set of server */
1653 const char *key
= "marmotte";
1654 const char *value
= "milka";
1656 memcached_reset_last_disconnected_server(memc
);
1657 test_false(memc
->last_disconnected_server
);
1658 rc
= memcached_set(memc
, key
, strlen(key
),
1659 value
, strlen(value
),
1660 (time_t)0, (uint32_t)0);
1661 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1663 disconnected_server
= memcached_server_get_last_disconnect(memc
);
1664 test_false(disconnected_server
);
1666 /* With a non existing server */
1668 memcached_server_st
*servers
;
1670 const char *server_list
= "localhost:9";
1672 servers
= memcached_servers_parse(server_list
);
1674 mine
= memcached_create(NULL
);
1675 rc
= memcached_server_push(mine
, servers
);
1676 test_compare(MEMCACHED_SUCCESS
, rc
);
1677 memcached_server_list_free(servers
);
1680 rc
= memcached_set(mine
, key
, strlen(key
),
1681 value
, strlen(value
),
1682 (time_t)0, (uint32_t)0);
1683 test_true(memcached_failed(rc
));
1685 disconnected_server
= memcached_server_get_last_disconnect(mine
);
1686 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
1687 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
1688 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
1690 memcached_quit(mine
);
1691 memcached_free(mine
);
1693 return TEST_SUCCESS
;
1696 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
1698 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
1699 char buffer
[BUFSIZ
];
1701 test_compare(MEMCACHED_SUCCESS
,
1702 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
1704 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
1707 // We will just use the error strings as our keys
1708 uint32_t counter
= 100;
1711 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
1713 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
1714 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
1715 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
1717 const memcached_instance_st
* disconnected_server
= memcached_server_get_last_disconnect(memc
);
1718 test_true(disconnected_server
);
1719 test_strcmp("localhost", memcached_server_name(disconnected_server
));
1720 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
1724 memcached_reset_last_disconnected_server(memc
);
1729 memcached_free(memc
);
1731 return TEST_SUCCESS
;
1734 test_return_t
test_verbosity(memcached_st
*memc
)
1736 test_compare(MEMCACHED_SUCCESS
, memcached_verbosity(memc
, 0));
1738 return TEST_SUCCESS
;
1742 static memcached_return_t
stat_printer(const memcached_instance_st
* server
,
1743 const char *key
, size_t key_length
,
1744 const char *value
, size_t value_length
,
1754 return MEMCACHED_SUCCESS
;
1757 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
1759 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
1760 test_compare(MEMCACHED_SUCCESS
, rc
);
1762 test_compare(MEMCACHED_SUCCESS
,
1763 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
1765 test_compare(MEMCACHED_SUCCESS
,
1766 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
1768 test_compare(MEMCACHED_SUCCESS
,
1769 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
1771 return TEST_SUCCESS
;
1775 * This test ensures that the failure counter isn't incremented during
1776 * normal termination of the memcached instance.
1778 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
1780 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
1782 /* Ensure that we are connected to the server by setting a value */
1783 memcached_return_t rc
= memcached_set(memc
,
1784 test_literal_param(__func__
), // Key
1785 test_literal_param(__func__
), // Value
1786 time_t(0), uint32_t(0));
1787 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1790 const memcached_instance_st
* instance
= memcached_server_instance_by_position(memc
, 0);
1792 /* The test is to see that the memcached_quit doesn't increase the
1793 * the server failure conter, so let's ensure that it is zero
1794 * before sending quit
1796 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
1798 memcached_quit(memc
);
1800 /* Verify that it memcached_quit didn't increment the failure counter
1801 * Please note that this isn't bullet proof, because an error could
1804 test_zero(instance
->server_failure_counter
);
1806 memcached_free(memc
);
1808 return TEST_SUCCESS
;
1812 * This tests ensures expected disconnections (for some behavior changes
1813 * for instance) do not wrongly increase failure counter
1815 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
1817 /* Set value to force connection to the server */
1818 const char *key
= "marmotte";
1819 const char *value
= "milka";
1821 test_compare_hint(MEMCACHED_SUCCESS
,
1822 memcached_set(memc
, key
, strlen(key
),
1823 value
, strlen(value
),
1824 (time_t)0, (uint32_t)0),
1825 memcached_last_error_message(memc
));
1828 /* put failure limit to 1 */
1829 test_compare(MEMCACHED_SUCCESS
,
1830 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
1832 /* Put a retry timeout to effectively activate failure_limit effect */
1833 test_compare(MEMCACHED_SUCCESS
,
1834 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
1836 /* change behavior that triggers memcached_quit()*/
1837 test_compare(MEMCACHED_SUCCESS
,
1838 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
1841 /* Check if we still are connected */
1843 size_t string_length
;
1844 memcached_return rc
;
1845 char *string
= memcached_get(memc
, key
, strlen(key
),
1846 &string_length
, &flags
, &rc
);
1848 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1852 return TEST_SUCCESS
;
1856 test_return_t
regression_1021819_TEST(memcached_st
*original
)
1858 memcached_st
*memc
= memcached_clone(NULL
, original
);
1861 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 2000000), MEMCACHED_SUCCESS
);
1862 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 3000000), MEMCACHED_SUCCESS
);
1864 memcached_return_t rc
;
1867 test_literal_param(__func__
),
1870 test_compare(rc
, MEMCACHED_NOTFOUND
);
1872 memcached_free(memc
);
1874 return TEST_SUCCESS
;
1877 test_return_t
regression_bug_583031(memcached_st
*)
1879 memcached_st
*memc
= memcached_create(NULL
);
1881 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.251.4", 11211));
1883 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 3000);
1884 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
1885 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
1886 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
1887 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
1888 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
1890 memcached_return_t rc
;
1894 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
1898 test_compare(MEMCACHED_TIMEOUT
, memc
);
1900 memcached_free(memc
);
1902 return TEST_SUCCESS
;
1905 test_return_t
regression_bug_581030(memcached_st
*)
1908 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
1909 test_false(local_stat
);
1911 memcached_stat_free(NULL
, NULL
);
1914 return TEST_SUCCESS
;
1917 #define regression_bug_655423_COUNT 6000
1918 test_return_t
regression_bug_655423(memcached_st
*memc
)
1920 memcached_st
*clone
= memcached_clone(NULL
, memc
);
1921 memc
= NULL
; // Just to make sure it is not used
1926 return TEST_SKIPPED
;
1929 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
1930 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
1931 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
1932 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
1934 memset(payload
, int('x'), sizeof(payload
));
1936 keys_st
keys(regression_bug_655423_COUNT
);
1938 for (size_t x
= 0; x
< keys
.size(); x
++)
1940 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
1943 payload
, sizeof(payload
), 0, 0));
1946 for (size_t x
= 0; x
< keys
.size(); x
++)
1948 size_t value_length
;
1949 memcached_return_t rc
;
1950 char *value
= memcached_get(clone
,
1953 &value_length
, NULL
, &rc
);
1955 if (rc
== MEMCACHED_NOTFOUND
)
1958 test_zero(value_length
);
1962 test_compare(MEMCACHED_SUCCESS
, rc
);
1964 test_compare(100LLU, value_length
);
1968 test_compare(MEMCACHED_SUCCESS
,
1969 memcached_mget(clone
,
1970 keys
.keys_ptr(), keys
.lengths_ptr(),
1974 memcached_result_st
*result
= NULL
;
1975 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
1977 test_compare(size_t(100), memcached_result_length(result
));
1981 test_true(count
> 100); // If we don't get back atleast this, something is up
1983 memcached_free(clone
);
1985 return TEST_SUCCESS
;
1989 * Test that ensures that buffered set to not trigger problems during io_flush
1991 #define regression_bug_490520_COUNT 200480
1992 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
1994 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
1996 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
1997 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
1998 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
1999 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
2000 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
2002 /* First add all of the items.. */
2003 char blob
[3333] = {0};
2004 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
2007 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
2009 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
2010 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
2013 memcached_free(memc
);
2015 return TEST_SUCCESS
;
2018 test_return_t
regression_bug_1251482(memcached_st
*)
2020 test::Memc
memc("--server=localhost:5");
2022 memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 0);
2024 for (size_t x
= 0; x
< 5; ++x
)
2026 size_t value_length
;
2027 memcached_return_t rc
;
2028 char *value
= memcached_get(&memc
,
2029 test_literal_param(__func__
),
2030 &value_length
, NULL
, &rc
);
2033 test_compare(0LLU, value_length
);
2035 test_ne_compare(MEMCACHED_SUCCESS
, rc
);
2037 test_compare(MEMCACHED_CONNECTION_FAILURE
, rc
);
2041 return TEST_SUCCESS
;
2044 test_return_t
regression_1009493_TEST(memcached_st
*)
2046 memcached_st
* memc
= memcached_create(NULL
);
2048 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, true));
2050 memcached_st
* clone
= memcached_clone(NULL
, memc
);
2053 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
),
2054 memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
2056 memcached_free(memc
);
2057 memcached_free(clone
);
2059 return TEST_SUCCESS
;
2062 test_return_t
regression_994772_TEST(memcached_st
* memc
)
2064 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
2066 test_compare(MEMCACHED_SUCCESS
,
2068 test_literal_param(__func__
), // Key
2069 test_literal_param(__func__
), // Value
2070 time_t(0), uint32_t(0)));
2072 const char *keys
[] = { __func__
};
2073 size_t key_length
[]= { strlen(__func__
) };
2074 test_compare(MEMCACHED_SUCCESS
,
2075 memcached_mget(memc
, keys
, key_length
, 1));
2077 memcached_return_t rc
;
2078 memcached_result_st
*results
= memcached_fetch_result(memc
, NULL
, &rc
);
2080 test_compare(MEMCACHED_SUCCESS
, rc
);
2082 test_strcmp(__func__
, memcached_result_value(results
));
2083 uint64_t cas_value
= memcached_result_cas(results
);
2084 test_true(cas_value
);
2086 char* take_value
= memcached_result_take_value(results
);
2087 test_strcmp(__func__
, take_value
);
2090 memcached_result_free(results
);
2092 // Bad cas value, sanity check
2093 test_true(cas_value
!= 9999);
2094 test_compare(MEMCACHED_END
,
2096 test_literal_param(__func__
), // Key
2097 test_literal_param(__FILE__
), // Value
2098 time_t(0), uint32_t(0), 9999));
2100 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
2101 "different", strlen("different"), // Key
2102 test_literal_param(__FILE__
), // Value
2103 time_t(0), uint32_t(0)));
2105 return TEST_SUCCESS
;
2108 test_return_t
regression_bug_854604(memcached_st
*)
2112 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
2114 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
2116 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
2117 test_compare(buffer
[0], 0);
2119 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
2120 test_true(strlen(buffer
));
2122 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
2123 test_true(strlen(buffer
));
2125 return TEST_SUCCESS
;
2128 static void die_message(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
2130 fprintf(stderr
, "Iteration #%u: ", it
);
2132 if (error
== MEMCACHED_ERRNO
)
2134 fprintf(stderr
, "system error %d from %s: %s\n",
2135 errno
, what
, strerror(errno
));
2139 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
2140 memcached_strerror(mc
, error
));