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