8a6fbfafce0746e1448b7f10633019c59ddb037b
[awesomized/libmemcached] / tests / function.c
1 /*
2 Sample test application.
3 */
4
5 #include "libmemcached/common.h"
6
7 #include <assert.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include <sys/time.h>
12 #include <sys/types.h>
13 #include <sys/stat.h>
14 #include <signal.h>
15 #include <unistd.h>
16 #include <time.h>
17 #include "server.h"
18 #include "clients/generator.h"
19 #include "clients/execute.h"
20
21 #ifndef INT64_MAX
22 #define INT64_MAX LONG_MAX
23 #endif
24 #ifndef INT32_MAX
25 #define INT32_MAX INT_MAX
26 #endif
27
28
29 #include "test.h"
30
31 #ifdef HAVE_LIBMEMCACHEDUTIL
32 #include <pthread.h>
33 #include "libmemcached/memcached_util.h"
34 #endif
35
36 #define GLOBAL_COUNT 10000
37 #define GLOBAL2_COUNT 100
38 #define SERVERS_TO_CREATE 5
39 static uint32_t global_count;
40
41 static pairs_st *global_pairs;
42 static const char *global_keys[GLOBAL_COUNT];
43 static size_t global_keys_length[GLOBAL_COUNT];
44
45 static test_return init_test(memcached_st *not_used __attribute__((unused)))
46 {
47 memcached_st memc;
48
49 (void)memcached_create(&memc);
50 memcached_free(&memc);
51
52 return 0;
53 }
54
55 static test_return server_list_null_test(memcached_st *ptr __attribute__((unused)))
56 {
57 memcached_server_st *server_list;
58 memcached_return rc;
59
60 server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, NULL);
61 assert(server_list == NULL);
62
63 server_list= memcached_server_list_append_with_weight(NULL, "localhost", 0, 0, NULL);
64 assert(server_list == NULL);
65
66 server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, &rc);
67 assert(server_list == NULL);
68
69 return 0;
70 }
71
72 #define TEST_PORT_COUNT 7
73 uint32_t test_ports[TEST_PORT_COUNT];
74
75 static memcached_return server_display_function(memcached_st *ptr __attribute__((unused)), memcached_server_st *server, void *context)
76 {
77 /* Do Nothing */
78 uint32_t bigger= *((uint32_t *)(context));
79 assert(bigger <= server->port);
80 *((uint32_t *)(context))= server->port;
81
82 return MEMCACHED_SUCCESS;
83 }
84
85 static test_return server_sort_test(memcached_st *ptr __attribute__((unused)))
86 {
87 uint32_t x;
88 uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */
89 memcached_return rc;
90 memcached_server_function callbacks[1];
91 memcached_st *local_memc;
92
93 local_memc= memcached_create(NULL);
94 assert(local_memc);
95 memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
96
97 for (x= 0; x < TEST_PORT_COUNT; x++)
98 {
99 test_ports[x]= (uint32_t)random() % 64000;
100 rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
101 assert(local_memc->number_of_hosts == x + 1);
102 assert(local_memc->hosts[0].count == x+1);
103 assert(rc == MEMCACHED_SUCCESS);
104 }
105
106 callbacks[0]= server_display_function;
107 memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
108
109
110 memcached_free(local_memc);
111
112 return 0;
113 }
114
115 static test_return server_sort2_test(memcached_st *ptr __attribute__((unused)))
116 {
117 uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */
118 memcached_return rc;
119 memcached_server_function callbacks[1];
120 memcached_st *local_memc;
121
122 local_memc= memcached_create(NULL);
123 assert(local_memc);
124 rc= memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
125 assert(rc == MEMCACHED_SUCCESS);
126
127 rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
128 assert(rc == MEMCACHED_SUCCESS);
129 assert(local_memc->hosts[0].port == 43043);
130
131 rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
132 assert(rc == MEMCACHED_SUCCESS);
133 assert(local_memc->hosts[0].port == 43042);
134 assert(local_memc->hosts[1].port == 43043);
135
136 callbacks[0]= server_display_function;
137 memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
138
139
140 memcached_free(local_memc);
141
142 return 0;
143 }
144
145 static memcached_return server_display_unsort_function(memcached_st *ptr __attribute__((unused)), memcached_server_st *server, void *context)
146 {
147 /* Do Nothing */
148 uint32_t x= *((uint32_t *)(context));
149
150 assert(test_ports[x] == server->port);
151 *((uint32_t *)(context))= ++x;
152
153 return MEMCACHED_SUCCESS;
154 }
155
156 static test_return server_unsort_test(memcached_st *ptr __attribute__((unused)))
157 {
158 uint32_t x;
159 uint32_t counter= 0; /* Prime the value for the assert in server_display_function */
160 uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */
161 memcached_return rc;
162 memcached_server_function callbacks[1];
163 memcached_st *local_memc;
164
165 local_memc= memcached_create(NULL);
166 assert(local_memc);
167
168 for (x= 0; x < TEST_PORT_COUNT; x++)
169 {
170 test_ports[x]= (uint32_t)(random() % 64000);
171 rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
172 assert(local_memc->number_of_hosts == x+1);
173 assert(local_memc->hosts[0].count == x+1);
174 assert(rc == MEMCACHED_SUCCESS);
175 }
176
177 callbacks[0]= server_display_unsort_function;
178 memcached_server_cursor(local_memc, callbacks, (void *)&counter, 1);
179
180 /* Now we sort old data! */
181 memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
182 callbacks[0]= server_display_function;
183 memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
184
185
186 memcached_free(local_memc);
187
188 return 0;
189 }
190
191 static test_return allocation_test(memcached_st *not_used __attribute__((unused)))
192 {
193 memcached_st *memc;
194 memc= memcached_create(NULL);
195 assert(memc);
196 memcached_free(memc);
197
198 return 0;
199 }
200
201 static test_return clone_test(memcached_st *memc)
202 {
203 /* All null? */
204 {
205 memcached_st *memc_clone;
206 memc_clone= memcached_clone(NULL, NULL);
207 assert(memc_clone);
208 memcached_free(memc_clone);
209 }
210
211 /* Can we init from null? */
212 {
213 memcached_st *memc_clone;
214 memc_clone= memcached_clone(NULL, memc);
215 assert(memc_clone);
216
217 assert(memc_clone->call_free == memc->call_free);
218 assert(memc_clone->call_malloc == memc->call_malloc);
219 assert(memc_clone->call_realloc == memc->call_realloc);
220 assert(memc_clone->call_calloc == memc->call_calloc);
221 assert(memc_clone->connect_timeout == memc->connect_timeout);
222 assert(memc_clone->delete_trigger == memc->delete_trigger);
223 assert(memc_clone->distribution == memc->distribution);
224 assert(memc_clone->flags == memc->flags);
225 assert(memc_clone->get_key_failure == memc->get_key_failure);
226 assert(memc_clone->hash == memc->hash);
227 assert(memc_clone->hash_continuum == memc->hash_continuum);
228 assert(memc_clone->io_bytes_watermark == memc->io_bytes_watermark);
229 assert(memc_clone->io_msg_watermark == memc->io_msg_watermark);
230 assert(memc_clone->io_key_prefetch == memc->io_key_prefetch);
231 assert(memc_clone->on_cleanup == memc->on_cleanup);
232 assert(memc_clone->on_clone == memc->on_clone);
233 assert(memc_clone->poll_timeout == memc->poll_timeout);
234 assert(memc_clone->rcv_timeout == memc->rcv_timeout);
235 assert(memc_clone->recv_size == memc->recv_size);
236 assert(memc_clone->retry_timeout == memc->retry_timeout);
237 assert(memc_clone->send_size == memc->send_size);
238 assert(memc_clone->server_failure_limit == memc->server_failure_limit);
239 assert(memc_clone->snd_timeout == memc->snd_timeout);
240 assert(memc_clone->user_data == memc->user_data);
241
242 memcached_free(memc_clone);
243 }
244
245 /* Can we init from struct? */
246 {
247 memcached_st declared_clone;
248 memcached_st *memc_clone;
249 memset(&declared_clone, 0 , sizeof(memcached_st));
250 memc_clone= memcached_clone(&declared_clone, NULL);
251 assert(memc_clone);
252 memcached_free(memc_clone);
253 }
254
255 /* Can we init from struct? */
256 {
257 memcached_st declared_clone;
258 memcached_st *memc_clone;
259 memset(&declared_clone, 0 , sizeof(memcached_st));
260 memc_clone= memcached_clone(&declared_clone, memc);
261 assert(memc_clone);
262 memcached_free(memc_clone);
263 }
264
265 return 0;
266 }
267
268 static test_return userdata_test(memcached_st *memc)
269 {
270 void* foo= NULL;
271 assert(memcached_set_user_data(memc, foo) == NULL);
272 assert(memcached_get_user_data(memc) == foo);
273 assert(memcached_set_user_data(memc, NULL) == foo);
274
275 return TEST_SUCCESS;
276 }
277
278 static test_return connection_test(memcached_st *memc)
279 {
280 memcached_return rc;
281
282 rc= memcached_server_add_with_weight(memc, "localhost", 0, 0);
283 assert(rc == MEMCACHED_SUCCESS);
284
285 return 0;
286 }
287
288 static test_return error_test(memcached_st *memc)
289 {
290 memcached_return rc;
291 uint32_t values[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U, 982370485U, 1263635348U, 4242906218U, 3829656100U, 1891735253U,
292 334139633U, 2257084983U, 3088286104U, 13199785U, 2542027183U, 1097051614U, 199566778U, 2748246961U, 2465192557U,
293 1664094137U, 2405439045U, 1842224848U, 692413798U, 3479807801U, 919913813U, 4269430871U, 610793021U, 527273862U,
294 1437122909U, 2300930706U, 2943759320U, 674306647U, 2400528935U, 54481931U, 4186304426U, 1741088401U, 2979625118U,
295 4159057246U };
296
297 assert(MEMCACHED_MAXIMUM_RETURN == 37); // You have updated the memcache_error messages but not updated docs/tests.
298 for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
299 {
300 uint32_t hash_val;
301 hash_val= memcached_generate_hash_value(memcached_strerror(memc, rc), strlen(memcached_strerror(memc, rc)), MEMCACHED_HASH_JENKINS);
302 assert(values[rc] == hash_val);
303 }
304
305 return 0;
306 }
307
308 static test_return set_test(memcached_st *memc)
309 {
310 memcached_return rc;
311 const char *key= "foo";
312 const char *value= "when we sanitize";
313
314 rc= memcached_set(memc, key, strlen(key),
315 value, strlen(value),
316 (time_t)0, (uint32_t)0);
317 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
318
319 return 0;
320 }
321
322 static test_return append_test(memcached_st *memc)
323 {
324 memcached_return rc;
325 const char *key= "fig";
326 const char *in_value= "we";
327 char *out_value= NULL;
328 size_t value_length;
329 uint32_t flags;
330
331 rc= memcached_flush(memc, 0);
332 assert(rc == MEMCACHED_SUCCESS);
333
334 rc= memcached_set(memc, key, strlen(key),
335 in_value, strlen(in_value),
336 (time_t)0, (uint32_t)0);
337 assert(rc == MEMCACHED_SUCCESS);
338
339 rc= memcached_append(memc, key, strlen(key),
340 " the", strlen(" the"),
341 (time_t)0, (uint32_t)0);
342 assert(rc == MEMCACHED_SUCCESS);
343
344 rc= memcached_append(memc, key, strlen(key),
345 " people", strlen(" people"),
346 (time_t)0, (uint32_t)0);
347 assert(rc == MEMCACHED_SUCCESS);
348
349 out_value= memcached_get(memc, key, strlen(key),
350 &value_length, &flags, &rc);
351 assert(!memcmp(out_value, "we the people", strlen("we the people")));
352 assert(strlen("we the people") == value_length);
353 assert(rc == MEMCACHED_SUCCESS);
354 free(out_value);
355
356 return 0;
357 }
358
359 static test_return append_binary_test(memcached_st *memc)
360 {
361 memcached_return rc;
362 const char *key= "numbers";
363 unsigned int *store_ptr;
364 unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
365 char *value;
366 size_t value_length;
367 uint32_t flags;
368 unsigned int x;
369
370 rc= memcached_flush(memc, 0);
371 assert(rc == MEMCACHED_SUCCESS);
372
373 rc= memcached_set(memc,
374 key, strlen(key),
375 NULL, 0,
376 (time_t)0, (uint32_t)0);
377 assert(rc == MEMCACHED_SUCCESS);
378
379 for (x= 0; store_list[x] ; x++)
380 {
381 rc= memcached_append(memc,
382 key, strlen(key),
383 (char *)&store_list[x], sizeof(unsigned int),
384 (time_t)0, (uint32_t)0);
385 assert(rc == MEMCACHED_SUCCESS);
386 }
387
388 value= memcached_get(memc, key, strlen(key),
389 &value_length, &flags, &rc);
390 assert((value_length == (sizeof(unsigned int) * x)));
391 assert(rc == MEMCACHED_SUCCESS);
392
393 store_ptr= (unsigned int *)value;
394 x= 0;
395 while ((size_t)store_ptr < (size_t)(value + value_length))
396 {
397 assert(*store_ptr == store_list[x++]);
398 store_ptr++;
399 }
400 free(value);
401
402 return 0;
403 }
404
405 static test_return cas2_test(memcached_st *memc)
406 {
407 memcached_return rc;
408 const char *keys[]= {"fudge", "son", "food"};
409 size_t key_length[]= {5, 3, 4};
410 const char *value= "we the people";
411 size_t value_length= strlen("we the people");
412 unsigned int x;
413 memcached_result_st results_obj;
414 memcached_result_st *results;
415 unsigned int set= 1;
416
417 rc= memcached_flush(memc, 0);
418 assert(rc == MEMCACHED_SUCCESS);
419
420 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
421
422 for (x= 0; x < 3; x++)
423 {
424 rc= memcached_set(memc, keys[x], key_length[x],
425 keys[x], key_length[x],
426 (time_t)50, (uint32_t)9);
427 assert(rc == MEMCACHED_SUCCESS);
428 }
429
430 rc= memcached_mget(memc, keys, key_length, 3);
431
432 results= memcached_result_create(memc, &results_obj);
433
434 results= memcached_fetch_result(memc, &results_obj, &rc);
435 assert(results);
436 assert(results->cas);
437 assert(rc == MEMCACHED_SUCCESS);
438 assert(memcached_result_cas(results));
439
440 assert(!memcmp(value, "we the people", strlen("we the people")));
441 assert(strlen("we the people") == value_length);
442 assert(rc == MEMCACHED_SUCCESS);
443
444 memcached_result_free(&results_obj);
445
446 return 0;
447 }
448
449 static test_return cas_test(memcached_st *memc)
450 {
451 memcached_return rc;
452 const char *key= "fun";
453 size_t key_length= strlen(key);
454 const char *value= "we the people";
455 const char* keys[2] = { key, NULL };
456 size_t keylengths[2] = { strlen(key), 0 };
457 size_t value_length= strlen(value);
458 const char *value2= "change the value";
459 size_t value2_length= strlen(value2);
460
461 memcached_result_st results_obj;
462 memcached_result_st *results;
463 unsigned int set= 1;
464
465 rc= memcached_flush(memc, 0);
466 assert(rc == MEMCACHED_SUCCESS);
467
468 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
469
470 rc= memcached_set(memc, key, strlen(key),
471 value, strlen(value),
472 (time_t)0, (uint32_t)0);
473 assert(rc == MEMCACHED_SUCCESS);
474
475 rc= memcached_mget(memc, keys, keylengths, 1);
476
477 results= memcached_result_create(memc, &results_obj);
478
479 results= memcached_fetch_result(memc, &results_obj, &rc);
480 assert(results);
481 assert(rc == MEMCACHED_SUCCESS);
482 assert(memcached_result_cas(results));
483 assert(!memcmp(value, memcached_result_value(results), value_length));
484 assert(strlen(memcached_result_value(results)) == value_length);
485 assert(rc == MEMCACHED_SUCCESS);
486 uint64_t cas = memcached_result_cas(results);
487
488 #if 0
489 results= memcached_fetch_result(memc, &results_obj, &rc);
490 assert(rc == MEMCACHED_END);
491 assert(results == NULL);
492 #endif
493
494 rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
495 assert(rc == MEMCACHED_SUCCESS);
496
497 /*
498 * The item will have a new cas value, so try to set it again with the old
499 * value. This should fail!
500 */
501 rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
502 assert(rc == MEMCACHED_DATA_EXISTS);
503
504 memcached_result_free(&results_obj);
505
506 return 0;
507 }
508
509 static test_return prepend_test(memcached_st *memc)
510 {
511 memcached_return rc;
512 const char *key= "fig";
513 const char *value= "people";
514 char *out_value= NULL;
515 size_t value_length;
516 uint32_t flags;
517
518 rc= memcached_flush(memc, 0);
519 assert(rc == MEMCACHED_SUCCESS);
520
521 rc= memcached_set(memc, key, strlen(key),
522 value, strlen(value),
523 (time_t)0, (uint32_t)0);
524 assert(rc == MEMCACHED_SUCCESS);
525
526 rc= memcached_prepend(memc, key, strlen(key),
527 "the ", strlen("the "),
528 (time_t)0, (uint32_t)0);
529 assert(rc == MEMCACHED_SUCCESS);
530
531 rc= memcached_prepend(memc, key, strlen(key),
532 "we ", strlen("we "),
533 (time_t)0, (uint32_t)0);
534 assert(rc == MEMCACHED_SUCCESS);
535
536 out_value= memcached_get(memc, key, strlen(key),
537 &value_length, &flags, &rc);
538 assert(!memcmp(out_value, "we the people", strlen("we the people")));
539 assert(strlen("we the people") == value_length);
540 assert(rc == MEMCACHED_SUCCESS);
541 free(out_value);
542
543 return 0;
544 }
545
546 /*
547 Set the value, then quit to make sure it is flushed.
548 Come back in and test that add fails.
549 */
550 static test_return add_test(memcached_st *memc)
551 {
552 memcached_return rc;
553 const char *key= "foo";
554 const char *value= "when we sanitize";
555 unsigned long long setting_value;
556
557 setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
558
559 rc= memcached_set(memc, key, strlen(key),
560 value, strlen(value),
561 (time_t)0, (uint32_t)0);
562 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
563 memcached_quit(memc);
564 rc= memcached_add(memc, key, strlen(key),
565 value, strlen(value),
566 (time_t)0, (uint32_t)0);
567
568 /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
569 if (setting_value)
570 assert(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);
571 else
572 assert(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_DATA_EXISTS);
573
574 return 0;
575 }
576
577 /*
578 ** There was a problem of leaking filedescriptors in the initial release
579 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
580 ** systems it seems that the kernel is slow on reclaiming the resources
581 ** because the connects starts to time out (the test doesn't do much
582 ** anyway, so just loop 10 iterations)
583 */
584 static test_return add_wrapper(memcached_st *memc)
585 {
586 unsigned int x;
587 unsigned int max= 10000;
588 #ifdef __sun
589 max= 10;
590 #endif
591
592 for (x= 0; x < max; x++)
593 add_test(memc);
594
595 return 0;
596 }
597
598 static test_return replace_test(memcached_st *memc)
599 {
600 memcached_return rc;
601 const char *key= "foo";
602 const char *value= "when we sanitize";
603 const char *original= "first we insert some data";
604
605 rc= memcached_set(memc, key, strlen(key),
606 original, strlen(original),
607 (time_t)0, (uint32_t)0);
608 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
609
610 rc= memcached_replace(memc, key, strlen(key),
611 value, strlen(value),
612 (time_t)0, (uint32_t)0);
613 assert(rc == MEMCACHED_SUCCESS);
614
615 return 0;
616 }
617
618 static test_return delete_test(memcached_st *memc)
619 {
620 memcached_return rc;
621 const char *key= "foo";
622 const char *value= "when we sanitize";
623
624 rc= memcached_set(memc, key, strlen(key),
625 value, strlen(value),
626 (time_t)0, (uint32_t)0);
627 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
628
629 rc= memcached_delete(memc, key, strlen(key), (time_t)0);
630 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
631
632 return 0;
633 }
634
635 static test_return flush_test(memcached_st *memc)
636 {
637 memcached_return rc;
638
639 rc= memcached_flush(memc, 0);
640 assert(rc == MEMCACHED_SUCCESS);
641
642 return 0;
643 }
644
645 static memcached_return server_function(memcached_st *ptr __attribute__((unused)),
646 memcached_server_st *server __attribute__((unused)),
647 void *context __attribute__((unused)))
648 {
649 /* Do Nothing */
650
651 return MEMCACHED_SUCCESS;
652 }
653
654 static test_return memcached_server_cursor_test(memcached_st *memc)
655 {
656 char context[8];
657 strcpy(context, "foo bad");
658 memcached_server_function callbacks[1];
659
660 callbacks[0]= server_function;
661 memcached_server_cursor(memc, callbacks, context, 1);
662 return 0;
663 }
664
665 static test_return bad_key_test(memcached_st *memc)
666 {
667 memcached_return rc;
668 const char *key= "foo bad";
669 char *string;
670 size_t string_length;
671 uint32_t flags;
672 memcached_st *memc_clone;
673 unsigned int set= 1;
674 size_t max_keylen= 0xffff;
675
676 memc_clone= memcached_clone(NULL, memc);
677 assert(memc_clone);
678
679 rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
680 assert(rc == MEMCACHED_SUCCESS);
681
682 /* All keys are valid in the binary protocol (except for length) */
683 if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0)
684 {
685 string= memcached_get(memc_clone, key, strlen(key),
686 &string_length, &flags, &rc);
687 assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
688 assert(string_length == 0);
689 assert(!string);
690
691 set= 0;
692 rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
693 assert(rc == MEMCACHED_SUCCESS);
694 string= memcached_get(memc_clone, key, strlen(key),
695 &string_length, &flags, &rc);
696 assert(rc == MEMCACHED_NOTFOUND);
697 assert(string_length == 0);
698 assert(!string);
699
700 /* Test multi key for bad keys */
701 const char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
702 size_t key_lengths[] = { 7, 7, 7 };
703 set= 1;
704 rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
705 assert(rc == MEMCACHED_SUCCESS);
706
707 rc= memcached_mget(memc_clone, keys, key_lengths, 3);
708 assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
709
710 rc= memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1);
711 assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
712
713 max_keylen= 250;
714
715 /* The following test should be moved to the end of this function when the
716 memcached server is updated to allow max size length of the keys in the
717 binary protocol
718 */
719 rc= memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
720 assert(rc == MEMCACHED_SUCCESS);
721
722 char *longkey= malloc(max_keylen + 1);
723 if (longkey != NULL)
724 {
725 memset(longkey, 'a', max_keylen + 1);
726 string= memcached_get(memc_clone, longkey, max_keylen,
727 &string_length, &flags, &rc);
728 assert(rc == MEMCACHED_NOTFOUND);
729 assert(string_length == 0);
730 assert(!string);
731
732 string= memcached_get(memc_clone, longkey, max_keylen + 1,
733 &string_length, &flags, &rc);
734 assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
735 assert(string_length == 0);
736 assert(!string);
737
738 free(longkey);
739 }
740 }
741
742 /* Make sure zero length keys are marked as bad */
743 set= 1;
744 rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
745 assert(rc == MEMCACHED_SUCCESS);
746 string= memcached_get(memc_clone, key, 0,
747 &string_length, &flags, &rc);
748 assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
749 assert(string_length == 0);
750 assert(!string);
751
752 memcached_free(memc_clone);
753
754 return 0;
755 }
756
757 #define READ_THROUGH_VALUE "set for me"
758 static memcached_return read_through_trigger(memcached_st *memc __attribute__((unused)),
759 char *key __attribute__((unused)),
760 size_t key_length __attribute__((unused)),
761 memcached_result_st *result)
762 {
763
764 return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
765 }
766
767 static test_return read_through(memcached_st *memc)
768 {
769 memcached_return rc;
770 const char *key= "foo";
771 char *string;
772 size_t string_length;
773 uint32_t flags;
774 memcached_trigger_key cb= (memcached_trigger_key)read_through_trigger;
775
776 string= memcached_get(memc, key, strlen(key),
777 &string_length, &flags, &rc);
778
779 assert(rc == MEMCACHED_NOTFOUND);
780 assert(string_length == 0);
781 assert(!string);
782
783 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE,
784 *(void **)&cb);
785 assert(rc == MEMCACHED_SUCCESS);
786
787 string= memcached_get(memc, key, strlen(key),
788 &string_length, &flags, &rc);
789
790 assert(rc == MEMCACHED_SUCCESS);
791 assert(string_length == strlen(READ_THROUGH_VALUE));
792 assert(!strcmp(READ_THROUGH_VALUE, string));
793 free(string);
794
795 string= memcached_get(memc, key, strlen(key),
796 &string_length, &flags, &rc);
797
798 assert(rc == MEMCACHED_SUCCESS);
799 assert(string_length == strlen(READ_THROUGH_VALUE));
800 assert(!strcmp(READ_THROUGH_VALUE, string));
801 free(string);
802
803 return 0;
804 }
805
806 static memcached_return delete_trigger(memcached_st *ptr __attribute__((unused)),
807 const char *key,
808 size_t key_length __attribute__((unused)))
809 {
810 assert(key);
811
812 return MEMCACHED_SUCCESS;
813 }
814
815 static test_return delete_through(memcached_st *memc)
816 {
817 memcached_trigger_delete_key callback;
818 memcached_return rc;
819
820 callback= (memcached_trigger_delete_key)delete_trigger;
821
822 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, *(void**)&callback);
823 assert(rc == MEMCACHED_SUCCESS);
824
825 return 0;
826 }
827
828 static test_return get_test(memcached_st *memc)
829 {
830 memcached_return rc;
831 const char *key= "foo";
832 char *string;
833 size_t string_length;
834 uint32_t flags;
835
836 rc= memcached_delete(memc, key, strlen(key), (time_t)0);
837 assert(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);
838
839 string= memcached_get(memc, key, strlen(key),
840 &string_length, &flags, &rc);
841
842 assert(rc == MEMCACHED_NOTFOUND);
843 assert(string_length == 0);
844 assert(!string);
845
846 return 0;
847 }
848
849 static test_return get_test2(memcached_st *memc)
850 {
851 memcached_return rc;
852 const char *key= "foo";
853 const char *value= "when we sanitize";
854 char *string;
855 size_t string_length;
856 uint32_t flags;
857
858 rc= memcached_set(memc, key, strlen(key),
859 value, strlen(value),
860 (time_t)0, (uint32_t)0);
861 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
862
863 string= memcached_get(memc, key, strlen(key),
864 &string_length, &flags, &rc);
865
866 assert(string);
867 assert(rc == MEMCACHED_SUCCESS);
868 assert(string_length == strlen(value));
869 assert(!memcmp(string, value, string_length));
870
871 free(string);
872
873 return 0;
874 }
875
876 static test_return set_test2(memcached_st *memc)
877 {
878 memcached_return rc;
879 const char *key= "foo";
880 const char *value= "train in the brain";
881 size_t value_length= strlen(value);
882 unsigned int x;
883
884 for (x= 0; x < 10; x++)
885 {
886 rc= memcached_set(memc, key, strlen(key),
887 value, value_length,
888 (time_t)0, (uint32_t)0);
889 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
890 }
891
892 return 0;
893 }
894
895 static test_return set_test3(memcached_st *memc)
896 {
897 memcached_return rc;
898 char *value;
899 size_t value_length= 8191;
900 unsigned int x;
901
902 value = (char*)malloc(value_length);
903 assert(value);
904
905 for (x= 0; x < value_length; x++)
906 value[x] = (char) (x % 127);
907
908 /* The dump test relies on there being at least 32 items in memcached */
909 for (x= 0; x < 32; x++)
910 {
911 char key[16];
912
913 sprintf(key, "foo%u", x);
914
915 rc= memcached_set(memc, key, strlen(key),
916 value, value_length,
917 (time_t)0, (uint32_t)0);
918 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
919 }
920
921 free(value);
922
923 return 0;
924 }
925
926 static test_return get_test3(memcached_st *memc)
927 {
928 memcached_return rc;
929 const char *key= "foo";
930 char *value;
931 size_t value_length= 8191;
932 char *string;
933 size_t string_length;
934 uint32_t flags;
935 uint32_t x;
936
937 value = (char*)malloc(value_length);
938 assert(value);
939
940 for (x= 0; x < value_length; x++)
941 value[x] = (char) (x % 127);
942
943 rc= memcached_set(memc, key, strlen(key),
944 value, value_length,
945 (time_t)0, (uint32_t)0);
946 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
947
948 string= memcached_get(memc, key, strlen(key),
949 &string_length, &flags, &rc);
950
951 assert(rc == MEMCACHED_SUCCESS);
952 assert(string);
953 assert(string_length == value_length);
954 assert(!memcmp(string, value, string_length));
955
956 free(string);
957 free(value);
958
959 return 0;
960 }
961
962 static test_return get_test4(memcached_st *memc)
963 {
964 memcached_return rc;
965 const char *key= "foo";
966 char *value;
967 size_t value_length= 8191;
968 char *string;
969 size_t string_length;
970 uint32_t flags;
971 uint32_t x;
972
973 value = (char*)malloc(value_length);
974 assert(value);
975
976 for (x= 0; x < value_length; x++)
977 value[x] = (char) (x % 127);
978
979 rc= memcached_set(memc, key, strlen(key),
980 value, value_length,
981 (time_t)0, (uint32_t)0);
982 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
983
984 for (x= 0; x < 10; x++)
985 {
986 string= memcached_get(memc, key, strlen(key),
987 &string_length, &flags, &rc);
988
989 assert(rc == MEMCACHED_SUCCESS);
990 assert(string);
991 assert(string_length == value_length);
992 assert(!memcmp(string, value, string_length));
993 free(string);
994 }
995
996 free(value);
997
998 return 0;
999 }
1000
1001 /*
1002 * This test verifies that memcached_read_one_response doesn't try to
1003 * dereference a NIL-pointer if you issue a multi-get and don't read out all
1004 * responses before you execute a storage command.
1005 */
1006 static test_return get_test5(memcached_st *memc)
1007 {
1008 /*
1009 ** Request the same key twice, to ensure that we hash to the same server
1010 ** (so that we have multiple response values queued up) ;-)
1011 */
1012 const char *keys[]= { "key", "key" };
1013 size_t lengths[]= { 3, 3 };
1014 uint32_t flags;
1015 size_t rlen;
1016
1017 memcached_return rc= memcached_set(memc, keys[0], lengths[0],
1018 keys[0], lengths[0], 0, 0);
1019 assert(rc == MEMCACHED_SUCCESS);
1020 rc= memcached_mget(memc, keys, lengths, 2);
1021
1022 memcached_result_st results_obj;
1023 memcached_result_st *results;
1024 results=memcached_result_create(memc, &results_obj);
1025 assert(results);
1026 results=memcached_fetch_result(memc, &results_obj, &rc);
1027 assert(results);
1028 memcached_result_free(&results_obj);
1029
1030 /* Don't read out the second result, but issue a set instead.. */
1031 rc= memcached_set(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0);
1032 assert(rc == MEMCACHED_SUCCESS);
1033
1034 char *val= memcached_get_by_key(memc, keys[0], lengths[0], "yek", 3,
1035 &rlen, &flags, &rc);
1036 assert(val == NULL);
1037 assert(rc == MEMCACHED_NOTFOUND);
1038 val= memcached_get(memc, keys[0], lengths[0], &rlen, &flags, &rc);
1039 assert(val != NULL);
1040 assert(rc == MEMCACHED_SUCCESS);
1041 free(val);
1042
1043 return TEST_SUCCESS;
1044 }
1045
1046 /* Do not copy the style of this code, I just access hosts to testthis function */
1047 static test_return stats_servername_test(memcached_st *memc)
1048 {
1049 memcached_return rc;
1050 memcached_stat_st memc_stat;
1051 rc= memcached_stat_servername(&memc_stat, NULL,
1052 memc->hosts[0].hostname,
1053 memc->hosts[0].port);
1054
1055 return 0;
1056 }
1057
1058 static test_return increment_test(memcached_st *memc)
1059 {
1060 uint64_t new_number;
1061 memcached_return rc;
1062 const char *key= "number";
1063 const char *value= "0";
1064
1065 rc= memcached_set(memc, key, strlen(key),
1066 value, strlen(value),
1067 (time_t)0, (uint32_t)0);
1068 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1069
1070 rc= memcached_increment(memc, key, strlen(key),
1071 1, &new_number);
1072 assert(rc == MEMCACHED_SUCCESS);
1073 assert(new_number == 1);
1074
1075 rc= memcached_increment(memc, key, strlen(key),
1076 1, &new_number);
1077 assert(rc == MEMCACHED_SUCCESS);
1078 assert(new_number == 2);
1079
1080 return 0;
1081 }
1082
1083 static test_return increment_with_initial_test(memcached_st *memc)
1084 {
1085 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1086 {
1087 uint64_t new_number;
1088 memcached_return rc;
1089 const char *key= "number";
1090 uint64_t initial= 0;
1091
1092 rc= memcached_increment_with_initial(memc, key, strlen(key),
1093 1, initial, 0, &new_number);
1094 assert(rc == MEMCACHED_SUCCESS);
1095 assert(new_number == initial);
1096
1097 rc= memcached_increment_with_initial(memc, key, strlen(key),
1098 1, initial, 0, &new_number);
1099 assert(rc == MEMCACHED_SUCCESS);
1100 assert(new_number == (initial + 1));
1101 }
1102 return 0;
1103 }
1104
1105 static test_return decrement_test(memcached_st *memc)
1106 {
1107 uint64_t new_number;
1108 memcached_return rc;
1109 const char *key= "number";
1110 const char *value= "3";
1111
1112 rc= memcached_set(memc, key, strlen(key),
1113 value, strlen(value),
1114 (time_t)0, (uint32_t)0);
1115 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1116
1117 rc= memcached_decrement(memc, key, strlen(key),
1118 1, &new_number);
1119 assert(rc == MEMCACHED_SUCCESS);
1120 assert(new_number == 2);
1121
1122 rc= memcached_decrement(memc, key, strlen(key),
1123 1, &new_number);
1124 assert(rc == MEMCACHED_SUCCESS);
1125 assert(new_number == 1);
1126
1127 return 0;
1128 }
1129
1130 static test_return decrement_with_initial_test(memcached_st *memc)
1131 {
1132 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1133 {
1134 uint64_t new_number;
1135 memcached_return rc;
1136 const char *key= "number";
1137 uint64_t initial= 3;
1138
1139 rc= memcached_decrement_with_initial(memc, key, strlen(key),
1140 1, initial, 0, &new_number);
1141 assert(rc == MEMCACHED_SUCCESS);
1142 assert(new_number == initial);
1143
1144 rc= memcached_decrement_with_initial(memc, key, strlen(key),
1145 1, initial, 0, &new_number);
1146 assert(rc == MEMCACHED_SUCCESS);
1147 assert(new_number == (initial - 1));
1148 }
1149 return 0;
1150 }
1151
1152 static test_return quit_test(memcached_st *memc)
1153 {
1154 memcached_return rc;
1155 const char *key= "fudge";
1156 const char *value= "sanford and sun";
1157
1158 rc= memcached_set(memc, key, strlen(key),
1159 value, strlen(value),
1160 (time_t)10, (uint32_t)3);
1161 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1162 memcached_quit(memc);
1163
1164 rc= memcached_set(memc, key, strlen(key),
1165 value, strlen(value),
1166 (time_t)50, (uint32_t)9);
1167 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1168
1169 return 0;
1170 }
1171
1172 static test_return mget_result_test(memcached_st *memc)
1173 {
1174 memcached_return rc;
1175 const char *keys[]= {"fudge", "son", "food"};
1176 size_t key_length[]= {5, 3, 4};
1177 unsigned int x;
1178
1179 memcached_result_st results_obj;
1180 memcached_result_st *results;
1181
1182 results= memcached_result_create(memc, &results_obj);
1183 assert(results);
1184 assert(&results_obj == results);
1185
1186 /* We need to empty the server before continueing test */
1187 rc= memcached_flush(memc, 0);
1188 assert(rc == MEMCACHED_SUCCESS);
1189
1190 rc= memcached_mget(memc, keys, key_length, 3);
1191 assert(rc == MEMCACHED_SUCCESS);
1192
1193 while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
1194 {
1195 assert(results);
1196 }
1197
1198 while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
1199 assert(!results);
1200 assert(rc == MEMCACHED_END);
1201
1202 for (x= 0; x < 3; x++)
1203 {
1204 rc= memcached_set(memc, keys[x], key_length[x],
1205 keys[x], key_length[x],
1206 (time_t)50, (uint32_t)9);
1207 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1208 }
1209
1210 rc= memcached_mget(memc, keys, key_length, 3);
1211 assert(rc == MEMCACHED_SUCCESS);
1212
1213 while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1214 {
1215 assert(results);
1216 assert(&results_obj == results);
1217 assert(rc == MEMCACHED_SUCCESS);
1218 assert(memcached_result_key_length(results) == memcached_result_length(results));
1219 assert(!memcmp(memcached_result_key_value(results),
1220 memcached_result_value(results),
1221 memcached_result_length(results)));
1222 }
1223
1224 memcached_result_free(&results_obj);
1225
1226 return 0;
1227 }
1228
1229 static test_return mget_result_alloc_test(memcached_st *memc)
1230 {
1231 memcached_return rc;
1232 const char *keys[]= {"fudge", "son", "food"};
1233 size_t key_length[]= {5, 3, 4};
1234 unsigned int x;
1235
1236 memcached_result_st *results;
1237
1238 /* We need to empty the server before continueing test */
1239 rc= memcached_flush(memc, 0);
1240 assert(rc == MEMCACHED_SUCCESS);
1241
1242 rc= memcached_mget(memc, keys, key_length, 3);
1243 assert(rc == MEMCACHED_SUCCESS);
1244
1245 while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
1246 {
1247 assert(results);
1248 }
1249 assert(!results);
1250 assert(rc == MEMCACHED_END);
1251
1252 for (x= 0; x < 3; x++)
1253 {
1254 rc= memcached_set(memc, keys[x], key_length[x],
1255 keys[x], key_length[x],
1256 (time_t)50, (uint32_t)9);
1257 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1258 }
1259
1260 rc= memcached_mget(memc, keys, key_length, 3);
1261 assert(rc == MEMCACHED_SUCCESS);
1262
1263 x= 0;
1264 while ((results= memcached_fetch_result(memc, NULL, &rc)))
1265 {
1266 assert(results);
1267 assert(rc == MEMCACHED_SUCCESS);
1268 assert(memcached_result_key_length(results) == memcached_result_length(results));
1269 assert(!memcmp(memcached_result_key_value(results),
1270 memcached_result_value(results),
1271 memcached_result_length(results)));
1272 memcached_result_free(results);
1273 x++;
1274 }
1275
1276 return 0;
1277 }
1278
1279 /* Count the results */
1280 static memcached_return callback_counter(memcached_st *ptr __attribute__((unused)),
1281 memcached_result_st *result __attribute__((unused)),
1282 void *context)
1283 {
1284 unsigned int *counter= (unsigned int *)context;
1285
1286 *counter= *counter + 1;
1287
1288 return MEMCACHED_SUCCESS;
1289 }
1290
1291 static test_return mget_result_function(memcached_st *memc)
1292 {
1293 memcached_return rc;
1294 const char *keys[]= {"fudge", "son", "food"};
1295 size_t key_length[]= {5, 3, 4};
1296 unsigned int x;
1297 unsigned int counter;
1298 memcached_execute_function callbacks[1];
1299
1300 /* We need to empty the server before continueing test */
1301 rc= memcached_flush(memc, 0);
1302 for (x= 0; x < 3; x++)
1303 {
1304 rc= memcached_set(memc, keys[x], key_length[x],
1305 keys[x], key_length[x],
1306 (time_t)50, (uint32_t)9);
1307 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1308 }
1309
1310 rc= memcached_mget(memc, keys, key_length, 3);
1311 assert(rc == MEMCACHED_SUCCESS);
1312
1313 callbacks[0]= &callback_counter;
1314 counter= 0;
1315 rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
1316
1317 assert(counter == 3);
1318
1319 return 0;
1320 }
1321
1322 static test_return mget_test(memcached_st *memc)
1323 {
1324 memcached_return rc;
1325 const char *keys[]= {"fudge", "son", "food"};
1326 size_t key_length[]= {5, 3, 4};
1327 unsigned int x;
1328 uint32_t flags;
1329
1330 char return_key[MEMCACHED_MAX_KEY];
1331 size_t return_key_length;
1332 char *return_value;
1333 size_t return_value_length;
1334
1335 /* We need to empty the server before continueing test */
1336 rc= memcached_flush(memc, 0);
1337 assert(rc == MEMCACHED_SUCCESS);
1338
1339 rc= memcached_mget(memc, keys, key_length, 3);
1340 assert(rc == MEMCACHED_SUCCESS);
1341
1342 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1343 &return_value_length, &flags, &rc)) != NULL)
1344 {
1345 assert(return_value);
1346 }
1347 assert(!return_value);
1348 assert(return_value_length == 0);
1349 assert(rc == MEMCACHED_END);
1350
1351 for (x= 0; x < 3; x++)
1352 {
1353 rc= memcached_set(memc, keys[x], key_length[x],
1354 keys[x], key_length[x],
1355 (time_t)50, (uint32_t)9);
1356 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1357 }
1358
1359 rc= memcached_mget(memc, keys, key_length, 3);
1360 assert(rc == MEMCACHED_SUCCESS);
1361
1362 x= 0;
1363 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1364 &return_value_length, &flags, &rc)))
1365 {
1366 assert(return_value);
1367 assert(rc == MEMCACHED_SUCCESS);
1368 assert(return_key_length == return_value_length);
1369 assert(!memcmp(return_value, return_key, return_value_length));
1370 free(return_value);
1371 x++;
1372 }
1373
1374 return 0;
1375 }
1376
1377 static test_return get_stats_keys(memcached_st *memc)
1378 {
1379 char **list;
1380 char **ptr;
1381 memcached_stat_st memc_stat;
1382 memcached_return rc;
1383
1384 list= memcached_stat_get_keys(memc, &memc_stat, &rc);
1385 assert(rc == MEMCACHED_SUCCESS);
1386 for (ptr= list; *ptr; ptr++)
1387 assert(*ptr);
1388 fflush(stdout);
1389
1390 free(list);
1391
1392 return 0;
1393 }
1394
1395 static test_return version_string_test(memcached_st *memc __attribute__((unused)))
1396 {
1397 const char *version_string;
1398
1399 version_string= memcached_lib_version();
1400
1401 assert(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING));
1402
1403 return 0;
1404 }
1405
1406 static test_return get_stats(memcached_st *memc)
1407 {
1408 unsigned int x;
1409 char **list;
1410 char **ptr;
1411 memcached_return rc;
1412 memcached_stat_st *memc_stat;
1413
1414 memc_stat= memcached_stat(memc, NULL, &rc);
1415 assert(rc == MEMCACHED_SUCCESS);
1416
1417 assert(rc == MEMCACHED_SUCCESS);
1418 assert(memc_stat);
1419
1420 for (x= 0; x < memcached_server_count(memc); x++)
1421 {
1422 list= memcached_stat_get_keys(memc, memc_stat+x, &rc);
1423 assert(rc == MEMCACHED_SUCCESS);
1424 for (ptr= list; *ptr; ptr++);
1425
1426 free(list);
1427 }
1428
1429 memcached_stat_free(NULL, memc_stat);
1430
1431 return 0;
1432 }
1433
1434 static test_return add_host_test(memcached_st *memc)
1435 {
1436 unsigned int x;
1437 memcached_server_st *servers;
1438 memcached_return rc;
1439 char servername[]= "0.example.com";
1440
1441 servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
1442 assert(servers);
1443 assert(1 == memcached_server_list_count(servers));
1444
1445 for (x= 2; x < 20; x++)
1446 {
1447 char buffer[SMALL_STRING_LEN];
1448
1449 snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1450 servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
1451 &rc);
1452 assert(rc == MEMCACHED_SUCCESS);
1453 assert(x == memcached_server_list_count(servers));
1454 }
1455
1456 rc= memcached_server_push(memc, servers);
1457 assert(rc == MEMCACHED_SUCCESS);
1458 rc= memcached_server_push(memc, servers);
1459 assert(rc == MEMCACHED_SUCCESS);
1460
1461 memcached_server_list_free(servers);
1462
1463 return 0;
1464 }
1465
1466 static memcached_return clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *memc_clone __attribute__((unused)))
1467 {
1468 return MEMCACHED_SUCCESS;
1469 }
1470
1471 static memcached_return cleanup_test_callback(memcached_st *ptr __attribute__((unused)))
1472 {
1473 return MEMCACHED_SUCCESS;
1474 }
1475
1476 static test_return callback_test(memcached_st *memc)
1477 {
1478 /* Test User Data */
1479 {
1480 int x= 5;
1481 int *test_ptr;
1482 memcached_return rc;
1483
1484 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x);
1485 assert(rc == MEMCACHED_SUCCESS);
1486 test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
1487 assert(*test_ptr == x);
1488 }
1489
1490 /* Test Clone Callback */
1491 {
1492 memcached_clone_func clone_cb= (memcached_clone_func)clone_test_callback;
1493 void *clone_cb_ptr= *(void **)&clone_cb;
1494 void *temp_function= NULL;
1495 memcached_return rc;
1496
1497 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION,
1498 clone_cb_ptr);
1499 assert(rc == MEMCACHED_SUCCESS);
1500 temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1501 assert(temp_function == clone_cb_ptr);
1502 }
1503
1504 /* Test Cleanup Callback */
1505 {
1506 memcached_cleanup_func cleanup_cb=
1507 (memcached_cleanup_func)cleanup_test_callback;
1508 void *cleanup_cb_ptr= *(void **)&cleanup_cb;
1509 void *temp_function= NULL;
1510 memcached_return rc;
1511
1512 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION,
1513 cleanup_cb_ptr);
1514 assert(rc == MEMCACHED_SUCCESS);
1515 temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1516 assert(temp_function == cleanup_cb_ptr);
1517 }
1518
1519 return 0;
1520 }
1521
1522 /* We don't test the behavior itself, we test the switches */
1523 static test_return behavior_test(memcached_st *memc)
1524 {
1525 uint64_t value;
1526 uint32_t set= 1;
1527
1528 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1529 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1530 assert(value == 1);
1531
1532 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1533 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1534 assert(value == 1);
1535
1536 set= MEMCACHED_HASH_MD5;
1537 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1538 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1539 assert(value == MEMCACHED_HASH_MD5);
1540
1541 set= 0;
1542
1543 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1544 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1545 assert(value == 0);
1546
1547 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1548 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1549 assert(value == 0);
1550
1551 set= MEMCACHED_HASH_DEFAULT;
1552 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1553 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1554 assert(value == MEMCACHED_HASH_DEFAULT);
1555
1556 set= MEMCACHED_HASH_CRC;
1557 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1558 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1559 assert(value == MEMCACHED_HASH_CRC);
1560
1561 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1562 assert(value > 0);
1563
1564 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1565 assert(value > 0);
1566
1567 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
1568 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value + 1);
1569 assert((value + 1) == memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));
1570 return 0;
1571 }
1572
1573 /* Test case provided by Cal Haldenbrand */
1574 static test_return user_supplied_bug1(memcached_st *memc)
1575 {
1576 unsigned int setter= 1;
1577 unsigned int x;
1578
1579 unsigned long long total= 0;
1580 uint32_t size= 0;
1581 char key[10];
1582 char randomstuff[6 * 1024];
1583 memcached_return rc;
1584
1585 memset(randomstuff, 0, 6 * 1024);
1586
1587 /* We just keep looking at the same values over and over */
1588 srandom(10);
1589
1590 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1591 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1592
1593
1594 /* add key */
1595 for (x= 0 ; total < 20 * 1024576 ; x++ )
1596 {
1597 unsigned int j= 0;
1598
1599 size= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
1600 memset(randomstuff, 0, 6 * 1024);
1601 assert(size < 6 * 1024); /* Being safe here */
1602
1603 for (j= 0 ; j < size ;j++)
1604 randomstuff[j] = (signed char) ((rand() % 26) + 97);
1605
1606 total += size;
1607 sprintf(key, "%d", x);
1608 rc = memcached_set(memc, key, strlen(key),
1609 randomstuff, strlen(randomstuff), 10, 0);
1610 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1611 /* If we fail, lets try again */
1612 if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
1613 rc = memcached_set(memc, key, strlen(key),
1614 randomstuff, strlen(randomstuff), 10, 0);
1615 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1616 }
1617
1618 return 0;
1619 }
1620
1621 /* Test case provided by Cal Haldenbrand */
1622 static test_return user_supplied_bug2(memcached_st *memc)
1623 {
1624 int errors;
1625 unsigned int setter;
1626 unsigned int x;
1627 unsigned long long total;
1628
1629 setter= 1;
1630 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1631 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1632 #ifdef NOT_YET
1633 setter = 20 * 1024576;
1634 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
1635 setter = 20 * 1024576;
1636 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
1637 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1638 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1639
1640 for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
1641 #endif
1642
1643 for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
1644 {
1645 memcached_return rc= MEMCACHED_SUCCESS;
1646 char buffer[SMALL_STRING_LEN];
1647 uint32_t flags= 0;
1648 size_t val_len= 0;
1649 char *getval;
1650
1651 memset(buffer, 0, SMALL_STRING_LEN);
1652
1653 snprintf(buffer, SMALL_STRING_LEN, "%u", x);
1654 getval= memcached_get(memc, buffer, strlen(buffer),
1655 &val_len, &flags, &rc);
1656 if (rc != MEMCACHED_SUCCESS)
1657 {
1658 if (rc == MEMCACHED_NOTFOUND)
1659 errors++;
1660 else
1661 {
1662 assert(rc);
1663 }
1664
1665 continue;
1666 }
1667 total+= val_len;
1668 errors= 0;
1669 free(getval);
1670 }
1671
1672 return 0;
1673 }
1674
1675 /* Do a large mget() over all the keys we think exist */
1676 #define KEY_COUNT 3000 // * 1024576
1677 static test_return user_supplied_bug3(memcached_st *memc)
1678 {
1679 memcached_return rc;
1680 unsigned int setter;
1681 unsigned int x;
1682 char **keys;
1683 size_t key_lengths[KEY_COUNT];
1684
1685 setter= 1;
1686 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1687 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1688 #ifdef NOT_YET
1689 setter = 20 * 1024576;
1690 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
1691 setter = 20 * 1024576;
1692 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
1693 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1694 getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1695 #endif
1696
1697 keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
1698 assert(keys);
1699 memset(keys, 0, (sizeof(char *) * KEY_COUNT));
1700 for (x= 0; x < KEY_COUNT; x++)
1701 {
1702 char buffer[30];
1703
1704 snprintf(buffer, 30, "%u", x);
1705 keys[x]= strdup(buffer);
1706 key_lengths[x]= strlen(keys[x]);
1707 }
1708
1709 rc= memcached_mget(memc, (const char **)keys, key_lengths, KEY_COUNT);
1710 assert(rc == MEMCACHED_SUCCESS);
1711
1712 /* Turn this into a help function */
1713 {
1714 char return_key[MEMCACHED_MAX_KEY];
1715 size_t return_key_length;
1716 char *return_value;
1717 size_t return_value_length;
1718 uint32_t flags;
1719
1720 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1721 &return_value_length, &flags, &rc)))
1722 {
1723 assert(return_value);
1724 assert(rc == MEMCACHED_SUCCESS);
1725 free(return_value);
1726 }
1727 }
1728
1729 for (x= 0; x < KEY_COUNT; x++)
1730 free(keys[x]);
1731 free(keys);
1732
1733 return 0;
1734 }
1735
1736 /* Make sure we behave properly if server list has no values */
1737 static test_return user_supplied_bug4(memcached_st *memc)
1738 {
1739 memcached_return rc;
1740 const char *keys[]= {"fudge", "son", "food"};
1741 size_t key_length[]= {5, 3, 4};
1742 unsigned int x;
1743 uint32_t flags;
1744 char return_key[MEMCACHED_MAX_KEY];
1745 size_t return_key_length;
1746 char *return_value;
1747 size_t return_value_length;
1748
1749 /* Here we free everything before running a bunch of mget tests */
1750 {
1751 memcached_server_list_free(memc->hosts);
1752 memc->hosts= NULL;
1753 memc->number_of_hosts= 0;
1754 }
1755
1756
1757 /* We need to empty the server before continueing test */
1758 rc= memcached_flush(memc, 0);
1759 assert(rc == MEMCACHED_NO_SERVERS);
1760
1761 rc= memcached_mget(memc, keys, key_length, 3);
1762 assert(rc == MEMCACHED_NO_SERVERS);
1763
1764 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1765 &return_value_length, &flags, &rc)) != NULL)
1766 {
1767 assert(return_value);
1768 }
1769 assert(!return_value);
1770 assert(return_value_length == 0);
1771 assert(rc == MEMCACHED_NO_SERVERS);
1772
1773 for (x= 0; x < 3; x++)
1774 {
1775 rc= memcached_set(memc, keys[x], key_length[x],
1776 keys[x], key_length[x],
1777 (time_t)50, (uint32_t)9);
1778 assert(rc == MEMCACHED_NO_SERVERS);
1779 }
1780
1781 rc= memcached_mget(memc, keys, key_length, 3);
1782 assert(rc == MEMCACHED_NO_SERVERS);
1783
1784 x= 0;
1785 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1786 &return_value_length, &flags, &rc)))
1787 {
1788 assert(return_value);
1789 assert(rc == MEMCACHED_SUCCESS);
1790 assert(return_key_length == return_value_length);
1791 assert(!memcmp(return_value, return_key, return_value_length));
1792 free(return_value);
1793 x++;
1794 }
1795
1796 return 0;
1797 }
1798
1799 #define VALUE_SIZE_BUG5 1048064
1800 static test_return user_supplied_bug5(memcached_st *memc)
1801 {
1802 memcached_return rc;
1803 const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1804 size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1805 char return_key[MEMCACHED_MAX_KEY];
1806 size_t return_key_length;
1807 char *value;
1808 size_t value_length;
1809 uint32_t flags;
1810 unsigned int count;
1811 unsigned int x;
1812 char insert_data[VALUE_SIZE_BUG5];
1813
1814 for (x= 0; x < VALUE_SIZE_BUG5; x++)
1815 insert_data[x]= (signed char)rand();
1816
1817 memcached_flush(memc, 0);
1818 value= memcached_get(memc, keys[0], key_length[0],
1819 &value_length, &flags, &rc);
1820 assert(value == NULL);
1821 rc= memcached_mget(memc, keys, key_length, 4);
1822
1823 count= 0;
1824 while ((value= memcached_fetch(memc, return_key, &return_key_length,
1825 &value_length, &flags, &rc)))
1826 count++;
1827 assert(count == 0);
1828
1829 for (x= 0; x < 4; x++)
1830 {
1831 rc= memcached_set(memc, keys[x], key_length[x],
1832 insert_data, VALUE_SIZE_BUG5,
1833 (time_t)0, (uint32_t)0);
1834 assert(rc == MEMCACHED_SUCCESS);
1835 }
1836
1837 for (x= 0; x < 10; x++)
1838 {
1839 value= memcached_get(memc, keys[0], key_length[0],
1840 &value_length, &flags, &rc);
1841 assert(value);
1842 free(value);
1843
1844 rc= memcached_mget(memc, keys, key_length, 4);
1845 count= 0;
1846 while ((value= memcached_fetch(memc, return_key, &return_key_length,
1847 &value_length, &flags, &rc)))
1848 {
1849 count++;
1850 free(value);
1851 }
1852 assert(count == 4);
1853 }
1854
1855 return 0;
1856 }
1857
1858 static test_return user_supplied_bug6(memcached_st *memc)
1859 {
1860 memcached_return rc;
1861 const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1862 size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1863 char return_key[MEMCACHED_MAX_KEY];
1864 size_t return_key_length;
1865 char *value;
1866 size_t value_length;
1867 uint32_t flags;
1868 unsigned int count;
1869 unsigned int x;
1870 char insert_data[VALUE_SIZE_BUG5];
1871
1872 for (x= 0; x < VALUE_SIZE_BUG5; x++)
1873 insert_data[x]= (signed char)rand();
1874
1875 memcached_flush(memc, 0);
1876 value= memcached_get(memc, keys[0], key_length[0],
1877 &value_length, &flags, &rc);
1878 assert(value == NULL);
1879 assert(rc == MEMCACHED_NOTFOUND);
1880 rc= memcached_mget(memc, keys, key_length, 4);
1881 assert(rc == MEMCACHED_SUCCESS);
1882
1883 count= 0;
1884 while ((value= memcached_fetch(memc, return_key, &return_key_length,
1885 &value_length, &flags, &rc)))
1886 count++;
1887 assert(count == 0);
1888 assert(rc == MEMCACHED_END);
1889
1890 for (x= 0; x < 4; x++)
1891 {
1892 rc= memcached_set(memc, keys[x], key_length[x],
1893 insert_data, VALUE_SIZE_BUG5,
1894 (time_t)0, (uint32_t)0);
1895 assert(rc == MEMCACHED_SUCCESS);
1896 }
1897
1898 for (x= 0; x < 2; x++)
1899 {
1900 value= memcached_get(memc, keys[0], key_length[0],
1901 &value_length, &flags, &rc);
1902 assert(value);
1903 free(value);
1904
1905 rc= memcached_mget(memc, keys, key_length, 4);
1906 assert(rc == MEMCACHED_SUCCESS);
1907 count= 3;
1908 /* We test for purge of partial complete fetches */
1909 for (count= 3; count; count--)
1910 {
1911 value= memcached_fetch(memc, return_key, &return_key_length,
1912 &value_length, &flags, &rc);
1913 assert(rc == MEMCACHED_SUCCESS);
1914 assert(!(memcmp(value, insert_data, value_length)));
1915 assert(value_length);
1916 free(value);
1917 }
1918 }
1919
1920 return 0;
1921 }
1922
1923 static test_return user_supplied_bug8(memcached_st *memc __attribute__((unused)))
1924 {
1925 memcached_return rc;
1926 memcached_st *mine;
1927 memcached_st *memc_clone;
1928
1929 memcached_server_st *servers;
1930 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";
1931
1932 servers= memcached_servers_parse(server_list);
1933 assert(servers);
1934
1935 mine= memcached_create(NULL);
1936 rc= memcached_server_push(mine, servers);
1937 assert(rc == MEMCACHED_SUCCESS);
1938 memcached_server_list_free(servers);
1939
1940 assert(mine);
1941 memc_clone= memcached_clone(NULL, mine);
1942
1943 memcached_quit(mine);
1944 memcached_quit(memc_clone);
1945
1946
1947 memcached_free(mine);
1948 memcached_free(memc_clone);
1949
1950 return 0;
1951 }
1952
1953 /* Test flag store/retrieve */
1954 static test_return user_supplied_bug7(memcached_st *memc)
1955 {
1956 memcached_return rc;
1957 const char *keys= "036790384900";
1958 size_t key_length= strlen(keys);
1959 char return_key[MEMCACHED_MAX_KEY];
1960 size_t return_key_length;
1961 char *value;
1962 size_t value_length;
1963 uint32_t flags;
1964 unsigned int x;
1965 char insert_data[VALUE_SIZE_BUG5];
1966
1967 for (x= 0; x < VALUE_SIZE_BUG5; x++)
1968 insert_data[x]= (signed char)rand();
1969
1970 memcached_flush(memc, 0);
1971
1972 flags= 245;
1973 rc= memcached_set(memc, keys, key_length,
1974 insert_data, VALUE_SIZE_BUG5,
1975 (time_t)0, flags);
1976 assert(rc == MEMCACHED_SUCCESS);
1977
1978 flags= 0;
1979 value= memcached_get(memc, keys, key_length,
1980 &value_length, &flags, &rc);
1981 assert(flags == 245);
1982 assert(value);
1983 free(value);
1984
1985 rc= memcached_mget(memc, &keys, &key_length, 1);
1986
1987 flags= 0;
1988 value= memcached_fetch(memc, return_key, &return_key_length,
1989 &value_length, &flags, &rc);
1990 assert(flags == 245);
1991 assert(value);
1992 free(value);
1993
1994
1995 return 0;
1996 }
1997
1998 static test_return user_supplied_bug9(memcached_st *memc)
1999 {
2000 memcached_return rc;
2001 const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2002 size_t key_length[3];
2003 unsigned int x;
2004 uint32_t flags;
2005 unsigned count= 0;
2006
2007 char return_key[MEMCACHED_MAX_KEY];
2008 size_t return_key_length;
2009 char *return_value;
2010 size_t return_value_length;
2011
2012
2013 key_length[0]= strlen("UDATA:edevil@sapo.pt");
2014 key_length[1]= strlen("fudge&*@#");
2015 key_length[2]= strlen("for^#@&$not");
2016
2017
2018 for (x= 0; x < 3; x++)
2019 {
2020 rc= memcached_set(memc, keys[x], key_length[x],
2021 keys[x], key_length[x],
2022 (time_t)50, (uint32_t)9);
2023 assert(rc == MEMCACHED_SUCCESS);
2024 }
2025
2026 rc= memcached_mget(memc, keys, key_length, 3);
2027 assert(rc == MEMCACHED_SUCCESS);
2028
2029 /* We need to empty the server before continueing test */
2030 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2031 &return_value_length, &flags, &rc)) != NULL)
2032 {
2033 assert(return_value);
2034 free(return_value);
2035 count++;
2036 }
2037 assert(count == 3);
2038
2039 return 0;
2040 }
2041
2042 /* We are testing with aggressive timeout to get failures */
2043 static test_return user_supplied_bug10(memcached_st *memc)
2044 {
2045 const char *key= "foo";
2046 char *value;
2047 size_t value_length= 512;
2048 unsigned int x;
2049 size_t key_len= 3;
2050 memcached_return rc;
2051 unsigned int set= 1;
2052 memcached_st *mclone= memcached_clone(NULL, memc);
2053 int32_t timeout;
2054
2055 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
2056 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
2057 timeout= 2;
2058 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
2059 (uint64_t)timeout);
2060
2061 value = (char*)malloc(value_length * sizeof(char));
2062
2063 for (x= 0; x < value_length; x++)
2064 value[x]= (char) (x % 127);
2065
2066 for (x= 1; x <= 100000; ++x)
2067 {
2068 rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
2069
2070 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE ||
2071 rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT);
2072
2073 if (rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_TIMEOUT)
2074 x--;
2075 }
2076
2077 free(value);
2078 memcached_free(mclone);
2079
2080 return 0;
2081 }
2082
2083 /*
2084 We are looking failures in the async protocol
2085 */
2086 static test_return user_supplied_bug11(memcached_st *memc)
2087 {
2088 const char *key= "foo";
2089 char *value;
2090 size_t value_length= 512;
2091 unsigned int x;
2092 size_t key_len= 3;
2093 memcached_return rc;
2094 unsigned int set= 1;
2095 int32_t timeout;
2096 memcached_st *mclone= memcached_clone(NULL, memc);
2097
2098 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
2099 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
2100 timeout= -1;
2101 memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
2102 (size_t)timeout);
2103
2104 timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
2105
2106 assert(timeout == -1);
2107
2108 value = (char*)malloc(value_length * sizeof(char));
2109
2110 for (x= 0; x < value_length; x++)
2111 value[x]= (char) (x % 127);
2112
2113 for (x= 1; x <= 100000; ++x)
2114 {
2115 rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
2116 }
2117
2118 free(value);
2119 memcached_free(mclone);
2120
2121 return 0;
2122 }
2123
2124 /*
2125 Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2126 */
2127 static test_return user_supplied_bug12(memcached_st *memc)
2128 {
2129 memcached_return rc;
2130 uint32_t flags;
2131 size_t value_length;
2132 char *value;
2133 uint64_t number_value;
2134
2135 value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
2136 &value_length, &flags, &rc);
2137 assert(value == NULL);
2138 assert(rc == MEMCACHED_NOTFOUND);
2139
2140 rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
2141 1, &number_value);
2142
2143 assert(value == NULL);
2144 /* The binary protocol will set the key if it doesn't exist */
2145 if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
2146 assert(rc == MEMCACHED_SUCCESS);
2147 else
2148 assert(rc == MEMCACHED_NOTFOUND);
2149
2150 rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2151
2152 value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
2153 &value_length, &flags, &rc);
2154 assert(value);
2155 assert(rc == MEMCACHED_SUCCESS);
2156 free(value);
2157
2158 rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
2159 1, &number_value);
2160 assert(number_value == 2);
2161 assert(rc == MEMCACHED_SUCCESS);
2162
2163 return 0;
2164 }
2165
2166 /*
2167 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2168 set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2169 */
2170 static test_return user_supplied_bug13(memcached_st *memc)
2171 {
2172 char key[] = "key34567890";
2173 char *overflow;
2174 memcached_return rc;
2175 size_t overflowSize;
2176
2177 char commandFirst[]= "set key34567890 0 0 ";
2178 char commandLast[] = " \r\n"; /* first line of command sent to server */
2179 size_t commandLength;
2180 size_t testSize;
2181
2182 commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
2183
2184 overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
2185
2186 for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
2187 {
2188 overflow= malloc(testSize);
2189 assert(overflow != NULL);
2190
2191 memset(overflow, 'x', testSize);
2192 rc= memcached_set(memc, key, strlen(key),
2193 overflow, testSize, 0, 0);
2194 assert(rc == MEMCACHED_SUCCESS);
2195 free(overflow);
2196 }
2197
2198 return 0;
2199 }
2200
2201
2202 /*
2203 Test values of many different sizes
2204 Bug found where command total one more than MEMCACHED_MAX_BUFFER
2205 set key34567890 0 0 8169 \r\n
2206 is sent followed by buffer of size 8169, followed by 8169
2207 */
2208 static test_return user_supplied_bug14(memcached_st *memc)
2209 {
2210 size_t setter= 1;
2211 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
2212 memcached_return rc;
2213 const char *key= "foo";
2214 char *value;
2215 size_t value_length= 18000;
2216 char *string;
2217 size_t string_length;
2218 uint32_t flags;
2219 unsigned int x;
2220 size_t current_length;
2221
2222 value = (char*)malloc(value_length);
2223 assert(value);
2224
2225 for (x= 0; x < value_length; x++)
2226 value[x] = (char) (x % 127);
2227
2228 for (current_length= 0; current_length < value_length; current_length++)
2229 {
2230 rc= memcached_set(memc, key, strlen(key),
2231 value, current_length,
2232 (time_t)0, (uint32_t)0);
2233 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
2234
2235 string= memcached_get(memc, key, strlen(key),
2236 &string_length, &flags, &rc);
2237
2238 assert(rc == MEMCACHED_SUCCESS);
2239 assert(string_length == current_length);
2240 assert(!memcmp(string, value, string_length));
2241
2242 free(string);
2243 }
2244
2245 free(value);
2246
2247 return 0;
2248 }
2249
2250 /*
2251 Look for zero length value problems
2252 */
2253 static test_return user_supplied_bug15(memcached_st *memc)
2254 {
2255 uint32_t x;
2256 memcached_return rc;
2257 const char *key= "mykey";
2258 char *value;
2259 size_t length;
2260 uint32_t flags;
2261
2262 for (x= 0; x < 2; x++)
2263 {
2264 rc= memcached_set(memc, key, strlen(key),
2265 NULL, 0,
2266 (time_t)0, (uint32_t)0);
2267
2268 assert(rc == MEMCACHED_SUCCESS);
2269
2270 value= memcached_get(memc, key, strlen(key),
2271 &length, &flags, &rc);
2272
2273 assert(rc == MEMCACHED_SUCCESS);
2274 assert(value == NULL);
2275 assert(length == 0);
2276 assert(flags == 0);
2277
2278 value= memcached_get(memc, key, strlen(key),
2279 &length, &flags, &rc);
2280
2281 assert(rc == MEMCACHED_SUCCESS);
2282 assert(value == NULL);
2283 assert(length == 0);
2284 assert(flags == 0);
2285 }
2286
2287 return 0;
2288 }
2289
2290 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2291 static test_return user_supplied_bug16(memcached_st *memc)
2292 {
2293 memcached_return rc;
2294 const char *key= "mykey";
2295 char *value;
2296 size_t length;
2297 uint32_t flags;
2298
2299 rc= memcached_set(memc, key, strlen(key),
2300 NULL, 0,
2301 (time_t)0, UINT32_MAX);
2302
2303 assert(rc == MEMCACHED_SUCCESS);
2304
2305 value= memcached_get(memc, key, strlen(key),
2306 &length, &flags, &rc);
2307
2308 assert(rc == MEMCACHED_SUCCESS);
2309 assert(value == NULL);
2310 assert(length == 0);
2311 assert(flags == UINT32_MAX);
2312
2313 return 0;
2314 }
2315
2316 #ifndef __sun
2317 /* Check the validity of chinese key*/
2318 static test_return user_supplied_bug17(memcached_st *memc)
2319 {
2320 memcached_return rc;
2321 const char *key= "豆瓣";
2322 const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
2323 char *value2;
2324 size_t length;
2325 uint32_t flags;
2326
2327 rc= memcached_set(memc, key, strlen(key),
2328 value, strlen(value),
2329 (time_t)0, 0);
2330
2331 assert(rc == MEMCACHED_SUCCESS);
2332
2333 value2= memcached_get(memc, key, strlen(key),
2334 &length, &flags, &rc);
2335
2336 assert(length==strlen(value));
2337 assert(rc == MEMCACHED_SUCCESS);
2338 assert(memcmp(value, value2, length)==0);
2339 free(value2);
2340
2341 return 0;
2342 }
2343 #endif
2344
2345 /*
2346 From Andrei on IRC
2347 */
2348
2349 static test_return user_supplied_bug19(memcached_st *memc)
2350 {
2351 memcached_st *m;
2352 memcached_server_st *s;
2353 memcached_return res;
2354
2355 (void)memc;
2356
2357 m= memcached_create(NULL);
2358 memcached_server_add_with_weight(m, "localhost", 11311, 100);
2359 memcached_server_add_with_weight(m, "localhost", 11312, 100);
2360
2361 s= memcached_server_by_key(m, "a", 1, &res);
2362 memcached_server_free(s);
2363
2364 memcached_free(m);
2365
2366 return 0;
2367 }
2368
2369 /* CAS test from Andei */
2370 static test_return user_supplied_bug20(memcached_st *memc)
2371 {
2372 memcached_return status;
2373 memcached_result_st *result, result_obj;
2374 const char *key = "abc";
2375 size_t key_len = strlen("abc");
2376 const char *value = "foobar";
2377 size_t value_len = strlen(value);
2378
2379 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
2380
2381 status = memcached_set(memc, key, key_len, value, value_len, (time_t)0, (uint32_t)0);
2382 assert(status == MEMCACHED_SUCCESS);
2383
2384 status = memcached_mget(memc, &key, &key_len, 1);
2385 assert(status == MEMCACHED_SUCCESS);
2386
2387 result= memcached_result_create(memc, &result_obj);
2388 assert(result);
2389
2390 memcached_result_create(memc, &result_obj);
2391 result= memcached_fetch_result(memc, &result_obj, &status);
2392
2393 assert(result);
2394 assert(status == MEMCACHED_SUCCESS);
2395
2396 memcached_result_free(result);
2397
2398 return 0;
2399 }
2400
2401 #include "ketama_test_cases.h"
2402 static test_return user_supplied_bug18(memcached_st *trash)
2403 {
2404 memcached_return rc;
2405 uint64_t value;
2406 int x;
2407 memcached_server_st *server_pool;
2408 memcached_st *memc;
2409
2410 (void)trash;
2411
2412 memc= memcached_create(NULL);
2413 assert(memc);
2414
2415 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
2416 assert(rc == MEMCACHED_SUCCESS);
2417
2418 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
2419 assert(value == 1);
2420
2421 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
2422 assert(rc == MEMCACHED_SUCCESS);
2423
2424 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
2425 assert(value == MEMCACHED_HASH_MD5);
2426
2427 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");
2428 memcached_server_push(memc, server_pool);
2429
2430 /* verify that the server list was parsed okay. */
2431 assert(memc->number_of_hosts == 8);
2432 assert(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
2433 assert(server_pool[0].port == 11211);
2434 assert(server_pool[0].weight == 600);
2435 assert(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
2436 assert(server_pool[2].port == 11211);
2437 assert(server_pool[2].weight == 200);
2438 assert(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
2439 assert(server_pool[7].port == 11211);
2440 assert(server_pool[7].weight == 100);
2441
2442 /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2443 * us test the boundary wraparound.
2444 */
2445 assert(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
2446
2447 /* verify the standard ketama set. */
2448 for (x= 0; x < 99; x++)
2449 {
2450 uint32_t server_idx = memcached_generate_hash(memc, test_cases[x].key, strlen(test_cases[x].key));
2451 char *hostname = memc->hosts[server_idx].hostname;
2452 assert(strcmp(hostname, test_cases[x].server) == 0);
2453 }
2454
2455 memcached_server_list_free(server_pool);
2456 memcached_free(memc);
2457
2458 return 0;
2459 }
2460
2461 /* Large mget() of missing keys with binary proto
2462 * See http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2463 */
2464
2465 void fail(int);
2466
2467 static test_return _user_supplied_bug21(size_t key_count)
2468 {
2469 memcached_return rc;
2470 unsigned int x;
2471 char **keys;
2472 size_t* key_lengths;
2473 void (*oldalarm)(int);
2474 memcached_st *memc;
2475
2476 key_lengths = malloc(sizeof(size_t) * key_count);
2477
2478 memc= memcached_create(NULL);
2479 assert(memc);
2480
2481 /* only binproto uses getq for mget */
2482 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
2483
2484 rc= memcached_server_add(memc, "localhost", 11221);
2485
2486 /* empty the cache to ensure misses (hence non-responses) */
2487 rc= memcached_flush(memc, 0);
2488 assert(rc == MEMCACHED_SUCCESS);
2489
2490 keys= (char **)malloc(sizeof(char *) * key_count);
2491 assert(keys);
2492 memset(keys, 0, (sizeof(char *) * key_count));
2493 for (x= 0; x < key_count; x++)
2494 {
2495 char buffer[30];
2496
2497 snprintf(buffer, 30, "%u", x);
2498 keys[x]= strdup(buffer);
2499 key_lengths[x]= strlen(keys[x]);
2500 }
2501
2502 oldalarm = signal(SIGALRM, fail);
2503 alarm(5);
2504
2505 rc= memcached_mget(memc, (const char **)keys, key_lengths, key_count);
2506 assert(rc == MEMCACHED_SUCCESS);
2507
2508 alarm(0);
2509 signal(SIGALRM, oldalarm);
2510
2511 /* Turn this into a help function */
2512 {
2513 char return_key[MEMCACHED_MAX_KEY];
2514 size_t return_key_length;
2515 char *return_value;
2516 size_t return_value_length;
2517 uint32_t flags;
2518
2519 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2520 &return_value_length, &flags, &rc)))
2521 {
2522 assert(return_value);
2523 assert(rc == MEMCACHED_SUCCESS);
2524 free(return_value);
2525 }
2526 }
2527
2528 for (x= 0; x < key_count; x++)
2529 free(keys[x]);
2530 free(keys);
2531
2532 memcached_free(memc);
2533
2534 free(key_lengths);
2535
2536 return MEMCACHED_SUCCESS;
2537 }
2538
2539 static test_return user_supplied_bug21(memcached_st *trash)
2540 {
2541 (void)trash;
2542 memcached_return rc;
2543
2544 /* should work as of r580 */
2545 rc = _user_supplied_bug21(10);
2546 assert(rc == MEMCACHED_SUCCESS);
2547
2548 /* should fail as of r580 */
2549 rc = _user_supplied_bug21(1000);
2550 assert(rc == MEMCACHED_SUCCESS);
2551
2552 return MEMCACHED_SUCCESS;
2553 }
2554
2555 void fail(int unused __attribute__((unused)))
2556 {
2557 assert(0);
2558 }
2559
2560 static test_return auto_eject_hosts(memcached_st *trash)
2561 {
2562 (void) trash;
2563
2564 memcached_return rc;
2565 memcached_st *memc= memcached_create(NULL);
2566 assert(memc);
2567
2568 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
2569 assert(rc == MEMCACHED_SUCCESS);
2570
2571 uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
2572 assert(value == 1);
2573
2574 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
2575 assert(rc == MEMCACHED_SUCCESS);
2576
2577 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
2578 assert(value == MEMCACHED_HASH_MD5);
2579
2580 /* server should be removed when in delay */
2581 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS, 1);
2582 assert(rc == MEMCACHED_SUCCESS);
2583
2584 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS);
2585 assert(value == 1);
2586
2587 memcached_server_st *server_pool;
2588 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");
2589 memcached_server_push(memc, server_pool);
2590
2591 /* verify that the server list was parsed okay. */
2592 assert(memc->number_of_hosts == 8);
2593 assert(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
2594 assert(server_pool[0].port == 11211);
2595 assert(server_pool[0].weight == 600);
2596 assert(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
2597 assert(server_pool[2].port == 11211);
2598 assert(server_pool[2].weight == 200);
2599 assert(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
2600 assert(server_pool[7].port == 11211);
2601 assert(server_pool[7].weight == 100);
2602
2603 memc->hosts[2].next_retry = time(NULL) + 15;
2604 memc->next_distribution_rebuild= time(NULL) - 1;
2605
2606 for (int x= 0; x < 99; x++)
2607 {
2608 uint32_t server_idx = memcached_generate_hash(memc, test_cases[x].key, strlen(test_cases[x].key));
2609 assert(server_idx != 2);
2610 }
2611
2612 /* and re-added when it's back. */
2613 memc->hosts[2].next_retry = time(NULL) - 1;
2614 memc->next_distribution_rebuild= time(NULL) - 1;
2615 run_distribution(memc);
2616 for (int x= 0; x < 99; x++)
2617 {
2618 uint32_t server_idx = memcached_generate_hash(memc, test_cases[x].key, strlen(test_cases[x].key));
2619 char *hostname = memc->hosts[server_idx].hostname;
2620 assert(strcmp(hostname, test_cases[x].server) == 0);
2621 }
2622
2623 memcached_server_list_free(server_pool);
2624 memcached_free(memc);
2625
2626 return TEST_SUCCESS;
2627 }
2628
2629 static test_return result_static(memcached_st *memc)
2630 {
2631 memcached_result_st result;
2632 memcached_result_st *result_ptr;
2633
2634 result_ptr= memcached_result_create(memc, &result);
2635 assert(result.is_allocated == false);
2636 assert(result_ptr);
2637 memcached_result_free(&result);
2638
2639 return 0;
2640 }
2641
2642 static test_return result_alloc(memcached_st *memc)
2643 {
2644 memcached_result_st *result;
2645
2646 result= memcached_result_create(memc, NULL);
2647 assert(result);
2648 memcached_result_free(result);
2649
2650 return 0;
2651 }
2652
2653 static test_return string_static_null(memcached_st *memc)
2654 {
2655 memcached_string_st string;
2656 memcached_string_st *string_ptr;
2657
2658 string_ptr= memcached_string_create(memc, &string, 0);
2659 assert(string.is_allocated == false);
2660 assert(string_ptr);
2661 memcached_string_free(&string);
2662
2663 return 0;
2664 }
2665
2666 static test_return string_alloc_null(memcached_st *memc)
2667 {
2668 memcached_string_st *string;
2669
2670 string= memcached_string_create(memc, NULL, 0);
2671 assert(string);
2672 memcached_string_free(string);
2673
2674 return 0;
2675 }
2676
2677 static test_return string_alloc_with_size(memcached_st *memc)
2678 {
2679 memcached_string_st *string;
2680
2681 string= memcached_string_create(memc, NULL, 1024);
2682 assert(string);
2683 memcached_string_free(string);
2684
2685 return 0;
2686 }
2687
2688 static test_return string_alloc_with_size_toobig(memcached_st *memc)
2689 {
2690 memcached_string_st *string;
2691
2692 string= memcached_string_create(memc, NULL, SIZE_MAX);
2693 assert(string == NULL);
2694
2695 return 0;
2696 }
2697
2698 static test_return string_alloc_append(memcached_st *memc)
2699 {
2700 unsigned int x;
2701 char buffer[SMALL_STRING_LEN];
2702 memcached_string_st *string;
2703
2704 /* Ring the bell! */
2705 memset(buffer, 6, SMALL_STRING_LEN);
2706
2707 string= memcached_string_create(memc, NULL, 100);
2708 assert(string);
2709
2710 for (x= 0; x < 1024; x++)
2711 {
2712 memcached_return rc;
2713 rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
2714 assert(rc == MEMCACHED_SUCCESS);
2715 }
2716 memcached_string_free(string);
2717
2718 return 0;
2719 }
2720
2721 static test_return string_alloc_append_toobig(memcached_st *memc)
2722 {
2723 memcached_return rc;
2724 unsigned int x;
2725 char buffer[SMALL_STRING_LEN];
2726 memcached_string_st *string;
2727
2728 /* Ring the bell! */
2729 memset(buffer, 6, SMALL_STRING_LEN);
2730
2731 string= memcached_string_create(memc, NULL, 100);
2732 assert(string);
2733
2734 for (x= 0; x < 1024; x++)
2735 {
2736 rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
2737 assert(rc == MEMCACHED_SUCCESS);
2738 }
2739 rc= memcached_string_append(string, buffer, SIZE_MAX);
2740 assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
2741 memcached_string_free(string);
2742
2743 return 0;
2744 }
2745
2746 static test_return cleanup_pairs(memcached_st *memc __attribute__((unused)))
2747 {
2748 pairs_free(global_pairs);
2749
2750 return 0;
2751 }
2752
2753 static test_return generate_pairs(memcached_st *memc __attribute__((unused)))
2754 {
2755 unsigned long long x;
2756 global_pairs= pairs_generate(GLOBAL_COUNT, 400);
2757 global_count= GLOBAL_COUNT;
2758
2759 for (x= 0; x < global_count; x++)
2760 {
2761 global_keys[x]= global_pairs[x].key;
2762 global_keys_length[x]= global_pairs[x].key_length;
2763 }
2764
2765 return 0;
2766 }
2767
2768 static test_return generate_large_pairs(memcached_st *memc __attribute__((unused)))
2769 {
2770 unsigned long long x;
2771 global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
2772 global_count= GLOBAL2_COUNT;
2773
2774 for (x= 0; x < global_count; x++)
2775 {
2776 global_keys[x]= global_pairs[x].key;
2777 global_keys_length[x]= global_pairs[x].key_length;
2778 }
2779
2780 return 0;
2781 }
2782
2783 static test_return generate_data(memcached_st *memc)
2784 {
2785 execute_set(memc, global_pairs, global_count);
2786
2787 return 0;
2788 }
2789
2790 static test_return generate_data_with_stats(memcached_st *memc)
2791 {
2792 memcached_stat_st *stat_p;
2793 memcached_return rc;
2794 uint32_t host_index= 0;
2795 execute_set(memc, global_pairs, global_count);
2796
2797 //TODO: hosts used size stats
2798 stat_p= memcached_stat(memc, NULL, &rc);
2799 assert(stat_p);
2800
2801 for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++)
2802 {
2803 /* This test was changes so that "make test" would work properlly */
2804 #ifdef DEBUG
2805 printf("\nserver %u|%s|%u bytes: %llu\n", host_index, (memc->hosts)[host_index].hostname, (memc->hosts)[host_index].port, (unsigned long long)(stat_p + host_index)->bytes);
2806 #endif
2807 assert((unsigned long long)(stat_p + host_index)->bytes);
2808 }
2809
2810 memcached_stat_free(NULL, stat_p);
2811
2812 return 0;
2813 }
2814 static test_return generate_buffer_data(memcached_st *memc)
2815 {
2816 size_t latch= 0;
2817
2818 latch= 1;
2819 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
2820 generate_data(memc);
2821
2822 return 0;
2823 }
2824
2825 static test_return get_read_count(memcached_st *memc)
2826 {
2827 unsigned int x;
2828 memcached_return rc;
2829 memcached_st *memc_clone;
2830
2831 memc_clone= memcached_clone(NULL, memc);
2832 assert(memc_clone);
2833
2834 memcached_server_add_with_weight(memc_clone, "localhost", 6666, 0);
2835
2836 {
2837 char *return_value;
2838 size_t return_value_length;
2839 uint32_t flags;
2840 uint32_t count;
2841
2842 for (x= count= 0; x < global_count; x++)
2843 {
2844 return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x],
2845 &return_value_length, &flags, &rc);
2846 if (rc == MEMCACHED_SUCCESS)
2847 {
2848 count++;
2849 if (return_value)
2850 free(return_value);
2851 }
2852 }
2853 fprintf(stderr, "\t%u -> %u", global_count, count);
2854 }
2855
2856 memcached_free(memc_clone);
2857
2858 return 0;
2859 }
2860
2861 static test_return get_read(memcached_st *memc)
2862 {
2863 unsigned int x;
2864 memcached_return rc;
2865
2866 {
2867 char *return_value;
2868 size_t return_value_length;
2869 uint32_t flags;
2870
2871 for (x= 0; x < global_count; x++)
2872 {
2873 return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
2874 &return_value_length, &flags, &rc);
2875 /*
2876 assert(return_value);
2877 assert(rc == MEMCACHED_SUCCESS);
2878 */
2879 if (rc == MEMCACHED_SUCCESS && return_value)
2880 free(return_value);
2881 }
2882 }
2883
2884 return 0;
2885 }
2886
2887 static test_return mget_read(memcached_st *memc)
2888 {
2889 memcached_return rc;
2890
2891 rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2892 assert(rc == MEMCACHED_SUCCESS);
2893 /* Turn this into a help function */
2894 {
2895 char return_key[MEMCACHED_MAX_KEY];
2896 size_t return_key_length;
2897 char *return_value;
2898 size_t return_value_length;
2899 uint32_t flags;
2900
2901 while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2902 &return_value_length, &flags, &rc)))
2903 {
2904 assert(return_value);
2905 assert(rc == MEMCACHED_SUCCESS);
2906 free(return_value);
2907 }
2908 }
2909
2910 return 0;
2911 }
2912
2913 static test_return mget_read_result(memcached_st *memc)
2914 {
2915 memcached_return rc;
2916
2917 rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2918 assert(rc == MEMCACHED_SUCCESS);
2919 /* Turn this into a help function */
2920 {
2921 memcached_result_st results_obj;
2922 memcached_result_st *results;
2923
2924 results= memcached_result_create(memc, &results_obj);
2925
2926 while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
2927 {
2928 assert(results);
2929 assert(rc == MEMCACHED_SUCCESS);
2930 }
2931
2932 memcached_result_free(&results_obj);
2933 }
2934
2935 return 0;
2936 }
2937
2938 static test_return mget_read_function(memcached_st *memc)
2939 {
2940 memcached_return rc;
2941 unsigned int counter;
2942 memcached_execute_function callbacks[1];
2943
2944 rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2945 assert(rc == MEMCACHED_SUCCESS);
2946
2947 callbacks[0]= &callback_counter;
2948 counter= 0;
2949 rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
2950
2951 return 0;
2952 }
2953
2954 static test_return delete_generate(memcached_st *memc)
2955 {
2956 unsigned int x;
2957
2958 for (x= 0; x < global_count; x++)
2959 {
2960 (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2961 }
2962
2963 return 0;
2964 }
2965
2966 static test_return delete_buffer_generate(memcached_st *memc)
2967 {
2968 size_t latch= 0;
2969 unsigned int x;
2970
2971 latch= 1;
2972 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
2973
2974 for (x= 0; x < global_count; x++)
2975 {
2976 (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2977 }
2978
2979 return 0;
2980 }
2981
2982 static test_return add_host_test1(memcached_st *memc)
2983 {
2984 unsigned int x;
2985 memcached_return rc;
2986 char servername[]= "0.example.com";
2987 memcached_server_st *servers;
2988
2989 servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
2990 assert(servers);
2991 assert(1 == memcached_server_list_count(servers));
2992
2993 for (x= 2; x < 20; x++)
2994 {
2995 char buffer[SMALL_STRING_LEN];
2996
2997 snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
2998 servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
2999 &rc);
3000 assert(rc == MEMCACHED_SUCCESS);
3001 assert(x == memcached_server_list_count(servers));
3002 }
3003
3004 rc= memcached_server_push(memc, servers);
3005 assert(rc == MEMCACHED_SUCCESS);
3006 rc= memcached_server_push(memc, servers);
3007 assert(rc == MEMCACHED_SUCCESS);
3008
3009 memcached_server_list_free(servers);
3010
3011 return 0;
3012 }
3013
3014 static memcached_return pre_nonblock(memcached_st *memc)
3015 {
3016 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
3017
3018 return MEMCACHED_SUCCESS;
3019 }
3020
3021 static memcached_return pre_nonblock_binary(memcached_st *memc)
3022 {
3023 memcached_return rc= MEMCACHED_FAILURE;
3024 memcached_st *memc_clone;
3025
3026 memc_clone= memcached_clone(NULL, memc);
3027 assert(memc_clone);
3028 // The memcached_version needs to be done on a clone, because the server
3029 // will not toggle protocol on an connection.
3030 memcached_version(memc_clone);
3031
3032 if (memc_clone->hosts[0].major_version >= 1 && memc_clone->hosts[0].minor_version > 2)
3033 {
3034 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
3035 rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3036 assert(rc == MEMCACHED_SUCCESS);
3037 assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
3038 }
3039
3040 memcached_free(memc_clone);
3041 return rc;
3042 }
3043
3044 static memcached_return pre_murmur(memcached_st *memc)
3045 {
3046 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
3047
3048 return MEMCACHED_SUCCESS;
3049 }
3050
3051 static memcached_return pre_jenkins(memcached_st *memc)
3052 {
3053 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_JENKINS);
3054
3055 return MEMCACHED_SUCCESS;
3056 }
3057
3058
3059 static memcached_return pre_md5(memcached_st *memc)
3060 {
3061 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5);
3062
3063 return MEMCACHED_SUCCESS;
3064 }
3065
3066 static memcached_return pre_crc(memcached_st *memc)
3067 {
3068 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_CRC);
3069
3070 return MEMCACHED_SUCCESS;
3071 }
3072
3073 static memcached_return pre_hsieh(memcached_st *memc)
3074 {
3075 #ifdef HAVE_HSIEH_HASH
3076 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH);
3077 return MEMCACHED_SUCCESS;
3078 #else
3079 (void) memc;
3080 return MEMCACHED_FAILURE;
3081 #endif
3082 }
3083
3084 static memcached_return pre_hash_fnv1_64(memcached_st *memc)
3085 {
3086 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_64);
3087
3088 return MEMCACHED_SUCCESS;
3089 }
3090
3091 static memcached_return pre_hash_fnv1a_64(memcached_st *memc)
3092 {
3093 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64);
3094
3095 return MEMCACHED_SUCCESS;
3096 }
3097
3098 static memcached_return pre_hash_fnv1_32(memcached_st *memc)
3099 {
3100 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_32);
3101
3102 return MEMCACHED_SUCCESS;
3103 }
3104
3105 static memcached_return pre_hash_fnv1a_32(memcached_st *memc)
3106 {
3107 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_32);
3108
3109 return MEMCACHED_SUCCESS;
3110 }
3111
3112 static memcached_return pre_behavior_ketama(memcached_st *memc)
3113 {
3114 memcached_return rc;
3115 uint64_t value;
3116
3117 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1);
3118 assert(rc == MEMCACHED_SUCCESS);
3119
3120 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);
3121 assert(value == 1);
3122
3123 return MEMCACHED_SUCCESS;
3124 }
3125
3126 static memcached_return pre_behavior_ketama_weighted(memcached_st *memc)
3127 {
3128 memcached_return rc;
3129 uint64_t value;
3130
3131 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
3132 assert(rc == MEMCACHED_SUCCESS);
3133
3134 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
3135 assert(value == 1);
3136
3137 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
3138 assert(rc == MEMCACHED_SUCCESS);
3139
3140 value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
3141 assert(value == MEMCACHED_HASH_MD5);
3142 return MEMCACHED_SUCCESS;
3143 }
3144
3145 static memcached_return pre_binary(memcached_st *memc)
3146 {
3147 memcached_return rc= MEMCACHED_FAILURE;
3148 memcached_st *memc_clone;
3149
3150 memc_clone= memcached_clone(NULL, memc);
3151 assert(memc_clone);
3152 // The memcached_version needs to be done on a clone, because the server
3153 // will not toggle protocol on an connection.
3154 memcached_version(memc_clone);
3155
3156 if (memc_clone->hosts[0].major_version >= 1 && memc_clone->hosts[0].minor_version > 2)
3157 {
3158 rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3159 assert(rc == MEMCACHED_SUCCESS);
3160 assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
3161 }
3162
3163 memcached_free(memc_clone);
3164 return rc;
3165 }
3166
3167 static memcached_return pre_replication(memcached_st *memc)
3168 {
3169 memcached_return rc= MEMCACHED_FAILURE;
3170 if (pre_binary(memc) == MEMCACHED_SUCCESS)
3171 {
3172 /*
3173 * Make sure that we store the item on all servers
3174 * (master + replicas == number of servers)
3175 */
3176 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS,
3177 memc->number_of_hosts - 1);
3178 assert(rc == MEMCACHED_SUCCESS);
3179 assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memc->number_of_hosts - 1);
3180 }
3181
3182 return rc;
3183 }
3184
3185 static memcached_return pre_replication_noblock(memcached_st *memc)
3186 {
3187 memcached_return rc= MEMCACHED_FAILURE;
3188 if (pre_replication(memc) == MEMCACHED_SUCCESS &&
3189 pre_nonblock(memc) == MEMCACHED_SUCCESS)
3190 rc= MEMCACHED_SUCCESS;
3191
3192 return rc;
3193 }
3194
3195 static void my_free(memcached_st *ptr __attribute__((unused)), void *mem)
3196 {
3197 free(mem);
3198 }
3199
3200 static void *my_malloc(memcached_st *ptr __attribute__((unused)), const size_t size)
3201 {
3202 void *ret= malloc(size);
3203 if (ret != NULL)
3204 memset(ret, 0xff, size);
3205
3206 return ret;
3207 }
3208
3209 static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, const size_t size)
3210 {
3211 return realloc(mem, size);
3212 }
3213
3214 static void *my_calloc(memcached_st *ptr __attribute__((unused)), size_t nelem, const size_t size)
3215 {
3216 return calloc(nelem, size);
3217 }
3218
3219 static memcached_return set_prefix(memcached_st *memc)
3220 {
3221 memcached_return rc;
3222 const char *key= "mine";
3223 char *value;
3224
3225 /* Make sure be default none exists */
3226 value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3227 assert(rc == MEMCACHED_FAILURE);
3228
3229 /* Test a clean set */
3230 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3231 assert(rc == MEMCACHED_SUCCESS);
3232
3233 value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3234 assert(memcmp(value, key, 4) == 0);
3235 assert(rc == MEMCACHED_SUCCESS);
3236
3237 /* Test that we can turn it off */
3238 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3239 assert(rc == MEMCACHED_SUCCESS);
3240
3241 value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3242 assert(rc == MEMCACHED_FAILURE);
3243
3244 /* Now setup for main test */
3245 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3246 assert(rc == MEMCACHED_SUCCESS);
3247
3248 value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3249 assert(rc == MEMCACHED_SUCCESS);
3250 assert(memcmp(value, key, 4) == 0);
3251
3252 /* Set to Zero, and then Set to something too large */
3253 {
3254 char long_key[255];
3255 memset(long_key, 0, 255);
3256
3257 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3258 assert(rc == MEMCACHED_SUCCESS);
3259
3260 value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3261 assert(rc == MEMCACHED_FAILURE);
3262 assert(value == NULL);
3263
3264 /* Test a long key for failure */
3265 /* TODO, extend test to determine based on setting, what result should be */
3266 strcpy(long_key, "Thisismorethentheallottednumberofcharacters");
3267 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3268 //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3269 assert(rc == MEMCACHED_SUCCESS);
3270
3271 /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3272 strcpy(long_key, "This is more then the allotted number of characters");
3273 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3274 assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3275
3276 /* Test for a bad prefix, but with a short key */
3277 rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
3278 assert(rc == MEMCACHED_SUCCESS);
3279
3280 strcpy(long_key, "dog cat");
3281 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3282 assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3283 }
3284
3285 return MEMCACHED_SUCCESS;
3286 }
3287
3288 #ifdef MEMCACHED_ENABLE_DEPRECATED
3289 static memcached_return deprecated_set_memory_alloc(memcached_st *memc)
3290 {
3291 void *test_ptr= NULL;
3292 void *cb_ptr= NULL;
3293 {
3294 memcached_malloc_function malloc_cb=
3295 (memcached_malloc_function)my_malloc;
3296 cb_ptr= *(void **)&malloc_cb;
3297 memcached_return rc;
3298
3299 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, cb_ptr);
3300 assert(rc == MEMCACHED_SUCCESS);
3301 test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
3302 assert(rc == MEMCACHED_SUCCESS);
3303 assert(test_ptr == cb_ptr);
3304 }
3305
3306 {
3307 memcached_realloc_function realloc_cb=
3308 (memcached_realloc_function)my_realloc;
3309 cb_ptr= *(void **)&realloc_cb;
3310 memcached_return rc;
3311
3312 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, cb_ptr);
3313 assert(rc == MEMCACHED_SUCCESS);
3314 test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
3315 assert(rc == MEMCACHED_SUCCESS);
3316 assert(test_ptr == cb_ptr);
3317 }
3318
3319 {
3320 memcached_free_function free_cb=
3321 (memcached_free_function)my_free;
3322 cb_ptr= *(void **)&free_cb;
3323 memcached_return rc;
3324
3325 rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, cb_ptr);
3326 assert(rc == MEMCACHED_SUCCESS);
3327 test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
3328 assert(rc == MEMCACHED_SUCCESS);
3329 assert(test_ptr == cb_ptr);
3330 }
3331 return MEMCACHED_SUCCESS;
3332 }
3333 #endif
3334
3335 static memcached_return set_memory_alloc(memcached_st *memc)
3336 {
3337 memcached_return rc;
3338 rc= memcached_set_memory_allocators(memc, NULL, my_free,
3339 my_realloc, my_calloc);
3340 assert(rc == MEMCACHED_FAILURE);
3341
3342 rc= memcached_set_memory_allocators(memc, my_malloc, my_free,
3343 my_realloc, my_calloc);
3344
3345 memcached_malloc_function mem_malloc;
3346 memcached_free_function mem_free;
3347 memcached_realloc_function mem_realloc;
3348 memcached_calloc_function mem_calloc;
3349 memcached_get_memory_allocators(memc, &mem_malloc, &mem_free,
3350 &mem_realloc, &mem_calloc);
3351
3352 assert(mem_malloc == my_malloc);
3353 assert(mem_realloc == my_realloc);
3354 assert(mem_calloc == my_calloc);
3355 assert(mem_free == my_free);
3356
3357 return MEMCACHED_SUCCESS;
3358 }
3359
3360 static memcached_return enable_consistent(memcached_st *memc)
3361 {
3362 memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;
3363 memcached_hash hash;
3364 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
3365 if (pre_hsieh(memc) != MEMCACHED_SUCCESS)
3366 return MEMCACHED_FAILURE;
3367
3368 value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
3369 assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
3370
3371 hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
3372 assert(hash == MEMCACHED_HASH_HSIEH);
3373
3374
3375 return MEMCACHED_SUCCESS;
3376 }
3377
3378 static memcached_return enable_cas(memcached_st *memc)
3379 {
3380 unsigned int set= 1;
3381
3382 memcached_version(memc);
3383
3384 if ((memc->hosts[0].major_version >= 1 && (memc->hosts[0].minor_version == 2 && memc->hosts[0].micro_version >= 4))
3385 || memc->hosts[0].minor_version > 2)
3386 {
3387 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
3388
3389 return MEMCACHED_SUCCESS;
3390 }
3391
3392 return MEMCACHED_FAILURE;
3393 }
3394
3395 static memcached_return check_for_1_2_3(memcached_st *memc)
3396 {
3397 memcached_version(memc);
3398
3399 if ((memc->hosts[0].major_version >= 1 && (memc->hosts[0].minor_version == 2 && memc->hosts[0].micro_version >= 4))
3400 || memc->hosts[0].minor_version > 2)
3401 return MEMCACHED_SUCCESS;
3402
3403 return MEMCACHED_FAILURE;
3404 }
3405
3406 static memcached_return pre_unix_socket(memcached_st *memc)
3407 {
3408 memcached_return rc;
3409 struct stat buf;
3410
3411 memcached_server_list_free(memc->hosts);
3412 memc->hosts= NULL;
3413 memc->number_of_hosts= 0;
3414
3415 if (stat("/tmp/memcached.socket", &buf))
3416 return MEMCACHED_FAILURE;
3417
3418 rc= memcached_server_add_unix_socket_with_weight(memc, "/tmp/memcached.socket", 0);
3419
3420 return rc;
3421 }
3422
3423 static memcached_return pre_nodelay(memcached_st *memc)
3424 {
3425 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
3426 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
3427
3428 return MEMCACHED_SUCCESS;
3429 }
3430
3431 static memcached_return pre_settimer(memcached_st *memc)
3432 {
3433 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
3434 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
3435
3436 return MEMCACHED_SUCCESS;
3437 }
3438
3439 static memcached_return poll_timeout(memcached_st *memc)
3440 {
3441 size_t timeout;
3442
3443 timeout= 100;
3444
3445 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
3446
3447 timeout= (size_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
3448
3449 assert(timeout == 100);
3450
3451 return MEMCACHED_SUCCESS;
3452 }
3453
3454 static test_return noreply_test(memcached_st *memc)
3455 {
3456 memcached_return ret;
3457 ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
3458 assert(ret == MEMCACHED_SUCCESS);
3459 ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
3460 assert(ret == MEMCACHED_SUCCESS);
3461 ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
3462 assert(ret == MEMCACHED_SUCCESS);
3463 assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY) == 1);
3464 assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS) == 1);
3465 assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS) == 1);
3466
3467 for (int count=0; count < 5; ++count)
3468 {
3469 for (int x=0; x < 100; ++x)
3470 {
3471 char key[10];
3472 size_t len= (size_t)sprintf(key, "%d", x);
3473 switch (count)
3474 {
3475 case 0:
3476 ret=memcached_add(memc, key, len, key, len, 0, 0);
3477 break;
3478 case 1:
3479 ret=memcached_replace(memc, key, len, key, len, 0, 0);
3480 break;
3481 case 2:
3482 ret=memcached_set(memc, key, len, key, len, 0, 0);
3483 break;
3484 case 3:
3485 ret=memcached_append(memc, key, len, key, len, 0, 0);
3486 break;
3487 case 4:
3488 ret=memcached_prepend(memc, key, len, key, len, 0, 0);
3489 break;
3490 default:
3491 assert(count);
3492 break;
3493 }
3494 assert(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED);
3495 }
3496
3497 /*
3498 ** NOTE: Don't ever do this in your code! this is not a supported use of the
3499 ** API and is _ONLY_ done this way to verify that the library works the
3500 ** way it is supposed to do!!!!
3501 */
3502 int no_msg=0;
3503 for (uint32_t x=0; x < memc->number_of_hosts; ++x)
3504 no_msg+=(int)(memc->hosts[x].cursor_active);
3505
3506 assert(no_msg == 0);
3507 assert(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
3508
3509 /*
3510 ** Now validate that all items was set properly!
3511 */
3512 for (int x=0; x < 100; ++x)
3513 {
3514 char key[10];
3515 size_t len= (size_t)sprintf(key, "%d", x);
3516 size_t length;
3517 uint32_t flags;
3518 char* value=memcached_get(memc, key, strlen(key),
3519 &length, &flags, &ret);
3520 assert(ret == MEMCACHED_SUCCESS && value != NULL);
3521 switch (count)
3522 {
3523 case 0: /* FALLTHROUGH */
3524 case 1: /* FALLTHROUGH */
3525 case 2:
3526 assert(strncmp(value, key, len) == 0);
3527 assert(len == length);
3528 break;
3529 case 3:
3530 assert(length == len * 2);
3531 break;
3532 case 4:
3533 assert(length == len * 3);
3534 break;
3535 default:
3536 assert(count);
3537 break;
3538 }
3539 free(value);
3540 }
3541 }
3542
3543 /* Try setting an illegal cas value (should not return an error to
3544 * the caller (because we don't expect a return message from the server)
3545 */
3546 const char* keys[]= {"0"};
3547 size_t lengths[]= {1};
3548 size_t length;
3549 uint32_t flags;
3550 memcached_result_st results_obj;
3551 memcached_result_st *results;
3552 ret= memcached_mget(memc, keys, lengths, 1);
3553 assert(ret == MEMCACHED_SUCCESS);
3554
3555 results= memcached_result_create(memc, &results_obj);
3556 assert(results);
3557 results= memcached_fetch_result(memc, &results_obj, &ret);
3558 assert(results);
3559 assert(ret == MEMCACHED_SUCCESS);
3560 uint64_t cas= memcached_result_cas(results);
3561 memcached_result_free(&results_obj);
3562
3563 ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
3564 assert(ret == MEMCACHED_SUCCESS);
3565
3566 /*
3567 * The item will have a new cas value, so try to set it again with the old
3568 * value. This should fail!
3569 */
3570 ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
3571 assert(ret == MEMCACHED_SUCCESS);
3572 assert(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
3573 char* value=memcached_get(memc, keys[0], lengths[0], &length, &flags, &ret);
3574 assert(ret == MEMCACHED_SUCCESS && value != NULL);
3575 free(value);
3576
3577 return TEST_SUCCESS;
3578 }
3579
3580 static test_return analyzer_test(memcached_st *memc)
3581 {
3582 memcached_return rc;
3583 memcached_stat_st *memc_stat;
3584 memcached_analysis_st *report;
3585
3586 memc_stat= memcached_stat(memc, NULL, &rc);
3587 assert(rc == MEMCACHED_SUCCESS);
3588 assert(memc_stat);
3589
3590 report= memcached_analyze(memc, memc_stat, &rc);
3591 assert(rc == MEMCACHED_SUCCESS);
3592 assert(report);
3593
3594 free(report);
3595 memcached_stat_free(NULL, memc_stat);
3596
3597 return TEST_SUCCESS;
3598 }
3599
3600 /* Count the objects */
3601 static memcached_return callback_dump_counter(memcached_st *ptr __attribute__((unused)),
3602 const char *key __attribute__((unused)),
3603 size_t key_length __attribute__((unused)),
3604 void *context)
3605 {
3606 uint32_t *counter= (uint32_t *)context;
3607
3608 *counter= *counter + 1;
3609
3610 return MEMCACHED_SUCCESS;
3611 }
3612
3613 static test_return dump_test(memcached_st *memc)
3614 {
3615 memcached_return rc;
3616 uint32_t counter= 0;
3617 memcached_dump_func callbacks[1];
3618 test_return main_rc;
3619
3620 callbacks[0]= &callback_dump_counter;
3621
3622 /* No support for Binary protocol yet */
3623 if (memc->flags & MEM_BINARY_PROTOCOL)
3624 return TEST_SUCCESS;
3625
3626 main_rc= set_test3(memc);
3627
3628 assert (main_rc == TEST_SUCCESS);
3629
3630 rc= memcached_dump(memc, callbacks, (void *)&counter, 1);
3631 assert(rc == MEMCACHED_SUCCESS);
3632
3633 /* We may have more then 32 if our previous flush has not completed */
3634 assert(counter >= 32);
3635
3636 return TEST_SUCCESS;
3637 }
3638
3639 #ifdef HAVE_LIBMEMCACHEDUTIL
3640 static void* connection_release(void *arg) {
3641 struct {
3642 memcached_pool_st* pool;
3643 memcached_st* mmc;
3644 } *resource= arg;
3645
3646 usleep(250);
3647 assert(memcached_pool_push(resource->pool, resource->mmc) == MEMCACHED_SUCCESS);
3648 return arg;
3649 }
3650
3651 static test_return connection_pool_test(memcached_st *memc)
3652 {
3653 memcached_pool_st* pool= memcached_pool_create(memc, 5, 10);
3654 assert(pool != NULL);
3655 memcached_st* mmc[10];
3656 memcached_return rc;
3657
3658 for (int x= 0; x < 10; ++x) {
3659 mmc[x]= memcached_pool_pop(pool, false, &rc);
3660 assert(mmc[x] != NULL);
3661 assert(rc == MEMCACHED_SUCCESS);
3662 }
3663
3664 assert(memcached_pool_pop(pool, false, &rc) == NULL);
3665 assert(rc == MEMCACHED_SUCCESS);
3666
3667 pthread_t tid;
3668 struct {
3669 memcached_pool_st* pool;
3670 memcached_st* mmc;
3671 } item= { .pool = pool, .mmc = mmc[9] };
3672 pthread_create(&tid, NULL, connection_release, &item);
3673 mmc[9]= memcached_pool_pop(pool, true, &rc);
3674 assert(rc == MEMCACHED_SUCCESS);
3675 pthread_join(tid, NULL);
3676 assert(mmc[9] == item.mmc);
3677 const char *key= "key";
3678 size_t keylen= strlen(key);
3679
3680 // verify that I can do ops with all connections
3681 rc= memcached_set(mmc[0], key, keylen, "0", 1, 0, 0);
3682 assert(rc == MEMCACHED_SUCCESS);
3683
3684 for (unsigned int x= 0; x < 10; ++x) {
3685 uint64_t number_value;
3686 rc= memcached_increment(mmc[x], key, keylen, 1, &number_value);
3687 assert(rc == MEMCACHED_SUCCESS);
3688 assert(number_value == (x+1));
3689 }
3690
3691 // Release them..
3692 for (int x= 0; x < 10; ++x)
3693 assert(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS);
3694
3695 assert(memcached_pool_destroy(pool) == memc);
3696 return TEST_SUCCESS;
3697 }
3698 #endif
3699
3700 static test_return replication_set_test(memcached_st *memc)
3701 {
3702 memcached_return rc;
3703 memcached_st *memc_clone= memcached_clone(NULL, memc);
3704 memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
3705
3706 rc= memcached_set(memc, "bubba", 5, "0", 1, 0, 0);
3707 assert(rc == MEMCACHED_SUCCESS);
3708
3709 /*
3710 ** We are using the quiet commands to store the replicas, so we need
3711 ** to ensure that all of them are processed before we can continue.
3712 ** In the test we go directly from storing the object to trying to
3713 ** receive the object from all of the different servers, so we
3714 ** could end up in a race condition (the memcached server hasn't yet
3715 ** processed the quiet command from the replication set when it process
3716 ** the request from the other client (created by the clone)). As a
3717 ** workaround for that we call memcached_quit to send the quit command
3718 ** to the server and wait for the response ;-) If you use the test code
3719 ** as an example for your own code, please note that you shouldn't need
3720 ** to do this ;-)
3721 */
3722 memcached_quit(memc);
3723
3724 /*
3725 ** "bubba" should now be stored on all of our servers. We don't have an
3726 ** easy to use API to address each individual server, so I'll just iterate
3727 ** through a bunch of "master keys" and I should most likely hit all of the
3728 ** servers...
3729 */
3730 for (int x= 'a'; x <= 'z'; ++x)
3731 {
3732 char key[2]= { [0]= (char)x };
3733 size_t len;
3734 uint32_t flags;
3735 char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
3736 &len, &flags, &rc);
3737 assert(rc == MEMCACHED_SUCCESS);
3738 assert(val != NULL);
3739 free(val);
3740 }
3741
3742 memcached_free(memc_clone);
3743
3744 return TEST_SUCCESS;
3745 }
3746
3747 static test_return replication_get_test(memcached_st *memc)
3748 {
3749 memcached_return rc;
3750
3751 /*
3752 * Don't do the following in your code. I am abusing the internal details
3753 * within the library, and this is not a supported interface.
3754 * This is to verify correct behavior in the library
3755 */
3756 for (uint32_t host= 0; host < memc->number_of_hosts; ++host)
3757 {
3758 memcached_st *memc_clone= memcached_clone(NULL, memc);
3759 memc_clone->hosts[host].port= 0;
3760
3761 for (int x= 'a'; x <= 'z'; ++x)
3762 {
3763 char key[2]= { [0]= (char)x };
3764 size_t len;
3765 uint32_t flags;
3766 char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
3767 &len, &flags, &rc);
3768 assert(rc == MEMCACHED_SUCCESS);
3769 assert(val != NULL);
3770 free(val);
3771 }
3772
3773 memcached_free(memc_clone);
3774 }
3775
3776 return TEST_SUCCESS;
3777 }
3778
3779 static test_return replication_mget_test(memcached_st *memc)
3780 {
3781 memcached_return rc;
3782 memcached_st *memc_clone= memcached_clone(NULL, memc);
3783 memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
3784
3785 const char *keys[]= { "bubba", "key1", "key2", "key3" };
3786 size_t len[]= { 5, 4, 4, 4 };
3787
3788 for (int x=0; x< 4; ++x)
3789 {
3790 rc= memcached_set(memc, keys[x], len[x], "0", 1, 0, 0);
3791 assert(rc == MEMCACHED_SUCCESS);
3792 }
3793
3794 /*
3795 ** We are using the quiet commands to store the replicas, so we need
3796 ** to ensure that all of them are processed before we can continue.
3797 ** In the test we go directly from storing the object to trying to
3798 ** receive the object from all of the different servers, so we
3799 ** could end up in a race condition (the memcached server hasn't yet
3800 ** processed the quiet command from the replication set when it process
3801 ** the request from the other client (created by the clone)). As a
3802 ** workaround for that we call memcached_quit to send the quit command
3803 ** to the server and wait for the response ;-) If you use the test code
3804 ** as an example for your own code, please note that you shouldn't need
3805 ** to do this ;-)
3806 */
3807 memcached_quit(memc);
3808
3809 /*
3810 * Don't do the following in your code. I am abusing the internal details
3811 * within the library, and this is not a supported interface.
3812 * This is to verify correct behavior in the library
3813 */
3814 memcached_result_st result_obj;
3815 for (uint32_t host= 0; host < memc_clone->number_of_hosts; host++)
3816 {
3817 memcached_st *new_clone= memcached_clone(NULL, memc);
3818 new_clone->hosts[host].port= 0;
3819
3820 for (int x= 'a'; x <= 'z'; ++x)
3821 {
3822 const char key[2]= { [0]= (const char)x };
3823
3824 rc= memcached_mget_by_key(new_clone, key, 1, keys, len, 4);
3825 assert(rc == MEMCACHED_SUCCESS);
3826
3827 memcached_result_st *results= memcached_result_create(new_clone, &result_obj);
3828 assert(results);
3829
3830 int hits= 0;
3831 while ((results= memcached_fetch_result(new_clone, &result_obj, &rc)) != NULL)
3832 {
3833 hits++;
3834 }
3835 assert(hits == 4);
3836 memcached_result_free(&result_obj);
3837 }
3838
3839 memcached_free(new_clone);
3840 }
3841
3842 memcached_free(memc_clone);
3843
3844 return TEST_SUCCESS;
3845 }
3846
3847 static test_return replication_delete_test(memcached_st *memc)
3848 {
3849 memcached_return rc;
3850 memcached_st *memc_clone= memcached_clone(NULL, memc);
3851 /* Delete the items from all of the servers except 1 */
3852 uint64_t repl= memcached_behavior_get(memc,
3853 MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
3854 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, --repl);
3855
3856 const char *keys[]= { "bubba", "key1", "key2", "key3" };
3857 size_t len[]= { 5, 4, 4, 4 };
3858
3859 for (int x=0; x< 4; ++x)
3860 {
3861 rc= memcached_delete_by_key(memc, keys[0], len[0], keys[x], len[x], 0);
3862 assert(rc == MEMCACHED_SUCCESS);
3863 }
3864
3865 /*
3866 * Don't do the following in your code. I am abusing the internal details
3867 * within the library, and this is not a supported interface.
3868 * This is to verify correct behavior in the library
3869 */
3870 uint32_t hash= memcached_generate_hash(memc, keys[0], len[0]);
3871 for (uint32_t x= 0; x < (repl + 1); ++x)
3872 {
3873 memc_clone->hosts[hash].port= 0;
3874 if (++hash == memc_clone->number_of_hosts)
3875 hash= 0;
3876 }
3877
3878 memcached_result_st result_obj;
3879 for (uint32_t host= 0; host < memc_clone->number_of_hosts; ++host)
3880 {
3881 for (int x= 'a'; x <= 'z'; ++x)
3882 {
3883 const char key[2]= { [0]= (const char)x };
3884
3885 rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 4);
3886 assert(rc == MEMCACHED_SUCCESS);
3887
3888 memcached_result_st *results= memcached_result_create(memc_clone, &result_obj);
3889 assert(results);
3890
3891 int hits= 0;
3892 while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL)
3893 {
3894 ++hits;
3895 }
3896 assert(hits == 4);
3897 memcached_result_free(&result_obj);
3898 }
3899 }
3900 memcached_free(memc_clone);
3901
3902 return TEST_SUCCESS;
3903 }
3904
3905 static void increment_request_id(uint16_t *id)
3906 {
3907 (*id)++;
3908 if ((*id & UDP_REQUEST_ID_THREAD_MASK) != 0)
3909 *id= 0;
3910 }
3911
3912 static uint16_t *get_udp_request_ids(memcached_st *memc)
3913 {
3914 uint16_t *ids= malloc(sizeof(uint16_t) * memc->number_of_hosts);
3915 assert(ids != NULL);
3916 unsigned int x;
3917
3918 for (x= 0; x < memc->number_of_hosts; x++)
3919 ids[x]= get_udp_datagram_request_id((struct udp_datagram_header_st *) memc->hosts[x].write_buffer);
3920
3921 return ids;
3922 }
3923
3924 static test_return post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ids)
3925 {
3926 unsigned int x;
3927 memcached_server_st *cur_server = memc->hosts;
3928 uint16_t *cur_req_ids = get_udp_request_ids(memc);
3929
3930 for (x= 0; x < memc->number_of_hosts; x++)
3931 {
3932 assert(cur_server[x].cursor_active == 0);
3933 assert(cur_req_ids[x] == expected_req_ids[x]);
3934 }
3935 free(expected_req_ids);
3936 free(cur_req_ids);
3937
3938 return TEST_SUCCESS;
3939 }
3940
3941 /*
3942 ** There is a little bit of a hack here, instead of removing
3943 ** the servers, I just set num host to 0 and them add then new udp servers
3944 **/
3945 static memcached_return init_udp(memcached_st *memc)
3946 {
3947 memcached_version(memc);
3948 /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
3949 if (memc->hosts[0].major_version != 1 || memc->hosts[0].minor_version != 2
3950 || memc->hosts[0].micro_version < 6)
3951 return MEMCACHED_FAILURE;
3952
3953 uint32_t num_hosts= memc->number_of_hosts;
3954 unsigned int x= 0;
3955 memcached_server_st servers[num_hosts];
3956 memcpy(servers, memc->hosts, sizeof(memcached_server_st) * num_hosts);
3957 for (x= 0; x < num_hosts; x++)
3958 memcached_server_free(&memc->hosts[x]);
3959
3960 memc->number_of_hosts= 0;
3961 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1);
3962 for (x= 0; x < num_hosts; x++)
3963 {
3964 assert(memcached_server_add_udp(memc, servers[x].hostname, servers[x].port) == MEMCACHED_SUCCESS);
3965 assert(memc->hosts[x].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
3966 }
3967
3968 return MEMCACHED_SUCCESS;
3969 }
3970
3971 static memcached_return binary_init_udp(memcached_st *memc)
3972 {
3973 pre_binary(memc);
3974 return init_udp(memc);
3975 }
3976
3977 /* Make sure that I cant add a tcp server to a udp client */
3978 static test_return add_tcp_server_udp_client_test(memcached_st *memc)
3979 {
3980 memcached_server_st server;
3981 memcached_server_clone(&server, &memc->hosts[0]);
3982 assert(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
3983 assert(memcached_server_add(memc, server.hostname, server.port) == MEMCACHED_INVALID_HOST_PROTOCOL);
3984 return TEST_SUCCESS;
3985 }
3986
3987 /* Make sure that I cant add a udp server to a tcp client */
3988 static test_return add_udp_server_tcp_client_test(memcached_st *memc)
3989 {
3990 memcached_server_st server;
3991 memcached_server_clone(&server, &memc->hosts[0]);
3992 assert(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
3993
3994 memcached_st tcp_client;
3995 memcached_create(&tcp_client);
3996 assert(memcached_server_add_udp(&tcp_client, server.hostname, server.port) == MEMCACHED_INVALID_HOST_PROTOCOL);
3997 return TEST_SUCCESS;
3998 }
3999
4000 static test_return set_udp_behavior_test(memcached_st *memc)
4001 {
4002
4003 memcached_quit(memc);
4004 memc->number_of_hosts= 0;
4005 run_distribution(memc);
4006 assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1) == MEMCACHED_SUCCESS);
4007 assert(memc->flags & MEM_USE_UDP);
4008 assert(memc->flags & MEM_NOREPLY);;
4009
4010 assert(memc->number_of_hosts == 0);
4011
4012 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP,0);
4013 assert(!(memc->flags & MEM_USE_UDP));
4014 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY,0);
4015 assert(!(memc->flags & MEM_NOREPLY));
4016 return TEST_SUCCESS;
4017 }
4018
4019 static test_return udp_set_test(memcached_st *memc)
4020 {
4021 unsigned int x= 0;
4022 unsigned int num_iters= 1025; //request id rolls over at 1024
4023 for (x= 0; x < num_iters;x++)
4024 {
4025 memcached_return rc;
4026 const char *key= "foo";
4027 const char *value= "when we sanitize";
4028 uint16_t *expected_ids= get_udp_request_ids(memc);
4029 unsigned int server_key= memcached_generate_hash(memc,key,strlen(key));
4030 size_t init_offset= memc->hosts[server_key].write_buffer_offset;
4031 rc= memcached_set(memc, key, strlen(key),
4032 value, strlen(value),
4033 (time_t)0, (uint32_t)0);
4034 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
4035 /** NB, the check below assumes that if new write_ptr is less than
4036 * the original write_ptr that we have flushed. For large payloads, this
4037 * maybe an invalid assumption, but for the small payload we have it is OK
4038 */
4039 if (rc == MEMCACHED_SUCCESS ||
4040 memc->hosts[server_key].write_buffer_offset < init_offset)
4041 increment_request_id(&expected_ids[server_key]);
4042
4043 if (rc == MEMCACHED_SUCCESS)
4044 {
4045 assert(memc->hosts[server_key].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
4046 }
4047 else
4048 {
4049 assert(memc->hosts[server_key].write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
4050 assert(memc->hosts[server_key].write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
4051 }
4052 assert(post_udp_op_check(memc,expected_ids) == TEST_SUCCESS);
4053 }
4054 return TEST_SUCCESS;
4055 }
4056
4057 static test_return udp_buffered_set_test(memcached_st *memc)
4058 {
4059 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
4060 return udp_set_test(memc);
4061 }
4062
4063 static test_return udp_set_too_big_test(memcached_st *memc)
4064 {
4065 memcached_return rc;
4066 const char *key= "bar";
4067 char value[MAX_UDP_DATAGRAM_LENGTH];
4068 uint16_t *expected_ids= get_udp_request_ids(memc);
4069 rc= memcached_set(memc, key, strlen(key),
4070 value, MAX_UDP_DATAGRAM_LENGTH,
4071 (time_t)0, (uint32_t)0);
4072 assert(rc == MEMCACHED_WRITE_FAILURE);
4073 return post_udp_op_check(memc,expected_ids);
4074 }
4075
4076 static test_return udp_delete_test(memcached_st *memc)
4077 {
4078 unsigned int x= 0;
4079 unsigned int num_iters= 1025; //request id rolls over at 1024
4080 for (x= 0; x < num_iters;x++)
4081 {
4082 memcached_return rc;
4083 const char *key= "foo";
4084 uint16_t *expected_ids=get_udp_request_ids(memc);
4085 unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
4086 size_t init_offset= memc->hosts[server_key].write_buffer_offset;
4087 rc= memcached_delete(memc, key, strlen(key), 0);
4088 assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
4089 if (rc == MEMCACHED_SUCCESS || memc->hosts[server_key].write_buffer_offset < init_offset)
4090 increment_request_id(&expected_ids[server_key]);
4091 if (rc == MEMCACHED_SUCCESS)
4092 assert(memc->hosts[server_key].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
4093 else
4094 {
4095 assert(memc->hosts[server_key].write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
4096 assert(memc->hosts[server_key].write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
4097 }
4098 assert(post_udp_op_check(memc,expected_ids) == TEST_SUCCESS);
4099 }
4100 return TEST_SUCCESS;
4101 }
4102
4103 static test_return udp_buffered_delete_test(memcached_st *memc)
4104 {
4105 memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
4106 return udp_delete_test(memc);
4107 }
4108
4109 static test_return udp_verbosity_test(memcached_st *memc)
4110 {
4111 memcached_return rc;
4112 uint16_t *expected_ids= get_udp_request_ids(memc);
4113 unsigned int x;
4114 for (x= 0; x < memc->number_of_hosts;x++)
4115 increment_request_id(&expected_ids[x]);
4116
4117 rc= memcached_verbosity(memc,3);
4118 assert(rc == MEMCACHED_SUCCESS);
4119 return post_udp_op_check(memc,expected_ids);
4120 }
4121
4122 static test_return udp_quit_test(memcached_st *memc)
4123 {
4124 uint16_t *expected_ids= get_udp_request_ids(memc);
4125 memcached_quit(memc);
4126 return post_udp_op_check(memc, expected_ids);
4127 }
4128
4129 static test_return udp_flush_test(memcached_st *memc)
4130 {
4131 memcached_return rc;
4132 uint16_t *expected_ids= get_udp_request_ids(memc);
4133 unsigned int x;
4134 for (x= 0; x < memc->number_of_hosts;x++)
4135 increment_request_id(&expected_ids[x]);
4136
4137 rc= memcached_flush(memc,0);
4138 assert(rc == MEMCACHED_SUCCESS);
4139 return post_udp_op_check(memc,expected_ids);
4140 }
4141
4142 static test_return udp_incr_test(memcached_st *memc)
4143 {
4144 memcached_return rc;
4145 const char *key= "incr";
4146 const char *value= "1";
4147 rc= memcached_set(memc, key, strlen(key),
4148 value, strlen(value),
4149 (time_t)0, (uint32_t)0);
4150
4151 assert(rc == MEMCACHED_SUCCESS);
4152 uint16_t *expected_ids= get_udp_request_ids(memc);
4153 unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
4154 increment_request_id(&expected_ids[server_key]);
4155 uint64_t newvalue;
4156 rc= memcached_increment(memc, key, strlen(key), 1, &newvalue);
4157 assert(rc == MEMCACHED_SUCCESS);
4158 return post_udp_op_check(memc, expected_ids);
4159 }
4160
4161 static test_return udp_decr_test(memcached_st *memc)
4162 {
4163 memcached_return rc;
4164 const char *key= "decr";
4165 const char *value= "1";
4166 rc= memcached_set(memc, key, strlen(key),
4167 value, strlen(value),
4168 (time_t)0, (uint32_t)0);
4169
4170 assert(rc == MEMCACHED_SUCCESS);
4171 uint16_t *expected_ids= get_udp_request_ids(memc);
4172 unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
4173 increment_request_id(&expected_ids[server_key]);
4174 uint64_t newvalue;
4175 rc= memcached_decrement(memc, key, strlen(key), 1, &newvalue);
4176 assert(rc == MEMCACHED_SUCCESS);
4177 return post_udp_op_check(memc, expected_ids);
4178 }
4179
4180
4181 static test_return udp_stat_test(memcached_st *memc)
4182 {
4183 memcached_stat_st * rv= NULL;
4184 memcached_return rc;
4185 char args[]= "";
4186 uint16_t *expected_ids = get_udp_request_ids(memc);
4187 rv = memcached_stat(memc, args, &rc);
4188 free(rv);
4189 assert(rc == MEMCACHED_NOT_SUPPORTED);
4190 return post_udp_op_check(memc, expected_ids);
4191 }
4192
4193 static test_return udp_version_test(memcached_st *memc)
4194 {
4195 memcached_return rc;
4196 uint16_t *expected_ids = get_udp_request_ids(memc);
4197 rc = memcached_version(memc);
4198 assert(rc == MEMCACHED_NOT_SUPPORTED);
4199 return post_udp_op_check(memc, expected_ids);
4200 }
4201
4202 static test_return udp_get_test(memcached_st *memc)
4203 {
4204 memcached_return rc;
4205 const char *key= "foo";
4206 size_t vlen;
4207 uint16_t *expected_ids = get_udp_request_ids(memc);
4208 char *val= memcached_get(memc, key, strlen(key), &vlen, (uint32_t)0, &rc);
4209 assert(rc == MEMCACHED_NOT_SUPPORTED);
4210 assert(val == NULL);
4211 return post_udp_op_check(memc, expected_ids);
4212 }
4213
4214 static test_return udp_mixed_io_test(memcached_st *memc)
4215 {
4216 test_st current_op;
4217 test_st mixed_io_ops [] ={
4218 {"udp_set_test", 0, udp_set_test},
4219 {"udp_set_too_big_test", 0, udp_set_too_big_test},
4220 {"udp_delete_test", 0, udp_delete_test},
4221 {"udp_verbosity_test", 0, udp_verbosity_test},
4222 {"udp_quit_test", 0, udp_quit_test},
4223 {"udp_flush_test", 0, udp_flush_test},
4224 {"udp_incr_test", 0, udp_incr_test},
4225 {"udp_decr_test", 0, udp_decr_test},
4226 {"udp_version_test", 0, udp_version_test}
4227 };
4228 unsigned int x= 0;
4229 for (x= 0; x < 500; x++)
4230 {
4231 current_op= mixed_io_ops[random() % 9];
4232 assert(current_op.function(memc) == TEST_SUCCESS);
4233 }
4234 return TEST_SUCCESS;
4235 }
4236
4237 static test_return hsieh_avaibility_test (memcached_st *memc)
4238 {
4239 memcached_return expected_rc= MEMCACHED_FAILURE;
4240 #ifdef HAVE_HSIEH_HASH
4241 expected_rc= MEMCACHED_SUCCESS;
4242 #endif
4243 memcached_return rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
4244 (uint64_t)MEMCACHED_HASH_HSIEH);
4245 assert(rc == expected_rc);
4246 return TEST_SUCCESS;
4247 }
4248
4249 static const char *list[]=
4250 {
4251 "apple",
4252 "beat",
4253 "carrot",
4254 "daikon",
4255 "eggplant",
4256 "flower",
4257 "green",
4258 "hide",
4259 "ick",
4260 "jack",
4261 "kick",
4262 "lime",
4263 "mushrooms",
4264 "nectarine",
4265 "orange",
4266 "peach",
4267 "quant",
4268 "ripen",
4269 "strawberry",
4270 "tang",
4271 "up",
4272 "volumne",
4273 "when",
4274 "yellow",
4275 "zip",
4276 NULL
4277 };
4278
4279 static test_return md5_run (memcached_st *memc __attribute__((unused)))
4280 {
4281 uint32_t x;
4282 const char **ptr;
4283 uint32_t values[]= { 3195025439U, 2556848621U, 3724893440U, 3332385401U,
4284 245758794U, 2550894432U, 121710495U, 3053817768U,
4285 1250994555U, 1862072655U, 2631955953U, 2951528551U,
4286 1451250070U, 2820856945U, 2060845566U, 3646985608U,
4287 2138080750U, 217675895U, 2230934345U, 1234361223U,
4288 3968582726U, 2455685270U, 1293568479U, 199067604U,
4289 2042482093U };
4290
4291
4292 for (ptr= list, x= 0; *ptr; ptr++, x++)
4293 {
4294 uint32_t hash_val;
4295
4296 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5);
4297 assert(values[x] == hash_val);
4298 }
4299
4300 return TEST_SUCCESS;
4301 }
4302
4303 static test_return crc_run (memcached_st *memc __attribute__((unused)))
4304 {
4305 uint32_t x;
4306 const char **ptr;
4307 uint32_t values[]= { 10542U, 22009U, 14526U, 19510U, 19432U, 10199U, 20634U,
4308 9369U, 11511U, 10362U, 7893U, 31289U, 11313U, 9354U,
4309 7621U, 30628U, 15218U, 25967U, 2695U, 9380U,
4310 17300U, 28156U, 9192U, 20484U, 16925U };
4311
4312 for (ptr= list, x= 0; *ptr; ptr++, x++)
4313 {
4314 uint32_t hash_val;
4315
4316 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC);
4317 assert(values[x] == hash_val);
4318 }
4319
4320 return TEST_SUCCESS;
4321 }
4322
4323 static test_return fnv1_64_run (memcached_st *memc __attribute__((unused)))
4324 {
4325 uint32_t x;
4326 const char **ptr;
4327 uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
4328 1722477987U, 2991193800U, 4147007314U, 3633179701U,
4329 1805162104U, 3503289120U, 3395702895U, 3325073042U,
4330 2345265314U, 3340346032U, 2722964135U, 1173398992U,
4331 2815549194U, 2562818319U, 224996066U, 2680194749U,
4332 3035305390U, 246890365U, 2395624193U, 4145193337U,
4333 1801941682U };
4334
4335 for (ptr= list, x= 0; *ptr; ptr++, x++)
4336 {
4337 uint32_t hash_val;
4338
4339 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
4340 assert(values[x] == hash_val);
4341 }
4342
4343 return TEST_SUCCESS;
4344 }
4345
4346 static test_return fnv1a_64_run (memcached_st *memc __attribute__((unused)))
4347 {
4348 uint32_t x;
4349 const char **ptr;
4350 uint32_t values[]= { 1488911807U, 2500855813U, 1510099634U, 1390325195U,
4351 3647689787U, 3241528582U, 1669328060U, 2604311949U,
4352 734810122U, 1516407546U, 560948863U, 1767346780U,
4353 561034892U, 4156330026U, 3716417003U, 3475297030U,
4354 1518272172U, 227211583U, 3938128828U, 126112909U,
4355 3043416448U, 3131561933U, 1328739897U, 2455664041U,
4356 2272238452U };
4357
4358 for (ptr= list, x= 0; *ptr; ptr++, x++)
4359 {
4360 uint32_t hash_val;
4361
4362 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64);
4363 assert(values[x] == hash_val);
4364 }
4365
4366 return TEST_SUCCESS;
4367 }
4368
4369 static test_return fnv1_32_run (memcached_st *memc __attribute__((unused)))
4370 {
4371 uint32_t x;
4372 const char **ptr;
4373 uint32_t values[]= { 67176023U, 1190179409U, 2043204404U, 3221866419U,
4374 2567703427U, 3787535528U, 4147287986U, 3500475733U,
4375 344481048U, 3865235296U, 2181839183U, 119581266U,
4376 510234242U, 4248244304U, 1362796839U, 103389328U,
4377 1449620010U, 182962511U, 3554262370U, 3206747549U,
4378 1551306158U, 4127558461U, 1889140833U, 2774173721U,
4379 1180552018U };
4380
4381
4382 for (ptr= list, x= 0; *ptr; ptr++, x++)
4383 {
4384 uint32_t hash_val;
4385
4386 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32);
4387 assert(values[x] == hash_val);
4388 }
4389
4390 return TEST_SUCCESS;
4391 }
4392
4393 static test_return fnv1a_32_run (memcached_st *memc __attribute__((unused)))
4394 {
4395 uint32_t x;
4396 const char **ptr;
4397 uint32_t values[]= { 280767167U, 2421315013U, 3072375666U, 855001899U,
4398 459261019U, 3521085446U, 18738364U, 1625305005U,
4399 2162232970U, 777243802U, 3323728671U, 132336572U,
4400 3654473228U, 260679466U, 1169454059U, 2698319462U,
4401 1062177260U, 235516991U, 2218399068U, 405302637U,
4402 1128467232U, 3579622413U, 2138539289U, 96429129U,
4403 2877453236U };
4404
4405 for (ptr= list, x= 0; *ptr; ptr++, x++)
4406 {
4407 uint32_t hash_val;
4408
4409 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32);
4410 assert(values[x] == hash_val);
4411 }
4412
4413 return TEST_SUCCESS;
4414 }
4415
4416 static test_return hsieh_run (memcached_st *memc __attribute__((unused)))
4417 {
4418 uint32_t x;
4419 const char **ptr;
4420 #ifdef HAVE_HSIEH_HASH
4421 uint32_t values[]= { 3738850110, 3636226060, 3821074029, 3489929160, 3485772682, 80540287,
4422 1805464076, 1895033657, 409795758, 979934958, 3634096985, 1284445480,
4423 2265380744, 707972988, 353823508, 1549198350, 1327930172, 9304163,
4424 4220749037, 2493964934, 2777873870, 2057831732, 1510213931, 2027828987,
4425 3395453351 };
4426 #else
4427 uint32_t values[]= { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
4428 #endif
4429
4430 for (ptr= list, x= 0; *ptr; ptr++, x++)
4431 {
4432 uint32_t hash_val;
4433
4434 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH);
4435 assert(values[x] == hash_val);
4436 }
4437
4438 return TEST_SUCCESS;
4439 }
4440
4441 static test_return murmur_run (memcached_st *memc __attribute__((unused)))
4442 {
4443 uint32_t x;
4444 const char **ptr;
4445 uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
4446 1722477987U, 2991193800U, 4147007314U, 3633179701U,
4447 1805162104U, 3503289120U, 3395702895U, 3325073042U,
4448 2345265314U, 3340346032U, 2722964135U, 1173398992U,
4449 2815549194U, 2562818319U, 224996066U, 2680194749U,
4450 3035305390U, 246890365U, 2395624193U, 4145193337U,
4451 1801941682U };
4452
4453 for (ptr= list, x= 0; *ptr; ptr++, x++)
4454 {
4455 uint32_t hash_val;
4456
4457 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
4458 assert(values[x] == hash_val);
4459 }
4460
4461 return TEST_SUCCESS;
4462 }
4463
4464 static test_return jenkins_run (memcached_st *memc __attribute__((unused)))
4465 {
4466 uint32_t x;
4467 const char **ptr;
4468 uint32_t values[]= { 1442444624U, 4253821186U, 1885058256U, 2120131735U,
4469 3261968576U, 3515188778U, 4232909173U, 4288625128U,
4470 1812047395U, 3689182164U, 2502979932U, 1214050606U,
4471 2415988847U, 1494268927U, 1025545760U, 3920481083U,
4472 4153263658U, 3824871822U, 3072759809U, 798622255U,
4473 3065432577U, 1453328165U, 2691550971U, 3408888387U,
4474 2629893356U };
4475
4476
4477 for (ptr= list, x= 0; *ptr; ptr++, x++)
4478 {
4479 uint32_t hash_val;
4480
4481 hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS);
4482 assert(values[x] == hash_val);
4483 }
4484
4485 return TEST_SUCCESS;
4486 }
4487
4488 test_st udp_setup_server_tests[] ={
4489 {"set_udp_behavior_test", 0, set_udp_behavior_test},
4490 {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test},
4491 {"add_udp_server_tcp_client_test", 0, add_udp_server_tcp_client_test},
4492 {0, 0, 0}
4493 };
4494
4495 test_st upd_io_tests[] ={
4496 {"udp_set_test", 0, udp_set_test},
4497 {"udp_buffered_set_test", 0, udp_buffered_set_test},
4498 {"udp_set_too_big_test", 0, udp_set_too_big_test},
4499 {"udp_delete_test", 0, udp_delete_test},
4500 {"udp_buffered_delete_test", 0, udp_buffered_delete_test},
4501 {"udp_verbosity_test", 0, udp_verbosity_test},
4502 {"udp_quit_test", 0, udp_quit_test},
4503 {"udp_flush_test", 0, udp_flush_test},
4504 {"udp_incr_test", 0, udp_incr_test},
4505 {"udp_decr_test", 0, udp_decr_test},
4506 {"udp_stat_test", 0, udp_stat_test},
4507 {"udp_version_test", 0, udp_version_test},
4508 {"udp_get_test", 0, udp_get_test},
4509 {"udp_mixed_io_test", 0, udp_mixed_io_test},
4510 {0, 0, 0}
4511 };
4512
4513 /* Clean the server before beginning testing */
4514 test_st tests[] ={
4515 {"flush", 0, flush_test },
4516 {"init", 0, init_test },
4517 {"allocation", 0, allocation_test },
4518 {"server_list_null_test", 0, server_list_null_test},
4519 {"server_unsort", 0, server_unsort_test},
4520 {"server_sort", 0, server_sort_test},
4521 {"server_sort2", 0, server_sort2_test},
4522 {"clone_test", 0, clone_test },
4523 {"connection_test", 0, connection_test},
4524 {"callback_test", 0, callback_test},
4525 {"behavior_test", 0, behavior_test},
4526 {"userdata_test", 0, userdata_test},
4527 {"error", 0, error_test },
4528 {"set", 0, set_test },
4529 {"set2", 0, set_test2 },
4530 {"set3", 0, set_test3 },
4531 {"dump", 1, dump_test},
4532 {"add", 1, add_test },
4533 {"replace", 1, replace_test },
4534 {"delete", 1, delete_test },
4535 {"get", 1, get_test },
4536 {"get2", 0, get_test2 },
4537 {"get3", 0, get_test3 },
4538 {"get4", 0, get_test4 },
4539 {"partial mget", 0, get_test5 },
4540 {"stats_servername", 0, stats_servername_test },
4541 {"increment", 0, increment_test },
4542 {"increment_with_initial", 1, increment_with_initial_test },
4543 {"decrement", 0, decrement_test },
4544 {"decrement_with_initial", 1, decrement_with_initial_test },
4545 {"quit", 0, quit_test },
4546 {"mget", 1, mget_test },
4547 {"mget_result", 1, mget_result_test },
4548 {"mget_result_alloc", 1, mget_result_alloc_test },
4549 {"mget_result_function", 1, mget_result_function },
4550 {"get_stats", 0, get_stats },
4551 {"add_host_test", 0, add_host_test },
4552 {"add_host_test_1", 0, add_host_test1 },
4553 {"get_stats_keys", 0, get_stats_keys },
4554 {"behavior_test", 0, get_stats_keys },
4555 {"callback_test", 0, get_stats_keys },
4556 {"version_string_test", 0, version_string_test},
4557 {"bad_key", 1, bad_key_test },
4558 {"memcached_server_cursor", 1, memcached_server_cursor_test },
4559 {"read_through", 1, read_through },
4560 {"delete_through", 1, delete_through },
4561 {"noreply", 1, noreply_test},
4562 {"analyzer", 1, analyzer_test},
4563 #ifdef HAVE_LIBMEMCACHEDUTIL
4564 {"connectionpool", 1, connection_pool_test },
4565 #endif
4566 {0, 0, 0}
4567 };
4568
4569 test_st async_tests[] ={
4570 {"add", 1, add_wrapper },
4571 {0, 0, 0}
4572 };
4573
4574 test_st string_tests[] ={
4575 {"string static with null", 0, string_static_null },
4576 {"string alloc with null", 0, string_alloc_null },
4577 {"string alloc with 1K", 0, string_alloc_with_size },
4578 {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
4579 {"string append", 0, string_alloc_append },
4580 {"string append failure (too big)", 0, string_alloc_append_toobig },
4581 {0, 0, 0}
4582 };
4583
4584 test_st result_tests[] ={
4585 {"result static", 0, result_static},
4586 {"result alloc", 0, result_alloc},
4587 {0, 0, 0}
4588 };
4589
4590 test_st version_1_2_3[] ={
4591 {"append", 0, append_test },
4592 {"prepend", 0, prepend_test },
4593 {"cas", 0, cas_test },
4594 {"cas2", 0, cas2_test },
4595 {"append_binary", 0, append_binary_test },
4596 {0, 0, 0}
4597 };
4598
4599 test_st user_tests[] ={
4600 {"user_supplied_bug1", 0, user_supplied_bug1 },
4601 {"user_supplied_bug2", 0, user_supplied_bug2 },
4602 {"user_supplied_bug3", 0, user_supplied_bug3 },
4603 {"user_supplied_bug4", 0, user_supplied_bug4 },
4604 {"user_supplied_bug5", 1, user_supplied_bug5 },
4605 {"user_supplied_bug6", 1, user_supplied_bug6 },
4606 {"user_supplied_bug7", 1, user_supplied_bug7 },
4607 {"user_supplied_bug8", 1, user_supplied_bug8 },
4608 {"user_supplied_bug9", 1, user_supplied_bug9 },
4609 {"user_supplied_bug10", 1, user_supplied_bug10 },
4610 {"user_supplied_bug11", 1, user_supplied_bug11 },
4611 {"user_supplied_bug12", 1, user_supplied_bug12 },
4612 {"user_supplied_bug13", 1, user_supplied_bug13 },
4613 {"user_supplied_bug14", 1, user_supplied_bug14 },
4614 {"user_supplied_bug15", 1, user_supplied_bug15 },
4615 {"user_supplied_bug16", 1, user_supplied_bug16 },
4616 #ifndef __sun
4617 /*
4618 ** It seems to be something weird with the character sets..
4619 ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
4620 ** guess I need to find out how this is supposed to work.. Perhaps I need
4621 ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
4622 ** so just disable the code for now...).
4623 */
4624 {"user_supplied_bug17", 1, user_supplied_bug17 },
4625 #endif
4626 {"user_supplied_bug18", 1, user_supplied_bug18 },
4627 {"user_supplied_bug19", 1, user_supplied_bug19 },
4628 {"user_supplied_bug20", 1, user_supplied_bug20 },
4629 {"user_supplied_bug21", 0, user_supplied_bug21 },
4630 {0, 0, 0}
4631 };
4632
4633 test_st replication_tests[]= {
4634 {"set", 1, replication_set_test },
4635 {"get", 0, replication_get_test },
4636 {"mget", 0, replication_mget_test },
4637 {"delete", 0, replication_delete_test },
4638 {0, 0, 0}
4639 };
4640
4641 test_st generate_tests[] ={
4642 {"generate_pairs", 1, generate_pairs },
4643 {"generate_data", 1, generate_data },
4644 {"get_read", 0, get_read },
4645 {"delete_generate", 0, delete_generate },
4646 {"generate_buffer_data", 1, generate_buffer_data },
4647 {"delete_buffer", 0, delete_buffer_generate},
4648 {"generate_data", 1, generate_data },
4649 {"mget_read", 0, mget_read },
4650 {"mget_read_result", 0, mget_read_result },
4651 {"mget_read_function", 0, mget_read_function },
4652 {"cleanup", 1, cleanup_pairs },
4653 {"generate_large_pairs", 1, generate_large_pairs },
4654 {"generate_data", 1, generate_data },
4655 {"generate_buffer_data", 1, generate_buffer_data },
4656 {"cleanup", 1, cleanup_pairs },
4657 {0, 0, 0}
4658 };
4659
4660 test_st consistent_tests[] ={
4661 {"generate_pairs", 1, generate_pairs },
4662 {"generate_data", 1, generate_data },
4663 {"get_read", 0, get_read_count },
4664 {"cleanup", 1, cleanup_pairs },
4665 {0, 0, 0}
4666 };
4667
4668 test_st consistent_weighted_tests[] ={
4669 {"generate_pairs", 1, generate_pairs },
4670 {"generate_data", 1, generate_data_with_stats },
4671 {"get_read", 0, get_read_count },
4672 {"cleanup", 1, cleanup_pairs },
4673 {0, 0, 0}
4674 };
4675
4676 test_st hsieh_availability[] ={
4677 {"hsieh_avaibility_test",0,hsieh_avaibility_test},
4678 {0, 0, 0}
4679 };
4680
4681 test_st ketama_auto_eject_hosts[] ={
4682 {"auto_eject_hosts", 1, auto_eject_hosts },
4683 {0, 0, 0}
4684 };
4685
4686 test_st hash_tests[] ={
4687 {"md5", 0, md5_run },
4688 {"crc", 0, crc_run },
4689 {"fnv1_64", 0, fnv1_64_run },
4690 {"fnv1a_64", 0, fnv1a_64_run },
4691 {"fnv1_32", 0, fnv1_32_run },
4692 {"fnv1a_32", 0, fnv1a_32_run },
4693 {"hsieh", 0, hsieh_run },
4694 {"murmur", 0, murmur_run },
4695 {"jenkis", 0, jenkins_run },
4696 {0, 0, 0}
4697 };
4698
4699 collection_st collection[] ={
4700 {"hsieh_availability",0,0,hsieh_availability},
4701 {"udp_setup", init_udp, 0, udp_setup_server_tests},
4702 {"udp_io", init_udp, 0, upd_io_tests},
4703 {"udp_binary_io", binary_init_udp, 0, upd_io_tests},
4704 {"block", 0, 0, tests},
4705 {"binary", pre_binary, 0, tests},
4706 {"nonblock", pre_nonblock, 0, tests},
4707 {"nodelay", pre_nodelay, 0, tests},
4708 {"settimer", pre_settimer, 0, tests},
4709 {"md5", pre_md5, 0, tests},
4710 {"crc", pre_crc, 0, tests},
4711 {"hsieh", pre_hsieh, 0, tests},
4712 {"jenkins", pre_jenkins, 0, tests},
4713 {"fnv1_64", pre_hash_fnv1_64, 0, tests},
4714 {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
4715 {"fnv1_32", pre_hash_fnv1_32, 0, tests},
4716 {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
4717 {"ketama", pre_behavior_ketama, 0, tests},
4718 {"ketama_auto_eject_hosts", pre_behavior_ketama, 0, ketama_auto_eject_hosts},
4719 {"unix_socket", pre_unix_socket, 0, tests},
4720 {"unix_socket_nodelay", pre_nodelay, 0, tests},
4721 {"poll_timeout", poll_timeout, 0, tests},
4722 {"gets", enable_cas, 0, tests},
4723 {"consistent", enable_consistent, 0, tests},
4724 #ifdef MEMCACHED_ENABLE_DEPRECATED
4725 {"deprecated_memory_allocators", deprecated_set_memory_alloc, 0, tests},
4726 #endif
4727 {"memory_allocators", set_memory_alloc, 0, tests},
4728 {"prefix", set_prefix, 0, tests},
4729 {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
4730 {"string", 0, 0, string_tests},
4731 {"result", 0, 0, result_tests},
4732 {"async", pre_nonblock, 0, async_tests},
4733 {"async_binary", pre_nonblock_binary, 0, async_tests},
4734 {"user", 0, 0, user_tests},
4735 {"generate", 0, 0, generate_tests},
4736 {"generate_hsieh", pre_hsieh, 0, generate_tests},
4737 {"generate_ketama", pre_behavior_ketama, 0, generate_tests},
4738 {"generate_hsieh_consistent", enable_consistent, 0, generate_tests},
4739 {"generate_md5", pre_md5, 0, generate_tests},
4740 {"generate_murmur", pre_murmur, 0, generate_tests},
4741 {"generate_jenkins", pre_jenkins, 0, generate_tests},
4742 {"generate_nonblock", pre_nonblock, 0, generate_tests},
4743 {"consistent_not", 0, 0, consistent_tests},
4744 {"consistent_ketama", pre_behavior_ketama, 0, consistent_tests},
4745 {"consistent_ketama_weighted", pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
4746 {"test_hashes", 0, 0, hash_tests},
4747 {"replication", pre_replication, 0, replication_tests},
4748 {"replication_noblock", pre_replication_noblock, 0, replication_tests},
4749 {0, 0, 0, 0}
4750 };
4751
4752 #define SERVERS_TO_CREATE 5
4753
4754 /* Prototypes for functions we will pass to test framework */
4755 void *world_create(void);
4756 void world_destroy(void *p);
4757
4758 void *world_create(void)
4759 {
4760 server_startup_st *construct;
4761
4762 construct= (server_startup_st *)malloc(sizeof(server_startup_st));
4763 memset(construct, 0, sizeof(server_startup_st));
4764 construct->count= SERVERS_TO_CREATE;
4765 construct->udp= 0;
4766 server_startup(construct);
4767
4768 return construct;
4769 }
4770
4771
4772 void world_destroy(void *p)
4773 {
4774 server_startup_st *construct= (server_startup_st *)p;
4775 memcached_server_st *servers= (memcached_server_st *)construct->servers;
4776 memcached_server_list_free(servers);
4777
4778 server_shutdown(construct);
4779 free(construct);
4780 }
4781
4782 void get_world(world_st *world)
4783 {
4784 world->collections= collection;
4785 world->create= world_create;
4786 world->destroy= world_destroy;
4787 }