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