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

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