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