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

   1 /*
   2   Sample test application.
   3 */
   4 #include <assert.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <sys/time.h>
   9 #include <sys/types.h>
  10 #include <sys/stat.h>
  11 #include <unistd.h>
  12 #include <time.h>
  13 #include "server.h"
  14 #include "../clients/generator.h"
  15 #include "../clients/execute.h"
  16
  17 #ifndef INT64_MAX
  18 #define INT64_MAX LONG_MAX
  19 #endif
  20 #ifndef INT32_MAX
  21 #define INT32_MAX INT_MAX
  22 #endif
  23
  24
  25 #include "test.h"
  26
  27 #define GLOBAL_COUNT 100000
  28 #define GLOBAL2_COUNT 1000
  29 static uint32_t global_count;
  30
  31 static pairs_st *global_pairs;
  32 static char *global_keys[GLOBAL_COUNT];
  33 static size_t global_keys_length[GLOBAL_COUNT];
  34
  35 uint8_t init_test(memcached_st *not_used)
  36 {
  37   memcached_st memc;
  38
  39   (void)memcached_create(&memc);
  40   memcached_free(&memc);
  41
  42   return 0;
  43 }
  44
  45 uint8_t server_list_null_test(memcached_st *ptr)
  46 {
  47   memcached_server_st *server_list;
  48   memcached_return rc;
  49
  50   server_list= memcached_server_list_append(NULL, NULL, 0, NULL);
  51   assert(server_list == NULL);
  52
  53   server_list= memcached_server_list_append(NULL, "localhost", 0, NULL);
  54   assert(server_list == NULL);
  55
  56   server_list= memcached_server_list_append(NULL, NULL, 0, &rc);
  57   assert(server_list == NULL);
  58
  59   return 0;
  60 }
  61
  62 #define TEST_PORT_COUNT 7
  63 uint32_t test_ports[TEST_PORT_COUNT];
  64
  65 memcached_return server_display_function(memcached_st *ptr, memcached_server_st *server, void *context)
  66 {
  67   /* Do Nothing */
  68   uint32_t bigger= *((uint32_t *)(context));
  69   assert(bigger <= server->port);
  70   *((uint32_t *)(context))= bigger;
  71
  72   return MEMCACHED_SUCCESS;
  73 }
  74
  75 uint8_t server_sort_test(memcached_st *ptr)
  76 {
  77   uint8_t x;
  78   uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */
  79   memcached_return rc;
  80   memcached_server_function callbacks[1];
  81   memcached_st *local_memc;
  82
  83   local_memc= memcached_create(NULL);
  84   assert(local_memc);
  85   memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
  86
  87   for (x= 0; x < TEST_PORT_COUNT; x++)
  88   {
  89     test_ports[x]= random() % 64000;
  90     rc= memcached_server_add(local_memc, "localhost", test_ports[x]);
  91     assert(local_memc->number_of_hosts == x+1);
  92     assert(local_memc->hosts[0].count == x+1);
  93     assert(rc == MEMCACHED_SUCCESS);
  94   }
  95
  96   callbacks[0]= server_display_function;
  97   memcached_server_cursor(local_memc, callbacks, (void *)&bigger,  1);
  98
  99
 100   memcached_free(local_memc);
 101
 102   return 0;
 103 }
 104
 105 uint8_t allocation_test(memcached_st *not_used)
 106 {
 107   memcached_st *memc;
 108   memc= memcached_create(NULL);
 109   assert(memc);
 110   memcached_free(memc);
 111
 112   return 0;
 113 }
 114
 115 uint8_t clone_test(memcached_st *memc)
 116 {
 117   /* All null? */
 118   {
 119     memcached_st *clone;
 120     clone= memcached_clone(NULL, NULL);
 121     assert(clone);
 122     memcached_free(clone);
 123   }
 124
 125   /* Can we init from null? */
 126   {
 127     memcached_st *clone;
 128     clone= memcached_clone(NULL, memc);
 129     assert(clone);
 130     memcached_free(clone);
 131   }
 132
 133   /* Can we init from struct? */
 134   {
 135     memcached_st declared_clone;
 136     memcached_st *clone;
 137     clone= memcached_clone(&declared_clone, NULL);
 138     assert(clone);
 139     memcached_free(clone);
 140   }
 141
 142   /* Can we init from struct? */
 143   {
 144     memcached_st declared_clone;
 145     memcached_st *clone;
 146     clone= memcached_clone(&declared_clone, memc);
 147     assert(clone);
 148     memcached_free(clone);
 149   }
 150
 151   return 0;
 152 }
 153
 154 uint8_t connection_test(memcached_st *memc)
 155 {
 156   memcached_return rc;
 157
 158   rc= memcached_server_add(memc, "localhost", 0);
 159   assert(rc == MEMCACHED_SUCCESS);
 160
 161   return 0;
 162 }
 163
 164 uint8_t error_test(memcached_st *memc)
 165 {
 166   memcached_return rc;
 167
 168   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
 169   {
 170     printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
 171   }
 172
 173   return 0;
 174 }
 175
 176 uint8_t set_test(memcached_st *memc)
 177 {
 178   memcached_return rc;
 179   char *key= "foo";
 180   char *value= "when we sanitize";
 181
 182   rc= memcached_set(memc, key, strlen(key),
 183                     value, strlen(value),
 184                     (time_t)0, (uint32_t)0);
 185   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 186
 187   return 0;
 188 }
 189
 190 uint8_t append_test(memcached_st *memc)
 191 {
 192   memcached_return rc;
 193   char *key= "fig";
 194   char *value= "we";
 195   size_t value_length;
 196   uint32_t flags;
 197
 198   rc= memcached_flush(memc, 0);
 199   assert(rc == MEMCACHED_SUCCESS);
 200
 201   rc= memcached_set(memc, key, strlen(key),
 202                     value, strlen(value),
 203                     (time_t)0, (uint32_t)0);
 204   assert(rc == MEMCACHED_SUCCESS);
 205
 206   rc= memcached_append(memc, key, strlen(key),
 207                        " the", strlen(" the"),
 208                        (time_t)0, (uint32_t)0);
 209   assert(rc == MEMCACHED_SUCCESS);
 210
 211   rc= memcached_append(memc, key, strlen(key),
 212                        " people", strlen(" people"),
 213                        (time_t)0, (uint32_t)0);
 214   assert(rc == MEMCACHED_SUCCESS);
 215
 216   value= memcached_get(memc, key, strlen(key),
 217                        &value_length, &flags, &rc);
 218   assert(!memcmp(value, "we the people", strlen("we the people")));
 219   assert(strlen("we the people") == value_length);
 220   assert(rc == MEMCACHED_SUCCESS);
 221   free(value);
 222
 223   return 0;
 224 }
 225
 226 uint8_t append_binary_test(memcached_st *memc)
 227 {
 228   memcached_return rc;
 229   char *key= "numbers";
 230   unsigned int *store_ptr;
 231   unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
 232   char *value;
 233   size_t value_length;
 234   uint32_t flags;
 235   unsigned int x;
 236
 237   rc= memcached_flush(memc, 0);
 238   assert(rc == MEMCACHED_SUCCESS);
 239
 240   rc= memcached_set(memc,
 241                     key, strlen(key),
 242                     NULL, 0,
 243                     (time_t)0, (uint32_t)0);
 244   assert(rc == MEMCACHED_SUCCESS);
 245
 246   for (x= 0; store_list[x] ; x++)
 247   {
 248     rc= memcached_append(memc,
 249                          key, strlen(key),
 250                          (char *)&store_list[x], sizeof(unsigned int),
 251                          (time_t)0, (uint32_t)0);
 252     assert(rc == MEMCACHED_SUCCESS);
 253   }
 254
 255   value= memcached_get(memc, key, strlen(key),
 256                        &value_length, &flags, &rc);
 257   assert((value_length == (sizeof(unsigned int) * x)));
 258   assert(rc == MEMCACHED_SUCCESS);
 259
 260   store_ptr= (unsigned int *)value;
 261   x= 0;
 262   while ((size_t)store_ptr < (size_t)(value + value_length))
 263   {
 264     assert(*store_ptr == store_list[x++]);
 265     store_ptr++;
 266   }
 267   free(value);
 268
 269   return 0;
 270 }
 271
 272 uint8_t cas2_test(memcached_st *memc)
 273 {
 274   memcached_return rc;
 275   char *keys[]= {"fudge", "son", "food"};
 276   size_t key_length[]= {5, 3, 4};
 277   char *value= "we the people";
 278   size_t value_length= strlen("we the people");
 279   unsigned int x;
 280   memcached_result_st results_obj;
 281   memcached_result_st *results;
 282   unsigned int set= 1;
 283
 284   rc= memcached_flush(memc, 0);
 285   assert(rc == MEMCACHED_SUCCESS);
 286
 287   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
 288
 289   for (x= 0; x < 3; x++)
 290   {
 291     rc= memcached_set(memc, keys[x], key_length[x],
 292                       keys[x], key_length[x],
 293                       (time_t)50, (uint32_t)9);
 294     assert(rc == MEMCACHED_SUCCESS);
 295   }
 296
 297   rc= memcached_mget(memc, keys, key_length, 3);
 298
 299   results= memcached_result_create(memc, &results_obj);
 300
 301   results= memcached_fetch_result(memc, &results_obj, &rc);
 302   assert(results);
 303   assert(results->cas);
 304   assert(rc == MEMCACHED_SUCCESS);
 305   WATCHPOINT_ASSERT(memcached_result_cas(results));
 306
 307   assert(!memcmp(value, "we the people", strlen("we the people")));
 308   assert(strlen("we the people") == value_length);
 309   assert(rc == MEMCACHED_SUCCESS);
 310
 311   memcached_result_free(&results_obj);
 312
 313   return 0;
 314 }
 315
 316 uint8_t cas_test(memcached_st *memc)
 317 {
 318   memcached_return rc;
 319   char *key= "fun";
 320   size_t key_length= strlen("fun");
 321   char *value= "we the people";
 322   size_t value_length= strlen("we the people");
 323   memcached_result_st results_obj;
 324   memcached_result_st *results;
 325   unsigned int set= 1;
 326
 327   rc= memcached_flush(memc, 0);
 328   assert(rc == MEMCACHED_SUCCESS);
 329
 330   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
 331
 332   rc= memcached_set(memc, key, strlen(key),
 333                     value, strlen(value),
 334                     (time_t)0, (uint32_t)0);
 335   assert(rc == MEMCACHED_SUCCESS);
 336
 337   rc= memcached_mget(memc, &key, &key_length, 1);
 338
 339   results= memcached_result_create(memc, &results_obj);
 340
 341   results= memcached_fetch_result(memc, &results_obj, &rc);
 342   assert(results);
 343   assert(rc == MEMCACHED_SUCCESS);
 344   WATCHPOINT_ASSERT(memcached_result_cas(results));
 345
 346   assert(!memcmp(value, "we the people", strlen("we the people")));
 347   assert(strlen("we the people") == value_length);
 348   assert(rc == MEMCACHED_SUCCESS);
 349
 350   rc= memcached_cas(memc, key, key_length,
 351                     "change the value", strlen("change the value"),
 352                     0, 0, memcached_result_cas(results));
 353
 354   assert(rc == MEMCACHED_SUCCESS);
 355
 356   rc= memcached_cas(memc, key, key_length,
 357                     "change the value", strlen("change the value"),
 358                     0, 0, 23);
 359
 360   assert(rc == MEMCACHED_DATA_EXISTS);
 361
 362
 363   memcached_result_free(&results_obj);
 364
 365   return 0;
 366 }
 367
 368 uint8_t prepend_test(memcached_st *memc)
 369 {
 370   memcached_return rc;
 371   char *key= "fig";
 372   char *value= "people";
 373   size_t value_length;
 374   uint32_t flags;
 375
 376   rc= memcached_flush(memc, 0);
 377   assert(rc == MEMCACHED_SUCCESS);
 378
 379   rc= memcached_set(memc, key, strlen(key),
 380                     value, strlen(value),
 381                     (time_t)0, (uint32_t)0);
 382   assert(rc == MEMCACHED_SUCCESS);
 383
 384   rc= memcached_prepend(memc, key, strlen(key),
 385                        "the ", strlen("the "),
 386                        (time_t)0, (uint32_t)0);
 387   assert(rc == MEMCACHED_SUCCESS);
 388
 389   rc= memcached_prepend(memc, key, strlen(key),
 390                        "we ", strlen("we "),
 391                        (time_t)0, (uint32_t)0);
 392   assert(rc == MEMCACHED_SUCCESS);
 393
 394   value= memcached_get(memc, key, strlen(key),
 395                        &value_length, &flags, &rc);
 396   assert(!memcmp(value, "we the people", strlen("we the people")));
 397   assert(strlen("we the people") == value_length);
 398   assert(rc == MEMCACHED_SUCCESS);
 399   free(value);
 400
 401   return 0;
 402 }
 403
 404 /*
 405   Set the value, then quit to make sure it is flushed.
 406   Come back in and test that add fails.
 407 */
 408 uint8_t add_test(memcached_st *memc)
 409 {
 410   memcached_return rc;
 411   char *key= "foo";
 412   char *value= "when we sanitize";
 413   unsigned long long setting_value;
 414
 415   setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 416
 417   rc= memcached_set(memc, key, strlen(key),
 418                     value, strlen(value),
 419                     (time_t)0, (uint32_t)0);
 420   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 421   memcached_quit(memc);
 422   rc= memcached_add(memc, key, strlen(key),
 423                     value, strlen(value),
 424                     (time_t)0, (uint32_t)0);
 425
 426   /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
 427   if (setting_value)
 428     assert(rc == MEMCACHED_NOTSTORED || MEMCACHED_STORED);
 429   else
 430     assert(rc == MEMCACHED_NOTSTORED);
 431
 432   return 0;
 433 }
 434
 435 uint8_t add_wrapper(memcached_st *memc)
 436 {
 437   unsigned int x;
 438
 439   for (x= 0; x < 10000; x++)
 440     add_test(memc);
 441
 442   return 0;
 443 }
 444
 445 uint8_t replace_test(memcached_st *memc)
 446 {
 447   memcached_return rc;
 448   char *key= "foo";
 449   char *value= "when we sanitize";
 450   char *original= "first we insert some data";
 451
 452   rc= memcached_set(memc, key, strlen(key),
 453                     original, strlen(original),
 454                     (time_t)0, (uint32_t)0);
 455   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 456
 457   rc= memcached_replace(memc, key, strlen(key),
 458                     value, strlen(value),
 459                     (time_t)0, (uint32_t)0);
 460   assert(rc == MEMCACHED_SUCCESS);
 461
 462   return 0;
 463 }
 464
 465 uint8_t delete_test(memcached_st *memc)
 466 {
 467   memcached_return rc;
 468   char *key= "foo";
 469   char *value= "when we sanitize";
 470
 471   rc= memcached_set(memc, key, strlen(key),
 472                     value, strlen(value),
 473                     (time_t)0, (uint32_t)0);
 474   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 475
 476   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 477   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 478
 479   return 0;
 480 }
 481
 482 uint8_t flush_test(memcached_st *memc)
 483 {
 484   memcached_return rc;
 485
 486   rc= memcached_flush(memc, 0);
 487   assert(rc == MEMCACHED_SUCCESS);
 488
 489   return 0;
 490 }
 491
 492 memcached_return server_function(memcached_st *ptr, memcached_server_st *server, void *context)
 493 {
 494   /* Do Nothing */
 495
 496   return MEMCACHED_SUCCESS;
 497 }
 498
 499 uint8_t memcached_server_cursor_test(memcached_st *memc)
 500 {
 501   char *context= "foo bad";
 502   memcached_server_function callbacks[1];
 503
 504   callbacks[0]= server_function;
 505   memcached_server_cursor(memc, callbacks, context,  1);
 506
 507   return 0;
 508 }
 509
 510 uint8_t bad_key_test(memcached_st *memc)
 511 {
 512   memcached_return rc;
 513   char *key= "foo bad";
 514   char *string;
 515   size_t string_length;
 516   uint32_t flags;
 517   memcached_st *clone;
 518   unsigned int set= 1;
 519
 520   clone= memcached_clone(NULL, memc);
 521   assert(clone);
 522
 523   (void)memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 524
 525   string= memcached_get(clone, key, strlen(key),
 526                         &string_length, &flags, &rc);
 527   assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 528   assert(string_length ==  0);
 529   assert(!string);
 530
 531   set= 0;
 532   (void)memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 533   string= memcached_get(clone, key, strlen(key),
 534                         &string_length, &flags, &rc);
 535   assert(rc == MEMCACHED_NOTFOUND);
 536   assert(string_length ==  0);
 537   assert(!string);
 538
 539   memcached_free(clone);
 540
 541   return 0;
 542 }
 543
 544 #define READ_THROUGH_VALUE "set for me"
 545 memcached_return read_through_trigger(memcached_st *memc,
 546                                       char *key, size_t key_length,
 547                                       memcached_result_st *result)
 548 {
 549
 550   return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
 551 }
 552
 553 uint8_t read_through(memcached_st *memc)
 554 {
 555   memcached_return rc;
 556   char *key= "foo";
 557   char *string;
 558   size_t string_length;
 559   uint32_t flags;
 560
 561   string= memcached_get(memc, key, strlen(key),
 562                         &string_length, &flags, &rc);
 563
 564   assert(rc == MEMCACHED_NOTFOUND);
 565   assert(string_length ==  0);
 566   assert(!string);
 567
 568   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, read_through_trigger);
 569   assert(rc == MEMCACHED_SUCCESS);
 570
 571   string= memcached_get(memc, key, strlen(key),
 572                         &string_length, &flags, &rc);
 573
 574   assert(rc == MEMCACHED_SUCCESS);
 575   assert(string_length ==  strlen(READ_THROUGH_VALUE));
 576   assert(!strcmp(READ_THROUGH_VALUE, string));
 577
 578   string= memcached_get(memc, key, strlen(key),
 579                         &string_length, &flags, &rc);
 580
 581   assert(rc == MEMCACHED_SUCCESS);
 582   assert(string_length ==  strlen(READ_THROUGH_VALUE));
 583   assert(!strcmp(READ_THROUGH_VALUE, string));
 584
 585   return 0;
 586 }
 587
 588 memcached_return delete_trigger(memcached_st *ptr,  char *key, size_t key_length)
 589 {
 590   assert(key);
 591
 592   return MEMCACHED_SUCCESS;
 593 }
 594
 595 uint8_t delete_through(memcached_st *memc)
 596 {
 597   memcached_trigger_delete_key callback;
 598   memcached_return rc;
 599
 600   callback= delete_trigger;
 601
 602   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, callback);
 603   assert(rc == MEMCACHED_SUCCESS);
 604
 605   return 0;
 606 }
 607
 608 uint8_t get_test(memcached_st *memc)
 609 {
 610   memcached_return rc;
 611   char *key= "foo";
 612   char *string;
 613   size_t string_length;
 614   uint32_t flags;
 615
 616   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 617   assert(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);
 618
 619   string= memcached_get(memc, key, strlen(key),
 620                         &string_length, &flags, &rc);
 621
 622   assert(rc == MEMCACHED_NOTFOUND);
 623   assert(string_length ==  0);
 624   assert(!string);
 625
 626   return 0;
 627 }
 628
 629 uint8_t get_test2(memcached_st *memc)
 630 {
 631   memcached_return rc;
 632   char *key= "foo";
 633   char *value= "when we sanitize";
 634   char *string;
 635   size_t string_length;
 636   uint32_t flags;
 637
 638   rc= memcached_set(memc, key, strlen(key),
 639                     value, strlen(value),
 640                     (time_t)0, (uint32_t)0);
 641   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 642
 643   string= memcached_get(memc, key, strlen(key),
 644                         &string_length, &flags, &rc);
 645
 646   assert(string);
 647   assert(rc == MEMCACHED_SUCCESS);
 648   assert(string_length == strlen(value));
 649   assert(!memcmp(string, value, string_length));
 650
 651   free(string);
 652
 653   return 0;
 654 }
 655
 656 uint8_t set_test2(memcached_st *memc)
 657 {
 658   memcached_return rc;
 659   char *key= "foo";
 660   char *value= "train in the brain";
 661   size_t value_length= strlen(value);
 662   unsigned int x;
 663
 664   for (x= 0; x < 10; x++)
 665   {
 666     rc= memcached_set(memc, key, strlen(key),
 667                       value, value_length,
 668                       (time_t)0, (uint32_t)0);
 669     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 670   }
 671
 672   return 0;
 673 }
 674
 675 uint8_t set_test3(memcached_st *memc)
 676 {
 677   memcached_return rc;
 678   char *key= "foo";
 679   char *value;
 680   size_t value_length= 8191;
 681   unsigned int x;
 682
 683   value = (char*)malloc(value_length);
 684   assert(value);
 685
 686   for (x= 0; x < value_length; x++)
 687     value[x] = (char) (x % 127);
 688
 689   for (x= 0; x < 1; x++)
 690   {
 691     rc= memcached_set(memc, key, strlen(key),
 692                       value, value_length,
 693                       (time_t)0, (uint32_t)0);
 694     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 695   }
 696
 697   free(value);
 698
 699   return 0;
 700 }
 701
 702 uint8_t get_test3(memcached_st *memc)
 703 {
 704   memcached_return rc;
 705   char *key= "foo";
 706   char *value;
 707   size_t value_length= 8191;
 708   char *string;
 709   size_t string_length;
 710   uint32_t flags;
 711   int x;
 712
 713   value = (char*)malloc(value_length);
 714   assert(value);
 715
 716   for (x= 0; x < value_length; x++)
 717     value[x] = (char) (x % 127);
 718
 719   rc= memcached_set(memc, key, strlen(key),
 720                     value, value_length,
 721                     (time_t)0, (uint32_t)0);
 722   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 723
 724   string= memcached_get(memc, key, strlen(key),
 725                         &string_length, &flags, &rc);
 726
 727   assert(rc == MEMCACHED_SUCCESS);
 728   assert(string);
 729   assert(string_length == value_length);
 730   assert(!memcmp(string, value, string_length));
 731
 732   free(string);
 733   free(value);
 734
 735   return 0;
 736 }
 737
 738 uint8_t get_test4(memcached_st *memc)
 739 {
 740   memcached_return rc;
 741   char *key= "foo";
 742   char *value;
 743   size_t value_length= 8191;
 744   char *string;
 745   size_t string_length;
 746   uint32_t flags;
 747   int x;
 748
 749   value = (char*)malloc(value_length);
 750   assert(value);
 751
 752   for (x= 0; x < value_length; x++)
 753     value[x] = (char) (x % 127);
 754
 755   rc= memcached_set(memc, key, strlen(key),
 756                     value, value_length,
 757                     (time_t)0, (uint32_t)0);
 758   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 759
 760   for (x= 0; x < 10; x++)
 761   {
 762     string= memcached_get(memc, key, strlen(key),
 763                           &string_length, &flags, &rc);
 764
 765     assert(rc == MEMCACHED_SUCCESS);
 766     assert(string);
 767     assert(string_length == value_length);
 768     assert(!memcmp(string, value, string_length));
 769     free(string);
 770   }
 771
 772   free(value);
 773
 774   return 0;
 775 }
 776
 777 /* Do not copy the style of this code, I just access hosts to testthis function */
 778 uint8_t stats_servername_test(memcached_st *memc)
 779 {
 780   memcached_return rc;
 781   memcached_stat_st stat;
 782   rc= memcached_stat_servername(&stat, NULL,
 783                                  memc->hosts[0].hostname,
 784                                  memc->hosts[0].port);
 785
 786   return 0;
 787 }
 788
 789 uint8_t increment_test(memcached_st *memc)
 790 {
 791   uint64_t new_number;
 792   memcached_return rc;
 793   char *key= "number";
 794   char *value= "0";
 795
 796   rc= memcached_set(memc, key, strlen(key),
 797                     value, strlen(value),
 798                     (time_t)0, (uint32_t)0);
 799   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 800
 801   rc= memcached_increment(memc, key, strlen(key),
 802                           1, &new_number);
 803   assert(rc == MEMCACHED_SUCCESS);
 804   assert(new_number == 1);
 805
 806   rc= memcached_increment(memc, key, strlen(key),
 807                           1, &new_number);
 808   assert(rc == MEMCACHED_SUCCESS);
 809   assert(new_number == 2);
 810
 811   return 0;
 812 }
 813
 814 uint8_t decrement_test(memcached_st *memc)
 815 {
 816   uint64_t new_number;
 817   memcached_return rc;
 818   char *key= "number";
 819   char *value= "3";
 820
 821   rc= memcached_set(memc, key, strlen(key),
 822                     value, strlen(value),
 823                     (time_t)0, (uint32_t)0);
 824   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 825
 826   rc= memcached_decrement(memc, key, strlen(key),
 827                           1, &new_number);
 828   assert(rc == MEMCACHED_SUCCESS);
 829   assert(new_number == 2);
 830
 831   rc= memcached_decrement(memc, key, strlen(key),
 832                           1, &new_number);
 833   assert(rc == MEMCACHED_SUCCESS);
 834   assert(new_number == 1);
 835
 836   return 0;
 837 }
 838
 839 uint8_t quit_test(memcached_st *memc)
 840 {
 841   memcached_return rc;
 842   char *key= "fudge";
 843   char *value= "sanford and sun";
 844
 845   rc= memcached_set(memc, key, strlen(key),
 846                     value, strlen(value),
 847                     (time_t)10, (uint32_t)3);
 848   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 849   memcached_quit(memc);
 850
 851   rc= memcached_set(memc, key, strlen(key),
 852                     value, strlen(value),
 853                     (time_t)50, (uint32_t)9);
 854   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 855
 856   return 0;
 857 }
 858
 859 uint8_t mget_result_test(memcached_st *memc)
 860 {
 861   memcached_return rc;
 862   char *keys[]= {"fudge", "son", "food"};
 863   size_t key_length[]= {5, 3, 4};
 864   unsigned int x;
 865
 866   memcached_result_st results_obj;
 867   memcached_result_st *results;
 868
 869   results= memcached_result_create(memc, &results_obj);
 870   assert(results);
 871   assert(&results_obj == results);
 872
 873   /* We need to empty the server before continueing test */
 874   rc= memcached_flush(memc, 0);
 875   assert(rc == MEMCACHED_SUCCESS);
 876
 877   rc= memcached_mget(memc, keys, key_length, 3);
 878   assert(rc == MEMCACHED_SUCCESS);
 879
 880   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 881   {
 882     assert(results);
 883   }
 884
 885   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 886   assert(!results);
 887   assert(rc == MEMCACHED_END);
 888
 889   for (x= 0; x < 3; x++)
 890   {
 891     rc= memcached_set(memc, keys[x], key_length[x],
 892                       keys[x], key_length[x],
 893                       (time_t)50, (uint32_t)9);
 894     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 895   }
 896
 897   rc= memcached_mget(memc, keys, key_length, 3);
 898   assert(rc == MEMCACHED_SUCCESS);
 899
 900   while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
 901   {
 902     assert(results);
 903     assert(&results_obj == results);
 904     assert(rc == MEMCACHED_SUCCESS);
 905     assert(memcached_result_key_length(results) == memcached_result_length(results));
 906     assert(!memcmp(memcached_result_key_value(results),
 907                    memcached_result_value(results),
 908                    memcached_result_length(results)));
 909   }
 910
 911   memcached_result_free(&results_obj);
 912
 913   return 0;
 914 }
 915
 916 uint8_t mget_result_alloc_test(memcached_st *memc)
 917 {
 918   memcached_return rc;
 919   char *keys[]= {"fudge", "son", "food"};
 920   size_t key_length[]= {5, 3, 4};
 921   unsigned int x;
 922
 923   memcached_result_st *results;
 924
 925   /* We need to empty the server before continueing test */
 926   rc= memcached_flush(memc, 0);
 927   assert(rc == MEMCACHED_SUCCESS);
 928
 929   rc= memcached_mget(memc, keys, key_length, 3);
 930   assert(rc == MEMCACHED_SUCCESS);
 931
 932   while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
 933   {
 934     assert(results);
 935   }
 936   assert(!results);
 937   assert(rc == MEMCACHED_END);
 938
 939   for (x= 0; x < 3; x++)
 940   {
 941     rc= memcached_set(memc, keys[x], key_length[x],
 942                       keys[x], key_length[x],
 943                       (time_t)50, (uint32_t)9);
 944     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 945   }
 946
 947   rc= memcached_mget(memc, keys, key_length, 3);
 948   assert(rc == MEMCACHED_SUCCESS);
 949
 950   x= 0;
 951   while ((results= memcached_fetch_result(memc, NULL, &rc)))
 952   {
 953     assert(results);
 954     assert(rc == MEMCACHED_SUCCESS);
 955     assert(memcached_result_key_length(results) == memcached_result_length(results));
 956     assert(!memcmp(memcached_result_key_value(results),
 957                    memcached_result_value(results),
 958                    memcached_result_length(results)));
 959     memcached_result_free(results);
 960     x++;
 961   }
 962
 963   return 0;
 964 }
 965
 966 /* Count the results */
 967 unsigned int callback_counter(memcached_st *ptr, memcached_result_st *result, void *context)
 968 {
 969   unsigned int *counter= (unsigned int *)context;
 970
 971   *counter= *counter + 1;
 972
 973   return 0;
 974 }
 975
 976 uint8_t mget_result_function(memcached_st *memc)
 977 {
 978   memcached_return rc;
 979   char *keys[]= {"fudge", "son", "food"};
 980   size_t key_length[]= {5, 3, 4};
 981   unsigned int x;
 982   unsigned int counter;
 983   memcached_execute_function callbacks[1];
 984
 985   /* We need to empty the server before continueing test */
 986   rc= memcached_flush(memc, 0);
 987   for (x= 0; x < 3; x++)
 988   {
 989     rc= memcached_set(memc, keys[x], key_length[x],
 990                       keys[x], key_length[x],
 991                       (time_t)50, (uint32_t)9);
 992     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 993   }
 994
 995   rc= memcached_mget(memc, keys, key_length, 3);
 996   assert(rc == MEMCACHED_SUCCESS);
 997
 998   callbacks[0]= &callback_counter;
 999   counter= 0;
1000   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
1001
1002   assert(counter == 3);
1003
1004   return 0;
1005 }
1006
1007 uint8_t mget_test(memcached_st *memc)
1008 {
1009   memcached_return rc;
1010   char *keys[]= {"fudge", "son", "food"};
1011   size_t key_length[]= {5, 3, 4};
1012   unsigned int x;
1013   uint32_t flags;
1014
1015   char return_key[MEMCACHED_MAX_KEY];
1016   size_t return_key_length;
1017   char *return_value;
1018   size_t return_value_length;
1019
1020   /* We need to empty the server before continueing test */
1021   rc= memcached_flush(memc, 0);
1022   assert(rc == MEMCACHED_SUCCESS);
1023
1024   rc= memcached_mget(memc, keys, key_length, 3);
1025   assert(rc == MEMCACHED_SUCCESS);
1026
1027   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1028                       &return_value_length, &flags, &rc)) != NULL)
1029   {
1030     assert(return_value);
1031   }
1032   assert(!return_value);
1033   assert(return_value_length == 0);
1034   assert(rc == MEMCACHED_END);
1035
1036   for (x= 0; x < 3; x++)
1037   {
1038     rc= memcached_set(memc, keys[x], key_length[x],
1039                       keys[x], key_length[x],
1040                       (time_t)50, (uint32_t)9);
1041     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1042   }
1043
1044   rc= memcached_mget(memc, keys, key_length, 3);
1045   assert(rc == MEMCACHED_SUCCESS);
1046
1047   x= 0;
1048   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1049                                         &return_value_length, &flags, &rc)))
1050   {
1051     assert(return_value);
1052     assert(rc == MEMCACHED_SUCCESS);
1053     assert(return_key_length == return_value_length);
1054     assert(!memcmp(return_value, return_key, return_value_length));
1055     free(return_value);
1056     x++;
1057   }
1058
1059   return 0;
1060 }
1061
1062 uint8_t get_stats_keys(memcached_st *memc)
1063 {
1064  char **list;
1065  char **ptr;
1066  memcached_stat_st stat;
1067  memcached_return rc;
1068
1069  list= memcached_stat_get_keys(memc, &stat, &rc);
1070  assert(rc == MEMCACHED_SUCCESS);
1071  for (ptr= list; *ptr; ptr++)
1072    assert(*ptr);
1073  fflush(stdout);
1074
1075  free(list);
1076
1077  return 0;
1078 }
1079
1080 uint8_t version_string_test(memcached_st *memc)
1081 {
1082   const char *version_string;
1083
1084   version_string= memcached_lib_version();
1085
1086   assert(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING));
1087
1088   return 0;
1089 }
1090
1091 uint8_t get_stats(memcached_st *memc)
1092 {
1093  unsigned int x;
1094  char **list;
1095  char **ptr;
1096  memcached_return rc;
1097  memcached_stat_st *stat;
1098
1099  stat= memcached_stat(memc, NULL, &rc);
1100  assert(rc == MEMCACHED_SUCCESS);
1101
1102  assert(rc == MEMCACHED_SUCCESS);
1103  assert(stat);
1104
1105  for (x= 0; x < memcached_server_count(memc); x++)
1106  {
1107    list= memcached_stat_get_keys(memc, stat+x, &rc);
1108    assert(rc == MEMCACHED_SUCCESS);
1109    for (ptr= list; *ptr; ptr++);
1110
1111    free(list);
1112  }
1113
1114  memcached_stat_free(NULL, stat);
1115
1116   return 0;
1117 }
1118
1119 uint8_t add_host_test(memcached_st *memc)
1120 {
1121   unsigned int x;
1122   memcached_server_st *servers;
1123   memcached_return rc;
1124   char servername[]= "0.example.com";
1125
1126   servers= memcached_server_list_append(NULL, servername, 400, &rc);
1127   assert(servers);
1128   assert(1 == memcached_server_list_count(servers));
1129
1130   for (x= 2; x < 20; x++)
1131   {
1132     char buffer[SMALL_STRING_LEN];
1133
1134     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1135     servers= memcached_server_list_append(servers, buffer, 401,
1136                                      &rc);
1137     assert(rc == MEMCACHED_SUCCESS);
1138     assert(x == memcached_server_list_count(servers));
1139   }
1140
1141   rc= memcached_server_push(memc, servers);
1142   assert(rc == MEMCACHED_SUCCESS);
1143   rc= memcached_server_push(memc, servers);
1144   assert(rc == MEMCACHED_SUCCESS);
1145
1146   memcached_server_list_free(servers);
1147
1148   return 0;
1149 }
1150
1151 memcached_return clone_test_callback(memcached_st *parent, memcached_st *clone)
1152 {
1153   return MEMCACHED_SUCCESS;
1154 }
1155
1156 memcached_return cleanup_test_callback(memcached_st *ptr)
1157 {
1158   return MEMCACHED_SUCCESS;
1159 }
1160
1161 uint8_t callback_test(memcached_st *memc)
1162 {
1163   /* Test User Data */
1164   {
1165     int x= 5;
1166     int *test_ptr;
1167     memcached_return rc;
1168
1169     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x);
1170     assert(rc == MEMCACHED_SUCCESS);
1171     test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
1172     assert(*test_ptr == x);
1173   }
1174
1175   /* Test Clone Callback */
1176   {
1177     memcached_clone_func temp_function;
1178     memcached_return rc;
1179
1180     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, clone_test_callback);
1181     assert(rc == MEMCACHED_SUCCESS);
1182     temp_function= (memcached_clone_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1183     assert(temp_function == clone_test_callback);
1184   }
1185
1186   /* Test Cleanup Callback */
1187   {
1188     memcached_cleanup_func temp_function;
1189     memcached_return rc;
1190
1191     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, cleanup_test_callback);
1192     assert(rc == MEMCACHED_SUCCESS);
1193     temp_function= (memcached_cleanup_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1194     assert(temp_function == cleanup_test_callback);
1195   }
1196
1197   return 0;
1198 }
1199
1200 /* We don't test the behavior itself, we test the switches */
1201 uint8_t behavior_test(memcached_st *memc)
1202 {
1203   unsigned long long value;
1204   unsigned int set= 1;
1205
1206   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1207   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1208   assert(value == 1);
1209
1210   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1211   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1212   assert(value == 1);
1213
1214   set= MEMCACHED_HASH_MD5;
1215   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1216   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1217   assert(value == MEMCACHED_HASH_MD5);
1218
1219   set= 0;
1220
1221   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1222   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1223   assert(value == 0);
1224
1225   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1226   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1227   assert(value == 0);
1228
1229   set= MEMCACHED_HASH_DEFAULT;
1230   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1231   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1232   assert(value == MEMCACHED_HASH_DEFAULT);
1233
1234   set= MEMCACHED_HASH_CRC;
1235   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1236   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1237   assert(value == MEMCACHED_HASH_CRC);
1238
1239   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1240   assert(value > 0);
1241
1242   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1243   assert(value > 0);
1244
1245   return 0;
1246 }
1247
1248 /* Test case provided by Cal Haldenbrand */
1249 uint8_t user_supplied_bug1(memcached_st *memc)
1250 {
1251   unsigned int setter= 1;
1252   unsigned int x;
1253
1254   unsigned long long total= 0;
1255   int size= 0;
1256   char key[10];
1257   char randomstuff[6 * 1024];
1258   memcached_return rc;
1259
1260   memset(randomstuff, 0, 6 * 1024);
1261
1262   /* We just keep looking at the same values over and over */
1263   srandom(10);
1264
1265   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1266   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1267
1268
1269   /* add key */
1270   for (x= 0 ; total < 20 * 1024576 ; x++ )
1271   {
1272     unsigned int j= 0;
1273
1274     size= (rand() % ( 5 * 1024 ) ) + 400;
1275     memset(randomstuff, 0, 6 * 1024);
1276     assert(size < 6 * 1024); /* Being safe here */
1277
1278     for (j= 0 ; j < size ;j++)
1279       randomstuff[j] = (char) (rand() % 26) + 97;
1280
1281     total += size;
1282     sprintf(key, "%d", x);
1283     rc = memcached_set(memc, key, strlen(key),
1284                        randomstuff, strlen(randomstuff), 10, 0);
1285     /* If we fail, lets try again */
1286     if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
1287       rc = memcached_set(memc, key, strlen(key),
1288                          randomstuff, strlen(randomstuff), 10, 0);
1289     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1290   }
1291
1292   return 0;
1293 }
1294
1295 /* Test case provided by Cal Haldenbrand */
1296 uint8_t user_supplied_bug2(memcached_st *memc)
1297 {
1298   int errors;
1299   unsigned int setter;
1300   unsigned int x;
1301   unsigned long long total;
1302
1303   setter= 1;
1304   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1305   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1306 #ifdef NOT_YET
1307   setter = 20 * 1024576;
1308   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
1309   setter = 20 * 1024576;
1310   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
1311   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1312   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1313
1314   for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
1315 #endif
1316
1317   for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
1318   {
1319     memcached_return rc= MEMCACHED_SUCCESS;
1320     char buffer[SMALL_STRING_LEN];
1321     uint32_t flags= 0;
1322     size_t val_len= 0;
1323     char *getval;
1324
1325     memset(buffer, 0, SMALL_STRING_LEN);
1326
1327     snprintf(buffer, SMALL_STRING_LEN, "%u", x);
1328     getval= memcached_get(memc, buffer, strlen(buffer),
1329                            &val_len, &flags, &rc);
1330     if (rc != MEMCACHED_SUCCESS)
1331     {
1332       if (rc == MEMCACHED_NOTFOUND)
1333         errors++;
1334       else
1335       {
1336         WATCHPOINT_ERROR(rc);
1337         assert(0);
1338       }
1339
1340       continue;
1341     }
1342     total+= val_len;
1343     errors= 0;
1344     free(getval);
1345   }
1346
1347   return 0;
1348 }
1349
1350 /* Do a large mget() over all the keys we think exist */
1351 #define KEY_COUNT 3000 // * 1024576
1352 uint8_t user_supplied_bug3(memcached_st *memc)
1353 {
1354   memcached_return rc;
1355   unsigned int setter;
1356   unsigned int x;
1357   char **keys;
1358   size_t key_lengths[KEY_COUNT];
1359
1360   setter= 1;
1361   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1362   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1363 #ifdef NOT_YET
1364   setter = 20 * 1024576;
1365   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
1366   setter = 20 * 1024576;
1367   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
1368   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1369   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1370 #endif
1371
1372   keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
1373   assert(keys);
1374   memset(keys, 0, (sizeof(char *) * KEY_COUNT));
1375   for (x= 0; x < KEY_COUNT; x++)
1376   {
1377     char buffer[30];
1378
1379     snprintf(buffer, 30, "%u", x);
1380     keys[x]= strdup(buffer);
1381     key_lengths[x]= strlen(keys[x]);
1382   }
1383
1384   rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
1385   assert(rc == MEMCACHED_SUCCESS);
1386
1387   /* Turn this into a help function */
1388   {
1389     char return_key[MEMCACHED_MAX_KEY];
1390     size_t return_key_length;
1391     char *return_value;
1392     size_t return_value_length;
1393     uint32_t flags;
1394
1395     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1396                                           &return_value_length, &flags, &rc)))
1397     {
1398       assert(return_value);
1399       assert(rc == MEMCACHED_SUCCESS);
1400       free(return_value);
1401     }
1402   }
1403
1404   for (x= 0; x < KEY_COUNT; x++)
1405     free(keys[x]);
1406   free(keys);
1407
1408   return 0;
1409 }
1410
1411 /* Make sure we behave properly if server list has no values */
1412 uint8_t user_supplied_bug4(memcached_st *memc)
1413 {
1414   memcached_return rc;
1415   char *keys[]= {"fudge", "son", "food"};
1416   size_t key_length[]= {5, 3, 4};
1417   unsigned int x;
1418   uint32_t flags;
1419   char return_key[MEMCACHED_MAX_KEY];
1420   size_t return_key_length;
1421   char *return_value;
1422   size_t return_value_length;
1423
1424   /* Here we free everything before running a bunch of mget tests */
1425   {
1426     memcached_server_list_free(memc->hosts);
1427     memc->hosts= NULL;
1428     memc->number_of_hosts= 0;
1429   }
1430
1431
1432   /* We need to empty the server before continueing test */
1433   rc= memcached_flush(memc, 0);
1434   assert(rc == MEMCACHED_NO_SERVERS);
1435
1436   rc= memcached_mget(memc, keys, key_length, 3);
1437   assert(rc == MEMCACHED_NO_SERVERS);
1438
1439   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1440                       &return_value_length, &flags, &rc)) != NULL)
1441   {
1442     assert(return_value);
1443   }
1444   assert(!return_value);
1445   assert(return_value_length == 0);
1446   assert(rc == MEMCACHED_NO_SERVERS);
1447
1448   for (x= 0; x < 3; x++)
1449   {
1450     rc= memcached_set(memc, keys[x], key_length[x],
1451                       keys[x], key_length[x],
1452                       (time_t)50, (uint32_t)9);
1453     assert(rc == MEMCACHED_NO_SERVERS);
1454   }
1455
1456   rc= memcached_mget(memc, keys, key_length, 3);
1457   assert(rc == MEMCACHED_NO_SERVERS);
1458
1459   x= 0;
1460   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1461                                         &return_value_length, &flags, &rc)))
1462   {
1463     assert(return_value);
1464     assert(rc == MEMCACHED_SUCCESS);
1465     assert(return_key_length == return_value_length);
1466     assert(!memcmp(return_value, return_key, return_value_length));
1467     free(return_value);
1468     x++;
1469   }
1470
1471   return 0;
1472 }
1473
1474 #define VALUE_SIZE_BUG5 1048064
1475 uint8_t user_supplied_bug5(memcached_st *memc)
1476 {
1477   memcached_return rc;
1478   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1479   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1480   char return_key[MEMCACHED_MAX_KEY];
1481   size_t return_key_length;
1482   char *value;
1483   size_t value_length;
1484   uint32_t flags;
1485   unsigned int count;
1486   unsigned int x;
1487   char insert_data[VALUE_SIZE_BUG5];
1488
1489   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1490     insert_data[x]= rand();
1491
1492   memcached_flush(memc, 0);
1493   value= memcached_get(memc, keys[0], key_length[0],
1494                         &value_length, &flags, &rc);
1495   assert(value == NULL);
1496   rc= memcached_mget(memc, keys, key_length, 4);
1497
1498   count= 0;
1499   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1500                                         &value_length, &flags, &rc)))
1501     count++;
1502   assert(count == 0);
1503
1504   for (x= 0; x < 4; x++)
1505   {
1506     rc= memcached_set(memc, keys[x], key_length[x],
1507                       insert_data, VALUE_SIZE_BUG5,
1508                       (time_t)0, (uint32_t)0);
1509     assert(rc == MEMCACHED_SUCCESS);
1510   }
1511
1512   for (x= 0; x < 10; x++)
1513   {
1514     value= memcached_get(memc, keys[0], key_length[0],
1515                          &value_length, &flags, &rc);
1516     assert(value);
1517     free(value);
1518
1519     rc= memcached_mget(memc, keys, key_length, 4);
1520     count= 0;
1521     while ((value= memcached_fetch(memc, return_key, &return_key_length,
1522                                           &value_length, &flags, &rc)))
1523     {
1524       count++;
1525       free(value);
1526     }
1527     assert(count == 4);
1528   }
1529
1530   return 0;
1531 }
1532
1533 uint8_t user_supplied_bug6(memcached_st *memc)
1534 {
1535   memcached_return rc;
1536   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1537   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1538   char return_key[MEMCACHED_MAX_KEY];
1539   size_t return_key_length;
1540   char *value;
1541   size_t value_length;
1542   uint32_t flags;
1543   unsigned int count;
1544   unsigned int x;
1545   char insert_data[VALUE_SIZE_BUG5];
1546
1547   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1548     insert_data[x]= rand();
1549
1550   memcached_flush(memc, 0);
1551   value= memcached_get(memc, keys[0], key_length[0],
1552                         &value_length, &flags, &rc);
1553   assert(value == NULL);
1554   assert(rc == MEMCACHED_NOTFOUND);
1555   rc= memcached_mget(memc, keys, key_length, 4);
1556   assert(rc == MEMCACHED_SUCCESS);
1557
1558   count= 0;
1559   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1560                                         &value_length, &flags, &rc)))
1561     count++;
1562   assert(count == 0);
1563   assert(rc == MEMCACHED_END);
1564
1565   for (x= 0; x < 4; x++)
1566   {
1567     rc= memcached_set(memc, keys[x], key_length[x],
1568                       insert_data, VALUE_SIZE_BUG5,
1569                       (time_t)0, (uint32_t)0);
1570     assert(rc == MEMCACHED_SUCCESS);
1571   }
1572
1573   for (x= 0; x < 2; x++)
1574   {
1575     value= memcached_get(memc, keys[0], key_length[0],
1576                          &value_length, &flags, &rc);
1577     assert(value);
1578     free(value);
1579
1580     rc= memcached_mget(memc, keys, key_length, 4);
1581     assert(rc == MEMCACHED_SUCCESS);
1582     count= 3;
1583     /* We test for purge of partial complete fetches */
1584     for (count= 3; count; count--)
1585     {
1586       value= memcached_fetch(memc, return_key, &return_key_length,
1587                              &value_length, &flags, &rc);
1588       assert(rc == MEMCACHED_SUCCESS);
1589       assert(!(memcmp(value, insert_data, value_length)));
1590       assert(value_length);
1591       free(value);
1592     }
1593   }
1594
1595   return 0;
1596 }
1597
1598 uint8_t user_supplied_bug8(memcached_st *memc)
1599 {
1600   memcached_return rc;
1601   memcached_st *mine;
1602   memcached_st *clone;
1603
1604   memcached_server_st *servers;
1605   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";
1606
1607   servers= memcached_servers_parse(server_list);
1608   assert(servers);
1609
1610   mine= memcached_create(NULL);
1611   rc= memcached_server_push(mine, servers);
1612   assert(rc == MEMCACHED_SUCCESS);
1613   memcached_server_list_free(servers);
1614
1615   assert(mine);
1616   clone= memcached_clone(NULL, mine);
1617
1618   memcached_quit(mine);
1619   memcached_quit(clone);
1620
1621
1622   memcached_free(mine);
1623   memcached_free(clone);
1624
1625   return 0;
1626 }
1627
1628 /* Test flag store/retrieve */
1629 uint8_t user_supplied_bug7(memcached_st *memc)
1630 {
1631   memcached_return rc;
1632   char *keys= "036790384900";
1633   size_t key_length=  strlen("036790384900");
1634   char return_key[MEMCACHED_MAX_KEY];
1635   size_t return_key_length;
1636   char *value;
1637   size_t value_length;
1638   uint32_t flags;
1639   unsigned int x;
1640   char insert_data[VALUE_SIZE_BUG5];
1641
1642   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1643     insert_data[x]= rand();
1644
1645   memcached_flush(memc, 0);
1646
1647   flags= 245;
1648   rc= memcached_set(memc, keys, key_length,
1649                     insert_data, VALUE_SIZE_BUG5,
1650                     (time_t)0, flags);
1651   assert(rc == MEMCACHED_SUCCESS);
1652
1653   flags= 0;
1654   value= memcached_get(memc, keys, key_length,
1655                         &value_length, &flags, &rc);
1656   assert(flags == 245);
1657   assert(value);
1658   free(value);
1659
1660   rc= memcached_mget(memc, &keys, &key_length, 1);
1661
1662   flags= 0;
1663   value= memcached_fetch(memc, return_key, &return_key_length,
1664                          &value_length, &flags, &rc);
1665   assert(flags == 245);
1666   assert(value);
1667   free(value);
1668
1669
1670   return 0;
1671 }
1672
1673 uint8_t user_supplied_bug9(memcached_st *memc)
1674 {
1675   memcached_return rc;
1676   char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1677   size_t key_length[3];
1678   unsigned int x;
1679   uint32_t flags;
1680   unsigned count= 0;
1681
1682   char return_key[MEMCACHED_MAX_KEY];
1683   size_t return_key_length;
1684   char *return_value;
1685   size_t return_value_length;
1686
1687
1688   key_length[0]= strlen("UDATA:edevil@sapo.pt");
1689   key_length[1]= strlen("fudge&*@#");
1690   key_length[2]= strlen("for^#@&$not");
1691
1692
1693   for (x= 0; x < 3; x++)
1694   {
1695     rc= memcached_set(memc, keys[x], key_length[x],
1696                       keys[x], key_length[x],
1697                       (time_t)50, (uint32_t)9);
1698     assert(rc == MEMCACHED_SUCCESS);
1699   }
1700
1701   rc= memcached_mget(memc, keys, key_length, 3);
1702   assert(rc == MEMCACHED_SUCCESS);
1703
1704   /* We need to empty the server before continueing test */
1705   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1706                       &return_value_length, &flags, &rc)) != NULL)
1707   {
1708     assert(return_value);
1709     free(return_value);
1710     count++;
1711   }
1712   assert(count == 3);
1713
1714   return 0;
1715 }
1716
1717 /* We are testing with aggressive timeout to get failures */
1718 uint8_t user_supplied_bug10(memcached_st *memc)
1719 {
1720   char *key= "foo";
1721   char *value;
1722   size_t value_length= 512;
1723   unsigned int x;
1724   int key_len= 3;
1725   memcached_return rc;
1726   unsigned int set= 1;
1727   memcached_st *mclone= memcached_clone(NULL, memc);
1728   int32_t timeout;
1729
1730   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1731   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1732   timeout= 2;
1733   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
1734
1735   value = (char*)malloc(value_length * sizeof(char));
1736
1737   for (x= 0; x < value_length; x++)
1738     value[x]= (char) (x % 127);
1739
1740   for (x= 1; x <= 100000; ++x)
1741   {
1742     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
1743
1744     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_BUFFERED);
1745
1746     if (rc == MEMCACHED_WRITE_FAILURE)
1747       x--;
1748   }
1749
1750   free(value);
1751   memcached_free(mclone);
1752
1753   return 0;
1754 }
1755
1756 /*
1757   We are looking failures in the async protocol
1758 */
1759 uint8_t user_supplied_bug11(memcached_st *memc)
1760 {
1761   char *key= "foo";
1762   char *value;
1763   size_t value_length= 512;
1764   unsigned int x;
1765   int key_len= 3;
1766   memcached_return rc;
1767   unsigned int set= 1;
1768   int32_t timeout;
1769   memcached_st *mclone= memcached_clone(NULL, memc);
1770
1771   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1772   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1773   timeout= -1;
1774   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
1775
1776   timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
1777
1778   assert(timeout == -1);
1779
1780   value = (char*)malloc(value_length * sizeof(char));
1781
1782   for (x= 0; x < value_length; x++)
1783     value[x]= (char) (x % 127);
1784
1785   for (x= 1; x <= 100000; ++x)
1786   {
1787     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
1788   }
1789
1790   free(value);
1791   memcached_free(mclone);
1792
1793   return 0;
1794 }
1795
1796 /*
1797   Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
1798 */
1799 uint8_t user_supplied_bug12(memcached_st *memc)
1800 {
1801   memcached_return rc;
1802   uint32_t flags;
1803   size_t value_length;
1804   char *value;
1805   uint64_t number_value;
1806
1807   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
1808                         &value_length, &flags, &rc);
1809   assert(value == NULL);
1810   assert(rc == MEMCACHED_NOTFOUND);
1811
1812   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
1813                           1, &number_value);
1814
1815   assert(value == NULL);
1816   assert(rc == MEMCACHED_NOTFOUND);
1817
1818   rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
1819
1820   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
1821                         &value_length, &flags, &rc);
1822   assert(value);
1823   assert(rc == MEMCACHED_SUCCESS);
1824   free(value);
1825
1826   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
1827                           1, &number_value);
1828   assert(number_value == 2);
1829   assert(rc == MEMCACHED_SUCCESS);
1830
1831   return 0;
1832 }
1833
1834 /*
1835   Bug found where command total one more than MEMCACHED_MAX_BUFFER
1836   set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
1837  */
1838 uint8_t user_supplied_bug13(memcached_st *memc)
1839 {
1840   char key[] = "key34567890";
1841   char *overflow;
1842   memcached_return rc;
1843   size_t overflowSize;
1844
1845   char commandFirst[]= "set key34567890 0 0 ";
1846   char commandLast[] = " \r\n"; /* first line of command sent to server */
1847   size_t commandLength;
1848   size_t testSize;
1849
1850   commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
1851
1852   overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
1853
1854   for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
1855   {
1856     overflow= malloc(testSize);
1857     assert(overflow != NULL);
1858
1859     memset(overflow, 'x', testSize);
1860     rc= memcached_set(memc, key, strlen(key),
1861                       overflow, testSize, 0, 0);
1862     assert(rc == MEMCACHED_SUCCESS);
1863     free(overflow);
1864   }
1865
1866   return 0;
1867 }
1868
1869
1870 /*
1871   Test values of many different sizes
1872   Bug found where command total one more than MEMCACHED_MAX_BUFFER
1873   set key34567890 0 0 8169 \r\n
1874   is sent followed by buffer of size 8169, followed by 8169
1875  */
1876 uint8_t user_supplied_bug14(memcached_st *memc)
1877 {
1878   int setter= 1;
1879   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1880   memcached_return rc;
1881   char *key= "foo";
1882   char *value;
1883   size_t value_length= 18000;
1884   char *string;
1885   size_t string_length;
1886   uint32_t flags;
1887   unsigned int x;
1888   size_t current_length;
1889
1890   value = (char*)malloc(value_length);
1891   assert(value);
1892
1893   for (x= 0; x < value_length; x++)
1894     value[x] = (char) (x % 127);
1895
1896   for (current_length= 0; current_length < value_length; current_length++)
1897   {
1898     rc= memcached_set(memc, key, strlen(key),
1899                       value, current_length,
1900                       (time_t)0, (uint32_t)0);
1901     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1902
1903     string= memcached_get(memc, key, strlen(key),
1904                           &string_length, &flags, &rc);
1905
1906     assert(rc == MEMCACHED_SUCCESS);
1907     if (current_length > 0)
1908       assert(string);
1909     assert(string_length == current_length);
1910     assert(!memcmp(string, value, string_length));
1911
1912     free(string);
1913   }
1914
1915   free(value);
1916
1917   return 0;
1918 }
1919
1920 /*
1921   Look for zero length value problems
1922   */
1923 uint8_t user_supplied_bug15(memcached_st *memc)
1924 {
1925   uint32_t x;
1926   memcached_return rc;
1927   char *key= "mykey";
1928   char *value;
1929   size_t length;
1930   uint32_t flags;
1931
1932   for (x= 0; x < 2; x++)
1933   {
1934     rc= memcached_set(memc, key, strlen(key),
1935                       NULL, 0,
1936                       (time_t)0, (uint32_t)0);
1937
1938     assert(rc == MEMCACHED_SUCCESS);
1939
1940     value= memcached_get(memc, key, strlen(key),
1941                          &length, &flags, &rc);
1942
1943     assert(rc == MEMCACHED_SUCCESS);
1944     assert(value == NULL);
1945     assert(length == 0);
1946     assert(flags == 0);
1947
1948     value= memcached_get(memc, key, strlen(key),
1949                          &length, &flags, &rc);
1950
1951     assert(rc == MEMCACHED_SUCCESS);
1952     assert(value == NULL);
1953     assert(length == 0);
1954     assert(flags == 0);
1955   }
1956
1957   return 0;
1958 }
1959
1960 uint8_t result_static(memcached_st *memc)
1961 {
1962   memcached_result_st result;
1963   memcached_result_st *result_ptr;
1964
1965   result_ptr= memcached_result_create(memc, &result);
1966   assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
1967   assert(result_ptr);
1968   memcached_result_free(&result);
1969
1970   return 0;
1971 }
1972
1973 uint8_t result_alloc(memcached_st *memc)
1974 {
1975   memcached_result_st *result;
1976
1977   result= memcached_result_create(memc, NULL);
1978   assert(result);
1979   memcached_result_free(result);
1980
1981   return 0;
1982 }
1983
1984 uint8_t string_static_null(memcached_st *memc)
1985 {
1986   memcached_string_st string;
1987   memcached_string_st *string_ptr;
1988
1989   string_ptr= memcached_string_create(memc, &string, 0);
1990   assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
1991   assert(string_ptr);
1992   memcached_string_free(&string);
1993
1994   return 0;
1995 }
1996
1997 uint8_t string_alloc_null(memcached_st *memc)
1998 {
1999   memcached_string_st *string;
2000
2001   string= memcached_string_create(memc, NULL, 0);
2002   assert(string);
2003   memcached_string_free(string);
2004
2005   return 0;
2006 }
2007
2008 uint8_t string_alloc_with_size(memcached_st *memc)
2009 {
2010   memcached_string_st *string;
2011
2012   string= memcached_string_create(memc, NULL, 1024);
2013   assert(string);
2014   memcached_string_free(string);
2015
2016   return 0;
2017 }
2018
2019 uint8_t string_alloc_with_size_toobig(memcached_st *memc)
2020 {
2021   memcached_string_st *string;
2022
2023   string= memcached_string_create(memc, NULL, INT64_MAX);
2024   assert(string == NULL);
2025
2026   return 0;
2027 }
2028
2029 uint8_t string_alloc_append(memcached_st *memc)
2030 {
2031   unsigned int x;
2032   char buffer[SMALL_STRING_LEN];
2033   memcached_string_st *string;
2034
2035   /* Ring the bell! */
2036   memset(buffer, 6, SMALL_STRING_LEN);
2037
2038   string= memcached_string_create(memc, NULL, 100);
2039   assert(string);
2040
2041   for (x= 0; x < 1024; x++)
2042   {
2043     memcached_return rc;
2044     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
2045     assert(rc == MEMCACHED_SUCCESS);
2046   }
2047   memcached_string_free(string);
2048
2049   return 0;
2050 }
2051
2052 uint8_t string_alloc_append_toobig(memcached_st *memc)
2053 {
2054   memcached_return rc;
2055   unsigned int x;
2056   char buffer[SMALL_STRING_LEN];
2057   memcached_string_st *string;
2058
2059   /* Ring the bell! */
2060   memset(buffer, 6, SMALL_STRING_LEN);
2061
2062   string= memcached_string_create(memc, NULL, 100);
2063   assert(string);
2064
2065   for (x= 0; x < 1024; x++)
2066   {
2067     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
2068     assert(rc == MEMCACHED_SUCCESS);
2069   }
2070   rc= memcached_string_append(string, buffer, INT64_MAX);
2071   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
2072   memcached_string_free(string);
2073
2074   return 0;
2075 }
2076
2077 uint8_t cleanup_pairs(memcached_st *memc)
2078 {
2079   pairs_free(global_pairs);
2080
2081   return 0;
2082 }
2083
2084 uint8_t generate_pairs(memcached_st *memc)
2085 {
2086   unsigned long long x;
2087   global_pairs= pairs_generate(GLOBAL_COUNT, 400);
2088   global_count= GLOBAL_COUNT;
2089
2090   for (x= 0; x < global_count; x++)
2091   {
2092     global_keys[x]= global_pairs[x].key;
2093     global_keys_length[x]=  global_pairs[x].key_length;
2094   }
2095
2096   return 0;
2097 }
2098
2099 uint8_t generate_large_pairs(memcached_st *memc)
2100 {
2101   unsigned long long x;
2102   global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
2103   global_count= GLOBAL2_COUNT;
2104
2105   for (x= 0; x < global_count; x++)
2106   {
2107     global_keys[x]= global_pairs[x].key;
2108     global_keys_length[x]=  global_pairs[x].key_length;
2109   }
2110
2111   return 0;
2112 }
2113
2114 uint8_t generate_data(memcached_st *memc)
2115 {
2116   execute_set(memc, global_pairs, global_count);
2117
2118   return 0;
2119 }
2120
2121 uint8_t generate_buffer_data(memcached_st *memc)
2122 {
2123   int latch= 0;
2124
2125   latch= 1;
2126   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
2127   generate_data(memc);
2128
2129   return 0;
2130 }
2131
2132 uint8_t get_read(memcached_st *memc)
2133 {
2134   unsigned int x;
2135   memcached_return rc;
2136
2137   {
2138     char *return_value;
2139     size_t return_value_length;
2140     uint32_t flags;
2141
2142     for (x= 0; x < global_count; x++)
2143     {
2144       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
2145                                   &return_value_length, &flags, &rc);
2146       /*
2147       assert(return_value);
2148       assert(rc == MEMCACHED_SUCCESS);
2149     */
2150       if (rc == MEMCACHED_SUCCESS && return_value)
2151         free(return_value);
2152     }
2153   }
2154
2155   return 0;
2156 }
2157
2158 uint8_t mget_read(memcached_st *memc)
2159 {
2160   memcached_return rc;
2161
2162   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2163   assert(rc == MEMCACHED_SUCCESS);
2164   /* Turn this into a help function */
2165   {
2166     char return_key[MEMCACHED_MAX_KEY];
2167     size_t return_key_length;
2168     char *return_value;
2169     size_t return_value_length;
2170     uint32_t flags;
2171
2172     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2173                                           &return_value_length, &flags, &rc)))
2174     {
2175       assert(return_value);
2176       assert(rc == MEMCACHED_SUCCESS);
2177       free(return_value);
2178     }
2179   }
2180
2181   return 0;
2182 }
2183
2184 uint8_t mget_read_result(memcached_st *memc)
2185 {
2186   memcached_return rc;
2187
2188   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2189   assert(rc == MEMCACHED_SUCCESS);
2190   /* Turn this into a help function */
2191   {
2192     memcached_result_st results_obj;
2193     memcached_result_st *results;
2194
2195     results= memcached_result_create(memc, &results_obj);
2196
2197     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
2198     {
2199       assert(results);
2200       assert(rc == MEMCACHED_SUCCESS);
2201     }
2202
2203     memcached_result_free(&results_obj);
2204   }
2205
2206   return 0;
2207 }
2208
2209 uint8_t mget_read_function(memcached_st *memc)
2210 {
2211   memcached_return rc;
2212   unsigned int counter;
2213   unsigned int (*callbacks[1])(memcached_st *, memcached_result_st *, void *);
2214
2215   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2216   assert(rc == MEMCACHED_SUCCESS);
2217
2218   callbacks[0]= &callback_counter;
2219   counter= 0;
2220   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
2221
2222   return 0;
2223 }
2224
2225 uint8_t delete_generate(memcached_st *memc)
2226 {
2227   unsigned int x;
2228
2229   for (x= 0; x < global_count; x++)
2230   {
2231     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2232   }
2233
2234   return 0;
2235 }
2236
2237 uint8_t delete_buffer_generate(memcached_st *memc)
2238 {
2239   int latch= 0;
2240   unsigned int x;
2241
2242   latch= 1;
2243   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
2244
2245   for (x= 0; x < global_count; x++)
2246   {
2247     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2248   }
2249
2250   return 0;
2251 }
2252
2253 uint8_t free_data(memcached_st *memc)
2254 {
2255   pairs_free(global_pairs);
2256
2257   return 0;
2258 }
2259
2260 uint8_t add_host_test1(memcached_st *memc)
2261 {
2262   unsigned int x;
2263   memcached_return rc;
2264   char servername[]= "0.example.com";
2265   memcached_server_st *servers;
2266
2267   servers= memcached_server_list_append(NULL, servername, 400, &rc);
2268   assert(servers);
2269   assert(1 == memcached_server_list_count(servers));
2270
2271   for (x= 2; x < 20; x++)
2272   {
2273     char buffer[SMALL_STRING_LEN];
2274
2275     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
2276     servers= memcached_server_list_append(servers, buffer, 401,
2277                                      &rc);
2278     assert(rc == MEMCACHED_SUCCESS);
2279     assert(x == memcached_server_list_count(servers));
2280   }
2281
2282   rc= memcached_server_push(memc, servers);
2283   assert(rc == MEMCACHED_SUCCESS);
2284   rc= memcached_server_push(memc, servers);
2285   assert(rc == MEMCACHED_SUCCESS);
2286
2287   memcached_server_list_free(servers);
2288
2289   return 0;
2290 }
2291
2292 memcached_return pre_nonblock(memcached_st *memc)
2293 {
2294   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
2295
2296   return MEMCACHED_SUCCESS;
2297 }
2298
2299 memcached_return pre_murmur(memcached_st *memc)
2300 {
2301   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
2302
2303   return MEMCACHED_SUCCESS;
2304 }
2305
2306 memcached_return pre_md5(memcached_st *memc)
2307 {
2308   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5);
2309
2310   return MEMCACHED_SUCCESS;
2311 }
2312
2313 memcached_return pre_crc(memcached_st *memc)
2314 {
2315   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_CRC);
2316
2317   return MEMCACHED_SUCCESS;
2318 }
2319
2320 memcached_return pre_hsieh(memcached_st *memc)
2321 {
2322   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH);
2323
2324   return MEMCACHED_SUCCESS;
2325 }
2326
2327 memcached_return pre_hash_fnv1_64(memcached_st *memc)
2328 {
2329   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_64);
2330
2331   return MEMCACHED_SUCCESS;
2332 }
2333
2334 memcached_return pre_hash_fnv1a_64(memcached_st *memc)
2335 {
2336   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64);
2337
2338   return MEMCACHED_SUCCESS;
2339 }
2340
2341 memcached_return pre_hash_fnv1_32(memcached_st *memc)
2342 {
2343   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_32);
2344
2345   return MEMCACHED_SUCCESS;
2346 }
2347
2348 memcached_return pre_hash_fnv1a_32(memcached_st *memc)
2349 {
2350   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_32);
2351
2352   return MEMCACHED_SUCCESS;
2353 }
2354
2355 memcached_return pre_hash_ketama(memcached_st *memc)
2356 {
2357   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_KETAMA);
2358
2359   return MEMCACHED_SUCCESS;
2360 }
2361
2362 void my_free(memcached_st *ptr, void *mem)
2363 {
2364   free(mem);
2365 }
2366
2367 void *my_malloc(memcached_st *ptr, const size_t size)
2368 {
2369   return malloc(size);
2370 }
2371
2372 void *my_realloc(memcached_st *ptr, void *mem, const size_t size)
2373 {
2374   return realloc(mem, size);
2375 }
2376
2377 memcached_return set_memory_alloc(memcached_st *memc)
2378 {
2379   {
2380     memcached_malloc_function test_ptr;
2381     memcached_return rc;
2382
2383     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &my_malloc);
2384     assert(rc == MEMCACHED_SUCCESS);
2385     test_ptr= (memcached_malloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
2386     assert(rc == MEMCACHED_SUCCESS);
2387     assert(test_ptr == my_malloc);
2388   }
2389
2390   {
2391     memcached_realloc_function test_ptr;
2392     memcached_return rc;
2393
2394     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &my_realloc);
2395     assert(rc == MEMCACHED_SUCCESS);
2396     test_ptr= (memcached_realloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
2397     assert(rc == MEMCACHED_SUCCESS);
2398     assert(test_ptr == my_realloc);
2399   }
2400
2401   {
2402     memcached_free_function test_ptr;
2403     memcached_return rc;
2404
2405     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, my_free);
2406     assert(rc == MEMCACHED_SUCCESS);
2407     test_ptr= (memcached_free_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
2408     assert(rc == MEMCACHED_SUCCESS);
2409     assert(test_ptr == my_free);
2410   }
2411
2412   return MEMCACHED_SUCCESS;
2413 }
2414
2415 memcached_return enable_consistent(memcached_st *memc)
2416 {
2417   memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;
2418   memcached_hash hash;
2419   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
2420   pre_hsieh(memc);
2421
2422   value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
2423   assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
2424
2425   hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
2426   assert(hash == MEMCACHED_HASH_HSIEH);
2427
2428
2429   return MEMCACHED_SUCCESS;
2430 }
2431
2432 memcached_return enable_cas(memcached_st *memc)
2433 {
2434   unsigned int set= 1;
2435
2436   memcached_version(memc);
2437
2438   if (memc->hosts[0].major_version >= 1 &&
2439       memc->hosts[0].minor_version >= 2 &&
2440       memc->hosts[0].micro_version >= 4)
2441   {
2442     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
2443
2444     return MEMCACHED_SUCCESS;
2445   }
2446
2447   return MEMCACHED_FAILURE;
2448 }
2449
2450 memcached_return check_for_1_2_3(memcached_st *memc)
2451 {
2452   memcached_version(memc);
2453
2454   if (memc->hosts[0].major_version >= 1 &&
2455       memc->hosts[0].minor_version >= 2 &&
2456       memc->hosts[0].micro_version >= 4)
2457     return MEMCACHED_SUCCESS;
2458
2459   return MEMCACHED_FAILURE;
2460 }
2461
2462 memcached_return pre_unix_socket(memcached_st *memc)
2463 {
2464   memcached_return rc;
2465   struct stat buf;
2466
2467   memcached_server_list_free(memc->hosts);
2468   memc->hosts= NULL;
2469   memc->number_of_hosts= 0;
2470
2471   if (stat("/tmp/memcached.socket", &buf))
2472     return MEMCACHED_FAILURE;
2473
2474   rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");
2475
2476   return rc;
2477 }
2478
2479 memcached_return pre_udp(memcached_st *memc)
2480 {
2481   memcached_return rc;
2482
2483   memcached_server_list_free(memc->hosts);
2484   memc->hosts= NULL;
2485   memc->number_of_hosts= 0;
2486
2487   if (0)
2488     return MEMCACHED_FAILURE;
2489
2490   rc= memcached_server_add_udp(memc, "localhost", MEMCACHED_DEFAULT_PORT);
2491
2492   return rc;
2493 }
2494
2495 memcached_return pre_nodelay(memcached_st *memc)
2496 {
2497   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
2498   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
2499
2500   return MEMCACHED_SUCCESS;
2501 }
2502
2503 memcached_return poll_timeout(memcached_st *memc)
2504 {
2505   int32_t timeout;
2506
2507   timeout= 100;
2508
2509   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
2510
2511   timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
2512
2513   assert(timeout == 100);
2514
2515   return MEMCACHED_SUCCESS;
2516 }
2517
2518
2519 /* Clean the server before beginning testing */
2520 test_st tests[] ={
2521   {"flush", 0, flush_test },
2522   {"init", 0, init_test },
2523   {"allocation", 0, allocation_test },
2524   {"server_list_null_test", 0, server_list_null_test},
2525   {"server_sort", 0, server_sort_test},
2526   {"clone_test", 0, clone_test },
2527   {"error", 0, error_test },
2528   {"set", 0, set_test },
2529   {"set2", 0, set_test2 },
2530   {"set3", 0, set_test3 },
2531   {"add", 1, add_test },
2532   {"replace", 1, replace_test },
2533   {"delete", 1, delete_test },
2534   {"get", 1, get_test },
2535   {"get2", 0, get_test2 },
2536   {"get3", 0, get_test3 },
2537   {"get4", 0, get_test4 },
2538   {"stats_servername", 0, stats_servername_test },
2539   {"increment", 0, increment_test },
2540   {"decrement", 0, decrement_test },
2541   {"quit", 0, quit_test },
2542   {"mget", 1, mget_test },
2543   {"mget_result", 1, mget_result_test },
2544   {"mget_result_alloc", 1, mget_result_alloc_test },
2545   {"mget_result_function", 1, mget_result_function },
2546   {"get_stats", 0, get_stats },
2547   {"add_host_test", 0, add_host_test },
2548   {"get_stats_keys", 0, get_stats_keys },
2549   {"behavior_test", 0, get_stats_keys },
2550   {"callback_test", 0, get_stats_keys },
2551   {"version_string_test", 0, version_string_test},
2552   {"bad_key", 1, bad_key_test },
2553   {"memcached_server_cursor", 1, memcached_server_cursor_test },
2554   {"read_through", 1, read_through },
2555   {"delete_through", 1, delete_through },
2556   {0, 0, 0}
2557 };
2558
2559 test_st async_tests[] ={
2560   {"add", 1, add_wrapper },
2561   {0, 0, 0}
2562 };
2563
2564 test_st string_tests[] ={
2565   {"string static with null", 0, string_static_null },
2566   {"string alloc with null", 0, string_alloc_null },
2567   {"string alloc with 1K", 0, string_alloc_with_size },
2568   {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
2569   {"string append", 0, string_alloc_append },
2570   {"string append failure (too big)", 0, string_alloc_append_toobig },
2571   {0, 0, 0}
2572 };
2573
2574 test_st result_tests[] ={
2575   {"result static", 0, result_static},
2576   {"result alloc", 0, result_alloc},
2577   {0, 0, 0}
2578 };
2579
2580 test_st version_1_2_3[] ={
2581   {"append", 0, append_test },
2582   {"prepend", 0, prepend_test },
2583   {"cas", 0, cas_test },
2584   {"cas2", 0, cas2_test },
2585   {"append_binary", 0, append_binary_test },
2586   {0, 0, 0}
2587 };
2588
2589 test_st user_tests[] ={
2590   {"user_supplied_bug1", 0, user_supplied_bug1 },
2591   {"user_supplied_bug2", 0, user_supplied_bug2 },
2592   {"user_supplied_bug3", 0, user_supplied_bug3 },
2593   {"user_supplied_bug4", 0, user_supplied_bug4 },
2594   {"user_supplied_bug5", 1, user_supplied_bug5 },
2595   {"user_supplied_bug6", 1, user_supplied_bug6 },
2596   {"user_supplied_bug7", 1, user_supplied_bug7 },
2597   {"user_supplied_bug8", 1, user_supplied_bug8 },
2598   {"user_supplied_bug9", 1, user_supplied_bug9 },
2599   {"user_supplied_bug10", 1, user_supplied_bug10 },
2600   {"user_supplied_bug11", 1, user_supplied_bug11 },
2601   {"user_supplied_bug12", 1, user_supplied_bug12 },
2602   {"user_supplied_bug13", 1, user_supplied_bug13 },
2603   {"user_supplied_bug14", 1, user_supplied_bug14 },
2604   {"user_supplied_bug15", 1, user_supplied_bug15 },
2605   {0, 0, 0}
2606 };
2607
2608 test_st generate_tests[] ={
2609   {"generate_pairs", 1, generate_pairs },
2610   {"generate_data", 1, generate_data },
2611   {"get_read", 0, get_read },
2612   {"delete_generate", 0, delete_generate },
2613   {"generate_buffer_data", 1, generate_buffer_data },
2614   {"delete_buffer", 0, delete_buffer_generate},
2615   {"generate_data", 1, generate_data },
2616   {"mget_read", 0, mget_read },
2617   {"mget_read_result", 0, mget_read_result },
2618   {"mget_read_function", 0, mget_read_function },
2619   {"cleanup", 1, cleanup_pairs },
2620   {"generate_large_pairs", 1, generate_large_pairs },
2621   {"generate_data", 1, generate_data },
2622   {"generate_buffer_data", 1, generate_buffer_data },
2623   {"cleanup", 1, cleanup_pairs },
2624   {0, 0, 0}
2625 };
2626
2627
2628 collection_st collection[] ={
2629   {"block", 0, 0, tests},
2630   {"nonblock", pre_nonblock, 0, tests},
2631   {"nodelay", pre_nodelay, 0, tests},
2632   {"md5", pre_md5, 0, tests},
2633   {"crc", pre_crc, 0, tests},
2634   {"hsieh", pre_hsieh, 0, tests},
2635   {"fnv1_64", pre_hash_fnv1_64, 0, tests},
2636   {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
2637   {"fnv1_32", pre_hash_fnv1_32, 0, tests},
2638   {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
2639   {"ketama", pre_hash_ketama, 0, tests},
2640   {"unix_socket", pre_unix_socket, 0, tests},
2641   {"unix_socket_nodelay", pre_nodelay, 0, tests},
2642   {"poll_timeout", poll_timeout, 0, tests},
2643   {"gets", enable_cas, 0, tests},
2644   {"consistent", enable_consistent, 0, tests},
2645   {"memory_allocators", set_memory_alloc, 0, tests},
2646 //  {"udp", pre_udp, 0, tests},
2647   {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
2648   {"string", 0, 0, string_tests},
2649   {"result", 0, 0, result_tests},
2650   {"async", pre_nonblock, 0, async_tests},
2651   {"user", 0, 0, user_tests},
2652   {"generate", 0, 0, generate_tests},
2653   {"generate_hsieh", pre_hsieh, 0, generate_tests},
2654   {"generate_hsieh_consistent", enable_consistent, 0, generate_tests},
2655   {"generate_md5", pre_md5, 0, generate_tests},
2656   {"generate_murmur", pre_murmur, 0, generate_tests},
2657   {"generate_nonblock", pre_nonblock, 0, generate_tests},
2658   {0, 0, 0, 0}
2659 };
2660
2661 #define SERVERS_TO_CREATE 5
2662
2663 void *world_create(void)
2664 {
2665   server_startup_st *construct;
2666
2667   construct= (server_startup_st *)malloc(sizeof(server_startup_st));
2668   memset(construct, 0, sizeof(server_startup_st));
2669   construct->count= SERVERS_TO_CREATE;
2670   construct->udp= 0;
2671   server_startup(construct);
2672
2673   return construct;
2674 }
2675
2676 void world_destroy(void *p)
2677 {
2678   server_startup_st *construct= (server_startup_st *)p;
2679   memcached_server_st *servers= (memcached_server_st *)construct->servers;
2680   memcached_server_list_free(servers);
2681
2682   server_shutdown(construct);
2683   free(construct);
2684 }
2685
2686 void get_world(world_st *world)
2687 {
2688   world->collections= collection;
2689   world->create= world_create;
2690   world->destroy= world_destroy;
2691 }