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
libmemcached_string_behavior_test(memcached_st
*)
100 for (int x
= MEMCACHED_BEHAVIOR_NO_BLOCK
; x
< int(MEMCACHED_BEHAVIOR_MAX
); ++x
)
102 test_true(libmemcached_string_behavior(memcached_behavior_t(x
)));
104 test_compare(38, int(MEMCACHED_BEHAVIOR_MAX
));
109 test_return_t
libmemcached_string_distribution_test(memcached_st
*)
111 for (int x
= MEMCACHED_DISTRIBUTION_MODULA
; x
< int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
); ++x
)
113 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x
)));
115 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX
));
120 test_return_t
memcached_return_t_TEST(memcached_st
*memc
)
122 uint32_t values
[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
123 982370485U, 1263635348U, 4242906218U, 3829656100U,
124 1891735253U, 334139633U, 2257084983U, 3351789013U,
125 13199785U, 2542027183U, 1097051614U, 199566778U,
126 2748246961U, 2465192557U, 1664094137U, 2405439045U,
127 1842224848U, 692413798U, 3479807801U, 919913813U,
128 4269430871U, 610793021U, 527273862U, 1437122909U,
129 2300930706U, 2943759320U, 674306647U, 2400528935U,
130 54481931U, 4186304426U, 1741088401U, 2979625118U,
131 4159057246U, 3425930182U, 2593724503U, 1868899624U,
132 1769812374U, 2302537950U, 1110330676U, 3365377466U,
133 1336171666U, 3021258493U, 2334992265U, 3861994737U,
134 3582734124U, 3889811103, 3365377466U };
136 // You have updated the memcache_error messages but not updated docs/tests.
137 for (int rc
= int(MEMCACHED_SUCCESS
); rc
< int(MEMCACHED_MAXIMUM_RETURN
); ++rc
)
140 const char *msg
= memcached_strerror(memc
, memcached_return_t(rc
));
141 hash_val
= memcached_generate_hash_value(msg
, strlen(msg
),
142 MEMCACHED_HASH_JENKINS
);
143 if (values
[rc
] != hash_val
)
145 fprintf(stderr
, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
146 fprintf(stderr
, "%u, %s, (%u)\n\n", (uint32_t)rc
, memcached_strerror(memc
, memcached_return_t(rc
)), hash_val
);
148 test_compare(values
[rc
], hash_val
);
150 test_compare(50, int(MEMCACHED_MAXIMUM_RETURN
));
155 test_return_t
mget_end(memcached_st
*memc
)
157 const char *keys
[]= { "foo", "foo2" };
158 size_t lengths
[]= { 3, 4 };
159 const char *values
[]= { "fjord", "41" };
162 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
164 test_compare(MEMCACHED_SUCCESS
,
167 values
[x
], strlen(values
[x
]),
168 time_t(0), uint32_t(0)));
172 size_t string_length
;
175 // retrieve both via mget
176 test_compare(MEMCACHED_SUCCESS
,
179 test_array_length(keys
)));
181 char key
[MEMCACHED_MAX_KEY
];
183 memcached_return_t rc
;
185 // this should get both
186 for (size_t x
= 0; x
< test_array_length(keys
); x
++)
188 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
,
190 test_compare(MEMCACHED_SUCCESS
, rc
);
197 test_compare(string_length
, strlen(values
[val
]));
198 test_true(strncmp(values
[val
], string
, string_length
) == 0);
202 // this should indicate end
203 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
204 test_compare(MEMCACHED_END
, rc
);
208 test_compare(MEMCACHED_SUCCESS
,
209 memcached_mget(memc
, keys
, lengths
, 1));
211 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
212 test_compare(key_length
, lengths
[0]);
213 test_true(strncmp(keys
[0], key
, key_length
) == 0);
214 test_compare(string_length
, strlen(values
[0]));
215 test_true(strncmp(values
[0], string
, string_length
) == 0);
216 test_compare(MEMCACHED_SUCCESS
, rc
);
219 // this should indicate end
220 string
= memcached_fetch(memc
, key
, &key_length
, &string_length
, &flags
, &rc
);
221 test_compare(MEMCACHED_END
, rc
);
227 test_return_t
mget_result_test(memcached_st
*memc
)
229 const char *keys
[]= {"fudge", "son", "food"};
230 size_t key_length
[]= {5, 3, 4};
232 memcached_result_st results_obj
;
233 memcached_result_st
*results
= memcached_result_create(memc
, &results_obj
);
235 test_true(&results_obj
== results
);
237 /* We need to empty the server before continueing test */
238 test_compare(MEMCACHED_SUCCESS
,
239 memcached_flush(memc
, 0));
241 test_compare(MEMCACHED_SUCCESS
,
242 memcached_mget(memc
, keys
, key_length
, 3));
244 memcached_return_t rc
;
245 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
250 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
))) { test_true(false); /* We should never see a value returned */ };
252 test_compare(MEMCACHED_NOTFOUND
, rc
);
254 for (uint32_t x
= 0; x
< 3; x
++)
256 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
257 keys
[x
], key_length
[x
],
258 (time_t)50, (uint32_t)9);
259 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
262 test_compare(MEMCACHED_SUCCESS
,
263 memcached_mget(memc
, keys
, key_length
, 3));
265 while ((results
= memcached_fetch_result(memc
, &results_obj
, &rc
)))
268 test_true(&results_obj
== results
);
269 test_compare(MEMCACHED_SUCCESS
, rc
);
270 test_memcmp(memcached_result_key_value(results
),
271 memcached_result_value(results
),
272 memcached_result_length(results
));
273 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
276 memcached_result_free(&results_obj
);
281 test_return_t
mget_result_alloc_test(memcached_st
*memc
)
283 const char *keys
[]= {"fudge", "son", "food"};
284 size_t key_length
[]= {5, 3, 4};
286 memcached_result_st
*results
;
288 /* We need to empty the server before continueing test */
289 test_compare(MEMCACHED_SUCCESS
,
290 memcached_flush(memc
, 0));
292 test_compare(MEMCACHED_SUCCESS
,
293 memcached_mget(memc
, keys
, key_length
, 3));
295 memcached_return_t rc
;
296 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
301 test_compare(MEMCACHED_NOTFOUND
, rc
);
303 for (uint32_t x
= 0; x
< 3; x
++)
305 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
306 keys
[x
], key_length
[x
],
307 (time_t)50, (uint32_t)9);
308 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
311 test_compare(MEMCACHED_SUCCESS
,
312 memcached_mget(memc
, keys
, key_length
, 3));
315 while ((results
= memcached_fetch_result(memc
, NULL
, &rc
)))
318 test_compare(MEMCACHED_SUCCESS
, rc
);
319 test_compare(memcached_result_key_length(results
), memcached_result_length(results
));
320 test_memcmp(memcached_result_key_value(results
),
321 memcached_result_value(results
),
322 memcached_result_length(results
));
323 memcached_result_free(results
);
330 test_return_t
mget_result_function(memcached_st
*memc
)
332 const char *keys
[]= {"fudge", "son", "food"};
333 size_t key_length
[]= {5, 3, 4};
335 memcached_execute_fn callbacks
[1];
337 for (uint32_t x
= 0; x
< 3; x
++)
339 test_compare(return_value_based_on_buffering(memc
),
340 memcached_set(memc
, keys
[x
], key_length
[x
],
341 keys
[x
], key_length
[x
],
342 time_t(50), uint32_t(9)));
344 test_compare(MEMCACHED_SUCCESS
, memcached_flush_buffers(memc
));
345 memcached_quit(memc
);
347 test_compare(MEMCACHED_SUCCESS
,
348 memcached_mget(memc
, keys
, key_length
, 3));
350 callbacks
[0]= &callback_counter
;
353 test_compare(MEMCACHED_SUCCESS
,
354 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
356 test_compare(size_t(3), counter
);
361 test_return_t
mget_test(memcached_st
*memc
)
363 const char *keys
[]= {"fudge", "son", "food"};
364 size_t key_length
[]= {5, 3, 4};
366 char return_key
[MEMCACHED_MAX_KEY
];
367 size_t return_key_length
;
369 size_t return_value_length
;
371 test_compare(MEMCACHED_SUCCESS
,
372 memcached_mget(memc
, keys
, key_length
, 3));
375 memcached_return_t rc
;
376 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
377 &return_value_length
, &flags
, &rc
)))
379 test_true(return_value
);
381 test_false(return_value
);
382 test_zero(return_value_length
);
383 test_compare(MEMCACHED_NOTFOUND
, rc
);
385 for (uint32_t x
= 0; x
< 3; x
++)
387 rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
388 keys
[x
], key_length
[x
],
389 (time_t)50, (uint32_t)9);
390 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
392 test_compare(MEMCACHED_SUCCESS
,
393 memcached_mget(memc
, keys
, key_length
, 3));
396 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
397 &return_value_length
, &flags
, &rc
)))
399 test_true(return_value
);
400 test_compare(MEMCACHED_SUCCESS
, rc
);
401 if (not memc
->_namespace
)
403 test_compare(return_key_length
, return_value_length
);
404 test_memcmp(return_value
, return_key
, return_value_length
);
413 test_return_t
mget_execute(memcached_st
*original_memc
)
415 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
417 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
422 /* First add all of the items.. */
423 char blob
[1024] = {0};
425 for (size_t x
= 0; x
< keys
.size(); ++x
)
427 uint64_t query_id
= memcached_query_id(memc
);
428 memcached_return_t rc
= memcached_add(memc
,
429 keys
.key_at(x
), keys
.length_at(x
),
432 ASSERT_TRUE_(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, "Returned %s", memcached_strerror(NULL
, rc
));
433 test_compare(query_id
+1, memcached_query_id(memc
));
436 /* Try to get all of them with a large multiget */
438 memcached_execute_fn callbacks
[]= { &callback_counter
};
439 test_compare(MEMCACHED_SUCCESS
,
440 memcached_mget_execute(memc
,
441 keys
.keys_ptr(), keys
.lengths_ptr(),
442 keys
.size(), callbacks
, &counter
, 1));
445 uint64_t query_id
= memcached_query_id(memc
);
446 test_compare(MEMCACHED_SUCCESS
,
447 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
448 test_compare(query_id
, memcached_query_id(memc
));
450 /* Verify that we got all of the items */
451 test_compare(keys
.size(), counter
);
454 memcached_free(memc
);
459 test_return_t
MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST(memcached_st
*original_memc
)
461 test_skip(true, memcached_behavior_get(original_memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
));
463 memcached_st
*memc
= create_single_instance_memcached(original_memc
, "--BINARY-PROTOCOL");
466 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 8));
470 /* First add all of the items.. */
471 char blob
[1024] = {0};
473 for (size_t x
= 0; x
< keys
.size(); ++x
)
475 uint64_t query_id
= memcached_query_id(memc
);
476 memcached_return_t rc
= memcached_add(memc
,
477 keys
.key_at(x
), keys
.length_at(x
),
480 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
481 test_compare(query_id
+1, memcached_query_id(memc
));
484 /* Try to get all of them with a large multiget */
486 memcached_execute_fn callbacks
[]= { &callback_counter
};
487 test_compare(MEMCACHED_SUCCESS
,
488 memcached_mget_execute(memc
,
489 keys
.keys_ptr(), keys
.lengths_ptr(),
490 keys
.size(), callbacks
, &counter
, 1));
493 uint64_t query_id
= memcached_query_id(memc
);
494 test_compare(MEMCACHED_SUCCESS
,
495 memcached_fetch_execute(memc
, callbacks
, (void *)&counter
, 1));
496 test_compare(query_id
, memcached_query_id(memc
));
498 /* Verify that we got all of the items */
499 test_compare(keys
.size(), counter
);
502 memcached_free(memc
);
507 test_return_t
memcached_fetch_result_NOT_FOUND(memcached_st
*memc
)
509 memcached_return_t rc
;
511 const char *key
= "not_found";
512 size_t key_length
= test_literal_param_size("not_found");
514 test_compare(MEMCACHED_SUCCESS
,
515 memcached_mget(memc
, &key
, &key_length
, 1));
517 memcached_result_st
*result
= memcached_fetch_result(memc
, NULL
, &rc
);
519 test_compare(MEMCACHED_NOTFOUND
, rc
);
521 memcached_result_free(result
);
526 /* We don't test the behavior itself, we test the switches */
527 test_return_t
behavior_test(memcached_st
*memc
)
529 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 1);
530 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
532 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1);
533 test_compare(true, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
535 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_MD5
);
536 test_compare(uint64_t(MEMCACHED_HASH_MD5
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
538 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
, 0);
539 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
));
541 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 0);
542 test_zero(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
));
544 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_DEFAULT
);
545 test_compare(uint64_t(MEMCACHED_HASH_DEFAULT
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
547 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, MEMCACHED_HASH_CRC
);
548 test_compare(uint64_t(MEMCACHED_HASH_CRC
), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_HASH
));
550 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE
));
552 test_true(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE
));
554 uint64_t value
= memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
);
555 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
, value
+1);
556 test_compare((value
+1), memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS
));
561 test_return_t
MEMCACHED_BEHAVIOR_CORK_test(memcached_st
*memc
)
563 test_compare(MEMCACHED_DEPRECATED
,
564 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CORK
, true));
566 // Platform dependent
568 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_CORK
);
576 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st
*memc
)
578 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
, true);
579 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
581 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE
);
583 if (memcached_success(rc
))
596 test_return_t
MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st
*memc
)
598 memcached_return_t rc
= memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
, true);
599 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_NOT_SUPPORTED
);
601 bool value
= (bool)memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE
);
603 if (memcached_success(rc
))
615 /* Make sure we behave properly if server list has no values */
616 test_return_t
user_supplied_bug4(memcached_st
*memc
)
618 const char *keys
[]= {"fudge", "son", "food"};
619 size_t key_length
[]= {5, 3, 4};
621 /* Here we free everything before running a bunch of mget tests */
622 memcached_servers_reset(memc
);
625 /* We need to empty the server before continueing test */
626 test_compare(MEMCACHED_NO_SERVERS
,
627 memcached_flush(memc
, 0));
629 test_compare(MEMCACHED_NO_SERVERS
,
630 memcached_mget(memc
, keys
, key_length
, 3));
633 unsigned int keys_returned
;
634 memcached_return_t rc
;
635 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, keys_returned
, rc
));
636 test_compare(MEMCACHED_NOTFOUND
, rc
);
637 test_zero(keys_returned
);
640 for (uint32_t x
= 0; x
< 3; x
++)
642 test_compare(MEMCACHED_NO_SERVERS
,
643 memcached_set(memc
, keys
[x
], key_length
[x
],
644 keys
[x
], key_length
[x
],
645 (time_t)50, (uint32_t)9));
648 test_compare(MEMCACHED_NO_SERVERS
,
649 memcached_mget(memc
, keys
, key_length
, 3));
653 char return_key
[MEMCACHED_MAX_KEY
];
654 memcached_return_t rc
;
655 size_t return_key_length
;
656 size_t return_value_length
;
659 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
660 &return_value_length
, &flags
, &rc
)))
662 test_true(return_value
);
663 test_compare(MEMCACHED_SUCCESS
, rc
);
664 test_true(return_key_length
== return_value_length
);
665 test_memcmp(return_value
, return_key
, return_value_length
);
674 #define VALUE_SIZE_BUG5 1048064
675 test_return_t
user_supplied_bug5(memcached_st
*memc
)
677 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
678 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
682 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
684 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
686 insert_data
[x
]= (signed char)rand();
689 test_compare(MEMCACHED_SUCCESS
,
690 memcached_flush(memc
, 0));
692 memcached_return_t rc
;
693 test_null(memcached_get(memc
, keys
[0], key_length
[0], &value_length
, &flags
, &rc
));
694 test_compare(MEMCACHED_SUCCESS
,
695 memcached_mget(memc
, keys
, key_length
, 4));
698 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
, rc
));
699 test_compare(MEMCACHED_NOTFOUND
, rc
);
702 for (uint32_t x
= 0; x
< 4; x
++)
704 test_compare(MEMCACHED_SUCCESS
,
705 memcached_set(memc
, keys
[x
], key_length
[x
],
706 insert_data
, VALUE_SIZE_BUG5
,
707 (time_t)0, (uint32_t)0));
710 for (uint32_t x
= 0; x
< 10; x
++)
712 value
= memcached_get(memc
, keys
[0], key_length
[0],
713 &value_length
, &flags
, &rc
);
714 test_compare(rc
, MEMCACHED_SUCCESS
);
718 test_compare(MEMCACHED_SUCCESS
,
719 memcached_mget(memc
, keys
, key_length
, 4));
721 test_compare(TEST_SUCCESS
, fetch_all_results(memc
, count
));
722 test_compare(4U, count
);
724 delete [] insert_data
;
729 test_return_t
user_supplied_bug6(memcached_st
*memc
)
731 const char *keys
[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
732 size_t key_length
[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
733 char return_key
[MEMCACHED_MAX_KEY
];
734 size_t return_key_length
;
738 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
740 for (uint32_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
742 insert_data
[x
]= (signed char)rand();
745 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc
, 0));
747 test_compare(TEST_SUCCESS
, confirm_keys_dont_exist(memc
, keys
, test_array_length(keys
)));
749 // We will now confirm that memcached_mget() returns success, but we will
750 // then check to make sure that no actual keys are returned.
751 test_compare(MEMCACHED_SUCCESS
,
752 memcached_mget(memc
, keys
, key_length
, 4));
754 memcached_return_t rc
;
756 while ((value
= memcached_fetch(memc
, return_key
, &return_key_length
,
757 &value_length
, &flags
, &rc
)))
762 test_compare(MEMCACHED_NOTFOUND
, rc
);
764 for (uint32_t x
= 0; x
< test_array_length(keys
); x
++)
766 test_compare(MEMCACHED_SUCCESS
,
767 memcached_set(memc
, keys
[x
], key_length
[x
],
768 insert_data
, VALUE_SIZE_BUG5
,
769 (time_t)0, (uint32_t)0));
771 test_compare(TEST_SUCCESS
, confirm_keys_exist(memc
, keys
, test_array_length(keys
)));
773 for (uint32_t x
= 0; x
< 2; x
++)
775 value
= memcached_get(memc
, keys
[0], key_length
[0],
776 &value_length
, &flags
, &rc
);
780 test_compare(MEMCACHED_SUCCESS
,
781 memcached_mget(memc
, keys
, key_length
, 4));
782 /* We test for purge of partial complete fetches */
783 for (count
= 3; count
; count
--)
785 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
786 &value_length
, &flags
, &rc
);
787 test_compare(MEMCACHED_SUCCESS
, rc
);
788 test_memcmp(value
, insert_data
, value_length
);
789 test_true(value_length
);
793 delete [] insert_data
;
798 test_return_t
user_supplied_bug8(memcached_st
*)
800 memcached_return_t rc
;
802 memcached_st
*memc_clone
;
804 memcached_server_st
*servers
;
805 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";
807 servers
= memcached_servers_parse(server_list
);
810 mine
= memcached_create(NULL
);
811 rc
= memcached_server_push(mine
, servers
);
812 test_compare(MEMCACHED_SUCCESS
, rc
);
813 memcached_server_list_free(servers
);
816 memc_clone
= memcached_clone(NULL
, mine
);
818 memcached_quit(mine
);
819 memcached_quit(memc_clone
);
822 memcached_free(mine
);
823 memcached_free(memc_clone
);
828 /* Test flag store/retrieve */
829 test_return_t
user_supplied_bug7(memcached_st
*memc
)
831 char *insert_data
= new (std::nothrow
) char[VALUE_SIZE_BUG5
];
832 test_true(insert_data
);
834 for (size_t x
= 0; x
< VALUE_SIZE_BUG5
; x
++)
836 insert_data
[x
]= (signed char)rand();
839 memcached_flush(memc
, 0);
841 const char *keys
= "036790384900";
842 size_t key_length
= strlen(keys
);
843 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, keys
, key_length
,
844 insert_data
, VALUE_SIZE_BUG5
,
847 memcached_return_t rc
;
850 char *value
= memcached_get(memc
, keys
, key_length
,
851 &value_length
, &flags
, &rc
);
852 test_compare(245U, flags
);
856 test_compare(MEMCACHED_SUCCESS
, memcached_mget(memc
, &keys
, &key_length
, 1));
858 char return_key
[MEMCACHED_MAX_KEY
];
859 size_t return_key_length
;
861 value
= memcached_fetch(memc
, return_key
, &return_key_length
,
862 &value_length
, &flags
, &rc
);
863 test_compare(uint32_t(245), flags
);
866 delete [] insert_data
;
872 test_return_t
user_supplied_bug9(memcached_st
*memc
)
874 const char *keys
[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
875 size_t key_length
[3];
879 char return_key
[MEMCACHED_MAX_KEY
];
880 size_t return_key_length
;
882 size_t return_value_length
;
885 key_length
[0]= strlen("UDATA:edevil@sapo.pt");
886 key_length
[1]= strlen("fudge&*@#");
887 key_length
[2]= strlen("for^#@&$not");
890 for (unsigned int x
= 0; x
< 3; x
++)
892 memcached_return_t rc
= memcached_set(memc
, keys
[x
], key_length
[x
],
893 keys
[x
], key_length
[x
],
894 (time_t)50, (uint32_t)9);
895 test_compare(MEMCACHED_SUCCESS
, rc
);
898 memcached_return_t rc
= memcached_mget(memc
, keys
, key_length
, 3);
899 test_compare(MEMCACHED_SUCCESS
, rc
);
901 /* We need to empty the server before continueing test */
902 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
903 &return_value_length
, &flags
, &rc
)) != NULL
)
905 test_true(return_value
);
909 test_compare(3U, count
);
914 /* We are testing with aggressive timeout to get failures */
915 test_return_t
user_supplied_bug10(memcached_st
*memc
)
917 test_skip(memc
->servers
[0].type
, MEMCACHED_CONNECTION_TCP
);
919 size_t value_length
= 512;
921 memcached_st
*mclone
= memcached_clone(NULL
, memc
);
923 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, set
);
924 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, set
);
925 memcached_behavior_set(mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, uint64_t(0));
927 libtest::vchar_t value
;
928 value
.reserve(value_length
);
929 for (uint32_t x
= 0; x
< value_length
; x
++)
931 value
.push_back(char(x
% 127));
934 for (unsigned int x
= 1; x
<= 100000; ++x
)
936 memcached_return_t rc
= memcached_set(mclone
,
937 test_literal_param("foo"),
938 &value
[0], value
.size(),
941 test_true((rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_BUFFERED
or rc
== MEMCACHED_TIMEOUT
or rc
== MEMCACHED_CONNECTION_FAILURE
942 or rc
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
));
944 if (rc
== MEMCACHED_WRITE_FAILURE
or rc
== MEMCACHED_TIMEOUT
)
950 memcached_free(mclone
);
956 We are looking failures in the async protocol
958 test_return_t
user_supplied_bug11(memcached_st
*memc
)
962 test::Memc
mclone(memc
);
964 memcached_behavior_set(&mclone
, MEMCACHED_BEHAVIOR_NO_BLOCK
, true);
965 memcached_behavior_set(&mclone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
966 memcached_behavior_set(&mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, size_t(-1));
968 test_compare(-1, int32_t(memcached_behavior_get(&mclone
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
)));
970 libtest::vchar_t value
;
972 for (unsigned int x
= 0; x
< 512; x
++)
974 value
.push_back(char(x
% 127));
977 for (unsigned int x
= 1; x
<= 100000; ++x
)
979 memcached_return_t rc
= memcached_set(&mclone
, test_literal_param("foo"), &value
[0], value
.size(), 0, 0);
989 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
991 test_return_t
user_supplied_bug12(memcached_st
*memc
)
993 memcached_return_t rc
;
997 uint64_t number_value
;
999 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"),
1000 &value_length
, &flags
, &rc
);
1002 test_compare(MEMCACHED_NOTFOUND
, rc
);
1004 rc
= memcached_increment(memc
, "autoincrement", strlen("autoincrement"),
1007 /* The binary protocol will set the key if it doesn't exist */
1008 if (memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
) == 1)
1010 test_compare(MEMCACHED_SUCCESS
, rc
);
1014 test_compare(MEMCACHED_NOTFOUND
, rc
);
1017 test_compare(MEMCACHED_SUCCESS
,
1018 memcached_set(memc
, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
1020 value
= memcached_get(memc
, "autoincrement", strlen("autoincrement"), &value_length
, &flags
, &rc
);
1024 test_compare(MEMCACHED_SUCCESS
,
1025 memcached_increment(memc
, "autoincrement", strlen("autoincrement"), 1, &number_value
));
1026 test_compare(2UL, number_value
);
1028 return TEST_SUCCESS
;
1032 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1033 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
1035 test_return_t
user_supplied_bug13(memcached_st
*memc
)
1037 char key
[] = "key34567890";
1039 char commandFirst
[]= "set key34567890 0 0 ";
1040 char commandLast
[] = " \r\n"; /* first line of command sent to server */
1041 size_t commandLength
;
1043 commandLength
= strlen(commandFirst
) + strlen(commandLast
) + 4; /* 4 is number of characters in size, probably 8196 */
1045 size_t overflowSize
= MEMCACHED_MAX_BUFFER
- commandLength
;
1047 for (size_t testSize
= overflowSize
- 1; testSize
< overflowSize
+ 1; testSize
++)
1049 char *overflow
= new (std::nothrow
) char[testSize
];
1050 test_true(overflow
);
1052 memset(overflow
, 'x', testSize
);
1053 test_compare(MEMCACHED_SUCCESS
,
1054 memcached_set(memc
, key
, strlen(key
),
1055 overflow
, testSize
, 0, 0));
1059 return TEST_SUCCESS
;
1064 Test values of many different sizes
1065 Bug found where command total one more than MEMCACHED_MAX_BUFFER
1066 set key34567890 0 0 8169 \r\n
1067 is sent followed by buffer of size 8169, followed by 8169
1069 test_return_t
user_supplied_bug14(memcached_st
*memc
)
1071 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true);
1073 libtest::vchar_t value
;
1074 value
.reserve(18000);
1075 for (ptrdiff_t x
= 0; x
< 18000; x
++)
1077 value
.push_back((char) (x
% 127));
1080 for (size_t current_length
= 1; current_length
< value
.size(); current_length
++)
1082 memcached_return_t rc
= memcached_set(memc
, test_literal_param("foo"),
1083 &value
[0], current_length
,
1084 (time_t)0, (uint32_t)0);
1085 ASSERT_TRUE_(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, "Instead got %s", memcached_strerror(NULL
, rc
));
1087 size_t string_length
;
1089 char *string
= memcached_get(memc
, test_literal_param("foo"),
1090 &string_length
, &flags
, &rc
);
1092 test_compare(MEMCACHED_SUCCESS
, rc
);
1093 test_compare(string_length
, current_length
);
1095 snprintf(buffer
, sizeof(buffer
), "%u", uint32_t(string_length
));
1096 test_memcmp(string
, &value
[0], string_length
);
1101 return TEST_SUCCESS
;
1105 Look for zero length value problems
1107 test_return_t
user_supplied_bug15(memcached_st
*memc
)
1109 for (uint32_t x
= 0; x
< 2; x
++)
1111 memcached_return_t rc
= memcached_set(memc
, test_literal_param("mykey"),
1113 (time_t)0, (uint32_t)0);
1115 test_compare(MEMCACHED_SUCCESS
, rc
);
1119 char *value
= memcached_get(memc
, test_literal_param("mykey"),
1120 &length
, &flags
, &rc
);
1122 test_compare(MEMCACHED_SUCCESS
, rc
);
1127 value
= memcached_get(memc
, test_literal_param("mykey"),
1128 &length
, &flags
, &rc
);
1130 test_compare(MEMCACHED_SUCCESS
, rc
);
1136 return TEST_SUCCESS
;
1139 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
1140 test_return_t
user_supplied_bug16(memcached_st
*memc
)
1142 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
, test_literal_param("mykey"),
1144 (time_t)0, UINT32_MAX
));
1149 memcached_return_t rc
;
1150 char *value
= memcached_get(memc
, test_literal_param("mykey"),
1151 &length
, &flags
, &rc
);
1153 test_compare(MEMCACHED_SUCCESS
, rc
);
1156 test_compare(flags
, UINT32_MAX
);
1158 return TEST_SUCCESS
;
1161 #if !defined(__sun) && !defined(__OpenBSD__)
1162 /* Check the validity of chinese key*/
1163 test_return_t
user_supplied_bug17(memcached_st
*memc
)
1165 const char *key
= "豆瓣";
1166 const char *value
="我们在炎热抑郁的夏天无法停止豆瓣";
1167 memcached_return_t rc
= memcached_set(memc
, key
, strlen(key
),
1168 value
, strlen(value
),
1171 test_compare(MEMCACHED_SUCCESS
, rc
);
1175 char *value2
= memcached_get(memc
, key
, strlen(key
),
1176 &length
, &flags
, &rc
);
1178 test_compare(length
, strlen(value
));
1179 test_compare(MEMCACHED_SUCCESS
, rc
);
1180 test_memcmp(value
, value2
, length
);
1183 return TEST_SUCCESS
;
1191 test_return_t
user_supplied_bug19(memcached_st
*)
1193 memcached_return_t res
;
1195 memcached_st
*memc
= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
1197 const memcached_instance_st
* server
= memcached_server_by_key(memc
, "a", 1, &res
);
1200 memcached_free(memc
);
1202 return TEST_SUCCESS
;
1205 /* CAS test from Andei */
1206 test_return_t
user_supplied_bug20(memcached_st
*memc
)
1208 const char *key
= "abc";
1209 size_t key_len
= strlen("abc");
1211 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, true));
1213 test_compare(MEMCACHED_SUCCESS
,
1215 test_literal_param("abc"),
1216 test_literal_param("foobar"),
1217 (time_t)0, (uint32_t)0));
1219 test_compare(MEMCACHED_SUCCESS
,
1220 memcached_mget(memc
, &key
, &key_len
, 1));
1222 memcached_result_st result_obj
;
1223 memcached_result_st
*result
= memcached_result_create(memc
, &result_obj
);
1226 memcached_result_create(memc
, &result_obj
);
1227 memcached_return_t status
;
1228 result
= memcached_fetch_result(memc
, &result_obj
, &status
);
1231 test_compare(MEMCACHED_SUCCESS
, status
);
1233 memcached_result_free(result
);
1235 return TEST_SUCCESS
;
1238 /* Large mget() of missing keys with binary proto
1240 * If many binary quiet commands (such as getq's in an mget) fill the output
1241 * buffer and the server chooses not to respond, memcached_flush hangs. See
1242 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
1245 /* sighandler_t function that always asserts false */
1246 static __attribute__((noreturn
)) void fail(int)
1252 test_return_t
_user_supplied_bug21(memcached_st
* memc
, size_t key_count
)
1257 return TEST_SKIPPED
;
1259 void (*oldalarm
)(int);
1261 memcached_st
*memc_clone
= memcached_clone(NULL
, memc
);
1262 test_true(memc_clone
);
1264 /* only binproto uses getq for mget */
1265 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc_clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, true));
1267 /* empty the cache to ensure misses (hence non-responses) */
1268 test_compare(MEMCACHED_SUCCESS
, memcached_flush(memc_clone
, 0));
1270 keys_st
keys(key_count
);
1272 oldalarm
= signal(SIGALRM
, fail
);
1275 test_compare_got(MEMCACHED_SUCCESS
,
1276 memcached_mget(memc_clone
, keys
.keys_ptr(), keys
.lengths_ptr(), keys
.size()),
1277 memcached_last_error_message(memc_clone
));
1280 signal(SIGALRM
, oldalarm
);
1282 memcached_return_t rc
;
1284 char return_key
[MEMCACHED_MAX_KEY
];
1285 size_t return_key_length
;
1287 size_t return_value_length
;
1288 while ((return_value
= memcached_fetch(memc
, return_key
, &return_key_length
,
1289 &return_value_length
, &flags
, &rc
)))
1291 test_false(return_value
); // There are no keys to fetch, so the value should never be returned
1293 test_compare(MEMCACHED_NOTFOUND
, rc
);
1294 test_zero(return_value_length
);
1295 test_zero(return_key_length
);
1296 test_false(return_key
[0]);
1297 test_false(return_value
);
1299 memcached_free(memc_clone
);
1301 return TEST_SUCCESS
;
1305 test_return_t
user_supplied_bug21(memcached_st
*memc
)
1307 test_skip(TEST_SUCCESS
, pre_binary(memc
));
1309 /* should work as of r580 */
1310 test_compare(TEST_SUCCESS
,
1311 _user_supplied_bug21(memc
, 10));
1313 /* should fail as of r580 */
1314 test_compare(TEST_SUCCESS
,
1315 _user_supplied_bug21(memc
, 1000));
1317 return TEST_SUCCESS
;
1320 test_return_t
comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st
*)
1324 memcached_st
*memc
= &memc_
;
1326 ASSERT_EQ(memc
, MEMCACHED_SUCCESS
);
1327 test_compare(memc
, MEMCACHED_SUCCESS
);
1329 ASSERT_NEQ(memc
, MEMCACHED_FAILURE
);
1331 return TEST_SUCCESS
;
1334 test_return_t
result_static(memcached_st
*memc
)
1336 memcached_result_st result
;
1337 memcached_result_st
*result_ptr
= memcached_result_create(memc
, &result
);
1338 test_false(result
.options
.is_allocated
);
1339 test_true(memcached_is_initialized(&result
));
1340 test_true(result_ptr
);
1341 test_true(result_ptr
== &result
);
1343 memcached_result_free(&result
);
1345 test_false(result
.options
.is_allocated
);
1346 test_false(memcached_is_initialized(&result
));
1348 return TEST_SUCCESS
;
1351 test_return_t
result_alloc(memcached_st
*memc
)
1353 memcached_result_st
*result_ptr
= memcached_result_create(memc
, NULL
);
1354 test_true(result_ptr
);
1355 test_true(result_ptr
->options
.is_allocated
);
1356 test_true(memcached_is_initialized(result_ptr
));
1357 memcached_result_free(result_ptr
);
1359 return TEST_SUCCESS
;
1363 static void my_free(const memcached_st
*ptr
, void *mem
, void *context
)
1367 #ifdef HARD_MALLOC_TESTS
1368 void *real_ptr
= (mem
== NULL
) ? mem
: (void*)((caddr_t
)mem
- 8);
1376 static void *my_malloc(const memcached_st
*ptr
, const size_t size
, void *context
)
1380 #ifdef HARD_MALLOC_TESTS
1381 void *ret
= malloc(size
+ 8);
1384 ret
= (void*)((caddr_t
)ret
+ 8);
1387 void *ret
= malloc(size
);
1392 memset(ret
, 0xff, size
);
1399 static void *my_realloc(const memcached_st
*ptr
, void *mem
, const size_t size
, void *)
1401 #ifdef HARD_MALLOC_TESTS
1402 void *real_ptr
= (mem
== NULL
) ? NULL
: (void*)((caddr_t
)mem
- 8);
1403 void *nmem
= realloc(real_ptr
, size
+ 8);
1408 ret
= (void*)((caddr_t
)nmem
+ 8);
1414 return realloc(mem
, size
);
1419 static void *my_calloc(const memcached_st
*ptr
, size_t nelem
, const size_t size
, void *)
1421 #ifdef HARD_MALLOC_TESTS
1422 void *mem
= my_malloc(ptr
, nelem
* size
);
1425 memset(mem
, 0, nelem
* size
);
1431 return calloc(nelem
, size
);
1435 #ifdef MEMCACHED_ENABLE_DEPRECATED
1436 test_return_t
deprecated_set_memory_alloc(memcached_st
*memc
)
1438 void *test_ptr
= NULL
;
1441 memcached_malloc_fn malloc_cb
= (memcached_malloc_fn
)my_malloc
;
1442 cb_ptr
= *(void **)&malloc_cb
;
1443 memcached_return_t rc
;
1445 test_compare(MEMCACHED_SUCCESS
,
1446 memcached_callback_set(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, cb_ptr
));
1447 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_MALLOC_FUNCTION
, &rc
);
1448 test_compare(MEMCACHED_SUCCESS
, rc
);
1449 test_true(test_ptr
== cb_ptr
);
1453 memcached_realloc_fn realloc_cb
=
1454 (memcached_realloc_fn
)my_realloc
;
1455 cb_ptr
= *(void **)&realloc_cb
;
1456 memcached_return_t rc
;
1458 test_compare(MEMCACHED_SUCCESS
,
1459 memcached_callback_set(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, cb_ptr
));
1460 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_REALLOC_FUNCTION
, &rc
);
1461 test_compare(MEMCACHED_SUCCESS
, rc
);
1462 test_true(test_ptr
== cb_ptr
);
1466 memcached_free_fn free_cb
=
1467 (memcached_free_fn
)my_free
;
1468 cb_ptr
= *(void **)&free_cb
;
1469 memcached_return_t rc
;
1471 test_compare(MEMCACHED_SUCCESS
,
1472 memcached_callback_set(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, cb_ptr
));
1473 test_ptr
= memcached_callback_get(memc
, MEMCACHED_CALLBACK_FREE_FUNCTION
, &rc
);
1474 test_compare(MEMCACHED_SUCCESS
, rc
);
1475 test_true(test_ptr
== cb_ptr
);
1478 return TEST_SUCCESS
;
1483 test_return_t
set_memory_alloc(memcached_st
*memc
)
1485 test_compare(MEMCACHED_INVALID_ARGUMENTS
,
1486 memcached_set_memory_allocators(memc
, NULL
, my_free
,
1487 my_realloc
, my_calloc
, NULL
));
1489 test_compare(MEMCACHED_SUCCESS
,
1490 memcached_set_memory_allocators(memc
, my_malloc
, my_free
,
1491 my_realloc
, my_calloc
, NULL
));
1493 memcached_malloc_fn mem_malloc
;
1494 memcached_free_fn mem_free
;
1495 memcached_realloc_fn mem_realloc
;
1496 memcached_calloc_fn mem_calloc
;
1497 memcached_get_memory_allocators(memc
, &mem_malloc
, &mem_free
,
1498 &mem_realloc
, &mem_calloc
);
1500 test_true(mem_malloc
== my_malloc
);
1501 test_true(mem_realloc
== my_realloc
);
1502 test_true(mem_calloc
== my_calloc
);
1503 test_true(mem_free
== my_free
);
1505 return TEST_SUCCESS
;
1508 test_return_t
MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st
*memc
)
1510 const uint64_t timeout
= 100; // Not using, just checking that it sets
1512 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, timeout
);
1514 test_compare(timeout
, memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
));
1516 return TEST_SUCCESS
;
1519 test_return_t
analyzer_test(memcached_st
*memc
)
1521 memcached_analysis_st
*report
;
1522 memcached_return_t rc
;
1524 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1525 test_compare(MEMCACHED_SUCCESS
, rc
);
1526 test_true(memc_stat
);
1528 report
= memcached_analyze(memc
, memc_stat
, &rc
);
1529 test_compare(MEMCACHED_SUCCESS
, rc
);
1533 memcached_stat_free(NULL
, memc_stat
);
1535 return TEST_SUCCESS
;
1538 test_return_t
hsieh_avaibility_test (memcached_st
*memc
)
1540 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH
));
1542 test_compare(MEMCACHED_SUCCESS
,
1543 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
,
1544 (uint64_t)MEMCACHED_HASH_HSIEH
));
1546 return TEST_SUCCESS
;
1549 test_return_t
murmur_avaibility_test (memcached_st
*memc
)
1551 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR
));
1553 test_compare(MEMCACHED_SUCCESS
,
1554 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_HASH
, (uint64_t)MEMCACHED_HASH_MURMUR
));
1556 return TEST_SUCCESS
;
1560 Test case adapted from John Gorman <johngorman2@gmail.com>
1562 We are testing the error condition when we connect to a server via memcached_get()
1563 but find that the server is not available.
1565 test_return_t
memcached_get_MEMCACHED_ERRNO(memcached_st
*)
1569 memcached_return rc
;
1572 memcached_st
*tl_memc_h
= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
1574 // See if memcached is reachable.
1575 char *value
= memcached_get(tl_memc_h
,
1576 test_literal_param(__func__
),
1581 test_true(memcached_failed(rc
));
1583 memcached_free(tl_memc_h
);
1585 return TEST_SUCCESS
;
1589 We connect to a server which exists, but search for a key that does not exist.
1591 test_return_t
memcached_get_MEMCACHED_NOTFOUND(memcached_st
*memc
)
1595 memcached_return rc
;
1597 // See if memcached is reachable.
1598 char *value
= memcached_get(memc
,
1599 test_literal_param(__func__
),
1604 test_compare(MEMCACHED_NOTFOUND
, rc
);
1606 return TEST_SUCCESS
;
1610 Test case adapted from John Gorman <johngorman2@gmail.com>
1612 We are testing the error condition when we connect to a server via memcached_get_by_key()
1613 but find that the server is not available.
1615 test_return_t
memcached_get_by_key_MEMCACHED_ERRNO(memcached_st
*)
1619 memcached_return rc
;
1622 memcached_st
*tl_memc_h
= memcached_create(NULL
);
1623 memcached_server_st
*servers
= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
1624 memcached_server_push(tl_memc_h
, servers
);
1625 memcached_server_list_free(servers
);
1627 // See if memcached is reachable.
1628 char *value
= memcached_get_by_key(tl_memc_h
,
1629 test_literal_param(__func__
), // Key
1630 test_literal_param(__func__
), // Value
1635 test_true(memcached_failed(rc
));
1637 memcached_free(tl_memc_h
);
1639 return TEST_SUCCESS
;
1643 We connect to a server which exists, but search for a key that does not exist.
1645 test_return_t
memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st
*memc
)
1649 memcached_return rc
;
1651 // See if memcached is reachable.
1652 char *value
= memcached_get_by_key(memc
,
1653 test_literal_param(__func__
), // Key
1654 test_literal_param(__func__
), // Value
1659 test_compare(MEMCACHED_NOTFOUND
, rc
);
1661 return TEST_SUCCESS
;
1664 test_return_t
regression_bug_421108(memcached_st
*memc
)
1666 memcached_return_t rc
;
1667 memcached_stat_st
*memc_stat
= memcached_stat(memc
, NULL
, &rc
);
1668 test_compare(MEMCACHED_SUCCESS
, rc
);
1670 char *bytes_str
= memcached_stat_get_value(memc
, memc_stat
, "bytes", &rc
);
1671 test_compare(MEMCACHED_SUCCESS
, rc
);
1672 test_true(bytes_str
);
1673 char *bytes_read_str
= memcached_stat_get_value(memc
, memc_stat
,
1675 test_compare(MEMCACHED_SUCCESS
, rc
);
1676 test_true(bytes_read_str
);
1678 char *bytes_written_str
= memcached_stat_get_value(memc
, memc_stat
,
1679 "bytes_written", &rc
);
1680 test_compare(MEMCACHED_SUCCESS
, rc
);
1681 test_true(bytes_written_str
);
1683 unsigned long long bytes
= strtoull(bytes_str
, 0, 10);
1684 unsigned long long bytes_read
= strtoull(bytes_read_str
, 0, 10);
1685 unsigned long long bytes_written
= strtoull(bytes_written_str
, 0, 10);
1687 test_true(bytes
!= bytes_read
);
1688 test_true(bytes
!= bytes_written
);
1690 /* Release allocated resources */
1692 free(bytes_read_str
);
1693 free(bytes_written_str
);
1694 memcached_stat_free(NULL
, memc_stat
);
1696 return TEST_SUCCESS
;
1700 /* Test memcached_server_get_last_disconnect
1701 * For a working server set, shall be NULL
1702 * For a set of non existing server, shall not be NULL
1704 test_return_t
test_get_last_disconnect(memcached_st
*memc
)
1706 memcached_return_t rc
;
1707 const memcached_instance_st
* disconnected_server
;
1709 /* With the working set of server */
1710 const char *key
= "marmotte";
1711 const char *value
= "milka";
1713 memcached_reset_last_disconnected_server(memc
);
1714 test_false(memc
->last_disconnected_server
);
1715 rc
= memcached_set(memc
, key
, strlen(key
),
1716 value
, strlen(value
),
1717 (time_t)0, (uint32_t)0);
1718 test_true(rc
== MEMCACHED_SUCCESS
|| rc
== MEMCACHED_BUFFERED
);
1720 disconnected_server
= memcached_server_get_last_disconnect(memc
);
1721 test_false(disconnected_server
);
1723 /* With a non existing server */
1725 memcached_server_st
*servers
;
1727 const char *server_list
= "localhost:9";
1729 servers
= memcached_servers_parse(server_list
);
1731 mine
= memcached_create(NULL
);
1732 rc
= memcached_server_push(mine
, servers
);
1733 test_compare(MEMCACHED_SUCCESS
, rc
);
1734 memcached_server_list_free(servers
);
1737 rc
= memcached_set(mine
, key
, strlen(key
),
1738 value
, strlen(value
),
1739 (time_t)0, (uint32_t)0);
1740 test_true(memcached_failed(rc
));
1742 disconnected_server
= memcached_server_get_last_disconnect(mine
);
1743 test_true_got(disconnected_server
, memcached_strerror(mine
, rc
));
1744 test_compare(in_port_t(9), memcached_server_port(disconnected_server
));
1745 test_false(strncmp(memcached_server_name(disconnected_server
),"localhost",9));
1747 memcached_quit(mine
);
1748 memcached_free(mine
);
1750 return TEST_SUCCESS
;
1753 test_return_t
test_multiple_get_last_disconnect(memcached_st
*)
1755 const char *server_string
= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
1756 char buffer
[BUFSIZ
];
1758 test_compare(MEMCACHED_SUCCESS
,
1759 libmemcached_check_configuration(server_string
, strlen(server_string
), buffer
, sizeof(buffer
)));
1761 memcached_st
*memc
= memcached(server_string
, strlen(server_string
));
1764 // We will just use the error strings as our keys
1765 uint32_t counter
= 100;
1768 for (int x
= int(MEMCACHED_SUCCESS
); x
< int(MEMCACHED_MAXIMUM_RETURN
); ++x
)
1770 const char *msg
= memcached_strerror(memc
, memcached_return_t(x
));
1771 memcached_return_t ret
= memcached_set(memc
, msg
, strlen(msg
), NULL
, 0, (time_t)0, (uint32_t)0);
1772 test_true_got((ret
== MEMCACHED_CONNECTION_FAILURE
or ret
== MEMCACHED_SERVER_TEMPORARILY_DISABLED
), memcached_last_error_message(memc
));
1774 const memcached_instance_st
* disconnected_server
= memcached_server_get_last_disconnect(memc
);
1775 test_true(disconnected_server
);
1776 test_strcmp("localhost", memcached_server_name(disconnected_server
));
1777 test_true(memcached_server_port(disconnected_server
) >= 8888 and memcached_server_port(disconnected_server
) <= 8892);
1781 memcached_reset_last_disconnected_server(memc
);
1786 memcached_free(memc
);
1788 return TEST_SUCCESS
;
1791 test_return_t
test_verbosity(memcached_st
*memc
)
1793 test_compare(MEMCACHED_SUCCESS
, memcached_verbosity(memc
, 0));
1795 return TEST_SUCCESS
;
1799 static memcached_return_t
stat_printer(const memcached_instance_st
* server
,
1800 const char *key
, size_t key_length
,
1801 const char *value
, size_t value_length
,
1811 return MEMCACHED_SUCCESS
;
1814 test_return_t
memcached_stat_execute_test(memcached_st
*memc
)
1816 memcached_return_t rc
= memcached_stat_execute(memc
, NULL
, stat_printer
, NULL
);
1817 test_compare(MEMCACHED_SUCCESS
, rc
);
1819 test_compare(MEMCACHED_SUCCESS
,
1820 memcached_stat_execute(memc
, "slabs", stat_printer
, NULL
));
1822 test_compare(MEMCACHED_SUCCESS
,
1823 memcached_stat_execute(memc
, "items", stat_printer
, NULL
));
1825 test_compare(MEMCACHED_SUCCESS
,
1826 memcached_stat_execute(memc
, "sizes", stat_printer
, NULL
));
1828 return TEST_SUCCESS
;
1832 * This test ensures that the failure counter isn't incremented during
1833 * normal termination of the memcached instance.
1835 test_return_t
wrong_failure_counter_test(memcached_st
*original_memc
)
1837 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
1839 /* Ensure that we are connected to the server by setting a value */
1840 memcached_return_t rc
= memcached_set(memc
,
1841 test_literal_param(__func__
), // Key
1842 test_literal_param(__func__
), // Value
1843 time_t(0), uint32_t(0));
1844 test_true(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
);
1847 const memcached_instance_st
* instance
= memcached_server_instance_by_position(memc
, 0);
1849 /* The test is to see that the memcached_quit doesn't increase the
1850 * the server failure conter, so let's ensure that it is zero
1851 * before sending quit
1853 ((memcached_server_write_instance_st
)instance
)->server_failure_counter
= 0;
1855 memcached_quit(memc
);
1857 /* Verify that it memcached_quit didn't increment the failure counter
1858 * Please note that this isn't bullet proof, because an error could
1861 test_zero(instance
->server_failure_counter
);
1863 memcached_free(memc
);
1865 return TEST_SUCCESS
;
1869 * This tests ensures expected disconnections (for some behavior changes
1870 * for instance) do not wrongly increase failure counter
1872 test_return_t
wrong_failure_counter_two_test(memcached_st
*memc
)
1874 /* Set value to force connection to the server */
1875 const char *key
= "marmotte";
1876 const char *value
= "milka";
1878 test_compare_hint(MEMCACHED_SUCCESS
,
1879 memcached_set(memc
, key
, strlen(key
),
1880 value
, strlen(value
),
1881 (time_t)0, (uint32_t)0),
1882 memcached_last_error_message(memc
));
1885 /* put failure limit to 1 */
1886 test_compare(MEMCACHED_SUCCESS
,
1887 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, true));
1889 /* Put a retry timeout to effectively activate failure_limit effect */
1890 test_compare(MEMCACHED_SUCCESS
,
1891 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1));
1893 /* change behavior that triggers memcached_quit()*/
1894 test_compare(MEMCACHED_SUCCESS
,
1895 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, true));
1898 /* Check if we still are connected */
1900 size_t string_length
;
1901 memcached_return rc
;
1902 char *string
= memcached_get(memc
, key
, strlen(key
),
1903 &string_length
, &flags
, &rc
);
1905 test_compare_got(MEMCACHED_SUCCESS
, rc
, memcached_strerror(NULL
, rc
));
1909 return TEST_SUCCESS
;
1913 test_return_t
regression_1021819_TEST(memcached_st
*original
)
1915 memcached_st
*memc
= memcached_clone(NULL
, original
);
1918 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 2000000), MEMCACHED_SUCCESS
);
1919 test_compare(memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 3000000), MEMCACHED_SUCCESS
);
1921 memcached_return_t rc
;
1924 test_literal_param(__func__
),
1927 test_compare(rc
, MEMCACHED_NOTFOUND
);
1929 memcached_free(memc
);
1931 return TEST_SUCCESS
;
1934 test_return_t
regression_bug_583031(memcached_st
*)
1936 memcached_st
*memc
= memcached_create(NULL
);
1938 test_compare(MEMCACHED_SUCCESS
, memcached_server_add(memc
, "10.2.251.4", 11211));
1940 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT
, 3000);
1941 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 1000);
1942 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SND_TIMEOUT
, 1000);
1943 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RCV_TIMEOUT
, 1000);
1944 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
1945 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
, 3);
1947 memcached_return_t rc
;
1951 const char *value
= memcached_get(memc
, "dsf", 3, &length
, &flags
, &rc
);
1955 test_compare(MEMCACHED_TIMEOUT
, memc
);
1957 memcached_free(memc
);
1959 return TEST_SUCCESS
;
1962 test_return_t
regression_bug_581030(memcached_st
*)
1965 memcached_stat_st
*local_stat
= memcached_stat(NULL
, NULL
, NULL
);
1966 test_false(local_stat
);
1968 memcached_stat_free(NULL
, NULL
);
1971 return TEST_SUCCESS
;
1974 #define regression_bug_655423_COUNT 6000
1975 test_return_t
regression_bug_655423(memcached_st
*memc
)
1977 memcached_st
*clone
= memcached_clone(NULL
, memc
);
1978 memc
= NULL
; // Just to make sure it is not used
1983 return TEST_SKIPPED
;
1986 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
1987 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_SUPPORT_CAS
, 1));
1988 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_TCP_NODELAY
, 1));
1989 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(clone
, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH
, 1));
1991 memset(payload
, int('x'), sizeof(payload
));
1993 keys_st
keys(regression_bug_655423_COUNT
);
1995 for (size_t x
= 0; x
< keys
.size(); x
++)
1997 test_compare(MEMCACHED_SUCCESS
, memcached_set(clone
,
2000 payload
, sizeof(payload
), 0, 0));
2003 for (size_t x
= 0; x
< keys
.size(); x
++)
2005 size_t value_length
;
2006 memcached_return_t rc
;
2007 char *value
= memcached_get(clone
,
2010 &value_length
, NULL
, &rc
);
2012 if (rc
== MEMCACHED_NOTFOUND
)
2015 test_zero(value_length
);
2019 test_compare(MEMCACHED_SUCCESS
, rc
);
2021 test_compare(100LLU, value_length
);
2025 test_compare(MEMCACHED_SUCCESS
,
2026 memcached_mget(clone
,
2027 keys
.keys_ptr(), keys
.lengths_ptr(),
2031 memcached_result_st
*result
= NULL
;
2032 while ((result
= memcached_fetch_result(clone
, result
, NULL
)))
2034 test_compare(size_t(100), memcached_result_length(result
));
2038 test_true(count
> 100); // If we don't get back atleast this, something is up
2040 memcached_free(clone
);
2042 return TEST_SUCCESS
;
2046 * Test that ensures that buffered set to not trigger problems during io_flush
2048 #define regression_bug_490520_COUNT 200480
2049 test_return_t
regression_bug_490520(memcached_st
*original_memc
)
2051 memcached_st
* memc
= create_single_instance_memcached(original_memc
, NULL
);
2053 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_NO_BLOCK
,1);
2054 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS
,1);
2055 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_POLL_TIMEOUT
, 1000);
2056 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT
,1);
2057 memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 3600);
2059 /* First add all of the items.. */
2060 char blob
[3333] = {0};
2061 for (uint32_t x
= 0; x
< regression_bug_490520_COUNT
; ++x
)
2064 int key_length
= snprintf(key
, sizeof(key
), "0200%u", x
);
2066 memcached_return rc
= memcached_set(memc
, key
, key_length
, blob
, sizeof(blob
), 0, 0);
2067 test_true_got(rc
== MEMCACHED_SUCCESS
or rc
== MEMCACHED_BUFFERED
, memcached_last_error_message(memc
));
2070 memcached_free(memc
);
2072 return TEST_SUCCESS
;
2075 test_return_t
regression_bug_1251482(memcached_st
*)
2077 test::Memc
memc("--server=localhost:5");
2079 memcached_behavior_set(&memc
, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT
, 0);
2081 for (size_t x
= 0; x
< 5; ++x
)
2083 size_t value_length
;
2084 memcached_return_t rc
;
2085 char *value
= memcached_get(&memc
,
2086 test_literal_param(__func__
),
2087 &value_length
, NULL
, &rc
);
2090 test_compare(0LLU, value_length
);
2092 test_ne_compare(MEMCACHED_SUCCESS
, rc
);
2094 test_compare(MEMCACHED_CONNECTION_FAILURE
, rc
);
2098 return TEST_SUCCESS
;
2101 test_return_t
regression_1009493_TEST(memcached_st
*)
2103 memcached_st
* memc
= memcached_create(NULL
);
2105 test_compare(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_KETAMA
, true));
2107 memcached_st
* clone
= memcached_clone(NULL
, memc
);
2110 test_compare(memcached_behavior_get(memc
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
),
2111 memcached_behavior_get(clone
, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED
));
2113 memcached_free(memc
);
2114 memcached_free(clone
);
2116 return TEST_SUCCESS
;
2119 test_return_t
regression_994772_TEST(memcached_st
* memc
)
2121 test_skip(MEMCACHED_SUCCESS
, memcached_behavior_set(memc
, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL
, 1));
2123 test_compare(MEMCACHED_SUCCESS
,
2125 test_literal_param(__func__
), // Key
2126 test_literal_param(__func__
), // Value
2127 time_t(0), uint32_t(0)));
2129 const char *keys
[] = { __func__
};
2130 size_t key_length
[]= { strlen(__func__
) };
2131 test_compare(MEMCACHED_SUCCESS
,
2132 memcached_mget(memc
, keys
, key_length
, 1));
2134 memcached_return_t rc
;
2135 memcached_result_st
*results
= memcached_fetch_result(memc
, NULL
, &rc
);
2137 test_compare(MEMCACHED_SUCCESS
, rc
);
2139 test_strcmp(__func__
, memcached_result_value(results
));
2140 uint64_t cas_value
= memcached_result_cas(results
);
2141 test_true(cas_value
);
2143 char* take_value
= memcached_result_take_value(results
);
2144 test_strcmp(__func__
, take_value
);
2147 memcached_result_free(results
);
2149 // Bad cas value, sanity check
2150 test_true(cas_value
!= 9999);
2151 test_compare(MEMCACHED_END
,
2153 test_literal_param(__func__
), // Key
2154 test_literal_param(__FILE__
), // Value
2155 time_t(0), uint32_t(0), 9999));
2157 test_compare(MEMCACHED_SUCCESS
, memcached_set(memc
,
2158 "different", strlen("different"), // Key
2159 test_literal_param(__FILE__
), // Value
2160 time_t(0), uint32_t(0)));
2162 return TEST_SUCCESS
;
2165 test_return_t
regression_bug_854604(memcached_st
*)
2169 test_compare(MEMCACHED_INVALID_ARGUMENTS
, libmemcached_check_configuration(0, 0, buffer
, 0));
2171 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 0));
2173 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 1));
2174 test_compare(buffer
[0], 0);
2176 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, 10));
2177 test_true(strlen(buffer
));
2179 test_compare(MEMCACHED_PARSE_ERROR
, libmemcached_check_configuration(test_literal_param("syntax error"), buffer
, sizeof(buffer
)));
2180 test_true(strlen(buffer
));
2182 return TEST_SUCCESS
;
2185 static void die_message(memcached_st
* mc
, memcached_return error
, const char* what
, uint32_t it
)
2187 fprintf(stderr
, "Iteration #%u: ", it
);
2189 if (error
== MEMCACHED_ERRNO
)
2191 fprintf(stderr
, "system error %d from %s: %s\n",
2192 errno
, what
, strerror(errno
));
2196 fprintf(stderr
, "error %d from %s: %s\n", error
, what
,
2197 memcached_strerror(mc
, error
));