git.m6w6.name Git - awesomized/libmemcached/blob - tests/function.c

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