projects / m6w6 / libmemcached / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
Test cleanup, extended error system to record host.
[m6w6/libmemcached] / tests / 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
39 /*
40 Sample test application.
41 */
42
43 #include "config.h"
44
45 #include <stdint.h>
46
47 #include <cassert>
48 #include <cstdio>
49 #include <cstdlib>
50 #include <cstring>
51 #include <ctime>
52 #include <memory>
53 #include <signal.h>
54 #include <sys/stat.h>
55 #include <sys/time.h>
56 #include <sys/types.h>
57 #include <unistd.h>
58
59 #include "libmemcached/common.h"
60
61 #include <libtest/server.h>
62
63 #include "clients/generator.h"
64 #include "clients/execute.h"
65
66 #define SMALL_STRING_LEN 1024
67
68 #include <libtest/test.h>
69 #include "tests/deprecated.h"
70 #include "tests/parser.h"
71 #include "tests/pool.h"
72 #include "tests/string.h"
73 #include "tests/replication.h"
74 #include "tests/basic.h"
75 #include "tests/error_conditions.h"
76 #include "tests/print.h"
77 #include "tests/virtual_buckets.h"
78
79
80 #ifdef HAVE_LIBMEMCACHEDUTIL
81 #include <pthread.h>
82 #include "libmemcached/memcached_util.h"
83 #endif
84
85 #include "hash_results.h"
86
87 #define GLOBAL_COUNT 10000
88 #define GLOBAL2_COUNT 100
89 #define SERVERS_TO_CREATE 5
90 static uint32_t global_count;
91
92 static pairs_st *global_pairs;
93 static const char *global_keys[GLOBAL_COUNT];
94 static size_t global_keys_length[GLOBAL_COUNT];
95
96 // Prototype
97 static test_return_t pre_binary(memcached_st *memc);
98
99
100 static test_return_t init_test(memcached_st *not_used)
101 {
102 memcached_st memc;
103 (void)not_used;
104
105 (void)memcached_create(&memc);
106 memcached_free(&memc);
107
108 return TEST_SUCCESS;
109 }
110
111 #define TEST_PORT_COUNT 7
112 in_port_t test_ports[TEST_PORT_COUNT];
113
114 static memcached_return_t server_display_function(const memcached_st *ptr,
115 const memcached_server_st *server,
116 void *context)
117 {
118 /* Do Nothing */
119 size_t bigger= *((size_t *)(context));
120 (void)ptr;
121 assert(bigger <= memcached_server_port(server));
122 *((size_t *)(context))= memcached_server_port(server);
123
124 return MEMCACHED_SUCCESS;
125 }
126
127 static memcached_return_t dump_server_information(const memcached_st *ptr,
128 const memcached_server_st *instance,
129 void *context)
130 {
131 /* Do Nothing */
132 FILE *stream= (FILE *)context;
133 (void)ptr;
134
135 fprintf(stream, "Memcached Server: %s %u Version %u.%u.%u\n",
136 memcached_server_name(instance),
137 memcached_server_port(instance),
138 instance->major_version,
139 instance->minor_version,
140 instance->micro_version);
141
142 return MEMCACHED_SUCCESS;
143 }
144
145 static test_return_t server_sort_test(memcached_st *ptr)
146 {
147 size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
148
149 memcached_return_t rc;
150 memcached_server_fn callbacks[1];
151 memcached_st *local_memc;
152 (void)ptr;
153
154 local_memc= memcached_create(NULL);
155 test_true(local_memc);
156 memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
157
158 for (size_t x= 0; x < TEST_PORT_COUNT; x++)
159 {
160 test_ports[x]= (in_port_t)random() % 64000;
161 rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
162 test_true(memcached_server_count(local_memc) == x + 1);
163 #if 0 // Rewrite
164 test_true(memcached_server_list_count(memcached_server_list(local_memc)) == x+1);
165 #endif
166 test_true(rc == MEMCACHED_SUCCESS);
167 }
168
169 callbacks[0]= server_display_function;
170 memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
171
172
173 memcached_free(local_memc);
174
175 return TEST_SUCCESS;
176 }
177
178 static test_return_t server_sort2_test(memcached_st *ptr)
179 {
180 size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
181 memcached_return_t rc;
182 memcached_server_fn callbacks[1];
183 memcached_st *local_memc;
184 memcached_server_instance_st instance;
185 (void)ptr;
186
187 local_memc= memcached_create(NULL);
188 test_true(local_memc);
189 rc= memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
190 test_true(rc == MEMCACHED_SUCCESS);
191
192 rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
193 test_true(rc == MEMCACHED_SUCCESS);
194 instance= memcached_server_instance_by_position(local_memc, 0);
195 test_true(memcached_server_port(instance) == 43043);
196
197 rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
198 test_true(rc == MEMCACHED_SUCCESS);
199
200 instance= memcached_server_instance_by_position(local_memc, 0);
201 test_true(memcached_server_port(instance) == 43042);
202
203 instance= memcached_server_instance_by_position(local_memc, 1);
204 test_true(memcached_server_port(instance) == 43043);
205
206 callbacks[0]= server_display_function;
207 memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
208
209
210 memcached_free(local_memc);
211
212 return TEST_SUCCESS;
213 }
214
215 static test_return_t memcached_server_remove_test(memcached_st *ptr)
216 {
217 const char *server_string= "--server=localhost:4444 --server=localhost:4445 --server=localhost:4446 --server=localhost:4447 --server=localhost --server=memcache1.memcache.bk.sapo.pt:11211 --server=memcache1.memcache.bk.sapo.pt:11212 --server=memcache1.memcache.bk.sapo.pt:11213 --server=memcache1.memcache.bk.sapo.pt:11214 --server=memcache2.memcache.bk.sapo.pt:11211 --server=memcache2.memcache.bk.sapo.pt:11212 --server=memcache2.memcache.bk.sapo.pt:11213 --server=memcache2.memcache.bk.sapo.pt:11214";
218 (void)ptr;
219
220 memcached_st *memc= memcached(server_string, strlen(server_string));
221 test_true(memc);
222
223 memcached_server_fn callbacks[1];
224 callbacks[0]= server_print_callback;
225 memcached_server_cursor(memc, callbacks, NULL, 1);
226
227 memcached_free(memc);
228
229 return TEST_SUCCESS;
230 }
231
232 static memcached_return_t server_display_unsort_function(const memcached_st *ptr,
233 const memcached_server_st *server,
234 void *context)
235 {
236 /* Do Nothing */
237 uint32_t x= *((uint32_t *)(context));
238 (void)ptr;
239
240 if (! (test_ports[x] == server->port))
241 {
242 fprintf(stderr, "%lu -> %lu\n", (unsigned long)test_ports[x], (unsigned long)server->port);
243 return MEMCACHED_FAILURE;
244 }
245
246 *((uint32_t *)(context))= ++x;
247
248 return MEMCACHED_SUCCESS;
249 }
250
251 static test_return_t server_unsort_test(memcached_st *ptr)
252 {
253 size_t counter= 0; /* Prime the value for the test_true in server_display_function */
254 size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
255 memcached_return_t rc;
256 memcached_server_fn callbacks[1];
257 memcached_st *local_memc;
258 (void)ptr;
259
260 local_memc= memcached_create(NULL);
261 test_true(local_memc);
262
263 for (size_t x= 0; x < TEST_PORT_COUNT; x++)
264 {
265 test_ports[x]= (in_port_t)(random() % 64000);
266 rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
267 test_true(memcached_server_count(local_memc) == x+1);
268 #if 0 // Rewrite
269 test_true(memcached_server_list_count(memcached_server_list(local_memc)) == x+1);
270 #endif
271 test_true(rc == MEMCACHED_SUCCESS);
272 }
273
274 callbacks[0]= server_display_unsort_function;
275 memcached_server_cursor(local_memc, callbacks, (void *)&counter, 1);
276
277 /* Now we sort old data! */
278 memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
279 callbacks[0]= server_display_function;
280 memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
281
282
283 memcached_free(local_memc);
284
285 return TEST_SUCCESS;
286 }
287
288 static test_return_t allocation_test(memcached_st *not_used)
289 {
290 (void)not_used;
291 memcached_st *memc;
292 memc= memcached_create(NULL);
293 test_true(memc);
294 memcached_free(memc);
295
296 return TEST_SUCCESS;
297 }
298
299 static test_return_t clone_test(memcached_st *memc)
300 {
301 /* All null? */
302 {
303 memcached_st *memc_clone;
304 memc_clone= memcached_clone(NULL, NULL);
305 test_true(memc_clone);
306 memcached_free(memc_clone);
307 }
308
309 /* Can we init from null? */
310 {
311 memcached_st *memc_clone;
312 memc_clone= memcached_clone(NULL, memc);
313 test_true(memc_clone);
314
315 { // Test allocators
316 test_true(memc_clone->allocators.free == memc->allocators.free);
317 test_true(memc_clone->allocators.malloc == memc->allocators.malloc);
318 test_true(memc_clone->allocators.realloc == memc->allocators.realloc);
319 test_true(memc_clone->allocators.calloc == memc->allocators.calloc);
320 }
321
322 test_true(memc_clone->connect_timeout == memc->connect_timeout);
323 test_true(memc_clone->delete_trigger == memc->delete_trigger);
324 test_true(memc_clone->distribution == memc->distribution);
325 { // Test all of the flags
326 test_true(memc_clone->flags.no_block == memc->flags.no_block);
327 test_true(memc_clone->flags.tcp_nodelay == memc->flags.tcp_nodelay);
328 test_true(memc_clone->flags.support_cas == memc->flags.support_cas);
329 test_true(memc_clone->flags.buffer_requests == memc->flags.buffer_requests);
330 test_true(memc_clone->flags.use_sort_hosts == memc->flags.use_sort_hosts);
331 test_true(memc_clone->flags.verify_key == memc->flags.verify_key);
332 test_true(memc_clone->ketama.weighted == memc->ketama.weighted);
333 test_true(memc_clone->flags.binary_protocol == memc->flags.binary_protocol);
334 test_true(memc_clone->flags.hash_with_prefix_key == memc->flags.hash_with_prefix_key);
335 test_true(memc_clone->flags.no_reply == memc->flags.no_reply);
336 test_true(memc_clone->flags.use_udp == memc->flags.use_udp);
337 test_true(memc_clone->flags.auto_eject_hosts == memc->flags.auto_eject_hosts);
338 test_true(memc_clone->flags.randomize_replica_read == memc->flags.randomize_replica_read);
339 }
340 test_true(memc_clone->get_key_failure == memc->get_key_failure);
341 test_true(hashkit_compare(&memc_clone->hashkit, &memc->hashkit));
342 test_true(memc_clone->io_bytes_watermark == memc->io_bytes_watermark);
343 test_true(memc_clone->io_msg_watermark == memc->io_msg_watermark);
344 test_true(memc_clone->io_key_prefetch == memc->io_key_prefetch);
345 test_true(memc_clone->on_cleanup == memc->on_cleanup);
346 test_true(memc_clone->on_clone == memc->on_clone);
347 test_true(memc_clone->poll_timeout == memc->poll_timeout);
348 test_true(memc_clone->rcv_timeout == memc->rcv_timeout);
349 test_true(memc_clone->recv_size == memc->recv_size);
350 test_true(memc_clone->retry_timeout == memc->retry_timeout);
351 test_true(memc_clone->send_size == memc->send_size);
352 test_true(memc_clone->server_failure_limit == memc->server_failure_limit);
353 test_true(memc_clone->snd_timeout == memc->snd_timeout);
354 test_true(memc_clone->user_data == memc->user_data);
355
356 memcached_free(memc_clone);
357 }
358
359 /* Can we init from struct? */
360 {
361 memcached_st declared_clone;
362 memcached_st *memc_clone;
363 memset(&declared_clone, 0 , sizeof(memcached_st));
364 memc_clone= memcached_clone(&declared_clone, NULL);
365 test_true(memc_clone);
366 memcached_free(memc_clone);
367 }
368
369 /* Can we init from struct? */
370 {
371 memcached_st declared_clone;
372 memcached_st *memc_clone;
373 memset(&declared_clone, 0 , sizeof(memcached_st));
374 memc_clone= memcached_clone(&declared_clone, memc);
375 test_true(memc_clone);
376 memcached_free(memc_clone);
377 }
378
379 return TEST_SUCCESS;
380 }
381
382 static test_return_t userdata_test(memcached_st *memc)
383 {
384 void* foo= NULL;
385 test_true(memcached_set_user_data(memc, foo) == NULL);
386 test_true(memcached_get_user_data(memc) == foo);
387 test_true(memcached_set_user_data(memc, NULL) == foo);
388
389 return TEST_SUCCESS;
390 }
391
392 static test_return_t connection_test(memcached_st *memc)
393 {
394 memcached_return_t rc;
395
396 rc= memcached_server_add_with_weight(memc, "localhost", 0, 0);
397 test_true(rc == MEMCACHED_SUCCESS);
398
399 return TEST_SUCCESS;
400 }
401
402 static test_return_t error_test(memcached_st *memc)
403 {
404 uint32_t values[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U,
405 982370485U, 1263635348U, 4242906218U, 3829656100U,
406 1891735253U, 334139633U, 2257084983U, 3088286104U,
407 13199785U, 2542027183U, 1097051614U, 199566778U,
408 2748246961U, 2465192557U, 1664094137U, 2405439045U,
409 1842224848U, 692413798U, 3479807801U, 919913813U,
410 4269430871U, 610793021U, 527273862U, 1437122909U,
411 2300930706U, 2943759320U, 674306647U, 2400528935U,
412 54481931U, 4186304426U, 1741088401U, 2979625118U,
413 4159057246U, 3425930182U, 2593724503U, 1868899624U,
414 1769812374U, 2302537950U, 1110330676U, 3365377466U,
415 1336171666U, 3021258493U, 3365377466U };
416
417 // You have updated the memcache_error messages but not updated docs/tests.
418 for (int rc= int(MEMCACHED_SUCCESS); rc < int(MEMCACHED_MAXIMUM_RETURN); ++rc)
419 {
420 uint32_t hash_val;
421 const char *msg= memcached_strerror(memc, memcached_return_t(rc));
422 hash_val= memcached_generate_hash_value(msg, strlen(msg),
423 MEMCACHED_HASH_JENKINS);
424 if (values[rc] != hash_val)
425 {
426 fprintf(stderr, "\n\nYou have updated memcached_return_t without updating the error_test\n");
427 fprintf(stderr, "%u, %s, (%u)\n\n", (uint32_t)rc, memcached_strerror(memc, memcached_return_t(rc)), hash_val);
428 }
429 test_true(values[rc] == hash_val);
430 }
431 test_true(MEMCACHED_MAXIMUM_RETURN == 46);
432
433 return TEST_SUCCESS;
434 }
435
436 static test_return_t set_test(memcached_st *memc)
437 {
438 memcached_return_t rc;
439 const char *key= "foo";
440 const char *value= "when we sanitize";
441
442 rc= memcached_set(memc, key, strlen(key),
443 value, strlen(value),
444 (time_t)0, (uint32_t)0);
445 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
446
447 return TEST_SUCCESS;
448 }
449
450 static test_return_t append_test(memcached_st *memc)
451 {
452 memcached_return_t rc;
453 const char *key= "fig";
454 const char *in_value= "we";
455 char *out_value= NULL;
456 size_t value_length;
457 uint32_t flags;
458
459 rc= memcached_flush(memc, 0);
460 test_true(rc == MEMCACHED_SUCCESS);
461
462 rc= memcached_set(memc, key, strlen(key),
463 in_value, strlen(in_value),
464 (time_t)0, (uint32_t)0);
465 test_true(rc == MEMCACHED_SUCCESS);
466
467 rc= memcached_append(memc, key, strlen(key),
468 " the", strlen(" the"),
469 (time_t)0, (uint32_t)0);
470 test_true(rc == MEMCACHED_SUCCESS);
471
472 rc= memcached_append(memc, key, strlen(key),
473 " people", strlen(" people"),
474 (time_t)0, (uint32_t)0);
475 test_true(rc == MEMCACHED_SUCCESS);
476
477 out_value= memcached_get(memc, key, strlen(key),
478 &value_length, &flags, &rc);
479 test_true(!memcmp(out_value, "we the people", strlen("we the people")));
480 test_true(strlen("we the people") == value_length);
481 test_true(rc == MEMCACHED_SUCCESS);
482 free(out_value);
483
484 return TEST_SUCCESS;
485 }
486
487 static test_return_t append_binary_test(memcached_st *memc)
488 {
489 memcached_return_t rc;
490 const char *key= "numbers";
491 uint32_t store_list[] = { 23, 56, 499, 98, 32847, 0 };
492 uint32_t *value;
493 size_t value_length;
494 uint32_t flags;
495 uint32_t x;
496
497 rc= memcached_flush(memc, 0);
498 test_true(rc == MEMCACHED_SUCCESS);
499
500 rc= memcached_set(memc,
501 key, strlen(key),
502 NULL, 0,
503 (time_t)0, (uint32_t)0);
504 test_true(rc == MEMCACHED_SUCCESS);
505
506 for (x= 0; store_list[x] ; x++)
507 {
508 rc= memcached_append(memc,
509 key, strlen(key),
510 (char *)&store_list[x], sizeof(uint32_t),
511 (time_t)0, (uint32_t)0);
512 test_true(rc == MEMCACHED_SUCCESS);
513 }
514
515 value= (uint32_t *)memcached_get(memc, key, strlen(key),
516 &value_length, &flags, &rc);
517 test_true((value_length == (sizeof(uint32_t) * x)));
518 test_true(rc == MEMCACHED_SUCCESS);
519
520 for (uint32_t counter= x, *ptr= value; counter; counter--)
521 {
522 test_true(*ptr == store_list[x - counter]);
523 ptr++;
524 }
525 free(value);
526
527 return TEST_SUCCESS;
528 }
529
530 static test_return_t cas2_test(memcached_st *memc)
531 {
532 memcached_return_t rc;
533 const char *keys[]= {"fudge", "son", "food"};
534 size_t key_length[]= {5, 3, 4};
535 const char *value= "we the people";
536 size_t value_length= strlen("we the people");
537 unsigned int x;
538 memcached_result_st results_obj;
539 memcached_result_st *results;
540 unsigned int set= 1;
541
542 rc= memcached_flush(memc, 0);
543 test_true(rc == MEMCACHED_SUCCESS);
544
545 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
546
547 for (x= 0; x < 3; x++)
548 {
549 rc= memcached_set(memc, keys[x], key_length[x],
550 keys[x], key_length[x],
551 (time_t)50, (uint32_t)9);
552 test_true(rc == MEMCACHED_SUCCESS);
553 }
554
555 rc= memcached_mget(memc, keys, key_length, 3);
556
557 results= memcached_result_create(memc, &results_obj);
558
559 results= memcached_fetch_result(memc, &results_obj, &rc);
560 test_true(results);
561 test_true(results->item_cas);
562 test_true(rc == MEMCACHED_SUCCESS);
563 test_true(memcached_result_cas(results));
564
565 test_true(!memcmp(value, "we the people", strlen("we the people")));
566 test_true(strlen("we the people") == value_length);
567 test_true(rc == MEMCACHED_SUCCESS);
568
569 memcached_result_free(&results_obj);
570
571 return TEST_SUCCESS;
572 }
573
574 static test_return_t cas_test(memcached_st *memc)
575 {
576 memcached_return_t rc;
577 const char *key= "fun";
578 size_t key_length= strlen(key);
579 const char *value= "we the people";
580 const char* keys[2] = { key, NULL };
581 size_t keylengths[2] = { strlen(key), 0 };
582 size_t value_length= strlen(value);
583 const char *value2= "change the value";
584 size_t value2_length= strlen(value2);
585
586 memcached_result_st results_obj;
587 memcached_result_st *results;
588 unsigned int set= 1;
589
590 rc= memcached_flush(memc, 0);
591 test_true(rc == MEMCACHED_SUCCESS);
592
593 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
594
595 rc= memcached_set(memc, key, strlen(key),
596 value, strlen(value),
597 (time_t)0, (uint32_t)0);
598 test_true(rc == MEMCACHED_SUCCESS);
599
600 rc= memcached_mget(memc, keys, keylengths, 1);
601
602 results= memcached_result_create(memc, &results_obj);
603
604 results= memcached_fetch_result(memc, &results_obj, &rc);
605 test_true(results);
606 test_true(rc == MEMCACHED_SUCCESS);
607 test_true(memcached_result_cas(results));
608 test_true(!memcmp(value, memcached_result_value(results), value_length));
609 test_true(strlen(memcached_result_value(results)) == value_length);
610 test_true(rc == MEMCACHED_SUCCESS);
611 uint64_t cas = memcached_result_cas(results);
612
613 #if 0
614 results= memcached_fetch_result(memc, &results_obj, &rc);
615 test_true(rc == MEMCACHED_END);
616 test_true(results == NULL);
617 #endif
618
619 rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
620 test_true(rc == MEMCACHED_SUCCESS);
621
622 /*
623 * The item will have a new cas value, so try to set it again with the old
624 * value. This should fail!
625 */
626 rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
627 test_true(rc == MEMCACHED_DATA_EXISTS);
628
629 memcached_result_free(&results_obj);
630
631 return TEST_SUCCESS;
632 }
633
634 static test_return_t prepend_test(memcached_st *memc)
635 {
636 memcached_return_t rc;
637 const char *key= "fig";
638 const char *value= "people";
639 char *out_value= NULL;
640 size_t value_length;
641 uint32_t flags;
642
643 rc= memcached_flush(memc, 0);
644 test_true(rc == MEMCACHED_SUCCESS);
645
646 rc= memcached_set(memc, key, strlen(key),
647 value, strlen(value),
648 (time_t)0, (uint32_t)0);
649 test_true(rc == MEMCACHED_SUCCESS);
650
651 rc= memcached_prepend(memc, key, strlen(key),
652 "the ", strlen("the "),
653 (time_t)0, (uint32_t)0);
654 test_true(rc == MEMCACHED_SUCCESS);
655
656 rc= memcached_prepend(memc, key, strlen(key),
657 "we ", strlen("we "),
658 (time_t)0, (uint32_t)0);
659 test_true(rc == MEMCACHED_SUCCESS);
660
661 out_value= memcached_get(memc, key, strlen(key),
662 &value_length, &flags, &rc);
663 test_true(!memcmp(out_value, "we the people", strlen("we the people")));
664 test_true(strlen("we the people") == value_length);
665 test_true(rc == MEMCACHED_SUCCESS);
666 free(out_value);
667
668 return TEST_SUCCESS;
669 }
670
671 /*
672 Set the value, then quit to make sure it is flushed.
673 Come back in and test that add fails.
674 */
675 static test_return_t add_test(memcached_st *memc)
676 {
677 memcached_return_t rc;
678 const char *key= "foo";
679 const char *value= "when we sanitize";
680 unsigned long long setting_value;
681
682 setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
683
684 rc= memcached_set(memc, key, strlen(key),
685 value, strlen(value),
686 (time_t)0, (uint32_t)0);
687 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
688 memcached_quit(memc);
689 rc= memcached_add(memc, key, strlen(key),
690 value, strlen(value),
691 (time_t)0, (uint32_t)0);
692
693 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
694 if (setting_value)
695 {
696 test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);
697 }
698 else
699 {
700 test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_DATA_EXISTS);
701 }
702
703 return TEST_SUCCESS;
704 }
705
706 /*
707 ** There was a problem of leaking filedescriptors in the initial release
708 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
709 ** systems it seems that the kernel is slow on reclaiming the resources
710 ** because the connects starts to time out (the test doesn't do much
711 ** anyway, so just loop 10 iterations)
712 */
713 static test_return_t add_wrapper(memcached_st *memc)
714 {
715 unsigned int max= 10000;
716 #ifdef __sun
717 max= 10;
718 #endif
719 #ifdef __APPLE__
720 max= 10;
721 #endif
722
723 for (uint32_t x= 0; x < max; x++)
724 add_test(memc);
725
726 return TEST_SUCCESS;
727 }
728
729 static test_return_t replace_test(memcached_st *memc)
730 {
731 memcached_return_t rc;
732 const char *key= "foo";
733 const char *value= "when we sanitize";
734 const char *original= "first we insert some data";
735
736 rc= memcached_set(memc, key, strlen(key),
737 original, strlen(original),
738 (time_t)0, (uint32_t)0);
739 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
740
741 rc= memcached_replace(memc, key, strlen(key),
742 value, strlen(value),
743 (time_t)0, (uint32_t)0);
744 test_true(rc == MEMCACHED_SUCCESS);
745
746 return TEST_SUCCESS;
747 }
748
749 static test_return_t delete_test(memcached_st *memc)
750 {
751 memcached_return_t rc;
752 const char *key= "foo";
753 const char *value= "when we sanitize";
754
755 rc= memcached_set(memc, key, strlen(key),
756 value, strlen(value),
757 (time_t)0, (uint32_t)0);
758 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
759
760 rc= memcached_delete(memc, key, strlen(key), (time_t)0);
761 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
762
763 return TEST_SUCCESS;
764 }
765
766 static test_return_t flush_test(memcached_st *memc)
767 {
768 memcached_return_t rc;
769
770 uint64_t query_id= memcached_query_id(memc);
771 rc= memcached_flush(memc, 0);
772 test_compare(rc, MEMCACHED_SUCCESS);
773 test_compare(query_id +1, memcached_query_id(memc));
774
775 return TEST_SUCCESS;
776 }
777
778 static memcached_return_t server_function(const memcached_st *ptr,
779 const memcached_server_st *server,
780 void *context)
781 {
782 (void)ptr; (void)server; (void)context;
783 /* Do Nothing */
784
785 return MEMCACHED_SUCCESS;
786 }
787
788 static test_return_t memcached_server_cursor_test(memcached_st *memc)
789 {
790 char context[10];
791 strncpy(context, "foo bad", sizeof(context));
792 memcached_server_fn callbacks[1];
793
794 callbacks[0]= server_function;
795 memcached_server_cursor(memc, callbacks, context, 1);
796 return TEST_SUCCESS;
797 }
798
799 static test_return_t bad_key_test(memcached_st *memc)
800 {
801 memcached_return_t rc;
802 const char *key= "foo bad";
803 char *string;
804 size_t string_length;
805 uint32_t flags;
806 memcached_st *memc_clone;
807 unsigned int set= 1;
808 size_t max_keylen= 0xffff;
809
810 // Just skip if we are in binary mode.
811 uint64_t query_id= memcached_query_id(memc);
812 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
813 return TEST_SKIPPED;
814 test_compare(query_id, memcached_query_id(memc)); // We should not increase the query_id for memcached_behavior_get()
815
816 memc_clone= memcached_clone(NULL, memc);
817 test_true(memc_clone);
818
819 query_id= memcached_query_id(memc_clone);
820 rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
821 test_true(rc == MEMCACHED_SUCCESS);
822 test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()
823
824 /* All keys are valid in the binary protocol (except for length) */
825 if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0)
826 {
827 query_id= memcached_query_id(memc_clone);
828 string= memcached_get(memc_clone, key, strlen(key),
829 &string_length, &flags, &rc);
830 test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
831 test_true(string_length == 0);
832 test_true(!string);
833
834 set= 0;
835 query_id= memcached_query_id(memc_clone);
836 rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
837 test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()
838 test_true(rc == MEMCACHED_SUCCESS);
839 string= memcached_get(memc_clone, key, strlen(key),
840 &string_length, &flags, &rc);
841 test_true(rc == MEMCACHED_NOTFOUND);
842 test_true(string_length == 0);
843 test_true(!string);
844
845 /* Test multi key for bad keys */
846 const char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
847 size_t key_lengths[] = { 7, 7, 7 };
848 set= 1;
849 query_id= memcached_query_id(memc_clone);
850 rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
851 test_true(rc == MEMCACHED_SUCCESS);
852 test_compare(query_id, memcached_query_id(memc_clone));
853
854 query_id= memcached_query_id(memc_clone);
855 rc= memcached_mget(memc_clone, keys, key_lengths, 3);
856 test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
857 test_compare(query_id +1, memcached_query_id(memc_clone));
858
859 query_id= memcached_query_id(memc_clone);
860 rc= memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1);
861 test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
862 test_compare(query_id +1, memcached_query_id(memc_clone));
863
864 max_keylen= 250;
865
866 /* The following test should be moved to the end of this function when the
867 memcached server is updated to allow max size length of the keys in the
868 binary protocol
869 */
870 rc= memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
871 test_true(rc == MEMCACHED_SUCCESS);
872
873 char *longkey= (char *)malloc(max_keylen + 1);
874 if (longkey != NULL)
875 {
876 memset(longkey, 'a', max_keylen + 1);
877 string= memcached_get(memc_clone, longkey, max_keylen,
878 &string_length, &flags, &rc);
879 test_true(rc == MEMCACHED_NOTFOUND);
880 test_true(string_length == 0);
881 test_true(!string);
882
883 string= memcached_get(memc_clone, longkey, max_keylen + 1,
884 &string_length, &flags, &rc);
885 test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
886 test_true(string_length == 0);
887 test_true(!string);
888
889 free(longkey);
890 }
891 }
892
893 /* Make sure zero length keys are marked as bad */
894 set= 1;
895 rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
896 test_true(rc == MEMCACHED_SUCCESS);
897 string= memcached_get(memc_clone, key, 0,
898 &string_length, &flags, &rc);
899 test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
900 test_true(string_length == 0);
901 test_true(!string);
902
903 memcached_free(memc_clone);
904
905 return TEST_SUCCESS;
906 }
907
908 #define READ_THROUGH_VALUE "set for me"
909 static memcached_return_t read_through_trigger(memcached_st *memc,
910 char *key,
911 size_t key_length,
912 memcached_result_st *result)
913 {
914 (void)memc;(void)key;(void)key_length;
915 return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
916 }
917
918 #ifndef __INTEL_COMPILER
919 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
920 #endif
921
922 static test_return_t read_through(memcached_st *memc)
923 {
924 memcached_return_t rc;
925 const char *key= "foo";
926 char *string;
927 size_t string_length;
928 uint32_t flags;
929 memcached_trigger_key_fn cb= (memcached_trigger_key_fn)read_through_trigger;
930
931 string= memcached_get(memc, key, strlen(key),
932 &string_length, &flags, &rc);
933
934 test_true(rc == MEMCACHED_NOTFOUND);
935 test_false(string_length);
936 test_false(string);
937
938 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, *(void **)&cb);
939 test_true(rc == MEMCACHED_SUCCESS);
940
941 string= memcached_get(memc, key, strlen(key),
942 &string_length, &flags, &rc);
943
944 test_true(rc == MEMCACHED_SUCCESS);
945 test_true(string_length == strlen(READ_THROUGH_VALUE));
946 test_strcmp(READ_THROUGH_VALUE, string);
947 free(string);
948
949 string= memcached_get(memc, key, strlen(key),
950 &string_length, &flags, &rc);
951
952 test_true(rc == MEMCACHED_SUCCESS);
953 test_true(string_length == strlen(READ_THROUGH_VALUE));
954 test_true(!strcmp(READ_THROUGH_VALUE, string));
955 free(string);
956
957 return TEST_SUCCESS;
958 }
959
960 static memcached_return_t delete_trigger(memcached_st *ptr,
961 const char *key,
962 size_t key_length)
963 {
964 (void)ptr;(void)key_length;
965 assert(key);
966
967 return MEMCACHED_SUCCESS;
968 }
969
970 static test_return_t delete_through(memcached_st *memc)
971 {
972 memcached_trigger_delete_key_fn callback;
973 memcached_return_t rc;
974
975 callback= (memcached_trigger_delete_key_fn)delete_trigger;
976
977 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, *(void**)&callback);
978 test_true(rc == MEMCACHED_SUCCESS);
979
980 return TEST_SUCCESS;
981 }
982
983 static test_return_t get_test(memcached_st *memc)
984 {
985 memcached_return_t rc;
986 const char *key= "foo";
987 char *string;
988 size_t string_length;
989 uint32_t flags;
990
991 uint64_t query_id= memcached_query_id(memc);
992 rc= memcached_delete(memc, key, strlen(key), (time_t)0);
993 test_true(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);
994 test_compare(query_id +1, memcached_query_id(memc));
995
996 string= memcached_get(memc, key, strlen(key),
997 &string_length, &flags, &rc);
998
999 test_true(rc == MEMCACHED_NOTFOUND);
1000 test_false(string_length);
1001 test_false(string);
1002
1003 return TEST_SUCCESS;
1004 }
1005
1006 static test_return_t get_test2(memcached_st *memc)
1007 {
1008 memcached_return_t rc;
1009 const char *key= "foo";
1010 const char *value= "when we sanitize";
1011 char *string;
1012 size_t string_length;
1013 uint32_t flags;
1014
1015 uint64_t query_id= memcached_query_id(memc);
1016 rc= memcached_set(memc, key, strlen(key),
1017 value, strlen(value),
1018 (time_t)0, (uint32_t)0);
1019 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1020 test_compare(query_id +1, memcached_query_id(memc));
1021
1022 query_id= memcached_query_id(memc);
1023 string= memcached_get(memc, key, strlen(key),
1024 &string_length, &flags, &rc);
1025 test_compare(query_id +1, memcached_query_id(memc));
1026
1027 test_true(string);
1028 test_true(rc == MEMCACHED_SUCCESS);
1029 test_true(string_length == strlen(value));
1030 test_memcmp(string, value, string_length);
1031
1032 free(string);
1033
1034 return TEST_SUCCESS;
1035 }
1036
1037 static test_return_t set_test2(memcached_st *memc)
1038 {
1039 memcached_return_t rc;
1040 const char *key= "foo";
1041 const char *value= "train in the brain";
1042 size_t value_length= strlen(value);
1043 unsigned int x;
1044
1045 for (x= 0; x < 10; x++)
1046 {
1047 rc= memcached_set(memc, key, strlen(key),
1048 value, value_length,
1049 (time_t)0, (uint32_t)0);
1050 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1051 }
1052
1053 return TEST_SUCCESS;
1054 }
1055
1056 static test_return_t set_test3(memcached_st *memc)
1057 {
1058 memcached_return_t rc;
1059 char *value;
1060 size_t value_length= 8191;
1061
1062 value = (char*)malloc(value_length);
1063 test_true(value);
1064
1065 for (uint32_t x= 0; x < value_length; x++)
1066 value[x] = (char) (x % 127);
1067
1068 /* The dump test relies on there being at least 32 items in memcached */
1069 for (uint32_t x= 0; x < 32; x++)
1070 {
1071 char key[16];
1072
1073 snprintf(key, sizeof(key), "foo%u", x);
1074
1075 uint64_t query_id= memcached_query_id(memc);
1076 rc= memcached_set(memc, key, strlen(key),
1077 value, value_length,
1078 (time_t)0, (uint32_t)0);
1079 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1080 test_compare(query_id +1, memcached_query_id(memc));
1081 }
1082
1083 free(value);
1084
1085 return TEST_SUCCESS;
1086 }
1087
1088 static test_return_t get_test3(memcached_st *memc)
1089 {
1090 memcached_return_t rc;
1091 const char *key= "foo";
1092 char *value;
1093 size_t value_length= 8191;
1094 char *string;
1095 size_t string_length;
1096 uint32_t flags;
1097 uint32_t x;
1098
1099 value = (char*)malloc(value_length);
1100 test_true(value);
1101
1102 for (x= 0; x < value_length; x++)
1103 value[x] = (char) (x % 127);
1104
1105 rc= memcached_set(memc, key, strlen(key),
1106 value, value_length,
1107 (time_t)0, (uint32_t)0);
1108 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1109
1110 string= memcached_get(memc, key, strlen(key),
1111 &string_length, &flags, &rc);
1112
1113 test_true(rc == MEMCACHED_SUCCESS);
1114 test_true(string);
1115 test_true(string_length == value_length);
1116 test_true(!memcmp(string, value, string_length));
1117
1118 free(string);
1119 free(value);
1120
1121 return TEST_SUCCESS;
1122 }
1123
1124 static test_return_t get_test4(memcached_st *memc)
1125 {
1126 memcached_return_t rc;
1127 const char *key= "foo";
1128 char *value;
1129 size_t value_length= 8191;
1130 char *string;
1131 size_t string_length;
1132 uint32_t flags;
1133 uint32_t x;
1134
1135 value = (char*)malloc(value_length);
1136 test_true(value);
1137
1138 for (x= 0; x < value_length; x++)
1139 value[x] = (char) (x % 127);
1140
1141 rc= memcached_set(memc, key, strlen(key),
1142 value, value_length,
1143 (time_t)0, (uint32_t)0);
1144 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1145
1146 for (x= 0; x < 10; x++)
1147 {
1148 string= memcached_get(memc, key, strlen(key),
1149 &string_length, &flags, &rc);
1150
1151 test_true(rc == MEMCACHED_SUCCESS);
1152 test_true(string);
1153 test_true(string_length == value_length);
1154 test_true(!memcmp(string, value, string_length));
1155 free(string);
1156 }
1157
1158 free(value);
1159
1160 return TEST_SUCCESS;
1161 }
1162
1163 /*
1164 * This test verifies that memcached_read_one_response doesn't try to
1165 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1166 * responses before you execute a storage command.
1167 */
1168 static test_return_t get_test5(memcached_st *memc)
1169 {
1170 /*
1171 ** Request the same key twice, to ensure that we hash to the same server
1172 ** (so that we have multiple response values queued up) ;-)
1173 */
1174 const char *keys[]= { "key", "key" };
1175 size_t lengths[]= { 3, 3 };
1176 uint32_t flags;
1177 size_t rlen;
1178
1179 memcached_return_t rc= memcached_set(memc, keys[0], lengths[0],
1180 keys[0], lengths[0], 0, 0);
1181 test_true(rc == MEMCACHED_SUCCESS);
1182 rc= memcached_mget(memc, keys, lengths, 2);
1183
1184 memcached_result_st results_obj;
1185 memcached_result_st *results;
1186 results=memcached_result_create(memc, &results_obj);
1187 test_true(results);
1188 results=memcached_fetch_result(memc, &results_obj, &rc);
1189 test_true(results);
1190 memcached_result_free(&results_obj);
1191
1192 /* Don't read out the second result, but issue a set instead.. */
1193 rc= memcached_set(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0);
1194 test_true(rc == MEMCACHED_SUCCESS);
1195
1196 char *val= memcached_get_by_key(memc, keys[0], lengths[0], "yek", 3,
1197 &rlen, &flags, &rc);
1198 test_true(val == NULL);
1199 test_true(rc == MEMCACHED_NOTFOUND);
1200 val= memcached_get(memc, keys[0], lengths[0], &rlen, &flags, &rc);
1201 test_true(val != NULL);
1202 test_true(rc == MEMCACHED_SUCCESS);
1203 free(val);
1204
1205 return TEST_SUCCESS;
1206 }
1207
1208 static test_return_t mget_end(memcached_st *memc)
1209 {
1210 const char *keys[]= { "foo", "foo2" };
1211 size_t lengths[]= { 3, 4 };
1212 const char *values[]= { "fjord", "41" };
1213
1214 memcached_return_t rc;
1215
1216 // Set foo and foo2
1217 for (int i= 0; i < 2; i++)
1218 {
1219 rc= memcached_set(memc, keys[i], lengths[i], values[i], strlen(values[i]),
1220 (time_t)0, (uint32_t)0);
1221 test_true(rc == MEMCACHED_SUCCESS);
1222 }
1223
1224 char *string;
1225 size_t string_length;
1226 uint32_t flags;
1227
1228 // retrieve both via mget
1229 rc= memcached_mget(memc, keys, lengths, 2);
1230 test_true(rc == MEMCACHED_SUCCESS);
1231
1232 char key[MEMCACHED_MAX_KEY];
1233 size_t key_length;
1234
1235 // this should get both
1236 for (int i = 0; i < 2; i++)
1237 {
1238 string= memcached_fetch(memc, key, &key_length, &string_length,
1239 &flags, &rc);
1240 test_true(rc == MEMCACHED_SUCCESS);
1241 int val = 0;
1242 if (key_length == 4)
1243 val= 1;
1244 test_true(string_length == strlen(values[val]));
1245 test_true(strncmp(values[val], string, string_length) == 0);
1246 free(string);
1247 }
1248
1249 // this should indicate end
1250 string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
1251 test_true(rc == MEMCACHED_END);
1252
1253 // now get just one
1254 rc= memcached_mget(memc, keys, lengths, 1);
1255 test_true(rc == MEMCACHED_SUCCESS);
1256
1257 string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
1258 test_true(key_length == lengths[0]);
1259 test_true(strncmp(keys[0], key, key_length) == 0);
1260 test_true(string_length == strlen(values[0]));
1261 test_true(strncmp(values[0], string, string_length) == 0);
1262 test_true(rc == MEMCACHED_SUCCESS);
1263 free(string);
1264
1265 // this should indicate end
1266 string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
1267 test_true(rc == MEMCACHED_END);
1268
1269 return TEST_SUCCESS;
1270 }
1271
1272 /* Do not copy the style of this code, I just access hosts to testthis function */
1273 static test_return_t stats_servername_test(memcached_st *memc)
1274 {
1275 memcached_return_t rc;
1276 memcached_stat_st memc_stat;
1277 memcached_server_instance_st instance=
1278 memcached_server_instance_by_position(memc, 0);
1279
1280 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
1281 if (memcached_get_sasl_callbacks(memc) != NULL)
1282 return TEST_SKIPPED;
1283 #endif
1284 rc= memcached_stat_servername(&memc_stat, NULL,
1285 memcached_server_name(instance),
1286 memcached_server_port(instance));
1287
1288 return TEST_SUCCESS;
1289 }
1290
1291 static test_return_t increment_test(memcached_st *memc)
1292 {
1293 uint64_t new_number;
1294 memcached_return_t rc;
1295 const char *key= "number";
1296 const char *value= "0";
1297
1298 rc= memcached_set(memc, key, strlen(key),
1299 value, strlen(value),
1300 (time_t)0, (uint32_t)0);
1301 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1302
1303 rc= memcached_increment(memc, key, strlen(key),
1304 1, &new_number);
1305 test_true(rc == MEMCACHED_SUCCESS);
1306 test_true(new_number == 1);
1307
1308 rc= memcached_increment(memc, key, strlen(key),
1309 1, &new_number);
1310 test_true(rc == MEMCACHED_SUCCESS);
1311 test_true(new_number == 2);
1312
1313 return TEST_SUCCESS;
1314 }
1315
1316 static test_return_t increment_with_initial_test(memcached_st *memc)
1317 {
1318 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1319 {
1320 uint64_t new_number;
1321 memcached_return_t rc;
1322 const char *key= "number";
1323 uint64_t initial= 0;
1324
1325 rc= memcached_increment_with_initial(memc, key, strlen(key),
1326 1, initial, 0, &new_number);
1327 test_true(rc == MEMCACHED_SUCCESS);
1328 test_true(new_number == initial);
1329
1330 rc= memcached_increment_with_initial(memc, key, strlen(key),
1331 1, initial, 0, &new_number);
1332 test_true(rc == MEMCACHED_SUCCESS);
1333 test_true(new_number == (initial + 1));
1334 }
1335 return TEST_SUCCESS;
1336 }
1337
1338 static test_return_t decrement_test(memcached_st *memc)
1339 {
1340 uint64_t new_number;
1341 memcached_return_t rc;
1342 const char *key= "number";
1343 const char *value= "3";
1344
1345 rc= memcached_set(memc, key, strlen(key),
1346 value, strlen(value),
1347 (time_t)0, (uint32_t)0);
1348 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1349
1350 rc= memcached_decrement(memc, key, strlen(key),
1351 1, &new_number);
1352 test_true(rc == MEMCACHED_SUCCESS);
1353 test_true(new_number == 2);
1354
1355 rc= memcached_decrement(memc, key, strlen(key),
1356 1, &new_number);
1357 test_true(rc == MEMCACHED_SUCCESS);
1358 test_true(new_number == 1);
1359
1360 return TEST_SUCCESS;
1361 }
1362
1363 static test_return_t decrement_with_initial_test(memcached_st *memc)
1364 {
1365 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1366 {
1367 uint64_t new_number;
1368 memcached_return_t rc;
1369 const char *key= "number";
1370 uint64_t initial= 3;
1371
1372 rc= memcached_decrement_with_initial(memc, key, strlen(key),
1373 1, initial, 0, &new_number);
1374 test_true(rc == MEMCACHED_SUCCESS);
1375 test_true(new_number == initial);
1376
1377 rc= memcached_decrement_with_initial(memc, key, strlen(key),
1378 1, initial, 0, &new_number);
1379 test_true(rc == MEMCACHED_SUCCESS);
1380 test_true(new_number == (initial - 1));
1381 }
1382 return TEST_SUCCESS;
1383 }
1384
1385 static test_return_t increment_by_key_test(memcached_st *memc)
1386 {
1387 uint64_t new_number;
1388 memcached_return_t rc;
1389 const char *master_key= "foo";
1390 const char *key= "number";
1391 const char *value= "0";
1392
1393 rc= memcached_set_by_key(memc, master_key, strlen(master_key),
1394 key, strlen(key),
1395 value, strlen(value),
1396 (time_t)0, (uint32_t)0);
1397 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1398
1399 rc= memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key),
1400 1, &new_number);
1401 test_true(rc == MEMCACHED_SUCCESS);
1402 test_true(new_number == 1);
1403
1404 rc= memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key),
1405 1, &new_number);
1406 test_true(rc == MEMCACHED_SUCCESS);
1407 test_true(new_number == 2);
1408
1409 return TEST_SUCCESS;
1410 }
1411
1412 static test_return_t increment_with_initial_by_key_test(memcached_st *memc)
1413 {
1414 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1415 {
1416 uint64_t new_number;
1417 memcached_return_t rc;
1418 const char *master_key= "foo";
1419 const char *key= "number";
1420 uint64_t initial= 0;
1421
1422 rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
1423 key, strlen(key),
1424 1, initial, 0, &new_number);
1425 test_true(rc == MEMCACHED_SUCCESS);
1426 test_true(new_number == initial);
1427
1428 rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
1429 key, strlen(key),
1430 1, initial, 0, &new_number);
1431 test_true(rc == MEMCACHED_SUCCESS);
1432 test_true(new_number == (initial + 1));
1433 }
1434 return TEST_SUCCESS;
1435 }
1436
1437 static test_return_t decrement_by_key_test(memcached_st *memc)
1438 {
1439 uint64_t new_number;
1440 memcached_return_t rc;
1441 const char *master_key= "foo";
1442 const char *key= "number";
1443 const char *value= "3";
1444
1445 rc= memcached_set_by_key(memc, master_key, strlen(master_key),
1446 key, strlen(key),
1447 value, strlen(value),
1448 (time_t)0, (uint32_t)0);
1449 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1450
1451 rc= memcached_decrement_by_key(memc, master_key, strlen(master_key),
1452 key, strlen(key),
1453 1, &new_number);
1454 test_true(rc == MEMCACHED_SUCCESS);
1455 test_true(new_number == 2);
1456
1457 rc= memcached_decrement_by_key(memc, master_key, strlen(master_key),
1458 key, strlen(key),
1459 1, &new_number);
1460 test_true(rc == MEMCACHED_SUCCESS);
1461 test_true(new_number == 1);
1462
1463 return TEST_SUCCESS;
1464 }
1465
1466 static test_return_t decrement_with_initial_by_key_test(memcached_st *memc)
1467 {
1468 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1469 {
1470 uint64_t new_number;
1471 memcached_return_t rc;
1472 const char *master_key= "foo";
1473 const char *key= "number";
1474 uint64_t initial= 3;
1475
1476 rc= memcached_decrement_with_initial_by_key(memc, master_key, strlen(master_key),
1477 key, strlen(key),
1478 1, initial, 0, &new_number);
1479 test_true(rc == MEMCACHED_SUCCESS);
1480 test_true(new_number == initial);
1481
1482 rc= memcached_decrement_with_initial_by_key(memc, master_key, strlen(master_key),
1483 key, strlen(key),
1484 1, initial, 0, &new_number);
1485 test_true(rc == MEMCACHED_SUCCESS);
1486 test_true(new_number == (initial - 1));
1487 }
1488 return TEST_SUCCESS;
1489 }
1490
1491 static test_return_t quit_test(memcached_st *memc)
1492 {
1493 memcached_return_t rc;
1494 const char *key= "fudge";
1495 const char *value= "sanford and sun";
1496
1497 rc= memcached_set(memc, key, strlen(key),
1498 value, strlen(value),
1499 (time_t)10, (uint32_t)3);
1500 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1501 memcached_quit(memc);
1502
1503 rc= memcached_set(memc, key, strlen(key),
1504 value, strlen(value),
1505 (time_t)50, (uint32_t)9);
1506 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1507
1508 return TEST_SUCCESS;
1509 }
1510
1511 static test_return_t mget_result_test(memcached_st *memc)
1512 {
1513 memcached_return_t rc;
1514 const char *keys[]= {"fudge", "son", "food"};
1515 size_t key_length[]= {5, 3, 4};
1516 unsigned int x;
1517
1518 memcached_result_st results_obj;
1519 memcached_result_st *results;
1520
1521 results= memcached_result_create(memc, &results_obj);
1522 test_true(results);
1523 test_true(&results_obj == results);
1524
1525 /* We need to empty the server before continueing test */
1526 rc= memcached_flush(memc, 0);
1527 test_true(rc == MEMCACHED_SUCCESS);
1528
1529 rc= memcached_mget(memc, keys, key_length, 3);
1530 test_true(rc == MEMCACHED_SUCCESS);
1531
1532 while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
1533 {
1534 test_true(results);
1535 }
1536
1537 while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
1538 test_true(!results);
1539 test_true(rc == MEMCACHED_END);
1540
1541 for (x= 0; x < 3; x++)
1542 {
1543 rc= memcached_set(memc, keys[x], key_length[x],
1544 keys[x], key_length[x],
1545 (time_t)50, (uint32_t)9);
1546 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1547 }
1548
1549 rc= memcached_mget(memc, keys, key_length, 3);
1550 test_true(rc == MEMCACHED_SUCCESS);
1551
1552 while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1553 {
1554 test_true(results);
1555 test_true(&results_obj == results);
1556 test_true(rc == MEMCACHED_SUCCESS);
1557 test_true(memcached_result_key_length(results) == memcached_result_length(results));
1558 test_true(!memcmp(memcached_result_key_value(results),
1559 memcached_result_value(results),
1560 memcached_result_length(results)));
1561 }
1562
1563 memcached_result_free(&results_obj);
1564
1565 return TEST_SUCCESS;
1566 }
1567
1568 static test_return_t mget_result_alloc_test(memcached_st *memc)
1569 {
1570 memcached_return_t rc;
1571 const char *keys[]= {"fudge", "son", "food"};
1572 size_t key_length[]= {5, 3, 4};
1573 unsigned int x;
1574
1575 memcached_result_st *results;
1576
1577 /* We need to empty the server before continueing test */
1578 rc= memcached_flush(memc, 0);
1579 test_true(rc == MEMCACHED_SUCCESS);
1580
1581 rc= memcached_mget(memc, keys, key_length, 3);
1582 test_true(rc == MEMCACHED_SUCCESS);
1583
1584 while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
1585 {
1586 test_true(results);
1587 }
1588 test_true(!results);
1589 test_true(rc == MEMCACHED_END);
1590
1591 for (x= 0; x < 3; x++)
1592 {
1593 rc= memcached_set(memc, keys[x], key_length[x],
1594 keys[x], key_length[x],
1595 (time_t)50, (uint32_t)9);
1596 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1597 }
1598
1599 rc= memcached_mget(memc, keys, key_length, 3);
1600 test_true(rc == MEMCACHED_SUCCESS);
1601
1602 x= 0;
1603 while ((results= memcached_fetch_result(memc, NULL, &rc)))
1604 {
1605 test_true(results);
1606 test_true(rc == MEMCACHED_SUCCESS);
1607 test_true(memcached_result_key_length(results) == memcached_result_length(results));
1608 test_true(!memcmp(memcached_result_key_value(results),
1609 memcached_result_value(results),
1610 memcached_result_length(results)));
1611 memcached_result_free(results);
1612 x++;
1613 }
1614
1615 return TEST_SUCCESS;
1616 }
1617
1618 /* Count the results */
1619 static memcached_return_t callback_counter(const memcached_st *ptr,
1620 memcached_result_st *result,
1621 void *context)
1622 {
1623 (void)ptr; (void)result;
1624 size_t *counter= (size_t *)context;
1625
1626 *counter= *counter + 1;
1627
1628 return MEMCACHED_SUCCESS;
1629 }
1630
1631 static test_return_t mget_result_function(memcached_st *memc)
1632 {
1633 memcached_return_t rc;
1634 const char *keys[]= {"fudge", "son", "food"};
1635 size_t key_length[]= {5, 3, 4};
1636 unsigned int x;
1637 size_t counter;
1638 memcached_execute_fn callbacks[1];
1639
1640 /* We need to empty the server before continueing test */
1641 rc= memcached_flush(memc, 0);
1642 for (x= 0; x < 3; x++)
1643 {
1644 rc= memcached_set(memc, keys[x], key_length[x],
1645 keys[x], key_length[x],
1646 (time_t)50, (uint32_t)9);
1647 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1648 }
1649
1650 rc= memcached_mget(memc, keys, key_length, 3);
1651 test_true(rc == MEMCACHED_SUCCESS);
1652
1653 callbacks[0]= &callback_counter;
1654 counter= 0;
1655 rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
1656
1657 test_true(counter == 3);
1658
1659 return TEST_SUCCESS;
1660 }
1661
1662 static test_return_t mget_test(memcached_st *memc)
1663 {
1664 memcached_return_t rc;
1665 const char *keys[]= {"fudge", "son", "food"};
1666 size_t key_length[]= {5, 3, 4};
1667 unsigned int x;
1668 uint32_t flags;
1669
1670 char return_key[MEMCACHED_MAX_KEY];
1671 size_t return_key_length;
1672 char *return_value;
1673 size_t return_value_length;
1674
1675 /* We need to empty the server before continueing test */
1676 rc= memcached_flush(memc, 0);
1677 test_true(rc == MEMCACHED_SUCCESS);
1678
1679 rc= memcached_mget(memc, keys, key_length, 3);
1680 test_true(rc == MEMCACHED_SUCCESS);
1681
1682 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1683 &return_value_length, &flags, &rc)) != NULL)
1684 {
1685 test_true(return_value);
1686 }
1687 test_true(!return_value);
1688 test_true(return_value_length == 0);
1689 test_true(rc == MEMCACHED_END);
1690
1691 for (x= 0; x < 3; x++)
1692 {
1693 rc= memcached_set(memc, keys[x], key_length[x],
1694 keys[x], key_length[x],
1695 (time_t)50, (uint32_t)9);
1696 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1697 }
1698
1699 rc= memcached_mget(memc, keys, key_length, 3);
1700 test_true(rc == MEMCACHED_SUCCESS);
1701
1702 x= 0;
1703 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1704 &return_value_length, &flags, &rc)))
1705 {
1706 test_true(return_value);
1707 test_true(rc == MEMCACHED_SUCCESS);
1708 test_true(return_key_length == return_value_length);
1709 test_true(!memcmp(return_value, return_key, return_value_length));
1710 free(return_value);
1711 x++;
1712 }
1713
1714 return TEST_SUCCESS;
1715 }
1716
1717 static test_return_t mget_execute(memcached_st *memc)
1718 {
1719 bool binary= false;
1720
1721 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1722 binary= true;
1723
1724 /*
1725 * I only want to hit _one_ server so I know the number of requests I'm
1726 * sending in the pipeline.
1727 */
1728 uint32_t number_of_hosts= memc->number_of_hosts;
1729 memc->number_of_hosts= 1;
1730
1731 size_t max_keys= 20480;
1732
1733
1734 char **keys= static_cast<char **>(calloc(max_keys, sizeof(char*)));
1735 size_t *key_length=static_cast<size_t *>(calloc(max_keys, sizeof(size_t)));
1736
1737 /* First add all of the items.. */
1738 char blob[1024] = {0};
1739 memcached_return_t rc;
1740
1741 for (size_t x= 0; x < max_keys; ++x)
1742 {
1743 char k[251];
1744
1745 key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
1746 keys[x]= strdup(k);
1747 test_true(keys[x] != NULL);
1748 uint64_t query_id= memcached_query_id(memc);
1749 rc= memcached_add(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
1750 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1751 test_compare(query_id +1, memcached_query_id(memc));
1752 }
1753
1754 /* Try to get all of them with a large multiget */
1755 size_t counter= 0;
1756 memcached_execute_fn callbacks[]= { &callback_counter };
1757 rc= memcached_mget_execute(memc, (const char**)keys, key_length,
1758 max_keys, callbacks, &counter, 1);
1759
1760 if (rc == MEMCACHED_SUCCESS)
1761 {
1762 test_true(binary);
1763 uint64_t query_id= memcached_query_id(memc);
1764 rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
1765 test_true(rc == MEMCACHED_END);
1766 test_compare(query_id, memcached_query_id(memc));
1767
1768 /* Verify that we got all of the items */
1769 test_true(counter == max_keys);
1770 }
1771 else if (rc == MEMCACHED_NOT_SUPPORTED)
1772 {
1773 test_true(counter == 0);
1774 }
1775 else
1776 {
1777 test_fail("note: this test functions differently when in binary mode");
1778 }
1779
1780 /* Release all allocated resources */
1781 for (size_t x= 0; x < max_keys; ++x)
1782 {
1783 free(keys[x]);
1784 }
1785 free(keys);
1786 free(key_length);
1787
1788 memc->number_of_hosts= number_of_hosts;
1789 return TEST_SUCCESS;
1790 }
1791
1792 #define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
1793
1794 static test_return_t key_setup(memcached_st *memc)
1795 {
1796 (void)memc;
1797
1798 if (pre_binary(memc) != TEST_SUCCESS)
1799 return TEST_SKIPPED;
1800
1801 global_pairs= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT, 0);
1802
1803 return TEST_SUCCESS;
1804 }
1805
1806 static test_return_t key_teardown(memcached_st *memc)
1807 {
1808 (void)memc;
1809 pairs_free(global_pairs);
1810
1811 return TEST_SUCCESS;
1812 }
1813
1814 static test_return_t block_add_regression(memcached_st *memc)
1815 {
1816 /* First add all of the items.. */
1817 for (size_t x= 0; x < REGRESSION_BINARY_VS_BLOCK_COUNT; ++x)
1818 {
1819 memcached_return_t rc;
1820 char blob[1024] = {0};
1821
1822 rc= memcached_add_by_key(memc, "bob", 3, global_pairs[x].key, global_pairs[x].key_length, blob, sizeof(blob), 0, 0);
1823 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1824 }
1825
1826 return TEST_SUCCESS;
1827 }
1828
1829 static test_return_t binary_add_regression(memcached_st *memc)
1830 {
1831 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
1832 test_return_t rc= block_add_regression(memc);
1833 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 0);
1834 return rc;
1835 }
1836
1837 static test_return_t get_stats_keys(memcached_st *memc)
1838 {
1839 char **stat_list;
1840 char **ptr;
1841 memcached_stat_st memc_stat;
1842 memcached_return_t rc;
1843
1844 stat_list= memcached_stat_get_keys(memc, &memc_stat, &rc);
1845 test_true(rc == MEMCACHED_SUCCESS);
1846 for (ptr= stat_list; *ptr; ptr++)
1847 test_true(*ptr);
1848
1849 free(stat_list);
1850
1851 return TEST_SUCCESS;
1852 }
1853
1854 static test_return_t version_string_test(memcached_st *memc)
1855 {
1856 const char *version_string;
1857 (void)memc;
1858
1859 version_string= memcached_lib_version();
1860
1861 test_true(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING));
1862
1863 return TEST_SUCCESS;
1864 }
1865
1866 static test_return_t get_stats(memcached_st *memc)
1867 {
1868 char **stat_list;
1869 char **ptr;
1870 memcached_return_t rc;
1871 memcached_stat_st *memc_stat;
1872
1873 memc_stat= memcached_stat(memc, NULL, &rc);
1874 test_true(rc == MEMCACHED_SUCCESS);
1875
1876 test_true(rc == MEMCACHED_SUCCESS);
1877 test_true(memc_stat);
1878
1879 for (uint32_t x= 0; x < memcached_server_count(memc); x++)
1880 {
1881 stat_list= memcached_stat_get_keys(memc, memc_stat+x, &rc);
1882 test_true(rc == MEMCACHED_SUCCESS);
1883 for (ptr= stat_list; *ptr; ptr++);
1884
1885 free(stat_list);
1886 }
1887
1888 memcached_stat_free(NULL, memc_stat);
1889
1890 return TEST_SUCCESS;
1891 }
1892
1893 static test_return_t add_host_test(memcached_st *memc)
1894 {
1895 unsigned int x;
1896 memcached_server_st *servers;
1897 memcached_return_t rc;
1898 char servername[]= "0.example.com";
1899
1900 servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
1901 test_true(servers);
1902 test_true(1 == memcached_server_list_count(servers));
1903
1904 for (x= 2; x < 20; x++)
1905 {
1906 char buffer[SMALL_STRING_LEN];
1907
1908 snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1909 servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
1910 &rc);
1911 test_true(rc == MEMCACHED_SUCCESS);
1912 test_true(x == memcached_server_list_count(servers));
1913 }
1914
1915 rc= memcached_server_push(memc, servers);
1916 test_true(rc == MEMCACHED_SUCCESS);
1917 rc= memcached_server_push(memc, servers);
1918 test_true(rc == MEMCACHED_SUCCESS);
1919
1920 memcached_server_list_free(servers);
1921
1922 return TEST_SUCCESS;
1923 }
1924
1925 static memcached_return_t clone_test_callback(memcached_st *parent, memcached_st *memc_clone)
1926 {
1927 (void)parent;(void)memc_clone;
1928 return MEMCACHED_SUCCESS;
1929 }
1930
1931 static memcached_return_t cleanup_test_callback(memcached_st *ptr)
1932 {
1933 (void)ptr;
1934 return MEMCACHED_SUCCESS;
1935 }
1936
1937 static test_return_t callback_test(memcached_st *memc)
1938 {
1939 /* Test User Data */
1940 {
1941 int x= 5;
1942 int *test_ptr;
1943 memcached_return_t rc;
1944
1945 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x);
1946 test_true(rc == MEMCACHED_SUCCESS);
1947 test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
1948 test_true(*test_ptr == x);
1949 }
1950
1951 /* Test Clone Callback */
1952 {
1953 memcached_clone_fn clone_cb= (memcached_clone_fn)clone_test_callback;
1954 void *clone_cb_ptr= *(void **)&clone_cb;
1955 void *temp_function= NULL;
1956 memcached_return_t rc;
1957
1958 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION,
1959 clone_cb_ptr);
1960 test_true(rc == MEMCACHED_SUCCESS);
1961 temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1962 test_true(temp_function == clone_cb_ptr);
1963 }
1964
1965 /* Test Cleanup Callback */
1966 {
1967 memcached_cleanup_fn cleanup_cb=
1968 (memcached_cleanup_fn)cleanup_test_callback;
1969 void *cleanup_cb_ptr= *(void **)&cleanup_cb;
1970 void *temp_function= NULL;
1971 memcached_return_t rc;
1972
1973 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION,
1974 cleanup_cb_ptr);
1975 test_true(rc == MEMCACHED_SUCCESS);
1976 temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1977 test_true(temp_function == cleanup_cb_ptr);
1978 }
1979
1980 return TEST_SUCCESS;
1981 }
1982
1983 /* We don't test the behavior itself, we test the switches */
1984 static test_return_t behavior_test(memcached_st *memc)
1985 {
1986 uint64_t value;
1987 uint32_t set= 1;
1988
1989 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1990 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1991 test_true(value == 1);
1992
1993 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1994 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1995 test_true(value == 1);
1996
1997 set= MEMCACHED_HASH_MD5;
1998 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1999 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
2000 test_true(value == MEMCACHED_HASH_MD5);
2001
2002 set= 0;
2003
2004 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
2005 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
2006 test_true(value == 0);
2007
2008 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
2009 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
2010 test_true(value == 0);
2011
2012 set= MEMCACHED_HASH_DEFAULT;
2013 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
2014 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
2015 test_true(value == MEMCACHED_HASH_DEFAULT);
2016
2017 set= MEMCACHED_HASH_CRC;
2018 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
2019 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
2020 test_true(value == MEMCACHED_HASH_CRC);
2021
2022 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
2023 test_true(value > 0);
2024
2025 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
2026 test_true(value > 0);
2027
2028 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
2029 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value + 1);
2030 test_true((value + 1) == memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));
2031
2032 return TEST_SUCCESS;
2033 }
2034
2035 static test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc)
2036 {
2037 memcached_return_t rc;
2038 bool set= true;
2039
2040 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set);
2041 test_true(rc == MEMCACHED_DEPRECATED);
2042
2043 // Platform dependent
2044 #if 0
2045 bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_CORK);
2046 test_false(value);
2047 #endif
2048
2049 return TEST_SUCCESS;
2050 }
2051
2052
2053 static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc)
2054 {
2055 memcached_return_t rc;
2056 bool set= true;
2057 bool value;
2058
2059 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, set);
2060 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
2061
2062 value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE);
2063
2064 if (rc == MEMCACHED_SUCCESS)
2065 {
2066 test_true((bool)value == set);
2067 }
2068 else
2069 {
2070 test_false((bool)value == set);
2071 }
2072
2073 return TEST_SUCCESS;
2074 }
2075
2076
2077 static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc)
2078 {
2079 memcached_return_t rc;
2080 bool set= true;
2081 bool value;
2082
2083 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, set);
2084 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
2085
2086 value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE);
2087
2088 if (rc == MEMCACHED_SUCCESS)
2089 {
2090 test_true((bool)value == set);
2091 }
2092 else
2093 {
2094 test_false((bool)value == set);
2095 }
2096
2097 return TEST_SUCCESS;
2098 }
2099
2100 static test_return_t fetch_all_results(memcached_st *memc, size_t *keys_returned)
2101 {
2102 memcached_return_t rc= MEMCACHED_SUCCESS;
2103 char return_key[MEMCACHED_MAX_KEY];
2104 size_t return_key_length;
2105 char *return_value;
2106 size_t return_value_length;
2107 uint32_t flags;
2108
2109 *keys_returned= 0;
2110
2111 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2112 &return_value_length, &flags, &rc)))
2113 {
2114 test_true(return_value);
2115 test_true(rc == MEMCACHED_SUCCESS);
2116 free(return_value);
2117 *keys_returned= *keys_returned +1;
2118 }
2119
2120 test_true_got(rc == MEMCACHED_END || rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
2121
2122 return TEST_SUCCESS;
2123 }
2124
2125 /* Test case provided by Cal Haldenbrand */
2126 static test_return_t user_supplied_bug1(memcached_st *memc)
2127 {
2128 unsigned int setter= 1;
2129
2130 unsigned long long total= 0;
2131 uint32_t size= 0;
2132 char key[10];
2133 char randomstuff[6 * 1024];
2134 memcached_return_t rc;
2135
2136 memset(randomstuff, 0, 6 * 1024);
2137
2138 /* We just keep looking at the same values over and over */
2139 srandom(10);
2140
2141 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
2142 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
2143
2144
2145 /* add key */
2146 for (uint32_t x= 0 ; total < 20 * 1024576 ; x++ )
2147 {
2148 unsigned int j= 0;
2149
2150 size= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2151 memset(randomstuff, 0, 6 * 1024);
2152 test_true(size < 6 * 1024); /* Being safe here */
2153
2154 for (j= 0 ; j < size ;j++)
2155 randomstuff[j] = (signed char) ((rand() % 26) + 97);
2156
2157 total += size;
2158 snprintf(key, sizeof(key), "%u", x);
2159 rc = memcached_set(memc, key, strlen(key),
2160 randomstuff, strlen(randomstuff), 10, 0);
2161 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
2162 /* If we fail, lets try again */
2163 if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
2164 rc = memcached_set(memc, key, strlen(key),
2165 randomstuff, strlen(randomstuff), 10, 0);
2166 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
2167 }
2168
2169 return TEST_SUCCESS;
2170 }
2171
2172 /* Test case provided by Cal Haldenbrand */
2173 static test_return_t user_supplied_bug2(memcached_st *memc)
2174 {
2175 unsigned int setter;
2176 size_t total= 0;
2177
2178 setter= 1;
2179 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
2180 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
2181 #ifdef NOT_YET
2182 setter = 20 * 1024576;
2183 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
2184 setter = 20 * 1024576;
2185 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
2186 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
2187 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
2188
2189 for (x= 0, errors= 0; total < 20 * 1024576 ; x++)
2190 #endif
2191
2192 for (uint32_t x= 0, errors= 0; total < 24576 ; x++)
2193 {
2194 memcached_return_t rc= MEMCACHED_SUCCESS;
2195 char buffer[SMALL_STRING_LEN];
2196 uint32_t flags= 0;
2197 size_t val_len= 0;
2198 char *getval;
2199
2200 memset(buffer, 0, SMALL_STRING_LEN);
2201
2202 snprintf(buffer, sizeof(buffer), "%u", x);
2203 getval= memcached_get(memc, buffer, strlen(buffer),
2204 &val_len, &flags, &rc);
2205 if (rc != MEMCACHED_SUCCESS)
2206 {
2207 if (rc == MEMCACHED_NOTFOUND)
2208 errors++;
2209 else
2210 {
2211 test_true(rc);
2212 }
2213
2214 continue;
2215 }
2216 total+= val_len;
2217 errors= 0;
2218 free(getval);
2219 }
2220
2221 return TEST_SUCCESS;
2222 }
2223
2224 /* Do a large mget() over all the keys we think exist */
2225 #define KEY_COUNT 3000 // * 1024576
2226 static test_return_t user_supplied_bug3(memcached_st *memc)
2227 {
2228 memcached_return_t rc;
2229 unsigned int setter;
2230 unsigned int x;
2231 char **keys;
2232 size_t key_lengths[KEY_COUNT];
2233
2234 setter= 1;
2235 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
2236 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
2237 #ifdef NOT_YET
2238 setter = 20 * 1024576;
2239 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
2240 setter = 20 * 1024576;
2241 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
2242 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
2243 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
2244 #endif
2245
2246 keys= static_cast<char **>(calloc(KEY_COUNT, sizeof(char *)));
2247 test_true(keys);
2248 for (x= 0; x < KEY_COUNT; x++)
2249 {
2250 char buffer[30];
2251
2252 snprintf(buffer, 30, "%u", x);
2253 keys[x]= strdup(buffer);
2254 key_lengths[x]= strlen(keys[x]);
2255 }
2256
2257 rc= memcached_mget(memc, (const char **)keys, key_lengths, KEY_COUNT);
2258 test_true(rc == MEMCACHED_SUCCESS);
2259
2260 size_t keys_returned;
2261 test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
2262
2263 for (x= 0; x < KEY_COUNT; x++)
2264 free(keys[x]);
2265 free(keys);
2266
2267 return TEST_SUCCESS;
2268 }
2269
2270 /* Make sure we behave properly if server list has no values */
2271 static test_return_t user_supplied_bug4(memcached_st *memc)
2272 {
2273 memcached_return_t rc;
2274 const char *keys[]= {"fudge", "son", "food"};
2275 size_t key_length[]= {5, 3, 4};
2276 unsigned int x;
2277 uint32_t flags;
2278 char return_key[MEMCACHED_MAX_KEY];
2279 size_t return_key_length;
2280 char *return_value;
2281 size_t return_value_length;
2282
2283 /* Here we free everything before running a bunch of mget tests */
2284 memcached_servers_reset(memc);
2285
2286
2287 /* We need to empty the server before continueing test */
2288 rc= memcached_flush(memc, 0);
2289 test_compare(rc, MEMCACHED_NO_SERVERS);
2290
2291 rc= memcached_mget(memc, keys, key_length, 3);
2292 test_true(rc == MEMCACHED_NO_SERVERS);
2293
2294 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2295 &return_value_length, &flags, &rc)) != NULL)
2296 {
2297 test_true(return_value);
2298 }
2299 test_false(return_value);
2300 test_true(return_value_length == 0);
2301 test_true(rc == MEMCACHED_NO_SERVERS);
2302
2303 for (x= 0; x < 3; x++)
2304 {
2305 rc= memcached_set(memc, keys[x], key_length[x],
2306 keys[x], key_length[x],
2307 (time_t)50, (uint32_t)9);
2308 test_true(rc == MEMCACHED_NO_SERVERS);
2309 }
2310
2311 rc= memcached_mget(memc, keys, key_length, 3);
2312 test_true(rc == MEMCACHED_NO_SERVERS);
2313
2314 x= 0;
2315 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2316 &return_value_length, &flags, &rc)))
2317 {
2318 test_true(return_value);
2319 test_true(rc == MEMCACHED_SUCCESS);
2320 test_true(return_key_length == return_value_length);
2321 test_memcmp(return_value, return_key, return_value_length);
2322 free(return_value);
2323 x++;
2324 }
2325
2326 return TEST_SUCCESS;
2327 }
2328
2329 #define VALUE_SIZE_BUG5 1048064
2330 static test_return_t user_supplied_bug5(memcached_st *memc)
2331 {
2332 memcached_return_t rc;
2333 const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2334 size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2335 char return_key[MEMCACHED_MAX_KEY];
2336 size_t return_key_length;
2337 char *value;
2338 size_t value_length;
2339 uint32_t flags;
2340 unsigned int count;
2341 unsigned int x;
2342 char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
2343
2344 for (x= 0; x < VALUE_SIZE_BUG5; x++)
2345 insert_data[x]= (signed char)rand();
2346
2347 memcached_flush(memc, 0);
2348 value= memcached_get(memc, keys[0], key_length[0],
2349 &value_length, &flags, &rc);
2350 test_true(value == NULL);
2351 rc= memcached_mget(memc, keys, key_length, 4);
2352
2353 count= 0;
2354 while ((value= memcached_fetch(memc, return_key, &return_key_length,
2355 &value_length, &flags, &rc)))
2356 count++;
2357 test_true(count == 0);
2358
2359 for (x= 0; x < 4; x++)
2360 {
2361 rc= memcached_set(memc, keys[x], key_length[x],
2362 insert_data, VALUE_SIZE_BUG5,
2363 (time_t)0, (uint32_t)0);
2364 test_true(rc == MEMCACHED_SUCCESS);
2365 }
2366
2367 for (x= 0; x < 10; x++)
2368 {
2369 value= memcached_get(memc, keys[0], key_length[0],
2370 &value_length, &flags, &rc);
2371 test_true(value);
2372 free(value);
2373
2374 rc= memcached_mget(memc, keys, key_length, 4);
2375 count= 0;
2376 while ((value= memcached_fetch(memc, return_key, &return_key_length,
2377 &value_length, &flags, &rc)))
2378 {
2379 count++;
2380 free(value);
2381 }
2382 test_true(count == 4);
2383 }
2384 delete [] insert_data;
2385
2386 return TEST_SUCCESS;
2387 }
2388
2389 static test_return_t user_supplied_bug6(memcached_st *memc)
2390 {
2391 memcached_return_t rc;
2392 const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2393 size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2394 char return_key[MEMCACHED_MAX_KEY];
2395 size_t return_key_length;
2396 char *value;
2397 size_t value_length;
2398 uint32_t flags;
2399 unsigned int count;
2400 unsigned int x;
2401 char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
2402
2403 for (x= 0; x < VALUE_SIZE_BUG5; x++)
2404 insert_data[x]= (signed char)rand();
2405
2406 memcached_flush(memc, 0);
2407 value= memcached_get(memc, keys[0], key_length[0],
2408 &value_length, &flags, &rc);
2409 test_true(value == NULL);
2410 test_true(rc == MEMCACHED_NOTFOUND);
2411 rc= memcached_mget(memc, keys, key_length, 4);
2412 test_true(rc == MEMCACHED_SUCCESS);
2413
2414 count= 0;
2415 while ((value= memcached_fetch(memc, return_key, &return_key_length,
2416 &value_length, &flags, &rc)))
2417 count++;
2418 test_true(count == 0);
2419 test_true(rc == MEMCACHED_END);
2420
2421 for (x= 0; x < 4; x++)
2422 {
2423 rc= memcached_set(memc, keys[x], key_length[x],
2424 insert_data, VALUE_SIZE_BUG5,
2425 (time_t)0, (uint32_t)0);
2426 test_true(rc == MEMCACHED_SUCCESS);
2427 }
2428
2429 for (x= 0; x < 2; x++)
2430 {
2431 value= memcached_get(memc, keys[0], key_length[0],
2432 &value_length, &flags, &rc);
2433 test_true(value);
2434 free(value);
2435
2436 rc= memcached_mget(memc, keys, key_length, 4);
2437 test_true(rc == MEMCACHED_SUCCESS);
2438 count= 3;
2439 /* We test for purge of partial complete fetches */
2440 for (count= 3; count; count--)
2441 {
2442 value= memcached_fetch(memc, return_key, &return_key_length,
2443 &value_length, &flags, &rc);
2444 test_true(rc == MEMCACHED_SUCCESS);
2445 test_true(!(memcmp(value, insert_data, value_length)));
2446 test_true(value_length);
2447 free(value);
2448 }
2449 }
2450 delete [] insert_data;
2451
2452 return TEST_SUCCESS;
2453 }
2454
2455 static test_return_t user_supplied_bug8(memcached_st *memc)
2456 {
2457 memcached_return_t rc;
2458 memcached_st *mine;
2459 memcached_st *memc_clone;
2460
2461 memcached_server_st *servers;
2462 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";
2463
2464 (void)memc;
2465 servers= memcached_servers_parse(server_list);
2466 test_true(servers);
2467
2468 mine= memcached_create(NULL);
2469 rc= memcached_server_push(mine, servers);
2470 test_true(rc == MEMCACHED_SUCCESS);
2471 memcached_server_list_free(servers);
2472
2473 test_true(mine);
2474 memc_clone= memcached_clone(NULL, mine);
2475
2476 memcached_quit(mine);
2477 memcached_quit(memc_clone);
2478
2479
2480 memcached_free(mine);
2481 memcached_free(memc_clone);
2482
2483 return TEST_SUCCESS;
2484 }
2485
2486 /* Test flag store/retrieve */
2487 static test_return_t user_supplied_bug7(memcached_st *memc)
2488 {
2489 const char *keys= "036790384900";
2490 size_t key_length= strlen(keys);
2491 char return_key[MEMCACHED_MAX_KEY];
2492 size_t return_key_length;
2493 char *value;
2494 size_t value_length;
2495 uint32_t flags;
2496 char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
2497
2498 for (unsigned int x= 0; x < VALUE_SIZE_BUG5; x++)
2499 insert_data[x]= (signed char)rand();
2500
2501 memcached_flush(memc, 0);
2502
2503 flags= 245;
2504 memcached_return_t rc= memcached_set(memc, keys, key_length,
2505 insert_data, VALUE_SIZE_BUG5,
2506 (time_t)0, flags);
2507 test_true(rc == MEMCACHED_SUCCESS);
2508
2509 flags= 0;
2510 value= memcached_get(memc, keys, key_length,
2511 &value_length, &flags, &rc);
2512 test_true(flags == 245);
2513 test_true(value);
2514 free(value);
2515
2516 rc= memcached_mget(memc, &keys, &key_length, 1);
2517
2518 flags= 0;
2519 value= memcached_fetch(memc, return_key, &return_key_length,
2520 &value_length, &flags, &rc);
2521 test_compare(245, flags);
2522 test_true(value);
2523 free(value);
2524 delete [] insert_data;
2525
2526
2527 return TEST_SUCCESS;
2528 }
2529
2530 static test_return_t user_supplied_bug9(memcached_st *memc)
2531 {
2532 const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2533 size_t key_length[3];
2534 uint32_t flags;
2535 unsigned count= 0;
2536
2537 char return_key[MEMCACHED_MAX_KEY];
2538 size_t return_key_length;
2539 char *return_value;
2540 size_t return_value_length;
2541
2542
2543 key_length[0]= strlen("UDATA:edevil@sapo.pt");
2544 key_length[1]= strlen("fudge&*@#");
2545 key_length[2]= strlen("for^#@&$not");
2546
2547
2548 for (unsigned int x= 0; x < 3; x++)
2549 {
2550 memcached_return_t rc= memcached_set(memc, keys[x], key_length[x],
2551 keys[x], key_length[x],
2552 (time_t)50, (uint32_t)9);
2553 test_true(rc == MEMCACHED_SUCCESS);
2554 }
2555
2556 memcached_return_t rc= memcached_mget(memc, keys, key_length, 3);
2557 test_true(rc == MEMCACHED_SUCCESS);
2558
2559 /* We need to empty the server before continueing test */
2560 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2561 &return_value_length, &flags, &rc)) != NULL)
2562 {
2563 test_true(return_value);
2564 free(return_value);
2565 count++;
2566 }
2567 test_compare(3, count);
2568
2569 return TEST_SUCCESS;
2570 }
2571
2572 /* We are testing with aggressive timeout to get failures */
2573 static test_return_t user_supplied_bug10(memcached_st *memc)
2574 {
2575 const char *key= "foo";
2576 char *value;
2577 size_t value_length= 512;
2578 unsigned int x;
2579 size_t key_len= 3;
2580 unsigned int set= 1;
2581 memcached_st *mclone= memcached_clone(NULL, memc);
2582 int32_t timeout;
2583
2584 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
2585 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
2586 timeout= 2;
2587 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
2588 (uint64_t)timeout);
2589
2590 value = (char*)malloc(value_length * sizeof(char));
2591
2592 for (x= 0; x < value_length; x++)
2593 value[x]= (char) (x % 127);
2594
2595 for (x= 1; x <= 100000; ++x)
2596 {
2597 memcached_return_t rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
2598
2599 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE ||
2600 rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT);
2601
2602 if (rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_TIMEOUT)
2603 x--;
2604 }
2605
2606 free(value);
2607 memcached_free(mclone);
2608
2609 return TEST_SUCCESS;
2610 }
2611
2612 /*
2613 We are looking failures in the async protocol
2614 */
2615 static test_return_t user_supplied_bug11(memcached_st *memc)
2616 {
2617 const char *key= "foo";
2618 char *value;
2619 size_t value_length= 512;
2620 unsigned int x;
2621 size_t key_len= 3;
2622 memcached_return_t rc;
2623 unsigned int set= 1;
2624 int32_t timeout;
2625 memcached_st *mclone= memcached_clone(NULL, memc);
2626
2627 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
2628 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
2629 timeout= -1;
2630 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
2631 (size_t)timeout);
2632
2633 timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
2634
2635 test_true(timeout == -1);
2636
2637 value = (char*)malloc(value_length * sizeof(char));
2638
2639 for (x= 0; x < value_length; x++)
2640 value[x]= (char) (x % 127);
2641
2642 for (x= 1; x <= 100000; ++x)
2643 {
2644 rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
2645 }
2646
2647 free(value);
2648 memcached_free(mclone);
2649
2650 return TEST_SUCCESS;
2651 }
2652
2653 /*
2654 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2655 */
2656 static test_return_t user_supplied_bug12(memcached_st *memc)
2657 {
2658 memcached_return_t rc;
2659 uint32_t flags;
2660 size_t value_length;
2661 char *value;
2662 uint64_t number_value;
2663
2664 value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
2665 &value_length, &flags, &rc);
2666 test_true(value == NULL);
2667 test_true(rc == MEMCACHED_NOTFOUND);
2668
2669 rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
2670 1, &number_value);
2671
2672 test_true(value == NULL);
2673 /* The binary protocol will set the key if it doesn't exist */
2674 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
2675 {
2676 test_true(rc == MEMCACHED_SUCCESS);
2677 }
2678 else
2679 {
2680 test_true(rc == MEMCACHED_NOTFOUND);
2681 }
2682
2683 rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2684
2685 value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
2686 &value_length, &flags, &rc);
2687 test_true(value);
2688 test_true(rc == MEMCACHED_SUCCESS);
2689 free(value);
2690
2691 rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
2692 1, &number_value);
2693 test_true(number_value == 2);
2694 test_true(rc == MEMCACHED_SUCCESS);
2695
2696 return TEST_SUCCESS;
2697 }
2698
2699 /*
2700 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2701 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2702 */
2703 static test_return_t user_supplied_bug13(memcached_st *memc)
2704 {
2705 char key[] = "key34567890";
2706 memcached_return_t rc;
2707 size_t overflowSize;
2708
2709 char commandFirst[]= "set key34567890 0 0 ";
2710 char commandLast[] = " \r\n"; /* first line of command sent to server */
2711 size_t commandLength;
2712 size_t testSize;
2713
2714 commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
2715
2716 overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
2717
2718 for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
2719 {
2720 char *overflow= new (std::nothrow) char[testSize];
2721 test_true(overflow);
2722
2723 memset(overflow, 'x', testSize);
2724 rc= memcached_set(memc, key, strlen(key),
2725 overflow, testSize, 0, 0);
2726 test_true(rc == MEMCACHED_SUCCESS);
2727 delete [] overflow;
2728 }
2729
2730 return TEST_SUCCESS;
2731 }
2732
2733
2734 /*
2735 Test values of many different sizes
2736 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2737 set key34567890 0 0 8169 \r\n
2738 is sent followed by buffer of size 8169, followed by 8169
2739 */
2740 static test_return_t user_supplied_bug14(memcached_st *memc)
2741 {
2742 size_t setter= 1;
2743 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
2744 memcached_return_t rc;
2745 const char *key= "foo";
2746 char *value;
2747 size_t value_length= 18000;
2748 char *string;
2749 size_t string_length;
2750 uint32_t flags;
2751 unsigned int x;
2752 size_t current_length;
2753
2754 value = (char*)malloc(value_length);
2755 test_true(value);
2756
2757 for (x= 0; x < value_length; x++)
2758 value[x] = (char) (x % 127);
2759
2760 for (current_length= 0; current_length < value_length; current_length++)
2761 {
2762 rc= memcached_set(memc, key, strlen(key),
2763 value, current_length,
2764 (time_t)0, (uint32_t)0);
2765 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
2766
2767 string= memcached_get(memc, key, strlen(key),
2768 &string_length, &flags, &rc);
2769
2770 test_true(rc == MEMCACHED_SUCCESS);
2771 test_true(string_length == current_length);
2772 test_true(!memcmp(string, value, string_length));
2773
2774 free(string);
2775 }
2776
2777 free(value);
2778
2779 return TEST_SUCCESS;
2780 }
2781
2782 /*
2783 Look for zero length value problems
2784 */
2785 static test_return_t user_supplied_bug15(memcached_st *memc)
2786 {
2787 uint32_t x;
2788 memcached_return_t rc;
2789 const char *key= "mykey";
2790 char *value;
2791 size_t length;
2792 uint32_t flags;
2793
2794 for (x= 0; x < 2; x++)
2795 {
2796 rc= memcached_set(memc, key, strlen(key),
2797 NULL, 0,
2798 (time_t)0, (uint32_t)0);
2799
2800 test_true(rc == MEMCACHED_SUCCESS);
2801
2802 value= memcached_get(memc, key, strlen(key),
2803 &length, &flags, &rc);
2804
2805 test_true(rc == MEMCACHED_SUCCESS);
2806 test_true(value == NULL);
2807 test_true(length == 0);
2808 test_true(flags == 0);
2809
2810 value= memcached_get(memc, key, strlen(key),
2811 &length, &flags, &rc);
2812
2813 test_true(rc == MEMCACHED_SUCCESS);
2814 test_true(value == NULL);
2815 test_true(length == 0);
2816 test_true(flags == 0);
2817 }
2818
2819 return TEST_SUCCESS;
2820 }
2821
2822 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2823 static test_return_t user_supplied_bug16(memcached_st *memc)
2824 {
2825 memcached_return_t rc;
2826 const char *key= "mykey";
2827 char *value;
2828 size_t length;
2829 uint32_t flags;
2830
2831 rc= memcached_set(memc, key, strlen(key),
2832 NULL, 0,
2833 (time_t)0, UINT32_MAX);
2834
2835 test_true(rc == MEMCACHED_SUCCESS);
2836
2837 value= memcached_get(memc, key, strlen(key),
2838 &length, &flags, &rc);
2839
2840 test_true(rc == MEMCACHED_SUCCESS);
2841 test_true(value == NULL);
2842 test_true(length == 0);
2843 test_true(flags == UINT32_MAX);
2844
2845 return TEST_SUCCESS;
2846 }
2847
2848 #if !defined(__sun) && !defined(__OpenBSD__)
2849 /* Check the validity of chinese key*/
2850 static test_return_t user_supplied_bug17(memcached_st *memc)
2851 {
2852 memcached_return_t rc;
2853 const char *key= "豆瓣";
2854 const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
2855 char *value2;
2856 size_t length;
2857 uint32_t flags;
2858
2859 rc= memcached_set(memc, key, strlen(key),
2860 value, strlen(value),
2861 (time_t)0, 0);
2862
2863 test_true(rc == MEMCACHED_SUCCESS);
2864
2865 value2= memcached_get(memc, key, strlen(key),
2866 &length, &flags, &rc);
2867
2868 test_true(length==strlen(value));
2869 test_true(rc == MEMCACHED_SUCCESS);
2870 test_true(memcmp(value, value2, length)==0);
2871 free(value2);
2872
2873 return TEST_SUCCESS;
2874 }
2875 #endif
2876
2877 /*
2878 From Andrei on IRC
2879 */
2880
2881 static test_return_t user_supplied_bug19(memcached_st *not_used)
2882 {
2883 memcached_st *memc;
2884 const memcached_server_st *server;
2885 memcached_return_t res;
2886
2887 (void)not_used;
2888
2889 memc= memcached_create(NULL);
2890 memcached_server_add_with_weight(memc, "localhost", 11311, 100);
2891 memcached_server_add_with_weight(memc, "localhost", 11312, 100);
2892
2893 server= memcached_server_by_key(memc, "a", 1, &res);
2894
2895 memcached_free(memc);
2896
2897 return TEST_SUCCESS;
2898 }
2899
2900 /* CAS test from Andei */
2901 static test_return_t user_supplied_bug20(memcached_st *memc)
2902 {
2903 memcached_return_t status;
2904 memcached_result_st *result, result_obj;
2905 const char *key = "abc";
2906 size_t key_len = strlen("abc");
2907 const char *value = "foobar";
2908 size_t value_len = strlen(value);
2909
2910 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
2911
2912 status = memcached_set(memc, key, key_len, value, value_len, (time_t)0, (uint32_t)0);
2913 test_true(status == MEMCACHED_SUCCESS);
2914
2915 status = memcached_mget(memc, &key, &key_len, 1);
2916 test_true(status == MEMCACHED_SUCCESS);
2917
2918 result= memcached_result_create(memc, &result_obj);
2919 test_true(result);
2920
2921 memcached_result_create(memc, &result_obj);
2922 result= memcached_fetch_result(memc, &result_obj, &status);
2923
2924 test_true(result);
2925 test_true(status == MEMCACHED_SUCCESS);
2926
2927 memcached_result_free(result);
2928
2929 return TEST_SUCCESS;
2930 }
2931
2932 #include "ketama_test_cases.h"
2933 static test_return_t user_supplied_bug18(memcached_st *trash)
2934 {
2935 memcached_return_t rc;
2936 uint64_t value;
2937 int x;
2938 memcached_server_st *server_pool;
2939 memcached_st *memc;
2940
2941 (void)trash;
2942
2943 memc= memcached_create(NULL);
2944 test_true(memc);
2945
2946 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
2947 test_true(rc == MEMCACHED_SUCCESS);
2948
2949 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
2950 test_true(value == 1);
2951
2952 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
2953 test_true(rc == MEMCACHED_SUCCESS);
2954
2955 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
2956 test_true(value == MEMCACHED_HASH_MD5);
2957
2958 server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
2959 memcached_server_push(memc, server_pool);
2960
2961 /* verify that the server list was parsed okay. */
2962 test_true(memcached_server_count(memc) == 8);
2963 test_true(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
2964 test_true(server_pool[0].port == 11211);
2965 test_true(server_pool[0].weight == 600);
2966 test_true(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
2967 test_true(server_pool[2].port == 11211);
2968 test_true(server_pool[2].weight == 200);
2969 test_true(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
2970 test_true(server_pool[7].port == 11211);
2971 test_true(server_pool[7].weight == 100);
2972
2973 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2974 * us test the boundary wraparound.
2975 */
2976 test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
2977
2978 /* verify the standard ketama set. */
2979 for (x= 0; x < 99; x++)
2980 {
2981 uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
2982
2983 memcached_server_instance_st instance=
2984 memcached_server_instance_by_position(memc, server_idx);
2985
2986 const char *hostname = memcached_server_name(instance);
2987 test_strcmp(hostname, ketama_test_cases[x].server);
2988 }
2989
2990 memcached_server_list_free(server_pool);
2991 memcached_free(memc);
2992
2993 return TEST_SUCCESS;
2994 }
2995
2996 /* Large mget() of missing keys with binary proto
2997 *
2998 * If many binary quiet commands (such as getq's in an mget) fill the output
2999 * buffer and the server chooses not to respond, memcached_flush hangs. See
3000 * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
3001 */
3002
3003 /* sighandler_t function that always asserts false */
3004 static void fail(int unused)
3005 {
3006 (void)unused;
3007 assert(0);
3008 }
3009
3010
3011 static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)
3012 {
3013 #ifdef WIN32
3014 (void)memc;
3015 (void)key_count;
3016 return TEST_SKIPPED;
3017 #else
3018 void (*oldalarm)(int);
3019
3020 memcached_st *memc_clone= memcached_clone(NULL, memc);
3021 test_true(memc_clone);
3022
3023 /* only binproto uses getq for mget */
3024 memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3025
3026 /* empty the cache to ensure misses (hence non-responses) */
3027 memcached_return_t rc= memcached_flush(memc_clone, 0);
3028 test_true(rc == MEMCACHED_SUCCESS);
3029
3030 size_t* key_lengths= new (std::nothrow) size_t[key_count];
3031 test_true(key_lengths);
3032 char **keys= static_cast<char **>(calloc(key_count, sizeof(char *)));
3033 test_true(keys);
3034 for (unsigned int x= 0; x < key_count; x++)
3035 {
3036 char buffer[30];
3037
3038 snprintf(buffer, 30, "%u", x);
3039 keys[x]= strdup(buffer);
3040 key_lengths[x]= strlen(keys[x]);
3041 }
3042
3043 oldalarm= signal(SIGALRM, fail);
3044 alarm(5);
3045
3046 test_true_got(memcached_success(memcached_mget(memc_clone, (const char **)keys, key_lengths, key_count)), memcached_last_error_message(memc_clone));
3047
3048 alarm(0);
3049 signal(SIGALRM, oldalarm);
3050
3051 size_t keys_returned;
3052 test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
3053
3054 for (unsigned int x= 0; x < key_count; x++)
3055 {
3056 free(keys[x]);
3057 }
3058 free(keys);
3059 delete [] key_lengths;
3060
3061 memcached_free(memc_clone);
3062
3063 return TEST_SUCCESS;
3064 #endif
3065 }
3066
3067 static test_return_t user_supplied_bug21(memcached_st *memc)
3068 {
3069 test_return_t test_rc;
3070 test_rc= pre_binary(memc);
3071
3072 if (test_rc != TEST_SUCCESS)
3073 return test_rc;
3074
3075 test_return_t rc;
3076
3077 /* should work as of r580 */
3078 rc= _user_supplied_bug21(memc, 10);
3079 test_true(rc == TEST_SUCCESS);
3080
3081 /* should fail as of r580 */
3082 rc= _user_supplied_bug21(memc, 1000);
3083 test_true(rc == TEST_SUCCESS);
3084
3085 return TEST_SUCCESS;
3086 }
3087
3088 static test_return_t auto_eject_hosts(memcached_st *trash)
3089 {
3090 (void) trash;
3091 memcached_server_instance_st instance;
3092
3093 memcached_return_t rc;
3094 memcached_st *memc= memcached_create(NULL);
3095 test_true(memc);
3096
3097 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
3098 test_true(rc == MEMCACHED_SUCCESS);
3099
3100 uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
3101 test_true(value == 1);
3102
3103 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
3104 test_true(rc == MEMCACHED_SUCCESS);
3105
3106 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
3107 test_true(value == MEMCACHED_HASH_MD5);
3108
3109 /* server should be removed when in delay */
3110 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS, 1);
3111 test_true(rc == MEMCACHED_SUCCESS);
3112
3113 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS);
3114 test_true(value == 1);
3115
3116 memcached_server_st *server_pool;
3117 server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
3118 memcached_server_push(memc, server_pool);
3119
3120 /* verify that the server list was parsed okay. */
3121 test_true(memcached_server_count(memc) == 8);
3122 test_true(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
3123 test_true(server_pool[0].port == 11211);
3124 test_true(server_pool[0].weight == 600);
3125 test_true(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
3126 test_true(server_pool[2].port == 11211);
3127 test_true(server_pool[2].weight == 200);
3128 test_true(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
3129 test_true(server_pool[7].port == 11211);
3130 test_true(server_pool[7].weight == 100);
3131
3132 instance= memcached_server_instance_by_position(memc, 2);
3133 ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) + 15;
3134 memc->ketama.next_distribution_rebuild= time(NULL) - 1;
3135
3136 /*
3137 This would not work if there were only two hosts.
3138 */
3139 for (size_t x= 0; x < 99; x++)
3140 {
3141 memcached_autoeject(memc);
3142 uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
3143 test_true(server_idx != 2);
3144 }
3145
3146 /* and re-added when it's back. */
3147 ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) - 1;
3148 memc->ketama.next_distribution_rebuild= time(NULL) - 1;
3149 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION,
3150 memc->distribution);
3151 for (size_t x= 0; x < 99; x++)
3152 {
3153 uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
3154 // We re-use instance from above.
3155 instance=
3156 memcached_server_instance_by_position(memc, server_idx);
3157 const char *hostname = memcached_server_name(instance);
3158 test_true(strcmp(hostname, ketama_test_cases[x].server) == 0);
3159 }
3160
3161 memcached_server_list_free(server_pool);
3162 memcached_free(memc);
3163
3164 return TEST_SUCCESS;
3165 }
3166
3167 static test_return_t output_ketama_weighted_keys(memcached_st *trash)
3168 {
3169 (void) trash;
3170
3171 memcached_return_t rc;
3172 memcached_st *memc= memcached_create(NULL);
3173 test_true(memc);
3174
3175
3176 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
3177 test_true(rc == MEMCACHED_SUCCESS);
3178
3179 uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
3180 test_true(value == 1);
3181
3182 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
3183 test_true(rc == MEMCACHED_SUCCESS);
3184
3185 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
3186 test_true(value == MEMCACHED_HASH_MD5);
3187
3188
3189 test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);
3190
3191 memcached_server_st *server_pool;
3192 server_pool = memcached_servers_parse("10.0.1.1:11211,10.0.1.2:11211,10.0.1.3:11211,10.0.1.4:11211,10.0.1.5:11211,10.0.1.6:11211,10.0.1.7:11211,10.0.1.8:11211,192.168.1.1:11211,192.168.100.1:11211");
3193 memcached_server_push(memc, server_pool);
3194
3195 // @todo this needs to be refactored to actually test something.
3196 #if 0
3197 FILE *fp;
3198 if ((fp = fopen("ketama_keys.txt", "w")))
3199 {
3200 // noop
3201 } else {
3202 printf("cannot write to file ketama_keys.txt");
3203 return TEST_FAILURE;
3204 }
3205
3206 for (int x= 0; x < 10000; x++)
3207 {
3208 char key[10];
3209 snprintf(key, sizeof(key), "%d", x);
3210
3211 uint32_t server_idx = memcached_generate_hash(memc, key, strlen(key));
3212 char *hostname = memc->hosts[server_idx].hostname;
3213 in_port_t port = memc->hosts[server_idx].port;
3214 fprintf(fp, "key %s is on host /%s:%u\n", key, hostname, port);
3215 memcached_server_instance_st instance=
3216 memcached_server_instance_by_position(memc, host_index);
3217 }
3218 fclose(fp);
3219 #endif
3220 memcached_server_list_free(server_pool);
3221 memcached_free(memc);
3222
3223 return TEST_SUCCESS;
3224 }
3225
3226
3227 static test_return_t result_static(memcached_st *memc)
3228 {
3229 memcached_result_st result;
3230 memcached_result_st *result_ptr;
3231
3232 result_ptr= memcached_result_create(memc, &result);
3233 test_true(result.options.is_allocated == false);
3234 test_true(memcached_is_initialized(&result) == true);
3235 test_true(result_ptr);
3236 test_true(result_ptr == &result);
3237
3238 memcached_result_free(&result);
3239
3240 test_true(result.options.is_allocated == false);
3241 test_true(memcached_is_initialized(&result) == false);
3242
3243 return TEST_SUCCESS;
3244 }
3245
3246 static test_return_t result_alloc(memcached_st *memc)
3247 {
3248 memcached_result_st *result_ptr;
3249
3250 result_ptr= memcached_result_create(memc, NULL);
3251 test_true(result_ptr);
3252 test_true(result_ptr->options.is_allocated == true);
3253 test_true(memcached_is_initialized(result_ptr) == true);
3254 memcached_result_free(result_ptr);
3255
3256 return TEST_SUCCESS;
3257 }
3258
3259 static test_return_t cleanup_pairs(memcached_st *memc)
3260 {
3261 (void)memc;
3262 pairs_free(global_pairs);
3263
3264 return TEST_SUCCESS;
3265 }
3266
3267 static test_return_t generate_pairs(memcached_st *memc)
3268 {
3269 (void)memc;
3270 global_pairs= pairs_generate(GLOBAL_COUNT, 400);
3271 global_count= GLOBAL_COUNT;
3272
3273 for (size_t x= 0; x < global_count; x++)
3274 {
3275 global_keys[x]= global_pairs[x].key;
3276 global_keys_length[x]= global_pairs[x].key_length;
3277 }
3278
3279 return TEST_SUCCESS;
3280 }
3281
3282 static test_return_t generate_large_pairs(memcached_st *)
3283 {
3284 global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
3285 global_count= GLOBAL2_COUNT;
3286
3287 for (size_t x= 0; x < global_count; x++)
3288 {
3289 global_keys[x]= global_pairs[x].key;
3290 global_keys_length[x]= global_pairs[x].key_length;
3291 }
3292
3293 return TEST_SUCCESS;
3294 }
3295
3296 static test_return_t generate_data(memcached_st *memc)
3297 {
3298 unsigned int check_execute= execute_set(memc, global_pairs, global_count);
3299
3300 test_true(check_execute == global_count);
3301
3302 return TEST_SUCCESS;
3303 }
3304
3305 static test_return_t generate_data_with_stats(memcached_st *memc)
3306 {
3307 uint32_t host_index= 0;
3308 unsigned int check_execute= execute_set(memc, global_pairs, global_count);
3309
3310 test_true(check_execute == global_count);
3311
3312 // @todo hosts used size stats
3313 memcached_return_t rc;
3314 memcached_stat_st *stat_p= memcached_stat(memc, NULL, &rc);
3315 test_true(stat_p);
3316
3317 for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++)
3318 {
3319 /* This test was changes so that "make test" would work properlly */
3320 #ifdef DEBUG
3321 memcached_server_instance_st instance=
3322 memcached_server_instance_by_position(memc, host_index);
3323
3324 printf("\nserver %u|%s|%u bytes: %llu\n", host_index, instance->hostname, instance->port, (unsigned long long)(stat_p + host_index)->bytes);
3325 #endif
3326 test_true((unsigned long long)(stat_p + host_index)->bytes);
3327 }
3328
3329 memcached_stat_free(NULL, stat_p);
3330
3331 return TEST_SUCCESS;
3332 }
3333 static test_return_t generate_buffer_data(memcached_st *memc)
3334 {
3335 size_t latch= 0;
3336
3337 latch= 1;
3338 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
3339 generate_data(memc);
3340
3341 return TEST_SUCCESS;
3342 }
3343
3344 static test_return_t get_read_count(memcached_st *memc)
3345 {
3346 memcached_st *memc_clone= memcached_clone(NULL, memc);
3347 test_true(memc_clone);
3348
3349 memcached_server_add_with_weight(memc_clone, "localhost", 6666, 0);
3350
3351 {
3352 char *return_value;
3353 size_t return_value_length;
3354 uint32_t flags;
3355 uint32_t count;
3356
3357 for (size_t x= count= 0; x < global_count; x++)
3358 {
3359 memcached_return_t rc;
3360 return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x],
3361 &return_value_length, &flags, &rc);
3362 if (rc == MEMCACHED_SUCCESS)
3363 {
3364 count++;
3365 if (return_value)
3366 free(return_value);
3367 }
3368 }
3369 }
3370
3371 memcached_free(memc_clone);
3372
3373 return TEST_SUCCESS;
3374 }
3375
3376 static test_return_t get_read(memcached_st *memc)
3377 {
3378 for (size_t x= 0; x < global_count; x++)
3379 {
3380 size_t return_value_length;
3381 uint32_t flags;
3382 memcached_return_t rc;
3383 char *return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
3384 &return_value_length, &flags, &rc);
3385 /*
3386 test_true(return_value);
3387 test_true(rc == MEMCACHED_SUCCESS);
3388 */
3389 if (rc == MEMCACHED_SUCCESS && return_value)
3390 free(return_value);
3391 }
3392
3393 return TEST_SUCCESS;
3394 }
3395
3396 static test_return_t mget_read(memcached_st *memc)
3397 {
3398
3399 if (not libmemcached_util_version_check(memc, 1, 4, 4))
3400 return TEST_SKIPPED;
3401
3402 memcached_return_t rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
3403
3404 test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
3405
3406 // Go fetch the keys and test to see if all of them were returned
3407 {
3408 size_t keys_returned;
3409 test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
3410 char buffer[30];
3411 snprintf(buffer, sizeof(buffer), "%lu", (unsigned long)keys_returned);
3412 test_true_got(global_count == keys_returned, buffer);
3413 }
3414
3415
3416 return TEST_SUCCESS;
3417 }
3418
3419 static test_return_t mget_read_result(memcached_st *memc)
3420 {
3421
3422 if (not libmemcached_util_version_check(memc, 1, 4, 4))
3423 return TEST_SKIPPED;
3424
3425 memcached_return_t rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
3426
3427 test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
3428
3429 /* Turn this into a help function */
3430 {
3431 memcached_result_st results_obj;
3432 memcached_result_st *results= memcached_result_create(memc, &results_obj);
3433
3434 while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
3435 {
3436 test_true(results);
3437 test_true(rc == MEMCACHED_SUCCESS);
3438 }
3439
3440 memcached_result_free(&results_obj);
3441 }
3442
3443 return TEST_SUCCESS;
3444 }
3445
3446 static test_return_t mget_read_function(memcached_st *memc)
3447 {
3448
3449 if (not libmemcached_util_version_check(memc, 1, 4, 4))
3450 return TEST_SKIPPED;
3451
3452 memcached_return_t rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
3453
3454 test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
3455
3456 memcached_execute_fn callbacks[]= { &callback_counter };
3457 size_t counter= 0;
3458 rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
3459
3460 return TEST_SUCCESS;
3461 }
3462
3463 static test_return_t delete_generate(memcached_st *memc)
3464 {
3465 for (size_t x= 0; x < global_count; x++)
3466 {
3467 (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
3468 }
3469
3470 return TEST_SUCCESS;
3471 }
3472
3473 static test_return_t delete_buffer_generate(memcached_st *memc)
3474 {
3475 uint64_t latch= 1;
3476 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
3477
3478 for (size_t x= 0; x < global_count; x++)
3479 {
3480 (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
3481 }
3482
3483 return TEST_SUCCESS;
3484 }
3485
3486 static test_return_t add_host_test1(memcached_st *memc)
3487 {
3488 memcached_return_t rc;
3489 char servername[]= "0.example.com";
3490
3491 memcached_server_st *servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
3492 test_true(servers);
3493 test_compare(1, memcached_server_list_count(servers));
3494
3495 for (size_t x= 2; x < 20; x++)
3496 {
3497 char buffer[SMALL_STRING_LEN];
3498
3499 snprintf(buffer, SMALL_STRING_LEN, "%lu.example.com", (unsigned long)(400 +x));
3500 servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
3501 &rc);
3502 test_compare(MEMCACHED_SUCCESS, rc);
3503 test_compare(x, memcached_server_list_count(servers));
3504 }
3505
3506 test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
3507 test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
3508
3509 memcached_server_list_free(servers);
3510
3511 return TEST_SUCCESS;
3512 }
3513
3514 static test_return_t pre_nonblock(memcached_st *memc)
3515 {
3516 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
3517
3518 return TEST_SUCCESS;
3519 }
3520
3521 static test_return_t pre_cork(memcached_st *memc)
3522 {
3523 #ifdef __APPLE__
3524 return TEST_SKIPPED;
3525 #endif
3526 bool set= true;
3527 if (memcached_success(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set)))
3528 return TEST_SUCCESS;
3529
3530 return TEST_SKIPPED;
3531 }
3532
3533 static test_return_t pre_cork_and_nonblock(memcached_st *memc)
3534 {
3535 #ifdef __APPLE__
3536 return TEST_SKIPPED;
3537 #endif
3538 test_return_t test_rc;
3539 if ((test_rc= pre_cork(memc)) != TEST_SUCCESS)
3540 return test_rc;
3541
3542 return pre_nonblock(memc);
3543 }
3544
3545 static test_return_t pre_nonblock_binary(memcached_st *memc)
3546 {
3547 memcached_return_t rc= MEMCACHED_FAILURE;
3548 memcached_st *memc_clone;
3549
3550 memc_clone= memcached_clone(NULL, memc);
3551 test_true(memc_clone);
3552 // The memcached_version needs to be done on a clone, because the server
3553 // will not toggle protocol on an connection.
3554 memcached_version(memc_clone);
3555
3556 if (libmemcached_util_version_check(memc_clone, 1, 4, 4))
3557 {
3558 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
3559 rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3560 test_true(rc == MEMCACHED_SUCCESS);
3561 test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
3562 }
3563 else
3564 {
3565 return TEST_SKIPPED;
3566 }
3567
3568 memcached_free(memc_clone);
3569
3570 return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3571 }
3572
3573 static test_return_t pre_murmur(memcached_st *memc)
3574 {
3575 #ifdef HAVE_MURMUR_HASH
3576 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
3577 return TEST_SUCCESS;
3578 #else
3579 (void) memc;
3580 return TEST_SKIPPED;
3581 #endif
3582 }
3583
3584 static test_return_t pre_jenkins(memcached_st *memc)
3585 {
3586 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_JENKINS);
3587
3588 return TEST_SUCCESS;
3589 }
3590
3591
3592 static test_return_t pre_md5(memcached_st *memc)
3593 {
3594 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5);
3595
3596 return TEST_SUCCESS;
3597 }
3598
3599 static test_return_t pre_crc(memcached_st *memc)
3600 {
3601 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_CRC);
3602
3603 return TEST_SUCCESS;
3604 }
3605
3606 static test_return_t pre_hsieh(memcached_st *memc)
3607 {
3608 #ifdef HAVE_HSIEH_HASH
3609 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH);
3610 return TEST_SUCCESS;
3611 #else
3612 (void) memc;
3613 return TEST_SKIPPED;
3614 #endif
3615 }
3616
3617 static test_return_t pre_hash_fnv1_64(memcached_st *memc)
3618 {
3619 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
3620
3621 return TEST_SUCCESS;
3622 }
3623
3624 static test_return_t pre_hash_fnv1a_64(memcached_st *memc)
3625 {
3626 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64);
3627
3628 return TEST_SUCCESS;
3629 }
3630
3631 static test_return_t pre_hash_fnv1_32(memcached_st *memc)
3632 {
3633 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_32);
3634
3635 return TEST_SUCCESS;
3636 }
3637
3638 static test_return_t pre_hash_fnv1a_32(memcached_st *memc)
3639 {
3640 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_32);
3641
3642 return TEST_SUCCESS;
3643 }
3644
3645 static test_return_t pre_behavior_ketama(memcached_st *memc)
3646 {
3647 memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1);
3648 test_true(rc == MEMCACHED_SUCCESS);
3649
3650 uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);
3651 test_true(value == 1);
3652
3653 return TEST_SUCCESS;
3654 }
3655
3656 static test_return_t pre_behavior_ketama_weighted(memcached_st *memc)
3657 {
3658 memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
3659 test_true(rc == MEMCACHED_SUCCESS);
3660
3661 uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
3662 test_true(value == 1);
3663
3664 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
3665 test_true(rc == MEMCACHED_SUCCESS);
3666
3667 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
3668 test_true(value == MEMCACHED_HASH_MD5);
3669
3670 return TEST_SUCCESS;
3671 }
3672
3673 /**
3674 @note This should be testing to see if the server really supports the binary protocol.
3675 */
3676 static test_return_t pre_binary(memcached_st *memc)
3677 {
3678 memcached_return_t rc= MEMCACHED_FAILURE;
3679
3680 if (libmemcached_util_version_check(memc, 1, 4, 4))
3681 {
3682 rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3683 test_true(rc == MEMCACHED_SUCCESS);
3684 test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
3685 }
3686
3687 return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3688 }
3689
3690 static test_return_t pre_sasl(memcached_st *memc)
3691 {
3692 memcached_return_t rc= MEMCACHED_FAILURE;
3693
3694 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
3695 const char *server= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
3696 const char *user= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
3697 const char *pass= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
3698
3699 if (server and user and pass)
3700 {
3701 memcached_server_st *servers= memcached_servers_parse(server);
3702 test_true(servers);
3703 memcached_servers_reset(memc);
3704 test_true(memcached_server_push(memc, servers) == MEMCACHED_SUCCESS);
3705 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3706 rc= memcached_set_sasl_auth_data(memc, user, pass);
3707 test_true(rc == MEMCACHED_SUCCESS);
3708 }
3709 #else
3710 (void)memc;
3711 #endif
3712
3713 return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3714 }
3715
3716 static test_return_t pre_replication(memcached_st *memc)
3717 {
3718 test_true(TEST_SUCCESS == pre_binary(memc));
3719
3720 /*
3721 * Make sure that we store the item on all servers
3722 * (master + replicas == number of servers)
3723 */
3724 memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS,
3725 memcached_server_count(memc) - 1);
3726 test_true(rc == MEMCACHED_SUCCESS);
3727 test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memcached_server_count(memc) - 1);
3728
3729 return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3730 }
3731
3732
3733 static test_return_t pre_replication_noblock(memcached_st *memc)
3734 {
3735 test_compare(TEST_SUCCESS, pre_replication(memc));
3736
3737 return pre_nonblock(memc);
3738 }
3739
3740
3741 static void my_free(const memcached_st *ptr, void *mem, void *context)
3742 {
3743 (void)context;
3744 (void)ptr;
3745 #ifdef HARD_MALLOC_TESTS
3746 void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8);
3747 free(real_ptr);
3748 #else
3749 free(mem);
3750 #endif
3751 }
3752
3753
3754 static void *my_malloc(const memcached_st *ptr, const size_t size, void *context)
3755 {
3756 (void)context;
3757 (void)ptr;
3758 #ifdef HARD_MALLOC_TESTS
3759 void *ret= malloc(size + 8);
3760 if (ret != NULL)
3761 {
3762 ret= (void*)((caddr_t)ret + 8);
3763 }
3764 #else
3765 void *ret= malloc(size);
3766 #endif
3767
3768 if (ret != NULL)
3769 {
3770 memset(ret, 0xff, size);
3771 }
3772
3773 return ret;
3774 }
3775
3776
3777 static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *)
3778 {
3779 #ifdef HARD_MALLOC_TESTS
3780 void *real_ptr= (mem == NULL) ? NULL : (void*)((caddr_t)mem - 8);
3781 void *nmem= realloc(real_ptr, size + 8);
3782
3783 void *ret= NULL;
3784 if (nmem != NULL)
3785 {
3786 ret= (void*)((caddr_t)nmem + 8);
3787 }
3788
3789 return ret;
3790 #else
3791 (void)ptr;
3792 return realloc(mem, size);
3793 #endif
3794 }
3795
3796
3797 static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *)
3798 {
3799 #ifdef HARD_MALLOC_TESTS
3800 void *mem= my_malloc(ptr, nelem * size);
3801 if (mem)
3802 {
3803 memset(mem, 0, nelem * size);
3804 }
3805
3806 return mem;
3807 #else
3808 (void)ptr;
3809 return calloc(nelem, size);
3810 #endif
3811 }
3812
3813 static test_return_t set_prefix(memcached_st *memc)
3814 {
3815 memcached_return_t rc;
3816 const char *key= "mine";
3817 char *value;
3818
3819 /* Make sure be default none exists */
3820 value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3821 test_true(rc == MEMCACHED_FAILURE);
3822
3823 /* Test a clean set */
3824 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3825 test_true_got(rc == MEMCACHED_SUCCESS, memcached_last_error_message(memc));
3826
3827 value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3828 test_true(value);
3829 test_true(memcmp(value, key, 4) == 0);
3830 test_true(rc == MEMCACHED_SUCCESS);
3831
3832 /* Test that we can turn it off */
3833 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3834 test_true(rc == MEMCACHED_SUCCESS);
3835
3836 value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3837 test_false(value);
3838 test_true(rc == MEMCACHED_FAILURE);
3839
3840 /* Now setup for main test */
3841 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3842 test_true(rc == MEMCACHED_SUCCESS);
3843
3844 value= (char *)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3845 test_true(value);
3846 test_true(rc == MEMCACHED_SUCCESS);
3847 test_true(memcmp(value, key, 4) == 0);
3848
3849 /* Set to Zero, and then Set to something too large */
3850 {
3851 char long_key[255];
3852 memset(long_key, 0, 255);
3853
3854 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3855 test_true(rc == MEMCACHED_SUCCESS);
3856
3857 value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3858 test_false(value);
3859 test_true(rc == MEMCACHED_FAILURE);
3860 test_true(value == NULL);
3861
3862 /* Test a long key for failure */
3863 /* TODO, extend test to determine based on setting, what result should be */
3864 strncpy(long_key, "Thisismorethentheallottednumberofcharacters", sizeof(long_key));
3865 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3866 //test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3867 test_true(rc == MEMCACHED_SUCCESS);
3868
3869 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3870 strncpy(long_key, "This is more then the allotted number of characters", sizeof(long_key));
3871 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3872 test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3873
3874 /* Test for a bad prefix, but with a short key */
3875 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
3876 test_true(rc == MEMCACHED_SUCCESS);
3877
3878 strncpy(long_key, "dog cat", sizeof(long_key));
3879 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3880 test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3881 }
3882
3883 return TEST_SUCCESS;
3884 }
3885
3886
3887 #ifdef MEMCACHED_ENABLE_DEPRECATED
3888 static test_return_t deprecated_set_memory_alloc(memcached_st *memc)
3889 {
3890 void *test_ptr= NULL;
3891 void *cb_ptr= NULL;
3892 {
3893 memcached_malloc_fn malloc_cb=
3894 (memcached_malloc_fn)my_malloc;
3895 cb_ptr= *(void **)&malloc_cb;
3896 memcached_return_t rc;
3897
3898 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, cb_ptr);
3899 test_true(rc == MEMCACHED_SUCCESS);
3900 test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
3901 test_true(rc == MEMCACHED_SUCCESS);
3902 test_true(test_ptr == cb_ptr);
3903 }
3904
3905 {
3906 memcached_realloc_fn realloc_cb=
3907 (memcached_realloc_fn)my_realloc;
3908 cb_ptr= *(void **)&realloc_cb;
3909 memcached_return_t rc;
3910
3911 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, cb_ptr);
3912 test_true(rc == MEMCACHED_SUCCESS);
3913 test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
3914 test_true(rc == MEMCACHED_SUCCESS);
3915 test_true(test_ptr == cb_ptr);
3916 }
3917
3918 {
3919 memcached_free_fn free_cb=
3920 (memcached_free_fn)my_free;
3921 cb_ptr= *(void **)&free_cb;
3922 memcached_return_t rc;
3923
3924 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, cb_ptr);
3925 test_true(rc == MEMCACHED_SUCCESS);
3926 test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
3927 test_true(rc == MEMCACHED_SUCCESS);
3928 test_true(test_ptr == cb_ptr);
3929 }
3930
3931 return TEST_SUCCESS;
3932 }
3933 #endif
3934
3935
3936 static test_return_t set_memory_alloc(memcached_st *memc)
3937 {
3938 memcached_return_t rc;
3939 rc= memcached_set_memory_allocators(memc, NULL, my_free,
3940 my_realloc, my_calloc, NULL);
3941 test_true(rc == MEMCACHED_FAILURE);
3942
3943 rc= memcached_set_memory_allocators(memc, my_malloc, my_free,
3944 my_realloc, my_calloc, NULL);
3945
3946 memcached_malloc_fn mem_malloc;
3947 memcached_free_fn mem_free;
3948 memcached_realloc_fn mem_realloc;
3949 memcached_calloc_fn mem_calloc;
3950 memcached_get_memory_allocators(memc, &mem_malloc, &mem_free,
3951 &mem_realloc, &mem_calloc);
3952
3953 test_true(mem_malloc == my_malloc);
3954 test_true(mem_realloc == my_realloc);
3955 test_true(mem_calloc == my_calloc);
3956 test_true(mem_free == my_free);
3957
3958 return TEST_SUCCESS;
3959 }
3960
3961 static test_return_t enable_consistent_crc(memcached_st *memc)
3962 {
3963 test_return_t rc;
3964 memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
3965 memcached_hash_t hash;
3966 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
3967 if ((rc= pre_crc(memc)) != TEST_SUCCESS)
3968 return rc;
3969
3970 value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
3971 test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
3972
3973 hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
3974
3975 if (hash != MEMCACHED_HASH_CRC)
3976 return TEST_SKIPPED;
3977
3978 return TEST_SUCCESS;
3979 }
3980
3981 static test_return_t enable_consistent_hsieh(memcached_st *memc)
3982 {
3983 test_return_t rc;
3984 memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
3985 memcached_hash_t hash;
3986 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
3987 if ((rc= pre_hsieh(memc)) != TEST_SUCCESS)
3988 return rc;
3989
3990 value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
3991 test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
3992
3993 hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
3994
3995 if (hash != MEMCACHED_HASH_HSIEH)
3996 return TEST_SKIPPED;
3997
3998
3999 return TEST_SUCCESS;
4000 }
4001
4002 static test_return_t enable_cas(memcached_st *memc)
4003 {
4004 unsigned int set= 1;
4005
4006 if (libmemcached_util_version_check(memc, 1, 2, 4))
4007 {
4008 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
4009
4010 return TEST_SUCCESS;
4011 }
4012
4013 return TEST_SKIPPED;
4014 }
4015
4016 static test_return_t check_for_1_2_3(memcached_st *memc)
4017 {
4018 memcached_version(memc);
4019
4020 memcached_server_instance_st instance=
4021 memcached_server_instance_by_position(memc, 0);
4022
4023 if ((instance->major_version >= 1 && (instance->minor_version == 2 && instance->micro_version >= 4))
4024 || instance->minor_version > 2)
4025 {
4026 return TEST_SUCCESS;
4027 }
4028
4029 return TEST_SKIPPED;
4030 }
4031
4032 static test_return_t pre_unix_socket(memcached_st *memc)
4033 {
4034 memcached_return_t rc;
4035 struct stat buf;
4036
4037 memcached_servers_reset(memc);
4038
4039 if (stat("/tmp/memcached.socket", &buf))
4040 return TEST_SKIPPED;
4041
4042 rc= memcached_server_add_unix_socket_with_weight(memc, "/tmp/memcached.socket", 0);
4043
4044 return ( rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_FAILURE );
4045 }
4046
4047 static test_return_t pre_nodelay(memcached_st *memc)
4048 {
4049 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
4050 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
4051
4052 return TEST_SUCCESS;
4053 }
4054
4055 static test_return_t pre_settimer(memcached_st *memc)
4056 {
4057 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
4058 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
4059
4060 return TEST_SUCCESS;
4061 }
4062
4063 static test_return_t poll_timeout(memcached_st *memc)
4064 {
4065 size_t timeout;
4066
4067 timeout= 100;
4068
4069 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
4070
4071 timeout= (size_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
4072
4073 test_true(timeout == 100);
4074
4075 return TEST_SUCCESS;
4076 }
4077
4078 static test_return_t noreply_test(memcached_st *memc)
4079 {
4080 memcached_return_t ret;
4081 ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
4082 test_true(ret == MEMCACHED_SUCCESS);
4083 ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
4084 test_true(ret == MEMCACHED_SUCCESS);
4085 ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
4086 test_true(ret == MEMCACHED_SUCCESS);
4087 test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY) == 1);
4088 test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS) == 1);
4089 test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS) == 1);
4090
4091 for (int count=0; count < 5; ++count)
4092 {
4093 for (size_t x= 0; x < 100; ++x)
4094 {
4095 char key[10];
4096 int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
4097 test_false((size_t)check_length >= sizeof(key) || check_length < 0);
4098
4099 size_t len= (size_t)check_length;
4100
4101 switch (count)
4102 {
4103 case 0:
4104 ret= memcached_add(memc, key, len, key, len, 0, 0);
4105 break;
4106 case 1:
4107 ret= memcached_replace(memc, key, len, key, len, 0, 0);
4108 break;
4109 case 2:
4110 ret= memcached_set(memc, key, len, key, len, 0, 0);
4111 break;
4112 case 3:
4113 ret= memcached_append(memc, key, len, key, len, 0, 0);
4114 break;
4115 case 4:
4116 ret= memcached_prepend(memc, key, len, key, len, 0, 0);
4117 break;
4118 default:
4119 test_true(count);
4120 break;
4121 }
4122 test_true(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED);
4123 }
4124
4125 /*
4126 ** NOTE: Don't ever do this in your code! this is not a supported use of the
4127 ** API and is _ONLY_ done this way to verify that the library works the
4128 ** way it is supposed to do!!!!
4129 */
4130 int no_msg=0;
4131 for (uint32_t x= 0; x < memcached_server_count(memc); ++x)
4132 {
4133 memcached_server_instance_st instance=
4134 memcached_server_instance_by_position(memc, x);
4135 no_msg+=(int)(instance->cursor_active);
4136 }
4137
4138 test_true(no_msg == 0);
4139 test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
4140
4141 /*
4142 ** Now validate that all items was set properly!
4143 */
4144 for (size_t x= 0; x < 100; ++x)
4145 {
4146 char key[10];
4147
4148 int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
4149
4150 test_false((size_t)check_length >= sizeof(key) || check_length < 0);
4151
4152 size_t len= (size_t)check_length;
4153 size_t length;
4154 uint32_t flags;
4155 char* value=memcached_get(memc, key, strlen(key),
4156 &length, &flags, &ret);
4157 test_true(ret == MEMCACHED_SUCCESS && value != NULL);
4158 switch (count)
4159 {
4160 case 0: /* FALLTHROUGH */
4161 case 1: /* FALLTHROUGH */
4162 case 2:
4163 test_true(strncmp(value, key, len) == 0);
4164 test_true(len == length);
4165 break;
4166 case 3:
4167 test_true(length == len * 2);
4168 break;
4169 case 4:
4170 test_true(length == len * 3);
4171 break;
4172 default:
4173 test_true(count);
4174 break;
4175 }
4176 free(value);
4177 }
4178 }
4179
4180 /* Try setting an illegal cas value (should not return an error to
4181 * the caller (because we don't expect a return message from the server)
4182 */
4183 const char* keys[]= {"0"};
4184 size_t lengths[]= {1};
4185 size_t length;
4186 uint32_t flags;
4187 memcached_result_st results_obj;
4188 memcached_result_st *results;
4189 ret= memcached_mget(memc, keys, lengths, 1);
4190 test_true(ret == MEMCACHED_SUCCESS);
4191
4192 results= memcached_result_create(memc, &results_obj);
4193 test_true(results);
4194 results= memcached_fetch_result(memc, &results_obj, &ret);
4195 test_true(results);
4196 test_true(ret == MEMCACHED_SUCCESS);
4197 uint64_t cas= memcached_result_cas(results);
4198 memcached_result_free(&results_obj);
4199
4200 ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
4201 test_true(ret == MEMCACHED_SUCCESS);
4202
4203 /*
4204 * The item will have a new cas value, so try to set it again with the old
4205 * value. This should fail!
4206 */
4207 ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
4208 test_true(ret == MEMCACHED_SUCCESS);
4209 test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
4210 char* value=memcached_get(memc, keys[0], lengths[0], &length, &flags, &ret);
4211 test_true(ret == MEMCACHED_SUCCESS && value != NULL);
4212 free(value);
4213
4214 return TEST_SUCCESS;
4215 }
4216
4217 static test_return_t analyzer_test(memcached_st *memc)
4218 {
4219 memcached_return_t rc;
4220 memcached_stat_st *memc_stat;
4221 memcached_analysis_st *report;
4222
4223 memc_stat= memcached_stat(memc, NULL, &rc);
4224 test_true(rc == MEMCACHED_SUCCESS);
4225 test_true(memc_stat);
4226
4227 report= memcached_analyze(memc, memc_stat, &rc);
4228 test_true(rc == MEMCACHED_SUCCESS);
4229 test_true(report);
4230
4231 free(report);
4232 memcached_stat_free(NULL, memc_stat);
4233
4234 return TEST_SUCCESS;
4235 }
4236
4237 /* Count the objects */
4238 static memcached_return_t callback_dump_counter(const memcached_st *ptr,
4239 const char *key,
4240 size_t key_length,
4241 void *context)
4242 {
4243 (void)ptr; (void)key; (void)key_length;
4244 size_t *counter= (size_t *)context;
4245
4246 *counter= *counter + 1;
4247
4248 return MEMCACHED_SUCCESS;
4249 }
4250
4251 static test_return_t dump_test(memcached_st *memc)
4252 {
4253 size_t counter= 0;
4254 memcached_dump_fn callbacks[1];
4255 test_return_t main_rc;
4256
4257 callbacks[0]= &callback_dump_counter;
4258
4259 /* No support for Binary protocol yet */
4260 if (memc->flags.binary_protocol)
4261 return TEST_SUCCESS;
4262
4263 main_rc= set_test3(memc);
4264
4265 test_true (main_rc == TEST_SUCCESS);
4266
4267 memcached_return_t rc= memcached_dump(memc, callbacks, (void *)&counter, 1);
4268 test_true(rc == MEMCACHED_SUCCESS);
4269
4270 /* We may have more then 32 if our previous flush has not completed */
4271 test_true(counter >= 32);
4272
4273 return TEST_SUCCESS;
4274 }
4275
4276 #ifdef HAVE_LIBMEMCACHEDUTIL
4277
4278 struct test_pool_context_st {
4279 memcached_pool_st* pool;
4280 memcached_st* mmc;
4281 };
4282
4283 static void* connection_release(void *arg)
4284 {
4285 test_pool_context_st *resource= static_cast<test_pool_context_st *>(arg);
4286
4287 usleep(250);
4288 // Release all of the memc we are holding
4289 assert(memcached_pool_push(resource->pool, resource->mmc) == MEMCACHED_SUCCESS);
4290 return arg;
4291 }
4292
4293 #define POOL_SIZE 10
4294 static test_return_t connection_pool_test(memcached_st *memc)
4295 {
4296 memcached_pool_st* pool= memcached_pool_create(memc, 5, POOL_SIZE);
4297 test_true(pool != NULL);
4298 memcached_st *mmc[POOL_SIZE];
4299 memcached_return_t rc;
4300
4301 // Fill up our array that we will store the memc that are in the pool
4302 for (size_t x= 0; x < POOL_SIZE; ++x)
4303 {
4304 mmc[x]= memcached_pool_pop(pool, false, &rc);
4305 test_true(mmc[x] != NULL);
4306 test_true(rc == MEMCACHED_SUCCESS);
4307 }
4308
4309 // All memc should be gone
4310 test_true(memcached_pool_pop(pool, false, &rc) == NULL);
4311 test_true(rc == MEMCACHED_SUCCESS);
4312
4313 pthread_t tid;
4314 test_pool_context_st item= { pool, mmc[9] };
4315
4316 pthread_create(&tid, NULL, connection_release, &item);
4317 mmc[9]= memcached_pool_pop(pool, true, &rc);
4318 test_true(rc == MEMCACHED_SUCCESS);
4319 pthread_join(tid, NULL);
4320 test_true(mmc[9]);
4321 const char *key= "key";
4322 size_t keylen= strlen(key);
4323
4324 // verify that I can do ops with all connections
4325 rc= memcached_set(mmc[0], key, keylen, "0", 1, 0, 0);
4326 test_true(rc == MEMCACHED_SUCCESS);
4327
4328 for (size_t x= 0; x < POOL_SIZE; ++x)
4329 {
4330 uint64_t number_value;
4331 rc= memcached_increment(mmc[x], key, keylen, 1, &number_value);
4332 test_true(rc == MEMCACHED_SUCCESS);
4333 test_true(number_value == (x+1));
4334 }
4335
4336 // Release them..
4337 for (size_t x= 0; x < POOL_SIZE; ++x)
4338 {
4339 test_true(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS);
4340 }
4341
4342
4343 /* verify that I can set behaviors on the pool when I don't have all
4344 * of the connections in the pool. It should however be enabled
4345 * when I push the item into the pool
4346 */
4347 mmc[0]= memcached_pool_pop(pool, false, &rc);
4348 test_true(mmc[0] != NULL);
4349
4350 rc= memcached_pool_behavior_set(pool, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 9999);
4351 test_true(rc == MEMCACHED_SUCCESS);
4352
4353 mmc[1]= memcached_pool_pop(pool, false, &rc);
4354 test_true(mmc[1] != NULL);
4355
4356 test_true(memcached_behavior_get(mmc[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
4357 test_true(memcached_pool_push(pool, mmc[1]) == MEMCACHED_SUCCESS);
4358 test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
4359
4360 mmc[0]= memcached_pool_pop(pool, false, &rc);
4361 test_true(memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
4362 test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
4363
4364 test_true(memcached_pool_destroy(pool) == memc);
4365
4366 return TEST_SUCCESS;
4367 }
4368
4369 static test_return_t util_version_test(memcached_st *memc)
4370 {
4371 bool if_successful;
4372
4373 if_successful= libmemcached_util_version_check(memc, 0, 0, 0);
4374 test_true(if_successful == true);
4375
4376 if_successful= libmemcached_util_version_check(memc, 9, 9, 9);
4377
4378 // We expect failure
4379 if (if_successful)
4380 {
4381 fprintf(stderr, "\n----------------------------------------------------------------------\n");
4382 fprintf(stderr, "\nDumping Server Information\n\n");
4383 memcached_server_fn callbacks[1];
4384
4385 callbacks[0]= dump_server_information;
4386 memcached_server_cursor(memc, callbacks, (void *)stderr, 1);
4387 fprintf(stderr, "\n----------------------------------------------------------------------\n");
4388 }
4389 test_true(if_successful == false);
4390
4391 memcached_server_instance_st instance=
4392 memcached_server_instance_by_position(memc, 0);
4393
4394 memcached_version(memc);
4395
4396 // We only use one binary when we test, so this should be just fine.
4397 if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, instance->micro_version);
4398 test_true(if_successful == true);
4399
4400 if (instance->micro_version > 0)
4401 if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version -1));
4402 else if (instance->minor_version > 0)
4403 if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version - 1), instance->micro_version);
4404 else if (instance->major_version > 0)
4405 if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version -1), instance->minor_version, instance->micro_version);
4406
4407 test_true(if_successful == true);
4408
4409 if (instance->micro_version > 0)
4410 if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version +1));
4411 else if (instance->minor_version > 0)
4412 if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version +1), instance->micro_version);
4413 else if (instance->major_version > 0)
4414 if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version +1), instance->minor_version, instance->micro_version);
4415
4416 test_true(if_successful == false);
4417
4418 return TEST_SUCCESS;
4419 }
4420
4421 static test_return_t ping_test(memcached_st *memc)
4422 {
4423 memcached_return_t rc;
4424 memcached_server_instance_st instance=
4425 memcached_server_instance_by_position(memc, 0);
4426
4427 // Test both the version that returns a code, and the one that does not.
4428 test_true(libmemcached_util_ping(memcached_server_name(instance),
4429 memcached_server_port(instance), NULL));
4430
4431 test_true(libmemcached_util_ping(memcached_server_name(instance),
4432 memcached_server_port(instance), &rc));
4433
4434 test_true(rc == MEMCACHED_SUCCESS);
4435
4436 return TEST_SUCCESS;
4437 }
4438 #endif
4439
4440
4441 #if 0
4442 static test_return_t hash_sanity_test (memcached_st *memc)
4443 {
4444 (void)memc;
4445
4446 assert(MEMCACHED_HASH_DEFAULT == MEMCACHED_HASH_DEFAULT);
4447 assert(MEMCACHED_HASH_MD5 == MEMCACHED_HASH_MD5);
4448 assert(MEMCACHED_HASH_CRC == MEMCACHED_HASH_CRC);
4449 assert(MEMCACHED_HASH_FNV1_64 == MEMCACHED_HASH_FNV1_64);
4450 assert(MEMCACHED_HASH_FNV1A_64 == MEMCACHED_HASH_FNV1A_64);
4451 assert(MEMCACHED_HASH_FNV1_32 == MEMCACHED_HASH_FNV1_32);
4452 assert(MEMCACHED_HASH_FNV1A_32 == MEMCACHED_HASH_FNV1A_32);
4453 #ifdef HAVE_HSIEH_HASH
4454 assert(MEMCACHED_HASH_HSIEH == MEMCACHED_HASH_HSIEH);
4455 #endif
4456 assert(MEMCACHED_HASH_MURMUR == MEMCACHED_HASH_MURMUR);
4457 assert(MEMCACHED_HASH_JENKINS == MEMCACHED_HASH_JENKINS);
4458 assert(MEMCACHED_HASH_MAX == MEMCACHED_HASH_MAX);
4459
4460 return TEST_SUCCESS;
4461 }
4462 #endif
4463
4464 static test_return_t hsieh_avaibility_test (memcached_st *memc)
4465 {
4466 memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS;
4467 #ifdef HAVE_HSIEH_HASH
4468 expected_rc= MEMCACHED_SUCCESS;
4469 #endif
4470 memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
4471 (uint64_t)MEMCACHED_HASH_HSIEH);
4472 test_true(rc == expected_rc);
4473
4474 return TEST_SUCCESS;
4475 }
4476
4477 static test_return_t murmur_avaibility_test (memcached_st *memc)
4478 {
4479 memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS;
4480 #ifdef HAVE_MURMUR_HASH
4481 expected_rc= MEMCACHED_SUCCESS;
4482 #endif
4483 memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
4484 (uint64_t)MEMCACHED_HASH_MURMUR);
4485 test_true(rc == expected_rc);
4486
4487 return TEST_SUCCESS;
4488 }
4489
4490 static test_return_t one_at_a_time_run (memcached_st *memc)
4491 {
4492 uint32_t x;
4493 const char **ptr;
4494 (void)memc;
4495
4496 for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4497 {
4498 uint32_t hash_val;
4499
4500 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_DEFAULT);
4501 test_true(one_at_a_time_values[x] == hash_val);
4502 }
4503
4504 return TEST_SUCCESS;
4505 }
4506
4507 static test_return_t md5_run (memcached_st *memc)
4508 {
4509 uint32_t x;
4510 const char **ptr;
4511 (void)memc;
4512
4513 for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4514 {
4515 uint32_t hash_val;
4516
4517 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5);
4518 test_true(md5_values[x] == hash_val);
4519 }
4520
4521 return TEST_SUCCESS;
4522 }
4523
4524 static test_return_t crc_run (memcached_st *memc)
4525 {
4526 uint32_t x;
4527 const char **ptr;
4528 (void)memc;
4529
4530 for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4531 {
4532 uint32_t hash_val;
4533
4534 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC);
4535 test_true(crc_values[x] == hash_val);
4536 }
4537
4538 return TEST_SUCCESS;
4539 }
4540
4541 static test_return_t fnv1_64_run (memcached_st *memc)
4542 {
4543 uint32_t x;
4544 const char **ptr;
4545 (void)memc;
4546
4547 for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4548 {
4549 uint32_t hash_val;
4550
4551 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
4552 test_true(fnv1_64_values[x] == hash_val);
4553 }
4554
4555 return TEST_SUCCESS;
4556 }
4557
4558 static test_return_t fnv1a_64_run (memcached_st *memc)
4559 {
4560 uint32_t x;
4561 const char **ptr;
4562 (void)memc;
4563
4564 for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4565 {
4566 uint32_t hash_val;
4567
4568 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64);
4569 test_true(fnv1a_64_values[x] == hash_val);
4570 }
4571
4572 return TEST_SUCCESS;
4573 }
4574
4575 static test_return_t fnv1_32_run (memcached_st *memc)
4576 {
4577 uint32_t x;
4578 const char **ptr;
4579 (void)memc;
4580
4581 for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4582 {
4583 uint32_t hash_val;
4584
4585 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32);
4586 test_true(fnv1_32_values[x] == hash_val);
4587 }
4588
4589 return TEST_SUCCESS;
4590 }
4591
4592 static test_return_t fnv1a_32_run (memcached_st *memc)
4593 {
4594 uint32_t x;
4595 const char **ptr;
4596 (void)memc;
4597
4598 for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4599 {
4600 uint32_t hash_val;
4601
4602 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32);
4603 test_true(fnv1a_32_values[x] == hash_val);
4604 }
4605
4606 return TEST_SUCCESS;
4607 }
4608
4609 static test_return_t hsieh_run (memcached_st *memc)
4610 {
4611 uint32_t x;
4612 const char **ptr;
4613 (void)memc;
4614
4615 for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4616 {
4617 uint32_t hash_val;
4618
4619 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH);
4620 test_true(hsieh_values[x] == hash_val);
4621 }
4622
4623 return TEST_SUCCESS;
4624 }
4625
4626 static test_return_t murmur_run (memcached_st *memc)
4627 {
4628 #ifdef WORDS_BIGENDIAN
4629 (void)murmur_values;
4630 return TEST_SKIPPED;
4631 #else
4632 uint32_t x;
4633 const char **ptr;
4634 (void)memc;
4635
4636 for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4637 {
4638 uint32_t hash_val;
4639
4640 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR);
4641 test_true(murmur_values[x] == hash_val);
4642 }
4643
4644 return TEST_SUCCESS;
4645 #endif
4646 }
4647
4648 static test_return_t jenkins_run (memcached_st *memc)
4649 {
4650 uint32_t x;
4651 const char **ptr;
4652 (void)memc;
4653
4654 for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4655 {
4656 uint32_t hash_val;
4657
4658 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS);
4659 test_true(jenkins_values[x] == hash_val);
4660 }
4661
4662 return TEST_SUCCESS;
4663 }
4664
4665 static uint32_t hash_md5_test_function(const char *string, size_t string_length, void *context)
4666 {
4667 (void)context;
4668 return libhashkit_md5(string, string_length);
4669 }
4670
4671 static uint32_t hash_crc_test_function(const char *string, size_t string_length, void *context)
4672 {
4673 (void)context;
4674 return libhashkit_crc32(string, string_length);
4675 }
4676
4677 static test_return_t memcached_get_hashkit_test (memcached_st *memc)
4678 {
4679 uint32_t x;
4680 const char **ptr;
4681 const hashkit_st *kit;
4682 hashkit_st new_kit;
4683 hashkit_return_t hash_rc;
4684
4685 uint32_t md5_hosts[]= {4U, 1U, 0U, 1U, 4U, 2U, 0U, 3U, 0U, 0U, 3U, 1U, 0U, 0U, 1U, 3U, 0U, 0U, 0U, 3U, 1U, 0U, 4U, 4U, 3U};
4686 uint32_t crc_hosts[]= {2U, 4U, 1U, 0U, 2U, 4U, 4U, 4U, 1U, 2U, 3U, 4U, 3U, 4U, 1U, 3U, 3U, 2U, 0U, 0U, 0U, 1U, 2U, 4U, 0U};
4687
4688 kit= memcached_get_hashkit(memc);
4689
4690 hashkit_clone(&new_kit, kit);
4691 hash_rc= hashkit_set_custom_function(&new_kit, hash_md5_test_function, NULL);
4692 test_true(hash_rc == HASHKIT_SUCCESS);
4693
4694 memcached_set_hashkit(memc, &new_kit);
4695
4696 /*
4697 Verify Setting the hash.
4698 */
4699 for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4700 {
4701 uint32_t hash_val;
4702
4703 hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));
4704 test_true(md5_values[x] == hash_val);
4705 }
4706
4707
4708 /*
4709 Now check memcached_st.
4710 */
4711 for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4712 {
4713 uint32_t hash_val;
4714
4715 hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
4716 test_true(md5_hosts[x] == hash_val);
4717 }
4718
4719 hash_rc= hashkit_set_custom_function(&new_kit, hash_crc_test_function, NULL);
4720 test_true(hash_rc == HASHKIT_SUCCESS);
4721
4722 memcached_set_hashkit(memc, &new_kit);
4723
4724 /*
4725 Verify Setting the hash.
4726 */
4727 for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4728 {
4729 uint32_t hash_val;
4730
4731 hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));
4732 test_true(crc_values[x] == hash_val);
4733 }
4734
4735 for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4736 {
4737 uint32_t hash_val;
4738
4739 hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
4740 test_true(crc_hosts[x] == hash_val);
4741 }
4742
4743 return TEST_SUCCESS;
4744 }
4745
4746 /*
4747 Test case adapted from John Gorman <johngorman2@gmail.com>
4748
4749 We are testing the error condition when we connect to a server via memcached_get()
4750 but find that the server is not available.
4751 */
4752 static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc)
4753 {
4754 (void)memc;
4755 memcached_st *tl_memc_h;
4756 memcached_server_st *servers;
4757
4758 const char *key= "MemcachedLives";
4759 size_t len;
4760 uint32_t flags;
4761 memcached_return rc;
4762 char *value;
4763
4764 // Create a handle.
4765 tl_memc_h= memcached_create(NULL);
4766 servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4767 memcached_server_push(tl_memc_h, servers);
4768 memcached_server_list_free(servers);
4769
4770 // See if memcached is reachable.
4771 value= memcached_get(tl_memc_h, key, strlen(key), &len, &flags, &rc);
4772
4773 test_false(value);
4774 test_true(len == 0);
4775 test_false(rc == MEMCACHED_SUCCESS);
4776
4777 memcached_free(tl_memc_h);
4778
4779 return TEST_SUCCESS;
4780 }
4781
4782 /*
4783 We connect to a server which exists, but search for a key that does not exist.
4784 */
4785 static test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc)
4786 {
4787 const char *key= "MemcachedKeyNotEXIST";
4788 size_t len;
4789 uint32_t flags;
4790 memcached_return rc;
4791 char *value;
4792
4793 // See if memcached is reachable.
4794 value= memcached_get(memc, key, strlen(key), &len, &flags, &rc);
4795
4796 test_false(value);
4797 test_true(len == 0);
4798 test_true(rc == MEMCACHED_NOTFOUND);
4799
4800 return TEST_SUCCESS;
4801 }
4802
4803 /*
4804 Test case adapted from John Gorman <johngorman2@gmail.com>
4805
4806 We are testing the error condition when we connect to a server via memcached_get_by_key()
4807 but find that the server is not available.
4808 */
4809 static test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *memc)
4810 {
4811 (void)memc;
4812 memcached_st *tl_memc_h;
4813 memcached_server_st *servers;
4814
4815 const char *key= "MemcachedLives";
4816 size_t len;
4817 uint32_t flags;
4818 memcached_return rc;
4819 char *value;
4820
4821 // Create a handle.
4822 tl_memc_h= memcached_create(NULL);
4823 servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4824 memcached_server_push(tl_memc_h, servers);
4825 memcached_server_list_free(servers);
4826
4827 // See if memcached is reachable.
4828 value= memcached_get_by_key(tl_memc_h, key, strlen(key), key, strlen(key), &len, &flags, &rc);
4829
4830 test_false(value);
4831 test_true(len == 0);
4832 test_false(rc == MEMCACHED_SUCCESS);
4833
4834 memcached_free(tl_memc_h);
4835
4836 return TEST_SUCCESS;
4837 }
4838
4839 /*
4840 We connect to a server which exists, but search for a key that does not exist.
4841 */
4842 static test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc)
4843 {
4844 const char *key= "MemcachedKeyNotEXIST";
4845 size_t len;
4846 uint32_t flags;
4847 memcached_return rc;
4848 char *value;
4849
4850 // See if memcached is reachable.
4851 value= memcached_get_by_key(memc, key, strlen(key), key, strlen(key), &len, &flags, &rc);
4852
4853 test_false(value);
4854 test_true(len == 0);
4855 test_true(rc == MEMCACHED_NOTFOUND);
4856
4857 return TEST_SUCCESS;
4858 }
4859
4860
4861 static test_return_t ketama_compatibility_libmemcached(memcached_st *trash)
4862 {
4863 memcached_return_t rc;
4864 uint64_t value;
4865 int x;
4866 memcached_server_st *server_pool;
4867 memcached_st *memc;
4868
4869 (void)trash;
4870
4871 memc= memcached_create(NULL);
4872 test_true(memc);
4873
4874 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
4875 test_true(rc == MEMCACHED_SUCCESS);
4876
4877 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
4878 test_true(value == 1);
4879
4880 test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) == MEMCACHED_SUCCESS);
4881 test_true(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
4882
4883
4884 server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
4885 memcached_server_push(memc, server_pool);
4886
4887 /* verify that the server list was parsed okay. */
4888 test_true(memcached_server_count(memc) == 8);
4889 test_strcmp(server_pool[0].hostname, "10.0.1.1");
4890 test_true(server_pool[0].port == 11211);
4891 test_true(server_pool[0].weight == 600);
4892 test_strcmp(server_pool[2].hostname, "10.0.1.3");
4893 test_true(server_pool[2].port == 11211);
4894 test_true(server_pool[2].weight == 200);
4895 test_strcmp(server_pool[7].hostname, "10.0.1.8");
4896 test_true(server_pool[7].port == 11211);
4897 test_true(server_pool[7].weight == 100);
4898
4899 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
4900 * us test the boundary wraparound.
4901 */
4902 test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
4903
4904 /* verify the standard ketama set. */
4905 for (x= 0; x < 99; x++)
4906 {
4907 uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
4908 memcached_server_instance_st instance=
4909 memcached_server_instance_by_position(memc, server_idx);
4910 const char *hostname = memcached_server_name(instance);
4911
4912 test_strcmp(hostname, ketama_test_cases[x].server);
4913 }
4914
4915 memcached_server_list_free(server_pool);
4916 memcached_free(memc);
4917
4918 return TEST_SUCCESS;
4919 }
4920
4921 static test_return_t ketama_compatibility_spymemcached(memcached_st *trash)
4922 {
4923 memcached_return_t rc;
4924 uint64_t value;
4925 memcached_server_st *server_pool;
4926 memcached_st *memc;
4927
4928 (void)trash;
4929
4930 memc= memcached_create(NULL);
4931 test_true(memc);
4932
4933 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
4934 test_true(rc == MEMCACHED_SUCCESS);
4935
4936 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
4937 test_true(value == 1);
4938
4939 test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);
4940 test_true(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY);
4941
4942 server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
4943 assert(server_pool);
4944 memcached_server_push(memc, server_pool);
4945
4946 /* verify that the server list was parsed okay. */
4947 test_true(memcached_server_count(memc) == 8);
4948 test_strcmp(server_pool[0].hostname, "10.0.1.1");
4949 test_true(server_pool[0].port == 11211);
4950 test_true(server_pool[0].weight == 600);
4951 test_strcmp(server_pool[2].hostname, "10.0.1.3");
4952 test_true(server_pool[2].port == 11211);
4953 test_true(server_pool[2].weight == 200);
4954 test_strcmp(server_pool[7].hostname, "10.0.1.8");
4955 test_true(server_pool[7].port == 11211);
4956 test_true(server_pool[7].weight == 100);
4957
4958 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
4959 * us test the boundary wraparound.
4960 */
4961 test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
4962
4963 /* verify the standard ketama set. */
4964 for (uint32_t x= 0; x < 99; x++)
4965 {
4966 uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases_spy[x].key, strlen(ketama_test_cases_spy[x].key));
4967
4968 memcached_server_instance_st instance=
4969 memcached_server_instance_by_position(memc, server_idx);
4970
4971 const char *hostname= memcached_server_name(instance);
4972
4973 test_strcmp(hostname, ketama_test_cases_spy[x].server);
4974 }
4975
4976 memcached_server_list_free(server_pool);
4977 memcached_free(memc);
4978
4979 return TEST_SUCCESS;
4980 }
4981
4982 static test_return_t regression_bug_434484(memcached_st *memc)
4983 {
4984 test_return_t test_rc;
4985 test_rc= pre_binary(memc);
4986
4987 if (test_rc != TEST_SUCCESS)
4988 return test_rc;
4989
4990 const char *key= "regression_bug_434484";
4991 size_t keylen= strlen(key);
4992
4993 memcached_return_t ret= memcached_append(memc, key, keylen, key, keylen, 0, 0);
4994 test_true(ret == MEMCACHED_NOTSTORED);
4995
4996 size_t size= 2048 * 1024;
4997 char *data= (char*)calloc(1, size);
4998 test_true(data);
4999 ret= memcached_set(memc, key, keylen, data, size, 0, 0);
5000 test_true(ret == MEMCACHED_E2BIG);
5001 free(data);
5002
5003 return TEST_SUCCESS;
5004 }
5005
5006 static test_return_t regression_bug_434843(memcached_st *memc)
5007 {
5008 test_return_t test_rc;
5009 test_rc= pre_binary(memc);
5010
5011 if (test_rc != TEST_SUCCESS)
5012 return test_rc;
5013
5014 memcached_return_t rc;
5015 size_t counter= 0;
5016 memcached_execute_fn callbacks[]= { &callback_counter };
5017
5018 /*
5019 * I only want to hit only _one_ server so I know the number of requests I'm
5020 * sending in the pipleine to the server. Let's try to do a multiget of
5021 * 1024 (that should satisfy most users don't you think?). Future versions
5022 * will include a mget_execute function call if you need a higher number.
5023 */
5024 uint32_t number_of_hosts= memcached_server_count(memc);
5025 memc->number_of_hosts= 1;
5026 const size_t max_keys= 1024;
5027 char **keys= (char**)calloc(max_keys, sizeof(char*));
5028 size_t *key_length= (size_t *)calloc(max_keys, sizeof(size_t));
5029
5030 for (size_t x= 0; x < max_keys; ++x)
5031 {
5032 char k[251];
5033
5034 key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
5035 keys[x]= strdup(k);
5036 test_true(keys[x] != NULL);
5037 }
5038
5039 /*
5040 * Run two times.. the first time we should have 100% cache miss,
5041 * and the second time we should have 100% cache hits
5042 */
5043 for (size_t y= 0; y < 2; y++)
5044 {
5045 rc= memcached_mget(memc, (const char**)keys, key_length, max_keys);
5046 test_true(rc == MEMCACHED_SUCCESS);
5047 rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5048
5049 if (y == 0)
5050 {
5051 /* The first iteration should give me a 100% cache miss. verify that*/
5052 char blob[1024]= { 0 };
5053
5054 test_true(counter == 0);
5055
5056 for (size_t x= 0; x < max_keys; ++x)
5057 {
5058 rc= memcached_add(memc, keys[x], key_length[x],
5059 blob, sizeof(blob), 0, 0);
5060 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5061 }
5062 }
5063 else
5064 {
5065 /* Verify that we received all of the key/value pairs */
5066 test_true(counter == max_keys);
5067 }
5068 }
5069
5070 /* Release allocated resources */
5071 for (size_t x= 0; x < max_keys; ++x)
5072 {
5073 free(keys[x]);
5074 }
5075 free(keys);
5076 free(key_length);
5077
5078 memc->number_of_hosts= number_of_hosts;
5079
5080 return TEST_SUCCESS;
5081 }
5082
5083 static test_return_t regression_bug_434843_buffered(memcached_st *memc)
5084 {
5085 memcached_return_t rc;
5086 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
5087 test_true(rc == MEMCACHED_SUCCESS);
5088
5089 return regression_bug_434843(memc);
5090 }
5091
5092 static test_return_t regression_bug_421108(memcached_st *memc)
5093 {
5094 memcached_return_t rc;
5095 memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
5096 test_true(rc == MEMCACHED_SUCCESS);
5097
5098 char *bytes= memcached_stat_get_value(memc, memc_stat, "bytes", &rc);
5099 test_true(rc == MEMCACHED_SUCCESS);
5100 test_true(bytes != NULL);
5101 char *bytes_read= memcached_stat_get_value(memc, memc_stat,
5102 "bytes_read", &rc);
5103 test_true(rc == MEMCACHED_SUCCESS);
5104 test_true(bytes_read != NULL);
5105
5106 char *bytes_written= memcached_stat_get_value(memc, memc_stat,
5107 "bytes_written", &rc);
5108 test_true(rc == MEMCACHED_SUCCESS);
5109 test_true(bytes_written != NULL);
5110
5111 test_true(strcmp(bytes, bytes_read) != 0);
5112 test_true(strcmp(bytes, bytes_written) != 0);
5113
5114 /* Release allocated resources */
5115 free(bytes);
5116 free(bytes_read);
5117 free(bytes_written);
5118 memcached_stat_free(NULL, memc_stat);
5119
5120 return TEST_SUCCESS;
5121 }
5122
5123 /*
5124 * The test case isn't obvious so I should probably document why
5125 * it works the way it does. Bug 442914 was caused by a bug
5126 * in the logic in memcached_purge (it did not handle the case
5127 * where the number of bytes sent was equal to the watermark).
5128 * In this test case, create messages so that we hit that case
5129 * and then disable noreply mode and issue a new command to
5130 * verify that it isn't stuck. If we change the format for the
5131 * delete command or the watermarks, we need to update this
5132 * test....
5133 */
5134 static test_return_t regression_bug_442914(memcached_st *memc)
5135 {
5136 memcached_return_t rc;
5137 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
5138 test_true(rc == MEMCACHED_SUCCESS);
5139 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
5140
5141 uint32_t number_of_hosts= memcached_server_count(memc);
5142 memc->number_of_hosts= 1;
5143
5144 char k[250];
5145 size_t len;
5146
5147 for (uint32_t x= 0; x < 250; ++x)
5148 {
5149 len= (size_t)snprintf(k, sizeof(k), "%0250u", x);
5150 rc= memcached_delete(memc, k, len, 0);
5151 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5152 }
5153
5154 (void)snprintf(k, sizeof(k), "%037u", 251U);
5155 len= strlen(k);
5156
5157 rc= memcached_delete(memc, k, len, 0);
5158 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5159
5160 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0);
5161 test_true(rc == MEMCACHED_SUCCESS);
5162 rc= memcached_delete(memc, k, len, 0);
5163 test_true(rc == MEMCACHED_NOTFOUND);
5164
5165 memc->number_of_hosts= number_of_hosts;
5166
5167 return TEST_SUCCESS;
5168 }
5169
5170 static test_return_t regression_bug_447342(memcached_st *memc)
5171 {
5172 memcached_server_instance_st instance_one;
5173 memcached_server_instance_st instance_two;
5174
5175 if (memcached_server_count(memc) < 3 || pre_replication(memc) != TEST_SUCCESS)
5176 return TEST_SKIPPED;
5177
5178 memcached_return_t rc;
5179
5180 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 2);
5181 test_true(rc == MEMCACHED_SUCCESS);
5182
5183 const size_t max_keys= 100;
5184 char **keys= (char**)calloc(max_keys, sizeof(char*));
5185 size_t *key_length= (size_t *)calloc(max_keys, sizeof(size_t));
5186
5187 for (size_t x= 0; x < max_keys; ++x)
5188 {
5189 char k[251];
5190
5191 key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
5192 keys[x]= strdup(k);
5193 test_true(keys[x] != NULL);
5194 rc= memcached_set(memc, k, key_length[x], k, key_length[x], 0, 0);
5195 test_true(rc == MEMCACHED_SUCCESS);
5196 }
5197
5198 /*
5199 ** We are using the quiet commands to store the replicas, so we need
5200 ** to ensure that all of them are processed before we can continue.
5201 ** In the test we go directly from storing the object to trying to
5202 ** receive the object from all of the different servers, so we
5203 ** could end up in a race condition (the memcached server hasn't yet
5204 ** processed the quiet command from the replication set when it process
5205 ** the request from the other client (created by the clone)). As a
5206 ** workaround for that we call memcached_quit to send the quit command
5207 ** to the server and wait for the response ;-) If you use the test code
5208 ** as an example for your own code, please note that you shouldn't need
5209 ** to do this ;-)
5210 */
5211 memcached_quit(memc);
5212
5213 /* Verify that all messages are stored, and we didn't stuff too much
5214 * into the servers
5215 */
5216 rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
5217 test_true(rc == MEMCACHED_SUCCESS);
5218
5219 size_t counter= 0;
5220 memcached_execute_fn callbacks[]= { &callback_counter };
5221 rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5222 /* Verify that we received all of the key/value pairs */
5223 test_true(counter == max_keys);
5224
5225 memcached_quit(memc);
5226 /*
5227 * Don't do the following in your code. I am abusing the internal details
5228 * within the library, and this is not a supported interface.
5229 * This is to verify correct behavior in the library. Fake that two servers
5230 * are dead..
5231 */
5232 instance_one= memcached_server_instance_by_position(memc, 0);
5233 instance_two= memcached_server_instance_by_position(memc, 2);
5234 in_port_t port0= instance_one->port;
5235 in_port_t port2= instance_two->port;
5236
5237 ((memcached_server_write_instance_st)instance_one)->port= 0;
5238 ((memcached_server_write_instance_st)instance_two)->port= 0;
5239
5240 rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
5241 test_true(rc == MEMCACHED_SUCCESS);
5242
5243 counter= 0;
5244 rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5245 test_true(counter == (unsigned int)max_keys);
5246
5247 /* restore the memc handle */
5248 ((memcached_server_write_instance_st)instance_one)->port= port0;
5249 ((memcached_server_write_instance_st)instance_two)->port= port2;
5250
5251 memcached_quit(memc);
5252
5253 /* Remove half of the objects */
5254 for (size_t x= 0; x < max_keys; ++x)
5255 {
5256 if (x & 1)
5257 {
5258 rc= memcached_delete(memc, keys[x], key_length[x], 0);
5259 test_true(rc == MEMCACHED_SUCCESS);
5260 }
5261 }
5262
5263 memcached_quit(memc);
5264 ((memcached_server_write_instance_st)instance_one)->port= 0;
5265 ((memcached_server_write_instance_st)instance_two)->port= 0;
5266
5267 /* now retry the command, this time we should have cache misses */
5268 rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
5269 test_true(rc == MEMCACHED_SUCCESS);
5270
5271 counter= 0;
5272 rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5273 test_true(counter == (unsigned int)(max_keys >> 1));
5274
5275 /* Release allocated resources */
5276 for (size_t x= 0; x < max_keys; ++x)
5277 {
5278 free(keys[x]);
5279 }
5280 free(keys);
5281 free(key_length);
5282
5283 /* restore the memc handle */
5284 ((memcached_server_write_instance_st)instance_one)->port= port0;
5285 ((memcached_server_write_instance_st)instance_two)->port= port2;
5286
5287 return TEST_SUCCESS;
5288 }
5289
5290 static test_return_t regression_bug_463297(memcached_st *memc)
5291 {
5292 memcached_st *memc_clone= memcached_clone(NULL, memc);
5293 test_true(memc_clone != NULL);
5294 test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
5295
5296 memcached_server_instance_st instance=
5297 memcached_server_instance_by_position(memc_clone, 0);
5298
5299 if (instance->major_version > 1 ||
5300 (instance->major_version == 1 &&
5301 instance->minor_version > 2))
5302 {
5303 /* Binary protocol doesn't support deferred delete */
5304 memcached_st *bin_clone= memcached_clone(NULL, memc);
5305 test_true(bin_clone != NULL);
5306 test_true(memcached_behavior_set(bin_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1) == MEMCACHED_SUCCESS);
5307 test_true(memcached_delete(bin_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
5308 memcached_free(bin_clone);
5309
5310 memcached_quit(memc_clone);
5311
5312 /* If we know the server version, deferred delete should fail
5313 * with invalid arguments */
5314 test_true(memcached_delete(memc_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
5315
5316 /* If we don't know the server version, we should get a protocol error */
5317 memcached_return_t rc= memcached_delete(memc, "foo", 3, 1);
5318
5319 /* but there is a bug in some of the memcached servers (1.4) that treats
5320 * the counter as noreply so it doesn't send the proper error message
5321 */
5322 test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
5323
5324 /* And buffered mode should be disabled and we should get protocol error */
5325 test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS);
5326 rc= memcached_delete(memc, "foo", 3, 1);
5327 test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
5328
5329 /* Same goes for noreply... */
5330 test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1) == MEMCACHED_SUCCESS);
5331 rc= memcached_delete(memc, "foo", 3, 1);
5332 test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
5333
5334 /* but a normal request should go through (and be buffered) */
5335 test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_BUFFERED);
5336 test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
5337
5338 test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0) == MEMCACHED_SUCCESS);
5339 /* unbuffered noreply should be success */
5340 test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_SUCCESS);
5341 /* unbuffered with reply should be not found... */
5342 test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0) == MEMCACHED_SUCCESS);
5343 test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_NOTFOUND);
5344 }
5345
5346 memcached_free(memc_clone);
5347 return TEST_SUCCESS;
5348 }
5349
5350
5351 /* Test memcached_server_get_last_disconnect
5352 * For a working server set, shall be NULL
5353 * For a set of non existing server, shall not be NULL
5354 */
5355 static test_return_t test_get_last_disconnect(memcached_st *memc)
5356 {
5357 memcached_return_t rc;
5358 memcached_server_instance_st disconnected_server;
5359
5360 /* With the working set of server */
5361 const char *key= "marmotte";
5362 const char *value= "milka";
5363
5364 memcached_reset_last_disconnected_server(memc);
5365 rc= memcached_set(memc, key, strlen(key),
5366 value, strlen(value),
5367 (time_t)0, (uint32_t)0);
5368 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5369
5370 disconnected_server = memcached_server_get_last_disconnect(memc);
5371 test_true(disconnected_server == NULL);
5372
5373 /* With a non existing server */
5374 memcached_st *mine;
5375 memcached_server_st *servers;
5376
5377 const char *server_list= "localhost:9";
5378
5379 servers= memcached_servers_parse(server_list);
5380 test_true(servers);
5381 mine= memcached_create(NULL);
5382 rc= memcached_server_push(mine, servers);
5383 test_true(rc == MEMCACHED_SUCCESS);
5384 memcached_server_list_free(servers);
5385 test_true(mine);
5386
5387 rc= memcached_set(mine, key, strlen(key),
5388 value, strlen(value),
5389 (time_t)0, (uint32_t)0);
5390 test_true(rc != MEMCACHED_SUCCESS);
5391
5392 disconnected_server= memcached_server_get_last_disconnect(mine);
5393 if (disconnected_server == NULL)
5394 {
5395 fprintf(stderr, "RC %s\n", memcached_strerror(mine, rc));
5396 abort();
5397 }
5398 test_true(disconnected_server != NULL);
5399 test_true(memcached_server_port(disconnected_server)== 9);
5400 test_true(strncmp(memcached_server_name(disconnected_server),"localhost",9) == 0);
5401
5402 memcached_quit(mine);
5403 memcached_free(mine);
5404
5405 return TEST_SUCCESS;
5406 }
5407
5408 static test_return_t test_verbosity(memcached_st *memc)
5409 {
5410 memcached_verbosity(memc, 3);
5411
5412 return TEST_SUCCESS;
5413 }
5414
5415 static test_return_t test_server_failure(memcached_st *memc)
5416 {
5417 memcached_st *local_memc;
5418 memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0);
5419
5420 local_memc= memcached_create(NULL);
5421
5422 memcached_server_add(local_memc, memcached_server_name(instance), memcached_server_port(instance));
5423 memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 2);
5424
5425 uint32_t server_count= memcached_server_count(local_memc);
5426
5427 test_true(server_count == 1);
5428
5429 // Disable the server
5430 instance= memcached_server_instance_by_position(local_memc, 0);
5431 ((memcached_server_write_instance_st)instance)->server_failure_counter= 2;
5432
5433 memcached_return_t rc;
5434 rc= memcached_set(local_memc, "foo", strlen("foo"),
5435 NULL, 0,
5436 (time_t)0, (uint32_t)0);
5437 test_true(rc == MEMCACHED_SERVER_MARKED_DEAD);
5438
5439 ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
5440 rc= memcached_set(local_memc, "foo", strlen("foo"),
5441 NULL, 0,
5442 (time_t)0, (uint32_t)0);
5443 test_true(rc == MEMCACHED_SUCCESS);
5444
5445
5446 memcached_free(local_memc);
5447
5448 return TEST_SUCCESS;
5449 }
5450
5451 static test_return_t test_cull_servers(memcached_st *memc)
5452 {
5453 uint32_t count = memcached_server_count(memc);
5454
5455 // Do not do this in your code, it is not supported.
5456 memc->servers[1].options.is_dead= true;
5457 memc->state.is_time_for_rebuild= true;
5458
5459 uint32_t new_count= memcached_server_count(memc);
5460 test_true(count == new_count);
5461
5462 #if 0
5463 test_true(count == new_count + 1 );
5464 #endif
5465
5466 return TEST_SUCCESS;
5467 }
5468
5469
5470 static memcached_return_t stat_printer(memcached_server_instance_st server,
5471 const char *key, size_t key_length,
5472 const char *value, size_t value_length,
5473 void *context)
5474 {
5475 (void)server;
5476 (void)context;
5477 (void)key;
5478 (void)key_length;
5479 (void)value;
5480 (void)value_length;
5481
5482 return MEMCACHED_SUCCESS;
5483 }
5484
5485 static test_return_t memcached_stat_execute_test(memcached_st *memc)
5486 {
5487 memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL);
5488 test_true(rc == MEMCACHED_SUCCESS);
5489
5490 rc= memcached_stat_execute(memc, "slabs", stat_printer, NULL);
5491 test_true(rc == MEMCACHED_SUCCESS);
5492
5493 rc= memcached_stat_execute(memc, "items", stat_printer, NULL);
5494 test_true(rc == MEMCACHED_SUCCESS);
5495
5496 rc= memcached_stat_execute(memc, "sizes", stat_printer, NULL);
5497 test_true(rc == MEMCACHED_SUCCESS);
5498
5499 return TEST_SUCCESS;
5500 }
5501
5502 /*
5503 * This test ensures that the failure counter isn't incremented during
5504 * normal termination of the memcached instance.
5505 */
5506 static test_return_t wrong_failure_counter_test(memcached_st *memc)
5507 {
5508 memcached_return_t rc;
5509 memcached_server_instance_st instance;
5510
5511 /* Set value to force connection to the server */
5512 const char *key= "marmotte";
5513 const char *value= "milka";
5514
5515 /*
5516 * Please note that I'm abusing the internal structures in libmemcached
5517 * in a non-portable way and you shouldn't be doing this. I'm only
5518 * doing this in order to verify that the library works the way it should
5519 */
5520 uint32_t number_of_hosts= memcached_server_count(memc);
5521 memc->number_of_hosts= 1;
5522
5523 /* Ensure that we are connected to the server by setting a value */
5524 rc= memcached_set(memc, key, strlen(key),
5525 value, strlen(value),
5526 (time_t)0, (uint32_t)0);
5527 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5528
5529
5530 instance= memcached_server_instance_by_position(memc, 0);
5531 /* The test is to see that the memcached_quit doesn't increase the
5532 * the server failure conter, so let's ensure that it is zero
5533 * before sending quit
5534 */
5535 ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
5536
5537 memcached_quit(memc);
5538
5539 /* Verify that it memcached_quit didn't increment the failure counter
5540 * Please note that this isn't bullet proof, because an error could
5541 * occur...
5542 */
5543 test_true(instance->server_failure_counter == 0);
5544
5545 /* restore the instance */
5546 memc->number_of_hosts= number_of_hosts;
5547
5548 return TEST_SUCCESS;
5549 }
5550
5551 /*
5552 * This tests ensures expected disconnections (for some behavior changes
5553 * for instance) do not wrongly increase failure counter
5554 */
5555 static test_return_t wrong_failure_counter_two_test(memcached_st *memc)
5556 {
5557 memcached_return rc;
5558
5559 memcached_st *memc_clone;
5560 memc_clone= memcached_clone(NULL, memc);
5561 test_true(memc_clone);
5562
5563 /* Set value to force connection to the server */
5564 const char *key= "marmotte";
5565 const char *value= "milka";
5566 char *string = NULL;
5567 size_t string_length;
5568 uint32_t flags;
5569
5570 rc= memcached_set(memc_clone, key, strlen(key),
5571 value, strlen(value),
5572 (time_t)0, (uint32_t)0);
5573 test_true_got(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
5574
5575
5576 /* put failure limit to 1 */
5577 rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 1);
5578 assert(rc == MEMCACHED_SUCCESS);
5579
5580 /* Put a retry timeout to effectively activate failure_limit effect */
5581 rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1);
5582 assert(rc == MEMCACHED_SUCCESS);
5583
5584 /* change behavior that triggers memcached_quit()*/
5585 rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
5586 assert(rc == MEMCACHED_SUCCESS);
5587
5588
5589 /* Check if we still are connected */
5590 string= memcached_get(memc_clone, key, strlen(key),
5591 &string_length, &flags, &rc);
5592
5593 test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
5594 test_true(string);
5595 free(string);
5596 memcached_free(memc_clone);
5597
5598 return TEST_SUCCESS;
5599 }
5600
5601
5602
5603
5604 /*
5605 * Test that ensures mget_execute does not end into recursive calls that finally fails
5606 */
5607 static test_return_t regression_bug_490486(memcached_st *memc)
5608 {
5609 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
5610 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
5611 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
5612 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 1);
5613 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 3600);
5614
5615 #ifdef __APPLE__
5616 return TEST_SKIPPED; // My MAC can't handle this test
5617 #endif
5618
5619 /*
5620 * I only want to hit _one_ server so I know the number of requests I'm
5621 * sending in the pipeline.
5622 */
5623 uint32_t number_of_hosts= memc->number_of_hosts;
5624 memc->number_of_hosts= 1;
5625 size_t max_keys= 20480;
5626
5627
5628 char **keys= (char **)calloc(max_keys, sizeof(char*));
5629 size_t *key_length= (size_t *)calloc(max_keys, sizeof(size_t));
5630
5631 /* First add all of the items.. */
5632 bool slept= false;
5633 char blob[1024]= { 0 };
5634 memcached_return rc;
5635 for (size_t x= 0; x < max_keys; ++x)
5636 {
5637 char k[251];
5638 key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
5639 keys[x]= strdup(k);
5640 assert(keys[x] != NULL);
5641 rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
5642 #ifdef __APPLE__
5643 if (rc == MEMCACHED_SERVER_MARKED_DEAD)
5644 {
5645 break; // We are out of business
5646 }
5647 #endif
5648 test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT); // MEMCACHED_TIMEOUT <-- only observed on OSX
5649
5650 if (rc == MEMCACHED_TIMEOUT && slept == false)
5651 {
5652 x++;
5653 sleep(1);// We will try to sleep
5654 slept= true;
5655 }
5656 else if (rc == MEMCACHED_TIMEOUT && slept == true)
5657 {
5658 // We failed to send everything.
5659 break;
5660 }
5661 }
5662
5663 if (rc != MEMCACHED_SERVER_MARKED_DEAD)
5664 {
5665
5666 /* Try to get all of them with a large multiget */
5667 size_t counter= 0;
5668 memcached_execute_function callbacks[]= { &callback_counter };
5669 rc= memcached_mget_execute(memc, (const char**)keys, key_length,
5670 (size_t)max_keys, callbacks, &counter, 1);
5671
5672 assert(rc == MEMCACHED_SUCCESS);
5673 char* the_value= NULL;
5674 char the_key[MEMCACHED_MAX_KEY];
5675 size_t the_key_length;
5676 size_t the_value_length;
5677 uint32_t the_flags;
5678
5679 do {
5680 the_value= memcached_fetch(memc, the_key, &the_key_length, &the_value_length, &the_flags, &rc);
5681
5682 if ((the_value!= NULL) && (rc == MEMCACHED_SUCCESS))
5683 {
5684 ++counter;
5685 free(the_value);
5686 }
5687
5688 } while ( (the_value!= NULL) && (rc == MEMCACHED_SUCCESS));
5689
5690
5691 assert(rc == MEMCACHED_END);
5692
5693 /* Verify that we got all of the items */
5694 assert(counter == max_keys);
5695 }
5696
5697 /* Release all allocated resources */
5698 for (size_t x= 0; x < max_keys; ++x)
5699 {
5700 free(keys[x]);
5701 }
5702 free(keys);
5703 free(key_length);
5704
5705 memc->number_of_hosts= number_of_hosts;
5706
5707 return TEST_SUCCESS;
5708 }
5709
5710 static test_return_t regression_bug_583031(memcached_st *)
5711 {
5712 memcached_st *memc= memcached_create(NULL);
5713 test_true(memc);
5714 test_true(memcached_success(memcached_server_add(memc, "10.2.3.4", 11211)));
5715
5716 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 1000);
5717 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);
5718 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
5719 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
5720 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
5721 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3);
5722
5723 memcached_return_t rc;
5724 size_t length;
5725 uint32_t flags;
5726
5727 const char *value= memcached_get(memc, "dsf", 3, &length, &flags, &rc);
5728 test_false(value);
5729 test_compare(0, length);
5730
5731 test_true_got(rc == MEMCACHED_TIMEOUT || rc == MEMCACHED_ERRNO || rc == MEMCACHED_FAILURE, memcached_strerror(memc, rc));
5732
5733 memcached_free(memc);
5734
5735 return TEST_SUCCESS;
5736 }
5737
5738 static test_return_t regression_bug_581030(memcached_st *)
5739 {
5740 #ifndef DEBUG
5741 memcached_stat_st *local_stat= memcached_stat(NULL, NULL, NULL);
5742 test_false(local_stat);
5743
5744 memcached_stat_free(NULL, NULL);
5745 #endif
5746
5747 return TEST_SUCCESS;
5748 }
5749
5750 static void memcached_die(memcached_st* mc, memcached_return error, const char* what, uint32_t it)
5751 {
5752 fprintf(stderr, "Iteration #%u: ", it);
5753
5754 if(error == MEMCACHED_ERRNO)
5755 {
5756 fprintf(stderr, "system error %d from %s: %s\n",
5757 errno, what, strerror(errno));
5758 }
5759 else
5760 {
5761 fprintf(stderr, "error %d from %s: %s\n", error, what,
5762 memcached_strerror(mc, error));
5763 }
5764 }
5765
5766 #define TEST_CONSTANT_CREATION 200
5767
5768 static test_return_t regression_bug_(memcached_st *memc)
5769 {
5770 const char *remote_server;
5771 (void)memc;
5772
5773 if (! (remote_server= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5774 {
5775 return TEST_SKIPPED;
5776 }
5777
5778 for (uint32_t x= 0; x < TEST_CONSTANT_CREATION; x++)
5779 {
5780 memcached_st* mc= memcached_create(NULL);
5781 memcached_return rc;
5782
5783 rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
5784 if (rc != MEMCACHED_SUCCESS)
5785 {
5786 memcached_die(mc, rc, "memcached_behavior_set", x);
5787 }
5788
5789 rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS, 1);
5790 if (rc != MEMCACHED_SUCCESS)
5791 {
5792 memcached_die(mc, rc, "memcached_behavior_set", x);
5793 }
5794
5795 rc= memcached_server_add(mc, remote_server, 0);
5796 if (rc != MEMCACHED_SUCCESS)
5797 {
5798 memcached_die(mc, rc, "memcached_server_add", x);
5799 }
5800
5801 const char *set_key= "akey";
5802 const size_t set_key_len= strlen(set_key);
5803 const char *set_value= "a value";
5804 const size_t set_value_len= strlen(set_value);
5805
5806 if (rc == MEMCACHED_SUCCESS)
5807 {
5808 if (x > 0)
5809 {
5810 size_t get_value_len;
5811 char *get_value;
5812 uint32_t get_value_flags;
5813
5814 get_value= memcached_get(mc, set_key, set_key_len, &get_value_len,
5815 &get_value_flags, &rc);
5816 if (rc != MEMCACHED_SUCCESS)
5817 {
5818 memcached_die(mc, rc, "memcached_get", x);
5819 }
5820 else
5821 {
5822
5823 if (x != 0 &&
5824 (get_value_len != set_value_len
5825 || 0!=strncmp(get_value, set_value, get_value_len)))
5826 {
5827 fprintf(stderr, "Values don't match?\n");
5828 rc= MEMCACHED_FAILURE;
5829 }
5830 free(get_value);
5831 }
5832 }
5833
5834 rc= memcached_set(mc,
5835 set_key, set_key_len,
5836 set_value, set_value_len,
5837 0, /* time */
5838 0 /* flags */
5839 );
5840 if (rc != MEMCACHED_SUCCESS)
5841 {
5842 memcached_die(mc, rc, "memcached_set", x);
5843 }
5844 }
5845
5846 memcached_quit(mc);
5847 memcached_free(mc);
5848
5849 if (rc != MEMCACHED_SUCCESS)
5850 {
5851 break;
5852 }
5853 }
5854
5855 return TEST_SUCCESS;
5856 }
5857
5858 /*
5859 * Test that the sasl authentication works. We cannot use the default
5860 * pool of servers, because that would require that all servers we want
5861 * to test supports SASL authentication, and that they use the default
5862 * creds.
5863 */
5864 static test_return_t sasl_auth_test(memcached_st *memc)
5865 {
5866 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
5867 memcached_return_t rc;
5868
5869 rc= memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
5870 test_true(rc == MEMCACHED_SUCCESS);
5871 test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_SUCCESS);
5872 test_true((rc= memcached_destroy_sasl_auth_data(memc)) == MEMCACHED_SUCCESS);
5873 test_true((rc= memcached_destroy_sasl_auth_data(memc)) == MEMCACHED_FAILURE);
5874 test_true((rc= memcached_destroy_sasl_auth_data(NULL)) == MEMCACHED_FAILURE);
5875 memcached_quit(memc);
5876
5877 rc= memcached_set_sasl_auth_data(memc,
5878 getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
5879 getenv("LIBMEMCACHED_TEST_SASL_SERVER"));
5880 test_true(rc == MEMCACHED_SUCCESS);
5881
5882 rc= memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
5883 test_true(rc == MEMCACHED_AUTH_FAILURE);
5884 test_true(memcached_destroy_sasl_auth_data(memc) == MEMCACHED_SUCCESS);
5885
5886 memcached_quit(memc);
5887 return TEST_SUCCESS;
5888 #else
5889 (void)memc;
5890 return TEST_FAILURE;
5891 #endif
5892 }
5893
5894 /* Clean the server before beginning testing */
5895 test_st tests[] ={
5896 {"util_version", 1, (test_callback_fn)util_version_test },
5897 {"flush", 0, (test_callback_fn)flush_test },
5898 {"init", 0, (test_callback_fn)init_test },
5899 {"allocation", 0, (test_callback_fn)allocation_test },
5900 {"server_list_null_test", 0, (test_callback_fn)server_list_null_test},
5901 {"server_unsort", 0, (test_callback_fn)server_unsort_test},
5902 {"server_sort", 0, (test_callback_fn)server_sort_test},
5903 {"server_sort2", 0, (test_callback_fn)server_sort2_test},
5904 {"memcached_server_remove", 0, (test_callback_fn)memcached_server_remove_test},
5905 {"clone_test", 0, (test_callback_fn)clone_test },
5906 {"connection_test", 0, (test_callback_fn)connection_test},
5907 {"callback_test", 0, (test_callback_fn)callback_test},
5908 {"userdata_test", 0, (test_callback_fn)userdata_test},
5909 {"error", 0, (test_callback_fn)error_test },
5910 {"set", 0, (test_callback_fn)set_test },
5911 {"set2", 0, (test_callback_fn)set_test2 },
5912 {"set3", 0, (test_callback_fn)set_test3 },
5913 {"dump", 1, (test_callback_fn)dump_test},
5914 {"add", 1, (test_callback_fn)add_test },
5915 {"replace", 1, (test_callback_fn)replace_test },
5916 {"delete", 1, (test_callback_fn)delete_test },
5917 {"get", 1, (test_callback_fn)get_test },
5918 {"get2", 0, (test_callback_fn)get_test2 },
5919 {"get3", 0, (test_callback_fn)get_test3 },
5920 {"get4", 0, (test_callback_fn)get_test4 },
5921 {"partial mget", 0, (test_callback_fn)get_test5 },
5922 {"stats_servername", 0, (test_callback_fn)stats_servername_test },
5923 {"increment", 0, (test_callback_fn)increment_test },
5924 {"increment_with_initial", 1, (test_callback_fn)increment_with_initial_test },
5925 {"decrement", 0, (test_callback_fn)decrement_test },
5926 {"decrement_with_initial", 1, (test_callback_fn)decrement_with_initial_test },
5927 {"increment_by_key", 0, (test_callback_fn)increment_by_key_test },
5928 {"increment_with_initial_by_key", 1, (test_callback_fn)increment_with_initial_by_key_test },
5929 {"decrement_by_key", 0, (test_callback_fn)decrement_by_key_test },
5930 {"decrement_with_initial_by_key", 1, (test_callback_fn)decrement_with_initial_by_key_test },
5931 {"quit", 0, (test_callback_fn)quit_test },
5932 {"mget", 1, (test_callback_fn)mget_test },
5933 {"mget_result", 1, (test_callback_fn)mget_result_test },
5934 {"mget_result_alloc", 1, (test_callback_fn)mget_result_alloc_test },
5935 {"mget_result_function", 1, (test_callback_fn)mget_result_function },
5936 {"mget_execute", 1, (test_callback_fn)mget_execute },
5937 {"mget_end", 0, (test_callback_fn)mget_end },
5938 {"get_stats", 0, (test_callback_fn)get_stats },
5939 {"add_host_test", 0, (test_callback_fn)add_host_test },
5940 {"add_host_test_1", 0, (test_callback_fn)add_host_test1 },
5941 {"get_stats_keys", 0, (test_callback_fn)get_stats_keys },
5942 {"version_string_test", 0, (test_callback_fn)version_string_test},
5943 {"bad_key", 1, (test_callback_fn)bad_key_test },
5944 {"memcached_server_cursor", 1, (test_callback_fn)memcached_server_cursor_test },
5945 {"read_through", 1, (test_callback_fn)read_through },
5946 {"delete_through", 1, (test_callback_fn)delete_through },
5947 {"noreply", 1, (test_callback_fn)noreply_test},
5948 {"analyzer", 1, (test_callback_fn)analyzer_test},
5949 {"connectionpool", 1, (test_callback_fn)connection_pool_test },
5950 {"memcached_pool_test", 1, (test_callback_fn)memcached_pool_test },
5951 {"ping", 1, (test_callback_fn)ping_test },
5952 {"test_get_last_disconnect", 1, (test_callback_fn)test_get_last_disconnect},
5953 {"verbosity", 1, (test_callback_fn)test_verbosity},
5954 {"test_server_failure", 1, (test_callback_fn)test_server_failure},
5955 {"cull_servers", 1, (test_callback_fn)test_cull_servers},
5956 {"memcached_stat_execute", 1, (test_callback_fn)memcached_stat_execute_test},
5957 {0, 0, 0}
5958 };
5959
5960 test_st behavior_tests[] ={
5961 {"behavior_test", 0, (test_callback_fn)behavior_test},
5962 {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_CORK_test},
5963 {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test},
5964 {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test},
5965 {0, 0, 0}
5966 };
5967
5968 test_st basic_tests[] ={
5969 {"init", 1, (test_callback_fn)basic_init_test},
5970 {"clone", 1, (test_callback_fn)basic_clone_test},
5971 {"reset", 1, (test_callback_fn)basic_reset_stack_test},
5972 {"reset heap", 1, (test_callback_fn)basic_reset_heap_test},
5973 {"reset stack clone", 1, (test_callback_fn)basic_reset_stack_clone_test},
5974 {"reset heap clone", 1, (test_callback_fn)basic_reset_heap_clone_test},
5975 {0, 0, 0}
5976 };
5977
5978 test_st regression_binary_vs_block[] ={
5979 {"block add", 1, (test_callback_fn)block_add_regression},
5980 {"binary add", 1, (test_callback_fn)binary_add_regression},
5981 {0, 0, 0}
5982 };
5983
5984 test_st async_tests[] ={
5985 {"add", 1, (test_callback_fn)add_wrapper },
5986 {0, 0, 0}
5987 };
5988
5989 test_st string_tests[] ={
5990 {"string static with null", 0, (test_callback_fn)string_static_null },
5991 {"string alloc with null", 0, (test_callback_fn)string_alloc_null },
5992 {"string alloc with 1K", 0, (test_callback_fn)string_alloc_with_size },
5993 {"string alloc with malloc failure", 0, (test_callback_fn)string_alloc_with_size_toobig },
5994 {"string append", 0, (test_callback_fn)string_alloc_append },
5995 {"string append failure (too big)", 0, (test_callback_fn)string_alloc_append_toobig },
5996 {"string_alloc_append_multiple", 0, (test_callback_fn)string_alloc_append_multiple },
5997 {0, 0, (test_callback_fn)0}
5998 };
5999
6000 test_st result_tests[] ={
6001 {"result static", 0, (test_callback_fn)result_static},
6002 {"result alloc", 0, (test_callback_fn)result_alloc},
6003 {0, 0, (test_callback_fn)0}
6004 };
6005
6006 test_st version_1_2_3[] ={
6007 {"append", 0, (test_callback_fn)append_test },
6008 {"prepend", 0, (test_callback_fn)prepend_test },
6009 {"cas", 0, (test_callback_fn)cas_test },
6010 {"cas2", 0, (test_callback_fn)cas2_test },
6011 {"append_binary", 0, (test_callback_fn)append_binary_test },
6012 {0, 0, (test_callback_fn)0}
6013 };
6014
6015 test_st user_tests[] ={
6016 {"user_supplied_bug1", 0, (test_callback_fn)user_supplied_bug1 },
6017 {"user_supplied_bug2", 0, (test_callback_fn)user_supplied_bug2 },
6018 {"user_supplied_bug3", 0, (test_callback_fn)user_supplied_bug3 },
6019 {"user_supplied_bug4", 0, (test_callback_fn)user_supplied_bug4 },
6020 {"user_supplied_bug5", 1, (test_callback_fn)user_supplied_bug5 },
6021 {"user_supplied_bug6", 1, (test_callback_fn)user_supplied_bug6 },
6022 {"user_supplied_bug7", 1, (test_callback_fn)user_supplied_bug7 },
6023 {"user_supplied_bug8", 1, (test_callback_fn)user_supplied_bug8 },
6024 {"user_supplied_bug9", 1, (test_callback_fn)user_supplied_bug9 },
6025 {"user_supplied_bug10", 1, (test_callback_fn)user_supplied_bug10 },
6026 {"user_supplied_bug11", 1, (test_callback_fn)user_supplied_bug11 },
6027 {"user_supplied_bug12", 1, (test_callback_fn)user_supplied_bug12 },
6028 {"user_supplied_bug13", 1, (test_callback_fn)user_supplied_bug13 },
6029 {"user_supplied_bug14", 1, (test_callback_fn)user_supplied_bug14 },
6030 {"user_supplied_bug15", 1, (test_callback_fn)user_supplied_bug15 },
6031 {"user_supplied_bug16", 1, (test_callback_fn)user_supplied_bug16 },
6032 #if !defined(__sun) && !defined(__OpenBSD__)
6033 /*
6034 ** It seems to be something weird with the character sets..
6035 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6036 ** guess I need to find out how this is supposed to work.. Perhaps I need
6037 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6038 ** so just disable the code for now...).
6039 */
6040 {"user_supplied_bug17", 1, (test_callback_fn)user_supplied_bug17 },
6041 #endif
6042 {"user_supplied_bug18", 1, (test_callback_fn)user_supplied_bug18 },
6043 {"user_supplied_bug19", 1, (test_callback_fn)user_supplied_bug19 },
6044 {"user_supplied_bug20", 1, (test_callback_fn)user_supplied_bug20 },
6045 {"user_supplied_bug21", 1, (test_callback_fn)user_supplied_bug21 },
6046 {"wrong_failure_counter_test", 1, (test_callback_fn)wrong_failure_counter_test},
6047 {"wrong_failure_counter_two_test", 1, (test_callback_fn)wrong_failure_counter_two_test},
6048 {0, 0, (test_callback_fn)0}
6049 };
6050
6051 test_st replication_tests[]= {
6052 {"set", 1, (test_callback_fn)replication_set_test },
6053 {"get", 0, (test_callback_fn)replication_get_test },
6054 {"mget", 0, (test_callback_fn)replication_mget_test },
6055 {"delete", 0, (test_callback_fn)replication_delete_test },
6056 {"rand_mget", 0, (test_callback_fn)replication_randomize_mget_test },
6057 {0, 0, (test_callback_fn)0}
6058 };
6059
6060 /*
6061 * The following test suite is used to verify that we don't introduce
6062 * regression bugs. If you want more information about the bug / test,
6063 * you should look in the bug report at
6064 * http://bugs.launchpad.net/libmemcached
6065 */
6066 test_st regression_tests[]= {
6067 {"lp:434484", 1, (test_callback_fn)regression_bug_434484 },
6068 {"lp:434843", 1, (test_callback_fn)regression_bug_434843 },
6069 {"lp:434843-buffered", 1, (test_callback_fn)regression_bug_434843_buffered },
6070 {"lp:421108", 1, (test_callback_fn)regression_bug_421108 },
6071 {"lp:442914", 1, (test_callback_fn)regression_bug_442914 },
6072 {"lp:447342", 1, (test_callback_fn)regression_bug_447342 },
6073 {"lp:463297", 1, (test_callback_fn)regression_bug_463297 },
6074 {"lp:490486", 1, (test_callback_fn)regression_bug_490486 },
6075 {"lp:583031", 1, (test_callback_fn)regression_bug_583031 },
6076 {"lp:?", 1, (test_callback_fn)regression_bug_ },
6077 {"lp:728286", 1, (test_callback_fn)regression_bug_728286 },
6078 {"lp:581030", 1, (test_callback_fn)regression_bug_581030 },
6079 {0, 0, (test_callback_fn)0}
6080 };
6081
6082 test_st sasl_auth_tests[]= {
6083 {"sasl_auth", 1, (test_callback_fn)sasl_auth_test },
6084 {0, 0, (test_callback_fn)0}
6085 };
6086
6087 test_st ketama_compatibility[]= {
6088 {"libmemcached", 1, (test_callback_fn)ketama_compatibility_libmemcached },
6089 {"spymemcached", 1, (test_callback_fn)ketama_compatibility_spymemcached },
6090 {0, 0, (test_callback_fn)0}
6091 };
6092
6093 test_st generate_tests[] ={
6094 {"generate_pairs", 1, (test_callback_fn)generate_pairs },
6095 {"generate_data", 1, (test_callback_fn)generate_data },
6096 {"get_read", 0, (test_callback_fn)get_read },
6097 {"delete_generate", 0, (test_callback_fn)delete_generate },
6098 {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
6099 {"delete_buffer", 0, (test_callback_fn)delete_buffer_generate},
6100 {"generate_data", 1, (test_callback_fn)generate_data },
6101 {"mget_read", 0, (test_callback_fn)mget_read },
6102 {"mget_read_result", 0, (test_callback_fn)mget_read_result },
6103 {"mget_read_function", 0, (test_callback_fn)mget_read_function },
6104 {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6105 {"generate_large_pairs", 1, (test_callback_fn)generate_large_pairs },
6106 {"generate_data", 1, (test_callback_fn)generate_data },
6107 {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
6108 {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6109 {0, 0, (test_callback_fn)0}
6110 };
6111
6112 test_st consistent_tests[] ={
6113 {"generate_pairs", 1, (test_callback_fn)generate_pairs },
6114 {"generate_data", 1, (test_callback_fn)generate_data },
6115 {"get_read", 0, (test_callback_fn)get_read_count },
6116 {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6117 {0, 0, (test_callback_fn)0}
6118 };
6119
6120 test_st consistent_weighted_tests[] ={
6121 {"generate_pairs", 1, (test_callback_fn)generate_pairs },
6122 {"generate_data", 1, (test_callback_fn)generate_data_with_stats },
6123 {"get_read", 0, (test_callback_fn)get_read_count },
6124 {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6125 {0, 0, (test_callback_fn)0}
6126 };
6127
6128 test_st hsieh_availability[] ={
6129 {"hsieh_avaibility_test", 0, (test_callback_fn)hsieh_avaibility_test},
6130 {0, 0, (test_callback_fn)0}
6131 };
6132
6133 test_st murmur_availability[] ={
6134 {"murmur_avaibility_test", 0, (test_callback_fn)murmur_avaibility_test},
6135 {0, 0, (test_callback_fn)0}
6136 };
6137
6138 #if 0
6139 test_st hash_sanity[] ={
6140 {"hash sanity", 0, (test_callback_fn)hash_sanity_test},
6141 {0, 0, (test_callback_fn)0}
6142 };
6143 #endif
6144
6145 test_st ketama_auto_eject_hosts[] ={
6146 {"auto_eject_hosts", 1, (test_callback_fn)auto_eject_hosts },
6147 {"output_ketama_weighted_keys", 1, (test_callback_fn)output_ketama_weighted_keys },
6148 {0, 0, (test_callback_fn)0}
6149 };
6150
6151 test_st hash_tests[] ={
6152 {"one_at_a_time_run", 0, (test_callback_fn)one_at_a_time_run },
6153 {"md5", 0, (test_callback_fn)md5_run },
6154 {"crc", 0, (test_callback_fn)crc_run },
6155 {"fnv1_64", 0, (test_callback_fn)fnv1_64_run },
6156 {"fnv1a_64", 0, (test_callback_fn)fnv1a_64_run },
6157 {"fnv1_32", 0, (test_callback_fn)fnv1_32_run },
6158 {"fnv1a_32", 0, (test_callback_fn)fnv1a_32_run },
6159 {"hsieh", 0, (test_callback_fn)hsieh_run },
6160 {"murmur", 0, (test_callback_fn)murmur_run },
6161 {"jenkis", 0, (test_callback_fn)jenkins_run },
6162 {"memcached_get_hashkit", 0, (test_callback_fn)memcached_get_hashkit_test },
6163 {0, 0, (test_callback_fn)0}
6164 };
6165
6166 test_st error_conditions[] ={
6167 {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_MEMCACHED_ERRNO },
6168 {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_MEMCACHED_NOTFOUND },
6169 {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_ERRNO },
6170 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
6171 {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
6172 {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn)memcached_increment_MEMCACHED_NO_SERVERS },
6173 {0, 0, (test_callback_fn)0}
6174 };
6175
6176
6177 test_st parser_tests[] ={
6178 {"behavior", 0, (test_callback_fn)behavior_parser_test },
6179 {"boolean_options", 0, (test_callback_fn)parser_boolean_options_test },
6180 {"configure_file", 0, (test_callback_fn)memcached_create_with_options_with_filename },
6181 {"distribtions", 0, (test_callback_fn)parser_distribution_test },
6182 {"hash", 0, (test_callback_fn)parser_hash_test },
6183 {"libmemcached_check_configuration", 0, (test_callback_fn)libmemcached_check_configuration_test },
6184 {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn)libmemcached_check_configuration_with_filename_test },
6185 {"number_options", 0, (test_callback_fn)parser_number_options_test },
6186 {"randomly generated options", 0, (test_callback_fn)random_statement_build_test },
6187 {"prefix_key", 0, (test_callback_fn)parser_key_prefix_test },
6188 {"server", 0, (test_callback_fn)server_test },
6189 {"bad server strings", 0, (test_callback_fn)servers_bad_test },
6190 {"server with weights", 0, (test_callback_fn)server_with_weight_test },
6191 {0, 0, (test_callback_fn)0}
6192 };
6193
6194 test_st virtual_bucket_tests[] ={
6195 {"basic", 0, (test_callback_fn)virtual_back_map },
6196 {0, 0, (test_callback_fn)0}
6197 };
6198
6199 collection_st collection[] ={
6200 #if 0
6201 {"hash_sanity", 0, 0, hash_sanity},
6202 #endif
6203 {"basic", 0, 0, basic_tests},
6204 {"hsieh_availability", 0, 0, hsieh_availability},
6205 {"murmur_availability", 0, 0, murmur_availability},
6206 {"block", 0, 0, tests},
6207 {"binary", (test_callback_fn)pre_binary, 0, tests},
6208 {"nonblock", (test_callback_fn)pre_nonblock, 0, tests},
6209 {"nodelay", (test_callback_fn)pre_nodelay, 0, tests},
6210 {"settimer", (test_callback_fn)pre_settimer, 0, tests},
6211 {"md5", (test_callback_fn)pre_md5, 0, tests},
6212 {"crc", (test_callback_fn)pre_crc, 0, tests},
6213 {"hsieh", (test_callback_fn)pre_hsieh, 0, tests},
6214 {"jenkins", (test_callback_fn)pre_jenkins, 0, tests},
6215 {"fnv1_64", (test_callback_fn)pre_hash_fnv1_64, 0, tests},
6216 {"fnv1a_64", (test_callback_fn)pre_hash_fnv1a_64, 0, tests},
6217 {"fnv1_32", (test_callback_fn)pre_hash_fnv1_32, 0, tests},
6218 {"fnv1a_32", (test_callback_fn)pre_hash_fnv1a_32, 0, tests},
6219 {"ketama", (test_callback_fn)pre_behavior_ketama, 0, tests},
6220 {"ketama_auto_eject_hosts", (test_callback_fn)pre_behavior_ketama, 0, ketama_auto_eject_hosts},
6221 {"unix_socket", (test_callback_fn)pre_unix_socket, 0, tests},
6222 {"unix_socket_nodelay", (test_callback_fn)pre_nodelay, 0, tests},
6223 {"poll_timeout", (test_callback_fn)poll_timeout, 0, tests},
6224 {"gets", (test_callback_fn)enable_cas, 0, tests},
6225 {"consistent_crc", (test_callback_fn)enable_consistent_crc, 0, tests},
6226 {"consistent_hsieh", (test_callback_fn)enable_consistent_hsieh, 0, tests},
6227 #ifdef MEMCACHED_ENABLE_DEPRECATED
6228 {"deprecated_memory_allocators", (test_callback_fn)deprecated_set_memory_alloc, 0, tests},
6229 #endif
6230 {"memory_allocators", (test_callback_fn)set_memory_alloc, 0, tests},
6231 {"prefix", (test_callback_fn)set_prefix, 0, tests},
6232 {"sasl_auth", (test_callback_fn)pre_sasl, 0, sasl_auth_tests },
6233 {"sasl", (test_callback_fn)pre_sasl, 0, tests },
6234 {"version_1_2_3", (test_callback_fn)check_for_1_2_3, 0, version_1_2_3},
6235 {"string", 0, 0, string_tests},
6236 {"result", 0, 0, result_tests},
6237 {"async", (test_callback_fn)pre_nonblock, 0, async_tests},
6238 {"async_binary", (test_callback_fn)pre_nonblock_binary, 0, async_tests},
6239 {"user", 0, 0, user_tests},
6240 {"generate", 0, 0, generate_tests},
6241 {"generate_hsieh", (test_callback_fn)pre_hsieh, 0, generate_tests},
6242 {"generate_ketama", (test_callback_fn)pre_behavior_ketama, 0, generate_tests},
6243 {"generate_hsieh_consistent", (test_callback_fn)enable_consistent_hsieh, 0, generate_tests},
6244 {"generate_md5", (test_callback_fn)pre_md5, 0, generate_tests},
6245 {"generate_murmur", (test_callback_fn)pre_murmur, 0, generate_tests},
6246 {"generate_jenkins", (test_callback_fn)pre_jenkins, 0, generate_tests},
6247 {"generate_nonblock", (test_callback_fn)pre_nonblock, 0, generate_tests},
6248 // Too slow
6249 {"generate_corked", (test_callback_fn)pre_cork, 0, generate_tests},
6250 {"generate_corked_and_nonblock", (test_callback_fn)pre_cork_and_nonblock, 0, generate_tests},
6251 {"consistent_not", 0, 0, consistent_tests},
6252 {"consistent_ketama", (test_callback_fn)pre_behavior_ketama, 0, consistent_tests},
6253 {"consistent_ketama_weighted", (test_callback_fn)pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
6254 {"ketama_compat", 0, 0, ketama_compatibility},
6255 {"test_hashes", 0, 0, hash_tests},
6256 {"replication", (test_callback_fn)pre_replication, 0, replication_tests},
6257 {"replication_noblock", (test_callback_fn)pre_replication_noblock, 0, replication_tests},
6258 {"regression", 0, 0, regression_tests},
6259 {"behaviors", 0, 0, behavior_tests},
6260 {"regression_binary_vs_block", (test_callback_fn)key_setup, (test_callback_fn)key_teardown, regression_binary_vs_block},
6261 {"error_conditions", 0, 0, error_conditions},
6262 {"parser", 0, 0, parser_tests},
6263 {"virtual buckets", 0, 0, virtual_bucket_tests},
6264 {0, 0, 0, 0}
6265 };
6266
6267 #include "tests/libmemcached_world.h"
6268
6269 void get_world(world_st *world)
6270 {
6271 world->collections= collection;
6272
6273 world->create= (test_callback_create_fn)world_create;
6274 world->destroy= (test_callback_fn)world_destroy;
6275
6276 world->test.startup= (test_callback_fn)world_test_startup;
6277 world->test.flush= (test_callback_fn)world_flush;
6278 world->test.pre_run= (test_callback_fn)world_pre_run;
6279 world->test.post_run= (test_callback_fn)world_post_run;
6280 world->test.on_error= (test_callback_error_fn)world_on_error;
6281
6282 world->collection.startup= (test_callback_fn)world_container_startup;
6283 world->collection.shutdown= (test_callback_fn)world_container_shutdown;
6284
6285 world->runner= &defualt_libmemcached_runner;
6286 }
Resurrection of libmemcached https://launchpad.net/libmemcached