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

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