projects / m6w6 / libmemcached / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
Merge branch 'catch' into v1.x
[m6w6/libmemcached] / tests / libmemcached-1.0 / mem_functions.cc
1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
2 *
3 * Libmemcached library
4 *
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
10 * met:
11 *
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
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
18 * distribution.
19 *
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
22 * written permission.
23 *
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.
35 *
36 */
37
38 #include "mem_config.h"
39 #include "libtest/test.hpp"
40
41 #if defined(HAVE_LIBUUID) && HAVE_LIBUUID
42 # include <uuid/uuid.h>
43 #endif
44
45 /*
46 Test cases
47 */
48
49 #include "libmemcached-1.0/memcached.h"
50 #include "libmemcached/is.h"
51 #include "libmemcached/server_instance.h"
52
53 #include "libhashkit-1.0/hashkit.h"
54
55 #include "libtest/memcached.hpp"
56
57 #include <cerrno>
58 #include <memory>
59 #include <pthread.h>
60 #include <semaphore.h>
61 #include <signal.h>
62 #include <sys/stat.h>
63 #include <sys/time.h>
64 #include <sys/types.h>
65 #include <unistd.h>
66
67 #include <iostream>
68
69 #include "libtest/server.h"
70
71 #include "bin/generator.h"
72
73 #define SMALL_STRING_LEN 1024
74
75 #include "libtest/test.hpp"
76
77 using namespace libtest;
78
79 #include "libmemcachedutil-1.0/util.h"
80
81 #include "tests/hash_results.h"
82
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"
90
91 #define UUID_STRING_MAXLENGTH 36
92
93 #include "tests/keys.hpp"
94
95 #include "libmemcached/instance.hpp"
96
97
98 test_return_t libmemcached_string_behavior_test(memcached_st *)
99 {
100 for (int x= MEMCACHED_BEHAVIOR_NO_BLOCK; x < int(MEMCACHED_BEHAVIOR_MAX); ++x)
101 {
102 test_true(libmemcached_string_behavior(memcached_behavior_t(x)));
103 }
104 test_compare(38, int(MEMCACHED_BEHAVIOR_MAX));
105
106 return TEST_SUCCESS;
107 }
108
109 test_return_t libmemcached_string_distribution_test(memcached_st *)
110 {
111 for (int x= MEMCACHED_DISTRIBUTION_MODULA; x < int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX); ++x)
112 {
113 test_true(libmemcached_string_distribution(memcached_server_distribution_t(x)));
114 }
115 test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX));
116
117 return TEST_SUCCESS;
118 }
119
120 test_return_t memcached_return_t_TEST(memcached_st *memc)
121 {
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 };
135
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)
138 {
139 uint32_t hash_val;
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)
144 {
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);
147 }
148 test_compare(values[rc], hash_val);
149 }
150 test_compare(50, int(MEMCACHED_MAXIMUM_RETURN));
151
152 return TEST_SUCCESS;
153 }
154
155 test_return_t mget_end(memcached_st *memc)
156 {
157 const char *keys[]= { "foo", "foo2" };
158 size_t lengths[]= { 3, 4 };
159 const char *values[]= { "fjord", "41" };
160
161 // Set foo and foo2
162 for (size_t x= 0; x < test_array_length(keys); x++)
163 {
164 test_compare(MEMCACHED_SUCCESS,
165 memcached_set(memc,
166 keys[x], lengths[x],
167 values[x], strlen(values[x]),
168 time_t(0), uint32_t(0)));
169 }
170
171 char *string;
172 size_t string_length;
173 uint32_t flags;
174
175 // retrieve both via mget
176 test_compare(MEMCACHED_SUCCESS,
177 memcached_mget(memc,
178 keys, lengths,
179 test_array_length(keys)));
180
181 char key[MEMCACHED_MAX_KEY];
182 size_t key_length;
183 memcached_return_t rc;
184
185 // this should get both
186 for (size_t x= 0; x < test_array_length(keys); x++)
187 {
188 string= memcached_fetch(memc, key, &key_length, &string_length,
189 &flags, &rc);
190 test_compare(MEMCACHED_SUCCESS, rc);
191 int val = 0;
192 if (key_length == 4)
193 {
194 val= 1;
195 }
196
197 test_compare(string_length, strlen(values[val]));
198 test_true(strncmp(values[val], string, string_length) == 0);
199 free(string);
200 }
201
202 // this should indicate end
203 string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
204 test_compare(MEMCACHED_END, rc);
205 test_null(string);
206
207 // now get just one
208 test_compare(MEMCACHED_SUCCESS,
209 memcached_mget(memc, keys, lengths, 1));
210
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);
217 free(string);
218
219 // this should indicate end
220 string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
221 test_compare(MEMCACHED_END, rc);
222 test_null(string);
223
224 return TEST_SUCCESS;
225 }
226
227 test_return_t mget_result_test(memcached_st *memc)
228 {
229 const char *keys[]= {"fudge", "son", "food"};
230 size_t key_length[]= {5, 3, 4};
231
232 memcached_result_st results_obj;
233 memcached_result_st *results= memcached_result_create(memc, &results_obj);
234 test_true(results);
235 test_true(&results_obj == results);
236
237 /* We need to empty the server before continueing test */
238 test_compare(MEMCACHED_SUCCESS,
239 memcached_flush(memc, 0));
240
241 test_compare(MEMCACHED_SUCCESS,
242 memcached_mget(memc, keys, key_length, 3));
243
244 memcached_return_t rc;
245 while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
246 {
247 test_true(results);
248 }
249
250 while ((results= memcached_fetch_result(memc, &results_obj, &rc))) { test_true(false); /* We should never see a value returned */ };
251 test_false(results);
252 test_compare(MEMCACHED_NOTFOUND, rc);
253
254 for (uint32_t x= 0; x < 3; x++)
255 {
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);
260 }
261
262 test_compare(MEMCACHED_SUCCESS,
263 memcached_mget(memc, keys, key_length, 3));
264
265 while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
266 {
267 test_true(results);
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));
274 }
275
276 memcached_result_free(&results_obj);
277
278 return TEST_SUCCESS;
279 }
280
281 test_return_t mget_result_alloc_test(memcached_st *memc)
282 {
283 const char *keys[]= {"fudge", "son", "food"};
284 size_t key_length[]= {5, 3, 4};
285
286 memcached_result_st *results;
287
288 /* We need to empty the server before continueing test */
289 test_compare(MEMCACHED_SUCCESS,
290 memcached_flush(memc, 0));
291
292 test_compare(MEMCACHED_SUCCESS,
293 memcached_mget(memc, keys, key_length, 3));
294
295 memcached_return_t rc;
296 while ((results= memcached_fetch_result(memc, NULL, &rc)))
297 {
298 test_true(results);
299 }
300 test_false(results);
301 test_compare(MEMCACHED_NOTFOUND, rc);
302
303 for (uint32_t x= 0; x < 3; x++)
304 {
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);
309 }
310
311 test_compare(MEMCACHED_SUCCESS,
312 memcached_mget(memc, keys, key_length, 3));
313
314 uint32_t x= 0;
315 while ((results= memcached_fetch_result(memc, NULL, &rc)))
316 {
317 test_true(results);
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);
324 x++;
325 }
326
327 return TEST_SUCCESS;
328 }
329
330 test_return_t mget_result_function(memcached_st *memc)
331 {
332 const char *keys[]= {"fudge", "son", "food"};
333 size_t key_length[]= {5, 3, 4};
334 size_t counter;
335 memcached_execute_fn callbacks[1];
336
337 for (uint32_t x= 0; x < 3; x++)
338 {
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)));
343 }
344 test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
345 memcached_quit(memc);
346
347 test_compare(MEMCACHED_SUCCESS,
348 memcached_mget(memc, keys, key_length, 3));
349
350 callbacks[0]= &callback_counter;
351 counter= 0;
352
353 test_compare(MEMCACHED_SUCCESS,
354 memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
355
356 test_compare(size_t(3), counter);
357
358 return TEST_SUCCESS;
359 }
360
361 test_return_t mget_test(memcached_st *memc)
362 {
363 const char *keys[]= {"fudge", "son", "food"};
364 size_t key_length[]= {5, 3, 4};
365
366 char return_key[MEMCACHED_MAX_KEY];
367 size_t return_key_length;
368 char *return_value;
369 size_t return_value_length;
370
371 test_compare(MEMCACHED_SUCCESS,
372 memcached_mget(memc, keys, key_length, 3));
373
374 uint32_t flags;
375 memcached_return_t rc;
376 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
377 &return_value_length, &flags, &rc)))
378 {
379 test_true(return_value);
380 }
381 test_false(return_value);
382 test_zero(return_value_length);
383 test_compare(MEMCACHED_NOTFOUND, rc);
384
385 for (uint32_t x= 0; x < 3; x++)
386 {
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);
391 }
392 test_compare(MEMCACHED_SUCCESS,
393 memcached_mget(memc, keys, key_length, 3));
394
395 uint32_t x= 0;
396 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
397 &return_value_length, &flags, &rc)))
398 {
399 test_true(return_value);
400 test_compare(MEMCACHED_SUCCESS, rc);
401 if (not memc->_namespace)
402 {
403 test_compare(return_key_length, return_value_length);
404 test_memcmp(return_value, return_key, return_value_length);
405 }
406 free(return_value);
407 x++;
408 }
409
410 return TEST_SUCCESS;
411 }
412
413 test_return_t mget_execute(memcached_st *original_memc)
414 {
415 test_skip(true, memcached_behavior_get(original_memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
416
417 memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL");
418 test_true(memc);
419
420 keys_st keys(20480);
421
422 /* First add all of the items.. */
423 char blob[1024] = {0};
424
425 for (size_t x= 0; x < keys.size(); ++x)
426 {
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),
430 blob, sizeof(blob),
431 0, 0);
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));
434 }
435
436 /* Try to get all of them with a large multiget */
437 size_t counter= 0;
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));
443
444 {
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));
449
450 /* Verify that we got all of the items */
451 test_compare(keys.size(), counter);
452 }
453
454 memcached_free(memc);
455
456 return TEST_SUCCESS;
457 }
458
459 test_return_t MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST(memcached_st *original_memc)
460 {
461 test_skip(true, memcached_behavior_get(original_memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
462
463 memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL");
464 test_true(memc);
465
466 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH, 8));
467
468 keys_st keys(20480);
469
470 /* First add all of the items.. */
471 char blob[1024] = {0};
472
473 for (size_t x= 0; x < keys.size(); ++x)
474 {
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),
478 blob, sizeof(blob),
479 0, 0);
480 test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
481 test_compare(query_id +1, memcached_query_id(memc));
482 }
483
484 /* Try to get all of them with a large multiget */
485 size_t counter= 0;
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));
491
492 {
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));
497
498 /* Verify that we got all of the items */
499 test_compare(keys.size(), counter);
500 }
501
502 memcached_free(memc);
503
504 return TEST_SUCCESS;
505 }
506
507 test_return_t memcached_fetch_result_NOT_FOUND(memcached_st *memc)
508 {
509 memcached_return_t rc;
510
511 const char *key= "not_found";
512 size_t key_length= test_literal_param_size("not_found");
513
514 test_compare(MEMCACHED_SUCCESS,
515 memcached_mget(memc, &key, &key_length, 1));
516
517 memcached_result_st *result= memcached_fetch_result(memc, NULL, &rc);
518 test_null(result);
519 test_compare(MEMCACHED_NOTFOUND, rc);
520
521 memcached_result_free(result);
522
523 return TEST_SUCCESS;
524 }
525
526 /* We don't test the behavior itself, we test the switches */
527 test_return_t behavior_test(memcached_st *memc)
528 {
529 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
530 test_compare(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK));
531
532 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
533 test_compare(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY));
534
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));
537
538 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
539 test_zero(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK));
540
541 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
542 test_zero(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY));
543
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));
546
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));
549
550 test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE));
551
552 test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE));
553
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));
557
558 return TEST_SUCCESS;
559 }
560
561 test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc)
562 {
563 test_compare(MEMCACHED_DEPRECATED,
564 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, true));
565
566 // Platform dependent
567 #if 0
568 bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_CORK);
569 test_false(value);
570 #endif
571
572 return TEST_SUCCESS;
573 }
574
575
576 test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc)
577 {
578 memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, true);
579 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
580
581 bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE);
582
583 if (memcached_success(rc))
584 {
585 test_true(value);
586 }
587 else
588 {
589 test_false(value);
590 }
591
592 return TEST_SUCCESS;
593 }
594
595
596 test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc)
597 {
598 memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, true);
599 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
600
601 bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE);
602
603 if (memcached_success(rc))
604 {
605 test_true(value);
606 }
607 else
608 {
609 test_false(value);
610 }
611
612 return TEST_SUCCESS;
613 }
614
615 /* Make sure we behave properly if server list has no values */
616 test_return_t user_supplied_bug4(memcached_st *memc)
617 {
618 const char *keys[]= {"fudge", "son", "food"};
619 size_t key_length[]= {5, 3, 4};
620
621 /* Here we free everything before running a bunch of mget tests */
622 memcached_servers_reset(memc);
623
624
625 /* We need to empty the server before continueing test */
626 test_compare(MEMCACHED_NO_SERVERS,
627 memcached_flush(memc, 0));
628
629 test_compare(MEMCACHED_NO_SERVERS,
630 memcached_mget(memc, keys, key_length, 3));
631
632 {
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);
638 }
639
640 for (uint32_t x= 0; x < 3; x++)
641 {
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));
646 }
647
648 test_compare(MEMCACHED_NO_SERVERS,
649 memcached_mget(memc, keys, key_length, 3));
650
651 {
652 char *return_value;
653 char return_key[MEMCACHED_MAX_KEY];
654 memcached_return_t rc;
655 size_t return_key_length;
656 size_t return_value_length;
657 uint32_t flags;
658 uint32_t x= 0;
659 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
660 &return_value_length, &flags, &rc)))
661 {
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);
666 free(return_value);
667 x++;
668 }
669 }
670
671 return TEST_SUCCESS;
672 }
673
674 #define VALUE_SIZE_BUG5 1048064
675 test_return_t user_supplied_bug5(memcached_st *memc)
676 {
677 const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
678 size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
679 char *value;
680 size_t value_length;
681 uint32_t flags;
682 char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
683
684 for (uint32_t x= 0; x < VALUE_SIZE_BUG5; x++)
685 {
686 insert_data[x]= (signed char)rand();
687 }
688
689 test_compare(MEMCACHED_SUCCESS,
690 memcached_flush(memc, 0));
691
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));
696
697 unsigned int count;
698 test_compare(TEST_SUCCESS, fetch_all_results(memc, count, rc));
699 test_compare(MEMCACHED_NOTFOUND, rc);
700 test_zero(count);
701
702 for (uint32_t x= 0; x < 4; x++)
703 {
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));
708 }
709
710 for (uint32_t x= 0; x < 10; x++)
711 {
712 value= memcached_get(memc, keys[0], key_length[0],
713 &value_length, &flags, &rc);
714 test_compare(rc, MEMCACHED_SUCCESS);
715 test_true(value);
716 ::free(value);
717
718 test_compare(MEMCACHED_SUCCESS,
719 memcached_mget(memc, keys, key_length, 4));
720
721 test_compare(TEST_SUCCESS, fetch_all_results(memc, count));
722 test_compare(4U, count);
723 }
724 delete [] insert_data;
725
726 return TEST_SUCCESS;
727 }
728
729 test_return_t user_supplied_bug6(memcached_st *memc)
730 {
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;
735 char *value;
736 size_t value_length;
737 uint32_t flags;
738 char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
739
740 for (uint32_t x= 0; x < VALUE_SIZE_BUG5; x++)
741 {
742 insert_data[x]= (signed char)rand();
743 }
744
745 test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));
746
747 test_compare(TEST_SUCCESS, confirm_keys_dont_exist(memc, keys, test_array_length(keys)));
748
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));
753
754 memcached_return_t rc;
755 uint32_t count= 0;
756 while ((value= memcached_fetch(memc, return_key, &return_key_length,
757 &value_length, &flags, &rc)))
758 {
759 count++;
760 }
761 test_zero(count);
762 test_compare(MEMCACHED_NOTFOUND, rc);
763
764 for (uint32_t x= 0; x < test_array_length(keys); x++)
765 {
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));
770 }
771 test_compare(TEST_SUCCESS, confirm_keys_exist(memc, keys, test_array_length(keys)));
772
773 for (uint32_t x= 0; x < 2; x++)
774 {
775 value= memcached_get(memc, keys[0], key_length[0],
776 &value_length, &flags, &rc);
777 test_true(value);
778 free(value);
779
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--)
784 {
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);
790 free(value);
791 }
792 }
793 delete [] insert_data;
794
795 return TEST_SUCCESS;
796 }
797
798 test_return_t user_supplied_bug8(memcached_st *)
799 {
800 memcached_return_t rc;
801 memcached_st *mine;
802 memcached_st *memc_clone;
803
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";
806
807 servers= memcached_servers_parse(server_list);
808 test_true(servers);
809
810 mine= memcached_create(NULL);
811 rc= memcached_server_push(mine, servers);
812 test_compare(MEMCACHED_SUCCESS, rc);
813 memcached_server_list_free(servers);
814
815 test_true(mine);
816 memc_clone= memcached_clone(NULL, mine);
817
818 memcached_quit(mine);
819 memcached_quit(memc_clone);
820
821
822 memcached_free(mine);
823 memcached_free(memc_clone);
824
825 return TEST_SUCCESS;
826 }
827
828 /* Test flag store/retrieve */
829 test_return_t user_supplied_bug7(memcached_st *memc)
830 {
831 char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
832 test_true(insert_data);
833
834 for (size_t x= 0; x < VALUE_SIZE_BUG5; x++)
835 {
836 insert_data[x]= (signed char)rand();
837 }
838
839 memcached_flush(memc, 0);
840
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,
845 time_t(0), 245U));
846
847 memcached_return_t rc;
848 size_t value_length;
849 uint32_t flags= 0;
850 char *value= memcached_get(memc, keys, key_length,
851 &value_length, &flags, &rc);
852 test_compare(245U, flags);
853 test_true(value);
854 free(value);
855
856 test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, &keys, &key_length, 1));
857
858 char return_key[MEMCACHED_MAX_KEY];
859 size_t return_key_length;
860 flags= 0;
861 value= memcached_fetch(memc, return_key, &return_key_length,
862 &value_length, &flags, &rc);
863 test_compare(uint32_t(245), flags);
864 test_true(value);
865 free(value);
866 delete [] insert_data;
867
868
869 return TEST_SUCCESS;
870 }
871
872 test_return_t user_supplied_bug9(memcached_st *memc)
873 {
874 const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
875 size_t key_length[3];
876 uint32_t flags;
877 unsigned count= 0;
878
879 char return_key[MEMCACHED_MAX_KEY];
880 size_t return_key_length;
881 char *return_value;
882 size_t return_value_length;
883
884
885 key_length[0]= strlen("UDATA:edevil@sapo.pt");
886 key_length[1]= strlen("fudge&*@#");
887 key_length[2]= strlen("for^#@&$not");
888
889
890 for (unsigned int x= 0; x < 3; x++)
891 {
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);
896 }
897
898 memcached_return_t rc= memcached_mget(memc, keys, key_length, 3);
899 test_compare(MEMCACHED_SUCCESS, rc);
900
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)
904 {
905 test_true(return_value);
906 free(return_value);
907 count++;
908 }
909 test_compare(3U, count);
910
911 return TEST_SUCCESS;
912 }
913
914 /* We are testing with aggressive timeout to get failures */
915 test_return_t user_supplied_bug10(memcached_st *memc)
916 {
917 test_skip(memc->servers[0].type, MEMCACHED_CONNECTION_TCP);
918
919 size_t value_length= 512;
920 unsigned int set= 1;
921 memcached_st *mclone= memcached_clone(NULL, memc);
922
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));
926
927 libtest::vchar_t value;
928 value.reserve(value_length);
929 for (uint32_t x= 0; x < value_length; x++)
930 {
931 value.push_back(char(x % 127));
932 }
933
934 for (unsigned int x= 1; x <= 100000; ++x)
935 {
936 memcached_return_t rc= memcached_set(mclone,
937 test_literal_param("foo"),
938 &value[0], value.size(),
939 0, 0);
940
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));
943
944 if (rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_TIMEOUT)
945 {
946 x--;
947 }
948 }
949
950 memcached_free(mclone);
951
952 return TEST_SUCCESS;
953 }
954
955 /*
956 We are looking failures in the async protocol
957 */
958 test_return_t user_supplied_bug11(memcached_st *memc)
959 {
960 (void)memc;
961 #ifndef __APPLE__
962 test::Memc mclone(memc);
963
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));
967
968 test_compare(-1, int32_t(memcached_behavior_get(&mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT)));
969
970 libtest::vchar_t value;
971 value.reserve(512);
972 for (unsigned int x= 0; x < 512; x++)
973 {
974 value.push_back(char(x % 127));
975 }
976
977 for (unsigned int x= 1; x <= 100000; ++x)
978 {
979 memcached_return_t rc= memcached_set(&mclone, test_literal_param("foo"), &value[0], value.size(), 0, 0);
980 (void)rc;
981 }
982
983 #endif
984
985 return TEST_SUCCESS;
986 }
987
988 /*
989 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
990 */
991 test_return_t user_supplied_bug12(memcached_st *memc)
992 {
993 memcached_return_t rc;
994 uint32_t flags;
995 size_t value_length;
996 char *value;
997 uint64_t number_value;
998
999 value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
1000 &value_length, &flags, &rc);
1001 test_null(value);
1002 test_compare(MEMCACHED_NOTFOUND, rc);
1003
1004 rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
1005 1, &number_value);
1006 test_null(value);
1007 /* The binary protocol will set the key if it doesn't exist */
1008 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
1009 {
1010 test_compare(MEMCACHED_SUCCESS, rc);
1011 }
1012 else
1013 {
1014 test_compare(MEMCACHED_NOTFOUND, rc);
1015 }
1016
1017 test_compare(MEMCACHED_SUCCESS,
1018 memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
1019
1020 value= memcached_get(memc, "autoincrement", strlen("autoincrement"), &value_length, &flags, &rc);
1021 test_true(value);
1022 free(value);
1023
1024 test_compare(MEMCACHED_SUCCESS,
1025 memcached_increment(memc, "autoincrement", strlen("autoincrement"), 1, &number_value));
1026 test_compare(2UL, number_value);
1027
1028 return TEST_SUCCESS;
1029 }
1030
1031 /*
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
1034 */
1035 test_return_t user_supplied_bug13(memcached_st *memc)
1036 {
1037 char key[] = "key34567890";
1038
1039 char commandFirst[]= "set key34567890 0 0 ";
1040 char commandLast[] = " \r\n"; /* first line of command sent to server */
1041 size_t commandLength;
1042
1043 commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
1044
1045 size_t overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
1046
1047 for (size_t testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
1048 {
1049 char *overflow= new (std::nothrow) char[testSize];
1050 test_true(overflow);
1051
1052 memset(overflow, 'x', testSize);
1053 test_compare(MEMCACHED_SUCCESS,
1054 memcached_set(memc, key, strlen(key),
1055 overflow, testSize, 0, 0));
1056 delete [] overflow;
1057 }
1058
1059 return TEST_SUCCESS;
1060 }
1061
1062
1063 /*
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
1068 */
1069 test_return_t user_supplied_bug14(memcached_st *memc)
1070 {
1071 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);
1072
1073 libtest::vchar_t value;
1074 value.reserve(18000);
1075 for (ptrdiff_t x= 0; x < 18000; x++)
1076 {
1077 value.push_back((char) (x % 127));
1078 }
1079
1080 for (size_t current_length= 1; current_length < value.size(); current_length++)
1081 {
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));
1086
1087 size_t string_length;
1088 uint32_t flags;
1089 char *string= memcached_get(memc, test_literal_param("foo"),
1090 &string_length, &flags, &rc);
1091
1092 test_compare(MEMCACHED_SUCCESS, rc);
1093 test_compare(string_length, current_length);
1094 char buffer[1024];
1095 snprintf(buffer, sizeof(buffer), "%u", uint32_t(string_length));
1096 test_memcmp(string, &value[0], string_length);
1097
1098 free(string);
1099 }
1100
1101 return TEST_SUCCESS;
1102 }
1103
1104 /*
1105 Look for zero length value problems
1106 */
1107 test_return_t user_supplied_bug15(memcached_st *memc)
1108 {
1109 for (uint32_t x= 0; x < 2; x++)
1110 {
1111 memcached_return_t rc= memcached_set(memc, test_literal_param("mykey"),
1112 NULL, 0,
1113 (time_t)0, (uint32_t)0);
1114
1115 test_compare(MEMCACHED_SUCCESS, rc);
1116
1117 size_t length;
1118 uint32_t flags;
1119 char *value= memcached_get(memc, test_literal_param("mykey"),
1120 &length, &flags, &rc);
1121
1122 test_compare(MEMCACHED_SUCCESS, rc);
1123 test_false(value);
1124 test_zero(length);
1125 test_zero(flags);
1126
1127 value= memcached_get(memc, test_literal_param("mykey"),
1128 &length, &flags, &rc);
1129
1130 test_compare(MEMCACHED_SUCCESS, rc);
1131 test_null(value);
1132 test_zero(length);
1133 test_zero(flags);
1134 }
1135
1136 return TEST_SUCCESS;
1137 }
1138
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)
1141 {
1142 test_compare(MEMCACHED_SUCCESS, memcached_set(memc, test_literal_param("mykey"),
1143 NULL, 0,
1144 (time_t)0, UINT32_MAX));
1145
1146
1147 size_t length;
1148 uint32_t flags;
1149 memcached_return_t rc;
1150 char *value= memcached_get(memc, test_literal_param("mykey"),
1151 &length, &flags, &rc);
1152
1153 test_compare(MEMCACHED_SUCCESS, rc);
1154 test_null(value);
1155 test_zero(length);
1156 test_compare(flags, UINT32_MAX);
1157
1158 return TEST_SUCCESS;
1159 }
1160
1161 #if !defined(__sun) && !defined(__OpenBSD__)
1162 /* Check the validity of chinese key*/
1163 test_return_t user_supplied_bug17(memcached_st *memc)
1164 {
1165 const char *key= "豆瓣";
1166 const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
1167 memcached_return_t rc= memcached_set(memc, key, strlen(key),
1168 value, strlen(value),
1169 (time_t)0, 0);
1170
1171 test_compare(MEMCACHED_SUCCESS, rc);
1172
1173 size_t length;
1174 uint32_t flags;
1175 char *value2= memcached_get(memc, key, strlen(key),
1176 &length, &flags, &rc);
1177
1178 test_compare(length, strlen(value));
1179 test_compare(MEMCACHED_SUCCESS, rc);
1180 test_memcmp(value, value2, length);
1181 free(value2);
1182
1183 return TEST_SUCCESS;
1184 }
1185 #endif
1186
1187 /*
1188 From Andrei on IRC
1189 */
1190
1191 test_return_t user_supplied_bug19(memcached_st *)
1192 {
1193 memcached_return_t res;
1194
1195 memcached_st *memc= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
1196
1197 const memcached_instance_st * server= memcached_server_by_key(memc, "a", 1, &res);
1198 test_true(server);
1199
1200 memcached_free(memc);
1201
1202 return TEST_SUCCESS;
1203 }
1204
1205 /* CAS test from Andei */
1206 test_return_t user_supplied_bug20(memcached_st *memc)
1207 {
1208 const char *key= "abc";
1209 size_t key_len= strlen("abc");
1210
1211 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));
1212
1213 test_compare(MEMCACHED_SUCCESS,
1214 memcached_set(memc,
1215 test_literal_param("abc"),
1216 test_literal_param("foobar"),
1217 (time_t)0, (uint32_t)0));
1218
1219 test_compare(MEMCACHED_SUCCESS,
1220 memcached_mget(memc, &key, &key_len, 1));
1221
1222 memcached_result_st result_obj;
1223 memcached_result_st *result= memcached_result_create(memc, &result_obj);
1224 test_true(result);
1225
1226 memcached_result_create(memc, &result_obj);
1227 memcached_return_t status;
1228 result= memcached_fetch_result(memc, &result_obj, &status);
1229
1230 test_true(result);
1231 test_compare(MEMCACHED_SUCCESS, status);
1232
1233 memcached_result_free(result);
1234
1235 return TEST_SUCCESS;
1236 }
1237
1238 /* Large mget() of missing keys with binary proto
1239 *
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
1243 */
1244
1245 /* sighandler_t function that always asserts false */
1246 static __attribute__((noreturn)) void fail(int)
1247 {
1248 fatal_assert(0);
1249 }
1250
1251
1252 test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)
1253 {
1254 #ifdef WIN32
1255 (void)memc;
1256 (void)key_count;
1257 return TEST_SKIPPED;
1258 #else
1259 void (*oldalarm)(int);
1260
1261 memcached_st *memc_clone= memcached_clone(NULL, memc);
1262 test_true(memc_clone);
1263
1264 /* only binproto uses getq for mget */
1265 test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true));
1266
1267 /* empty the cache to ensure misses (hence non-responses) */
1268 test_compare(MEMCACHED_SUCCESS, memcached_flush(memc_clone, 0));
1269
1270 keys_st keys(key_count);
1271
1272 oldalarm= signal(SIGALRM, fail);
1273 alarm(5);
1274
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));
1278
1279 alarm(0);
1280 signal(SIGALRM, oldalarm);
1281
1282 memcached_return_t rc;
1283 uint32_t flags;
1284 char return_key[MEMCACHED_MAX_KEY];
1285 size_t return_key_length;
1286 char *return_value;
1287 size_t return_value_length;
1288 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1289 &return_value_length, &flags, &rc)))
1290 {
1291 test_false(return_value); // There are no keys to fetch, so the value should never be returned
1292 }
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);
1298
1299 memcached_free(memc_clone);
1300
1301 return TEST_SUCCESS;
1302 #endif
1303 }
1304
1305 test_return_t user_supplied_bug21(memcached_st *memc)
1306 {
1307 test_skip(TEST_SUCCESS, pre_binary(memc));
1308
1309 /* should work as of r580 */
1310 test_compare(TEST_SUCCESS,
1311 _user_supplied_bug21(memc, 10));
1312
1313 /* should fail as of r580 */
1314 test_compare(TEST_SUCCESS,
1315 _user_supplied_bug21(memc, 1000));
1316
1317 return TEST_SUCCESS;
1318 }
1319
1320 test_return_t comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st *)
1321 {
1322 test::Memc memc_;
1323
1324 memcached_st *memc= &memc_;
1325
1326 ASSERT_EQ(memc, MEMCACHED_SUCCESS);
1327 test_compare(memc, MEMCACHED_SUCCESS);
1328
1329 ASSERT_NEQ(memc, MEMCACHED_FAILURE);
1330
1331 return TEST_SUCCESS;
1332 }
1333
1334 test_return_t result_static(memcached_st *memc)
1335 {
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);
1342
1343 memcached_result_free(&result);
1344
1345 test_false(result.options.is_allocated);
1346 test_false(memcached_is_initialized(&result));
1347
1348 return TEST_SUCCESS;
1349 }
1350
1351 test_return_t result_alloc(memcached_st *memc)
1352 {
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);
1358
1359 return TEST_SUCCESS;
1360 }
1361
1362
1363 static void my_free(const memcached_st *ptr, void *mem, void *context)
1364 {
1365 (void)context;
1366 (void)ptr;
1367 #ifdef HARD_MALLOC_TESTS
1368 void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8);
1369 free(real_ptr);
1370 #else
1371 free(mem);
1372 #endif
1373 }
1374
1375
1376 static void *my_malloc(const memcached_st *ptr, const size_t size, void *context)
1377 {
1378 (void)context;
1379 (void)ptr;
1380 #ifdef HARD_MALLOC_TESTS
1381 void *ret= malloc(size + 8);
1382 if (ret != NULL)
1383 {
1384 ret= (void*)((caddr_t)ret + 8);
1385 }
1386 #else
1387 void *ret= malloc(size);
1388 #endif
1389
1390 if (ret != NULL)
1391 {
1392 memset(ret, 0xff, size);
1393 }
1394
1395 return ret;
1396 }
1397
1398
1399 static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *)
1400 {
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);
1404
1405 void *ret= NULL;
1406 if (nmem != NULL)
1407 {
1408 ret= (void*)((caddr_t)nmem + 8);
1409 }
1410
1411 return ret;
1412 #else
1413 (void)ptr;
1414 return realloc(mem, size);
1415 #endif
1416 }
1417
1418
1419 static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *)
1420 {
1421 #ifdef HARD_MALLOC_TESTS
1422 void *mem= my_malloc(ptr, nelem * size);
1423 if (mem)
1424 {
1425 memset(mem, 0, nelem * size);
1426 }
1427
1428 return mem;
1429 #else
1430 (void)ptr;
1431 return calloc(nelem, size);
1432 #endif
1433 }
1434
1435 #ifdef MEMCACHED_ENABLE_DEPRECATED
1436 test_return_t deprecated_set_memory_alloc(memcached_st *memc)
1437 {
1438 void *test_ptr= NULL;
1439 void *cb_ptr= NULL;
1440 {
1441 memcached_malloc_fn malloc_cb= (memcached_malloc_fn)my_malloc;
1442 cb_ptr= *(void **)&malloc_cb;
1443 memcached_return_t rc;
1444
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);
1450 }
1451
1452 {
1453 memcached_realloc_fn realloc_cb=
1454 (memcached_realloc_fn)my_realloc;
1455 cb_ptr= *(void **)&realloc_cb;
1456 memcached_return_t rc;
1457
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);
1463 }
1464
1465 {
1466 memcached_free_fn free_cb=
1467 (memcached_free_fn)my_free;
1468 cb_ptr= *(void **)&free_cb;
1469 memcached_return_t rc;
1470
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);
1476 }
1477
1478 return TEST_SUCCESS;
1479 }
1480 #endif
1481
1482
1483 test_return_t set_memory_alloc(memcached_st *memc)
1484 {
1485 test_compare(MEMCACHED_INVALID_ARGUMENTS,
1486 memcached_set_memory_allocators(memc, NULL, my_free,
1487 my_realloc, my_calloc, NULL));
1488
1489 test_compare(MEMCACHED_SUCCESS,
1490 memcached_set_memory_allocators(memc, my_malloc, my_free,
1491 my_realloc, my_calloc, NULL));
1492
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);
1499
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);
1504
1505 return TEST_SUCCESS;
1506 }
1507
1508 test_return_t MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st *memc)
1509 {
1510 const uint64_t timeout= 100; // Not using, just checking that it sets
1511
1512 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
1513
1514 test_compare(timeout, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT));
1515
1516 return TEST_SUCCESS;
1517 }
1518
1519 test_return_t analyzer_test(memcached_st *memc)
1520 {
1521 memcached_analysis_st *report;
1522 memcached_return_t rc;
1523
1524 memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
1525 test_compare(MEMCACHED_SUCCESS, rc);
1526 test_true(memc_stat);
1527
1528 report= memcached_analyze(memc, memc_stat, &rc);
1529 test_compare(MEMCACHED_SUCCESS, rc);
1530 test_true(report);
1531
1532 free(report);
1533 memcached_stat_free(NULL, memc_stat);
1534
1535 return TEST_SUCCESS;
1536 }
1537
1538 test_return_t hsieh_avaibility_test (memcached_st *memc)
1539 {
1540 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH));
1541
1542 test_compare(MEMCACHED_SUCCESS,
1543 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
1544 (uint64_t)MEMCACHED_HASH_HSIEH));
1545
1546 return TEST_SUCCESS;
1547 }
1548
1549 test_return_t murmur_avaibility_test (memcached_st *memc)
1550 {
1551 test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR));
1552
1553 test_compare(MEMCACHED_SUCCESS,
1554 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR));
1555
1556 return TEST_SUCCESS;
1557 }
1558
1559 /*
1560 Test case adapted from John Gorman <johngorman2@gmail.com>
1561
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.
1564 */
1565 test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *)
1566 {
1567 size_t len;
1568 uint32_t flags;
1569 memcached_return rc;
1570
1571 // Create a handle.
1572 memcached_st *tl_memc_h= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
1573
1574 // See if memcached is reachable.
1575 char *value= memcached_get(tl_memc_h,
1576 test_literal_param(__func__),
1577 &len, &flags, &rc);
1578
1579 test_false(value);
1580 test_zero(len);
1581 test_true(memcached_failed(rc));
1582
1583 memcached_free(tl_memc_h);
1584
1585 return TEST_SUCCESS;
1586 }
1587
1588 /*
1589 We connect to a server which exists, but search for a key that does not exist.
1590 */
1591 test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc)
1592 {
1593 size_t len;
1594 uint32_t flags;
1595 memcached_return rc;
1596
1597 // See if memcached is reachable.
1598 char *value= memcached_get(memc,
1599 test_literal_param(__func__),
1600 &len, &flags, &rc);
1601
1602 test_false(value);
1603 test_zero(len);
1604 test_compare(MEMCACHED_NOTFOUND, rc);
1605
1606 return TEST_SUCCESS;
1607 }
1608
1609 /*
1610 Test case adapted from John Gorman <johngorman2@gmail.com>
1611
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.
1614 */
1615 test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *)
1616 {
1617 size_t len;
1618 uint32_t flags;
1619 memcached_return rc;
1620
1621 // Create a handle.
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);
1626
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
1631 &len, &flags, &rc);
1632
1633 test_false(value);
1634 test_zero(len);
1635 test_true(memcached_failed(rc));
1636
1637 memcached_free(tl_memc_h);
1638
1639 return TEST_SUCCESS;
1640 }
1641
1642 /*
1643 We connect to a server which exists, but search for a key that does not exist.
1644 */
1645 test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc)
1646 {
1647 size_t len;
1648 uint32_t flags;
1649 memcached_return rc;
1650
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
1655 &len, &flags, &rc);
1656
1657 test_false(value);
1658 test_zero(len);
1659 test_compare(MEMCACHED_NOTFOUND, rc);
1660
1661 return TEST_SUCCESS;
1662 }
1663
1664 test_return_t regression_bug_421108(memcached_st *memc)
1665 {
1666 memcached_return_t rc;
1667 memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
1668 test_compare(MEMCACHED_SUCCESS, rc);
1669
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,
1674 "bytes_read", &rc);
1675 test_compare(MEMCACHED_SUCCESS, rc);
1676 test_true(bytes_read_str);
1677
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);
1682
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);
1686
1687 test_true(bytes != bytes_read);
1688 test_true(bytes != bytes_written);
1689
1690 /* Release allocated resources */
1691 free(bytes_str);
1692 free(bytes_read_str);
1693 free(bytes_written_str);
1694 memcached_stat_free(NULL, memc_stat);
1695
1696 return TEST_SUCCESS;
1697 }
1698
1699
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
1703 */
1704 test_return_t test_get_last_disconnect(memcached_st *memc)
1705 {
1706 memcached_return_t rc;
1707 const memcached_instance_st * disconnected_server;
1708
1709 /* With the working set of server */
1710 const char *key= "marmotte";
1711 const char *value= "milka";
1712
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);
1719
1720 disconnected_server = memcached_server_get_last_disconnect(memc);
1721 test_false(disconnected_server);
1722
1723 /* With a non existing server */
1724 memcached_st *mine;
1725 memcached_server_st *servers;
1726
1727 const char *server_list= "localhost:9";
1728
1729 servers= memcached_servers_parse(server_list);
1730 test_true(servers);
1731 mine= memcached_create(NULL);
1732 rc= memcached_server_push(mine, servers);
1733 test_compare(MEMCACHED_SUCCESS, rc);
1734 memcached_server_list_free(servers);
1735 test_true(mine);
1736
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));
1741
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));
1746
1747 memcached_quit(mine);
1748 memcached_free(mine);
1749
1750 return TEST_SUCCESS;
1751 }
1752
1753 test_return_t test_multiple_get_last_disconnect(memcached_st *)
1754 {
1755 const char *server_string= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
1756 char buffer[BUFSIZ];
1757
1758 test_compare(MEMCACHED_SUCCESS,
1759 libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)));
1760
1761 memcached_st *memc= memcached(server_string, strlen(server_string));
1762 test_true(memc);
1763
1764 // We will just use the error strings as our keys
1765 uint32_t counter= 100;
1766 while (--counter)
1767 {
1768 for (int x= int(MEMCACHED_SUCCESS); x < int(MEMCACHED_MAXIMUM_RETURN); ++x)
1769 {
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));
1773
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);
1778
1779 if (random() % 2)
1780 {
1781 memcached_reset_last_disconnected_server(memc);
1782 }
1783 }
1784 }
1785
1786 memcached_free(memc);
1787
1788 return TEST_SUCCESS;
1789 }
1790
1791 test_return_t test_verbosity(memcached_st *memc)
1792 {
1793 test_compare(MEMCACHED_SUCCESS, memcached_verbosity(memc, 0));
1794
1795 return TEST_SUCCESS;
1796 }
1797
1798
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,
1802 void *context)
1803 {
1804 (void)server;
1805 (void)context;
1806 (void)key;
1807 (void)key_length;
1808 (void)value;
1809 (void)value_length;
1810
1811 return MEMCACHED_SUCCESS;
1812 }
1813
1814 test_return_t memcached_stat_execute_test(memcached_st *memc)
1815 {
1816 memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL);
1817 test_compare(MEMCACHED_SUCCESS, rc);
1818
1819 test_compare(MEMCACHED_SUCCESS,
1820 memcached_stat_execute(memc, "slabs", stat_printer, NULL));
1821
1822 test_compare(MEMCACHED_SUCCESS,
1823 memcached_stat_execute(memc, "items", stat_printer, NULL));
1824
1825 test_compare(MEMCACHED_SUCCESS,
1826 memcached_stat_execute(memc, "sizes", stat_printer, NULL));
1827
1828 return TEST_SUCCESS;
1829 }
1830
1831 /*
1832 * This test ensures that the failure counter isn't incremented during
1833 * normal termination of the memcached instance.
1834 */
1835 test_return_t wrong_failure_counter_test(memcached_st *original_memc)
1836 {
1837 memcached_st* memc= create_single_instance_memcached(original_memc, NULL);
1838
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);
1845
1846
1847 const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0);
1848
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
1852 */
1853 ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
1854
1855 memcached_quit(memc);
1856
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
1859 * occur...
1860 */
1861 test_zero(instance->server_failure_counter);
1862
1863 memcached_free(memc);
1864
1865 return TEST_SUCCESS;
1866 }
1867
1868 /*
1869 * This tests ensures expected disconnections (for some behavior changes
1870 * for instance) do not wrongly increase failure counter
1871 */
1872 test_return_t wrong_failure_counter_two_test(memcached_st *memc)
1873 {
1874 /* Set value to force connection to the server */
1875 const char *key= "marmotte";
1876 const char *value= "milka";
1877
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));
1883
1884
1885 /* put failure limit to 1 */
1886 test_compare(MEMCACHED_SUCCESS,
1887 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, true));
1888
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));
1892
1893 /* change behavior that triggers memcached_quit()*/
1894 test_compare(MEMCACHED_SUCCESS,
1895 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true));
1896
1897
1898 /* Check if we still are connected */
1899 uint32_t flags;
1900 size_t string_length;
1901 memcached_return rc;
1902 char *string= memcached_get(memc, key, strlen(key),
1903 &string_length, &flags, &rc);
1904
1905 test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
1906 test_true(string);
1907 free(string);
1908
1909 return TEST_SUCCESS;
1910 }
1911
1912
1913 test_return_t regression_1021819_TEST(memcached_st *original)
1914 {
1915 memcached_st *memc= memcached_clone(NULL, original);
1916 test_true(memc);
1917
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);
1920
1921 memcached_return_t rc;
1922
1923 memcached_get(memc,
1924 test_literal_param(__func__),
1925 NULL, NULL, &rc);
1926
1927 test_compare(rc, MEMCACHED_NOTFOUND);
1928
1929 memcached_free(memc);
1930
1931 return TEST_SUCCESS;
1932 }
1933
1934 test_return_t regression_bug_583031(memcached_st *)
1935 {
1936 memcached_st *memc= memcached_create(NULL);
1937 test_true(memc);
1938 test_compare(MEMCACHED_SUCCESS, memcached_server_add(memc, "10.2.251.4", 11211));
1939
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);
1946
1947 memcached_return_t rc;
1948 size_t length;
1949 uint32_t flags;
1950
1951 const char *value= memcached_get(memc, "dsf", 3, &length, &flags, &rc);
1952 test_false(value);
1953 test_zero(length);
1954
1955 test_compare(MEMCACHED_TIMEOUT, memc);
1956
1957 memcached_free(memc);
1958
1959 return TEST_SUCCESS;
1960 }
1961
1962 test_return_t regression_bug_581030(memcached_st *)
1963 {
1964 #ifndef DEBUG
1965 memcached_stat_st *local_stat= memcached_stat(NULL, NULL, NULL);
1966 test_false(local_stat);
1967
1968 memcached_stat_free(NULL, NULL);
1969 #endif
1970
1971 return TEST_SUCCESS;
1972 }
1973
1974 #define regression_bug_655423_COUNT 6000
1975 test_return_t regression_bug_655423(memcached_st *memc)
1976 {
1977 memcached_st *clone= memcached_clone(NULL, memc);
1978 memc= NULL; // Just to make sure it is not used
1979 test_true(clone);
1980 char payload[100];
1981
1982 #ifdef __APPLE__
1983 return TEST_SKIPPED;
1984 #endif
1985
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));
1990
1991 memset(payload, int('x'), sizeof(payload));
1992
1993 keys_st keys(regression_bug_655423_COUNT);
1994
1995 for (size_t x= 0; x < keys.size(); x++)
1996 {
1997 test_compare(MEMCACHED_SUCCESS, memcached_set(clone,
1998 keys.key_at(x),
1999 keys.length_at(x),
2000 payload, sizeof(payload), 0, 0));
2001 }
2002
2003 for (size_t x= 0; x < keys.size(); x++)
2004 {
2005 size_t value_length;
2006 memcached_return_t rc;
2007 char *value= memcached_get(clone,
2008 keys.key_at(x),
2009 keys.length_at(x),
2010 &value_length, NULL, &rc);
2011
2012 if (rc == MEMCACHED_NOTFOUND)
2013 {
2014 test_false(value);
2015 test_zero(value_length);
2016 continue;
2017 }
2018
2019 test_compare(MEMCACHED_SUCCESS, rc);
2020 test_true(value);
2021 test_compare(100LLU, value_length);
2022 free(value);
2023 }
2024
2025 test_compare(MEMCACHED_SUCCESS,
2026 memcached_mget(clone,
2027 keys.keys_ptr(), keys.lengths_ptr(),
2028 keys.size()));
2029
2030 uint32_t count= 0;
2031 memcached_result_st *result= NULL;
2032 while ((result= memcached_fetch_result(clone, result, NULL)))
2033 {
2034 test_compare(size_t(100), memcached_result_length(result));
2035 count++;
2036 }
2037
2038 test_true(count > 100); // If we don't get back atleast this, something is up
2039
2040 memcached_free(clone);
2041
2042 return TEST_SUCCESS;
2043 }
2044
2045 /*
2046 * Test that ensures that buffered set to not trigger problems during io_flush
2047 */
2048 #define regression_bug_490520_COUNT 200480
2049 test_return_t regression_bug_490520(memcached_st *original_memc)
2050 {
2051 memcached_st* memc= create_single_instance_memcached(original_memc, NULL);
2052
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);
2058
2059 /* First add all of the items.. */
2060 char blob[3333] = {0};
2061 for (uint32_t x= 0; x < regression_bug_490520_COUNT; ++x)
2062 {
2063 char key[251];
2064 int key_length= snprintf(key, sizeof(key), "0200%u", x);
2065
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));
2068 }
2069
2070 memcached_free(memc);
2071
2072 return TEST_SUCCESS;
2073 }
2074
2075 test_return_t regression_bug_1251482(memcached_st*)
2076 {
2077 test::Memc memc("--server=localhost:5");
2078
2079 memcached_behavior_set(&memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 0);
2080
2081 for (size_t x= 0; x < 5; ++x)
2082 {
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);
2088
2089 test_false(value);
2090 test_compare(0LLU, value_length);
2091 if (x) {
2092 test_ne_compare(MEMCACHED_SUCCESS, rc);
2093 } else {
2094 test_compare(MEMCACHED_CONNECTION_FAILURE, rc);
2095 }
2096 }
2097
2098 return TEST_SUCCESS;
2099 }
2100
2101 test_return_t regression_1009493_TEST(memcached_st*)
2102 {
2103 memcached_st* memc= memcached_create(NULL);
2104 test_true(memc);
2105 test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, true));
2106
2107 memcached_st* clone= memcached_clone(NULL, memc);
2108 test_true(clone);
2109
2110 test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED),
2111 memcached_behavior_get(clone, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED));
2112
2113 memcached_free(memc);
2114 memcached_free(clone);
2115
2116 return TEST_SUCCESS;
2117 }
2118
2119 test_return_t regression_994772_TEST(memcached_st* memc)
2120 {
2121 test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
2122
2123 test_compare(MEMCACHED_SUCCESS,
2124 memcached_set(memc,
2125 test_literal_param(__func__), // Key
2126 test_literal_param(__func__), // Value
2127 time_t(0), uint32_t(0)));
2128
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));
2133
2134 memcached_return_t rc;
2135 memcached_result_st *results= memcached_fetch_result(memc, NULL, &rc);
2136 test_true(results);
2137 test_compare(MEMCACHED_SUCCESS, rc);
2138
2139 test_strcmp(__func__, memcached_result_value(results));
2140 uint64_t cas_value= memcached_result_cas(results);
2141 test_true(cas_value);
2142
2143 char* take_value= memcached_result_take_value(results);
2144 test_strcmp(__func__, take_value);
2145 free(take_value);
2146
2147 memcached_result_free(results);
2148
2149 // Bad cas value, sanity check
2150 test_true(cas_value != 9999);
2151 test_compare(MEMCACHED_END,
2152 memcached_cas(memc,
2153 test_literal_param(__func__), // Key
2154 test_literal_param(__FILE__), // Value
2155 time_t(0), uint32_t(0), 9999));
2156
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)));
2161
2162 return TEST_SUCCESS;
2163 }
2164
2165 test_return_t regression_bug_854604(memcached_st *)
2166 {
2167 char buffer[1024];
2168
2169 test_compare(MEMCACHED_INVALID_ARGUMENTS, libmemcached_check_configuration(0, 0, buffer, 0));
2170
2171 test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 0));
2172
2173 test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 1));
2174 test_compare(buffer[0], 0);
2175
2176 test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 10));
2177 test_true(strlen(buffer));
2178
2179 test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, sizeof(buffer)));
2180 test_true(strlen(buffer));
2181
2182 return TEST_SUCCESS;
2183 }
2184
2185 static void die_message(memcached_st* mc, memcached_return error, const char* what, uint32_t it)
2186 {
2187 fprintf(stderr, "Iteration #%u: ", it);
2188
2189 if (error == MEMCACHED_ERRNO)
2190 {
2191 fprintf(stderr, "system error %d from %s: %s\n",
2192 errno, what, strerror(errno));
2193 }
2194 else
2195 {
2196 fprintf(stderr, "error %d from %s: %s\n", error, what,
2197 memcached_strerror(mc, error));
2198 }
2199 }
Resurrection of libmemcached https://launchpad.net/libmemcached