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