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

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