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
);
470 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
472 test_return_t
user_supplied_bug12(memcached_st
*memc
)
474 memcached_return_t rc
;
478 uint64_t number_value
;
480 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
481 &value_length
, &flags
, &rc
);
483 test_compare(MEMCACHED_NOTFOUND
, rc
);
485 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
488 /* The binary protocol will set the key if it doesn't exist */
489 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
491 test_compare(MEMCACHED_SUCCESS
, rc
);
495 test_compare(MEMCACHED_NOTFOUND
, rc
);
498 test_compare(MEMCACHED_SUCCESS
,
499 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
501 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
505 test_compare(MEMCACHED_SUCCESS
,
506 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
507 test_compare(2UL, number_value
);
513 Bug found where command total one more than MEMCACHED_MAX_BUFFER
514 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
516 test_return_t
user_supplied_bug13(memcached_st
*memc
)
518 char key
[] = "key34567890";
520 char commandFirst
[]= "set key34567890 0 0 ";
521 char commandLast
[] = " \r\n"; /* first line of command sent to server */
522 size_t commandLength
;
524 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
526 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
528 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
530 char *overflow
= new (std::nothrow
) char[testSize
];
533 memset(overflow
, 'x', testSize
);
534 test_compare(MEMCACHED_SUCCESS
,
535 memcached_set(memc
, key
, strlen(key
),
536 overflow
, testSize
, 0, 0));
545 Test values of many different sizes
546 Bug found where command total one more than MEMCACHED_MAX_BUFFER
547 set key34567890 0 0 8169 \r\n
548 is sent followed by buffer of size 8169, followed by 8169
550 test_return_t
user_supplied_bug14(memcached_st
*memc
)
552 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
554 libtest::vchar_t value
;
555 value
.reserve(18000);
556 for (ptrdiff_t x
= 0; x
< 18000; x
++)
558 value
.push_back((char) (x
% 127));
561 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
563 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
564 &value
[0], current_length
,
565 (time_t)0, (uint32_t)0);
566 ASSERT_TRUE_(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, "Instead got %s", memcached_strerror(NULL
, rc
));
568 size_t string_length
;
570 char *string
= memcached_get(memc
, test_literal_param("foo"),
571 &string_length
, &flags
, &rc
);
573 test_compare(MEMCACHED_SUCCESS
, rc
);
574 test_compare(string_length
, current_length
);
576 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
577 test_memcmp(string
, &value
[0], string_length
);
586 Look for zero length value problems
588 test_return_t
user_supplied_bug15(memcached_st
*memc
)
590 for (uint32_t x
= 0; x
< 2; x
++)
592 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
594 (time_t)0, (uint32_t)0);
596 test_compare(MEMCACHED_SUCCESS
, rc
);
600 char *value
= memcached_get(memc
, test_literal_param("mykey"),
601 &length
, &flags
, &rc
);
603 test_compare(MEMCACHED_SUCCESS
, rc
);
608 value
= memcached_get(memc
, test_literal_param("mykey"),
609 &length
, &flags
, &rc
);
611 test_compare(MEMCACHED_SUCCESS
, rc
);
620 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
621 test_return_t
user_supplied_bug16(memcached_st
*memc
)
623 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
625 (time_t)0, UINT32_MAX
));
630 memcached_return_t rc
;
631 char *value
= memcached_get(memc
, test_literal_param("mykey"),
632 &length
, &flags
, &rc
);
634 test_compare(MEMCACHED_SUCCESS
, rc
);
637 test_compare(flags
, UINT32_MAX
);
642 #if !defined(__sun) && !defined(__OpenBSD__)
643 /* Check the validity of chinese key*/
644 test_return_t
user_supplied_bug17(memcached_st
*memc
)
646 const char *key
= "豆瓣";
647 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
648 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
649 value
, strlen(value
),
652 test_compare(MEMCACHED_SUCCESS
, rc
);
656 char *value2
= memcached_get(memc
, key
, strlen(key
),
657 &length
, &flags
, &rc
);
659 test_compare(length
, strlen(value
));
660 test_compare(MEMCACHED_SUCCESS
, rc
);
661 test_memcmp(value
, value2
, length
);
672 test_return_t
user_supplied_bug19(memcached_st
*)
674 memcached_return_t res
;
676 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
678 const memcached_instance_st
* server
= memcached_server_by_key(memc
, "a", 1, &res
);
681 memcached_free(memc
);
686 /* CAS test from Andei */
687 test_return_t
user_supplied_bug20(memcached_st
*memc
)
689 const char *key
= "abc";
690 size_t key_len
= strlen("abc");
692 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
694 test_compare(MEMCACHED_SUCCESS
,
696 test_literal_param("abc"),
697 test_literal_param("foobar"),
698 (time_t)0, (uint32_t)0));
700 test_compare(MEMCACHED_SUCCESS
,
701 memcached_mget(memc
, &key
, &key_len
, 1));
703 memcached_result_st result_obj
;
704 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
707 memcached_result_create(memc
, &result_obj
);
708 memcached_return_t status
;
709 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
712 test_compare(MEMCACHED_SUCCESS
, status
);
714 memcached_result_free(result
);
719 /* Large mget() of missing keys with binary proto
721 * If many binary quiet commands (such as getq's in an mget) fill the output
722 * buffer and the server chooses not to respond, memcached_flush hangs. See
723 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
726 /* sighandler_t function that always asserts false */
727 static __attribute__((noreturn
)) void fail(int)
733 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
740 void (*oldalarm
)(int);
742 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
743 test_true(memc_clone
);
745 /* only binproto uses getq for mget */
746 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
748 /* empty the cache to ensure misses (hence non-responses) */
749 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
751 keys_st
keys(key_count
);
753 oldalarm
= signal(SIGALRM
, fail
);
756 test_compare_got(MEMCACHED_SUCCESS
,
757 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
758 memcached_last_error_message(memc_clone
));
761 signal(SIGALRM
, oldalarm
);
763 memcached_return_t rc
;
765 char return_key
[MEMCACHED_MAX_KEY
];
766 size_t return_key_length
;
768 size_t return_value_length
;
769 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
770 &return_value_length
, &flags
, &rc
)))
772 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
774 test_compare(MEMCACHED_NOTFOUND
, rc
);
775 test_zero(return_value_length
);
776 test_zero(return_key_length
);
777 test_false(return_key
[0]);
778 test_false(return_value
);
780 memcached_free(memc_clone
);
786 test_return_t
user_supplied_bug21(memcached_st
*memc
)
788 test_skip(TEST_SUCCESS
, pre_binary(memc
));
790 /* should work as of r580 */
791 test_compare(TEST_SUCCESS
,
792 _user_supplied_bug21(memc
, 10));
794 /* should fail as of r580 */
795 test_compare(TEST_SUCCESS
,
796 _user_supplied_bug21(memc
, 1000));
801 test_return_t
comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st
*)
805 memcached_st
*memc
= &memc_
;
807 ASSERT_EQ(memc
, MEMCACHED_SUCCESS
);
808 test_compare(memc
, MEMCACHED_SUCCESS
);
810 ASSERT_NEQ(memc
, MEMCACHED_FAILURE
);
815 test_return_t
result_static(memcached_st
*memc
)
817 memcached_result_st result
;
818 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
819 test_false(result
.options
.is_allocated
);
820 test_true(memcached_is_initialized(&result
));
821 test_true(result_ptr
);
822 test_true(result_ptr
== &result
);
824 memcached_result_free(&result
);
826 test_false(result
.options
.is_allocated
);
827 test_false(memcached_is_initialized(&result
));
832 test_return_t
result_alloc(memcached_st
*memc
)
834 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
835 test_true(result_ptr
);
836 test_true(result_ptr
->options
.is_allocated
);
837 test_true(memcached_is_initialized(result_ptr
));
838 memcached_result_free(result_ptr
);
844 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
848 #ifdef HARD_MALLOC_TESTS
849 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
857 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
861 #ifdef HARD_MALLOC_TESTS
862 void *ret
= malloc(size
+ 8);
865 ret
= (void*)((caddr_t
)ret
+ 8);
868 void *ret
= malloc(size
);
873 memset(ret
, 0xff, size
);
880 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
882 #ifdef HARD_MALLOC_TESTS
883 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
884 void *nmem
= realloc(real_ptr
, size
+ 8);
889 ret
= (void*)((caddr_t
)nmem
+ 8);
895 return realloc(mem
, size
);
900 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
902 #ifdef HARD_MALLOC_TESTS
903 void *mem
= my_malloc(ptr
, nelem
* size
);
906 memset(mem
, 0, nelem
* size
);
912 return calloc(nelem
, size
);
916 #ifdef MEMCACHED_ENABLE_DEPRECATED
917 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
919 void *test_ptr
= NULL
;
922 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
923 cb_ptr
= *(void **)&malloc_cb
;
924 memcached_return_t rc
;
926 test_compare(MEMCACHED_SUCCESS
,
927 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
928 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
929 test_compare(MEMCACHED_SUCCESS
, rc
);
930 test_true(test_ptr
== cb_ptr
);
934 memcached_realloc_fn realloc_cb
=
935 (memcached_realloc_fn
)my_realloc
;
936 cb_ptr
= *(void **)&realloc_cb
;
937 memcached_return_t rc
;
939 test_compare(MEMCACHED_SUCCESS
,
940 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
941 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
942 test_compare(MEMCACHED_SUCCESS
, rc
);
943 test_true(test_ptr
== cb_ptr
);
947 memcached_free_fn free_cb
=
948 (memcached_free_fn
)my_free
;
949 cb_ptr
= *(void **)&free_cb
;
950 memcached_return_t rc
;
952 test_compare(MEMCACHED_SUCCESS
,
953 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
954 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
955 test_compare(MEMCACHED_SUCCESS
, rc
);
956 test_true(test_ptr
== cb_ptr
);
964 test_return_t
set_memory_alloc(memcached_st
*memc
)
966 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
967 memcached_set_memory_allocators(memc
, NULL
, my_free
,
968 my_realloc
, my_calloc
, NULL
));
970 test_compare(MEMCACHED_SUCCESS
,
971 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
972 my_realloc
, my_calloc
, NULL
));
974 memcached_malloc_fn mem_malloc
;
975 memcached_free_fn mem_free
;
976 memcached_realloc_fn mem_realloc
;
977 memcached_calloc_fn mem_calloc
;
978 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
979 &mem_realloc
, &mem_calloc
);
981 test_true(mem_malloc
== my_malloc
);
982 test_true(mem_realloc
== my_realloc
);
983 test_true(mem_calloc
== my_calloc
);
984 test_true(mem_free
== my_free
);
989 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
991 const uint64_t timeout
= 100; // Not using, just checking that it sets
993 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
995 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
1000 test_return_t
analyzer_test(memcached_st
*memc
)
1002 memcached_analysis_st
*report
;
1003 memcached_return_t rc
;
1005 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1006 test_compare(MEMCACHED_SUCCESS
, rc
);
1007 test_true(memc_stat
);
1009 report
= memcached_analyze(memc
, memc_stat
, &rc
);
1010 test_compare(MEMCACHED_SUCCESS
, rc
);
1014 memcached_stat_free(NULL
, memc_stat
);
1016 return TEST_SUCCESS
;
1019 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
1021 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
1023 test_compare(MEMCACHED_SUCCESS
,
1024 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
1025 (uint64_t)MEMCACHED_HASH_HSIEH
));
1027 return TEST_SUCCESS
;
1030 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
1032 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
1034 test_compare(MEMCACHED_SUCCESS
,
1035 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
1037 return TEST_SUCCESS
;
1041 Test case adapted from John Gorman <johngorman2@gmail.com>
1043 We are testing the error condition when we connect to a server via memcached_get()
1044 but find that the server is not available.
1046 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
1050 memcached_return rc
;
1053 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
1055 // See if memcached is reachable.
1056 char *value
= memcached_get(tl_memc_h
,
1057 test_literal_param(__func__
),
1062 test_true(memcached_failed(rc
));
1064 memcached_free(tl_memc_h
);
1066 return TEST_SUCCESS
;
1070 We connect to a server which exists, but search for a key that does not exist.
1072 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
1076 memcached_return rc
;
1078 // See if memcached is reachable.
1079 char *value
= memcached_get(memc
,
1080 test_literal_param(__func__
),
1085 test_compare(MEMCACHED_NOTFOUND
, rc
);
1087 return TEST_SUCCESS
;
1091 Test case adapted from John Gorman <johngorman2@gmail.com>
1093 We are testing the error condition when we connect to a server via memcached_get_by_key()
1094 but find that the server is not available.
1096 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
1100 memcached_return rc
;
1103 memcached_st
*tl_memc_h
= memcached_create(NULL
);
1104 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
1105 memcached_server_push(tl_memc_h
, servers
);
1106 memcached_server_list_free(servers
);
1108 // See if memcached is reachable.
1109 char *value
= memcached_get_by_key(tl_memc_h
,
1110 test_literal_param(__func__
), // Key
1111 test_literal_param(__func__
), // Value
1116 test_true(memcached_failed(rc
));
1118 memcached_free(tl_memc_h
);
1120 return TEST_SUCCESS
;
1124 We connect to a server which exists, but search for a key that does not exist.
1126 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
1130 memcached_return rc
;
1132 // See if memcached is reachable.
1133 char *value
= memcached_get_by_key(memc
,
1134 test_literal_param(__func__
), // Key
1135 test_literal_param(__func__
), // Value
1140 test_compare(MEMCACHED_NOTFOUND
, rc
);
1142 return TEST_SUCCESS
;
1145 test_return_t
regression_bug_421108(memcached_st
*memc
)
1147 memcached_return_t rc
;
1148 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1149 test_compare(MEMCACHED_SUCCESS
, rc
);
1151 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
1152 test_compare(MEMCACHED_SUCCESS
, rc
);
1153 test_true(bytes_str
);
1154 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
1156 test_compare(MEMCACHED_SUCCESS
, rc
);
1157 test_true(bytes_read_str
);
1159 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
1160 "bytes_written", &rc
);
1161 test_compare(MEMCACHED_SUCCESS
, rc
);
1162 test_true(bytes_written_str
);
1164 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
1165 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
1166 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
1168 test_true(bytes
!= bytes_read
);
1169 test_true(bytes
!= bytes_written
);
1171 /* Release allocated resources */
1173 free(bytes_read_str
);
1174 free(bytes_written_str
);
1175 memcached_stat_free(NULL
, memc_stat
);
1177 return TEST_SUCCESS
;
1181 /* Test memcached_server_get_last_disconnect
1182 * For a working server set, shall be NULL
1183 * For a set of non existing server, shall not be NULL
1185 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
1187 memcached_return_t rc
;
1188 const memcached_instance_st
* disconnected_server
;
1190 /* With the working set of server */
1191 const char *key
= "marmotte";
1192 const char *value
= "milka";
1194 memcached_reset_last_disconnected_server(memc
);
1195 test_false(memc
->last_disconnected_server
);
1196 rc
= memcached_set(memc
, key
, strlen(key
),
1197 value
, strlen(value
),
1198 (time_t)0, (uint32_t)0);
1199 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1201 disconnected_server
= memcached_server_get_last_disconnect(memc
);
1202 test_false(disconnected_server
);
1204 /* With a non existing server */
1206 memcached_server_st
*servers
;
1208 const char *server_list
= "localhost:9";
1210 servers
= memcached_servers_parse(server_list
);
1212 mine
= memcached_create(NULL
);
1213 rc
= memcached_server_push(mine
, servers
);
1214 test_compare(MEMCACHED_SUCCESS
, rc
);
1215 memcached_server_list_free(servers
);
1218 rc
= memcached_set(mine
, key
, strlen(key
),
1219 value
, strlen(value
),
1220 (time_t)0, (uint32_t)0);
1221 test_true(memcached_failed(rc
));
1223 disconnected_server
= memcached_server_get_last_disconnect(mine
);
1224 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
1225 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
1226 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
1228 memcached_quit(mine
);
1229 memcached_free(mine
);
1231 return TEST_SUCCESS
;
1234 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
1236 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
1237 char buffer
[BUFSIZ
];
1239 test_compare(MEMCACHED_SUCCESS
,
1240 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
1242 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
1245 // We will just use the error strings as our keys
1246 uint32_t counter
= 100;
1249 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
1251 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
1252 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
1253 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
1255 const memcached_instance_st
* disconnected_server
= memcached_server_get_last_disconnect(memc
);
1256 test_true(disconnected_server
);
1257 test_strcmp("localhost", memcached_server_name(disconnected_server
));
1258 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
1262 memcached_reset_last_disconnected_server(memc
);
1267 memcached_free(memc
);
1269 return TEST_SUCCESS
;
1272 test_return_t
test_verbosity(memcached_st
*memc
)
1274 test_compare(MEMCACHED_SUCCESS
, memcached_verbosity(memc
, 0));
1276 return TEST_SUCCESS
;
1280 static memcached_return_t
stat_printer(const memcached_instance_st
* server
,
1281 const char *key
, size_t key_length
,
1282 const char *value
, size_t value_length
,
1292 return MEMCACHED_SUCCESS
;
1295 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
1297 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
1298 test_compare(MEMCACHED_SUCCESS
, rc
);
1300 test_compare(MEMCACHED_SUCCESS
,
1301 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
1303 test_compare(MEMCACHED_SUCCESS
,
1304 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
1306 test_compare(MEMCACHED_SUCCESS
,
1307 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
1309 return TEST_SUCCESS
;
1313 * This test ensures that the failure counter isn't incremented during
1314 * normal termination of the memcached instance.
1316 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
1318 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
1320 /* Ensure that we are connected to the server by setting a value */
1321 memcached_return_t rc
= memcached_set(memc
,
1322 test_literal_param(__func__
), // Key
1323 test_literal_param(__func__
), // Value
1324 time_t(0), uint32_t(0));
1325 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1328 const memcached_instance_st
* instance
= memcached_server_instance_by_position(memc
, 0);
1330 /* The test is to see that the memcached_quit doesn't increase the
1331 * the server failure conter, so let's ensure that it is zero
1332 * before sending quit
1334 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
1336 memcached_quit(memc
);
1338 /* Verify that it memcached_quit didn't increment the failure counter
1339 * Please note that this isn't bullet proof, because an error could
1342 test_zero(instance
->server_failure_counter
);
1344 memcached_free(memc
);
1346 return TEST_SUCCESS
;
1350 * This tests ensures expected disconnections (for some behavior changes
1351 * for instance) do not wrongly increase failure counter
1353 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
1355 /* Set value to force connection to the server */
1356 const char *key
= "marmotte";
1357 const char *value
= "milka";
1359 test_compare_hint(MEMCACHED_SUCCESS
,
1360 memcached_set(memc
, key
, strlen(key
),
1361 value
, strlen(value
),
1362 (time_t)0, (uint32_t)0),
1363 memcached_last_error_message(memc
));
1366 /* put failure limit to 1 */
1367 test_compare(MEMCACHED_SUCCESS
,
1368 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
1370 /* Put a retry timeout to effectively activate failure_limit effect */
1371 test_compare(MEMCACHED_SUCCESS
,
1372 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
1374 /* change behavior that triggers memcached_quit()*/
1375 test_compare(MEMCACHED_SUCCESS
,
1376 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
1379 /* Check if we still are connected */
1381 size_t string_length
;
1382 memcached_return rc
;
1383 char *string
= memcached_get(memc
, key
, strlen(key
),
1384 &string_length
, &flags
, &rc
);
1386 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1390 return TEST_SUCCESS
;
1394 test_return_t
regression_1021819_TEST(memcached_st
*original
)
1396 memcached_st
*memc
= memcached_clone(NULL
, original
);
1399 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 2000000), MEMCACHED_SUCCESS
);
1400 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 3000000), MEMCACHED_SUCCESS
);
1402 memcached_return_t rc
;
1405 test_literal_param(__func__
),
1408 test_compare(rc
, MEMCACHED_NOTFOUND
);
1410 memcached_free(memc
);
1412 return TEST_SUCCESS
;
1415 test_return_t
regression_bug_583031(memcached_st
*)
1417 memcached_st
*memc
= memcached_create(NULL
);
1419 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.251.4", 11211));
1421 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 3000);
1422 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
1423 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
1424 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
1425 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
1426 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
1428 memcached_return_t rc
;
1432 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
1436 test_compare(MEMCACHED_TIMEOUT
, memc
);
1438 memcached_free(memc
);
1440 return TEST_SUCCESS
;
1443 test_return_t
regression_bug_581030(memcached_st
*)
1446 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
1447 test_false(local_stat
);
1449 memcached_stat_free(NULL
, NULL
);
1452 return TEST_SUCCESS
;
1455 #define regression_bug_655423_COUNT 6000
1456 test_return_t
regression_bug_655423(memcached_st
*memc
)
1458 memcached_st
*clone
= memcached_clone(NULL
, memc
);
1459 memc
= NULL
; // Just to make sure it is not used
1464 return TEST_SKIPPED
;
1467 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
1468 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
1469 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
1470 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
1472 memset(payload
, int('x'), sizeof(payload
));
1474 keys_st
keys(regression_bug_655423_COUNT
);
1476 for (size_t x
= 0; x
< keys
.size(); x
++)
1478 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
1481 payload
, sizeof(payload
), 0, 0));
1484 for (size_t x
= 0; x
< keys
.size(); x
++)
1486 size_t value_length
;
1487 memcached_return_t rc
;
1488 char *value
= memcached_get(clone
,
1491 &value_length
, NULL
, &rc
);
1493 if (rc
== MEMCACHED_NOTFOUND
)
1496 test_zero(value_length
);
1500 test_compare(MEMCACHED_SUCCESS
, rc
);
1502 test_compare(100LLU, value_length
);
1506 test_compare(MEMCACHED_SUCCESS
,
1507 memcached_mget(clone
,
1508 keys
.keys_ptr(), keys
.lengths_ptr(),
1512 memcached_result_st
*result
= NULL
;
1513 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
1515 test_compare(size_t(100), memcached_result_length(result
));
1519 test_true(count
> 100); // If we don't get back atleast this, something is up
1521 memcached_free(clone
);
1523 return TEST_SUCCESS
;
1527 * Test that ensures that buffered set to not trigger problems during io_flush
1529 #define regression_bug_490520_COUNT 200480
1530 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
1532 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
1534 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
1535 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
1536 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
1537 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
1538 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
1540 /* First add all of the items.. */
1541 char blob
[3333] = {0};
1542 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
1545 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
1547 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
1548 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
1551 memcached_free(memc
);
1553 return TEST_SUCCESS
;
1556 test_return_t
regression_bug_1251482(memcached_st
*)
1558 test::Memc
memc("--server=localhost:5");
1560 memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 0);
1562 for (size_t x
= 0; x
< 5; ++x
)
1564 size_t value_length
;
1565 memcached_return_t rc
;
1566 char *value
= memcached_get(&memc
,
1567 test_literal_param(__func__
),
1568 &value_length
, NULL
, &rc
);
1571 test_compare(0LLU, value_length
);
1573 test_ne_compare(MEMCACHED_SUCCESS
, rc
);
1575 test_compare(MEMCACHED_CONNECTION_FAILURE
, rc
);
1579 return TEST_SUCCESS
;
1582 test_return_t
regression_1009493_TEST(memcached_st
*)
1584 memcached_st
* memc
= memcached_create(NULL
);
1586 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, true));
1588 memcached_st
* clone
= memcached_clone(NULL
, memc
);
1591 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
),
1592 memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
1594 memcached_free(memc
);
1595 memcached_free(clone
);
1597 return TEST_SUCCESS
;
1600 test_return_t
regression_994772_TEST(memcached_st
* memc
)
1602 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
1604 test_compare(MEMCACHED_SUCCESS
,
1606 test_literal_param(__func__
), // Key
1607 test_literal_param(__func__
), // Value
1608 time_t(0), uint32_t(0)));
1610 const char *keys
[] = { __func__
};
1611 size_t key_length
[]= { strlen(__func__
) };
1612 test_compare(MEMCACHED_SUCCESS
,
1613 memcached_mget(memc
, keys
, key_length
, 1));
1615 memcached_return_t rc
;
1616 memcached_result_st
*results
= memcached_fetch_result(memc
, NULL
, &rc
);
1618 test_compare(MEMCACHED_SUCCESS
, rc
);
1620 test_strcmp(__func__
, memcached_result_value(results
));
1621 uint64_t cas_value
= memcached_result_cas(results
);
1622 test_true(cas_value
);
1624 char* take_value
= memcached_result_take_value(results
);
1625 test_strcmp(__func__
, take_value
);
1628 memcached_result_free(results
);
1630 // Bad cas value, sanity check
1631 test_true(cas_value
!= 9999);
1632 test_compare(MEMCACHED_END
,
1634 test_literal_param(__func__
), // Key
1635 test_literal_param(__FILE__
), // Value
1636 time_t(0), uint32_t(0), 9999));
1638 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
1639 "different", strlen("different"), // Key
1640 test_literal_param(__FILE__
), // Value
1641 time_t(0), uint32_t(0)));
1643 return TEST_SUCCESS
;
1646 test_return_t
regression_bug_854604(memcached_st
*)
1650 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
1652 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
1654 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
1655 test_compare(buffer
[0], 0);
1657 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
1658 test_true(strlen(buffer
));
1660 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
1661 test_true(strlen(buffer
));
1663 return TEST_SUCCESS
;
1666 static void die_message(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
1668 fprintf(stderr
, "Iteration #%u: ", it
);
1670 if (error
== MEMCACHED_ERRNO
)
1672 fprintf(stderr
, "system error %d from %s: %s\n",
1673 errno
, what
, strerror(errno
));
1677 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
1678 memcached_strerror(mc
, error
));