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