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

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