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 "../lib/common.h"
  15 #include "../src/generator.h"
  16 #include "../src/execute.h"
  17
  18 #ifndef INT64_MAX
  19 #define INT64_MAX LONG_MAX
  20 #endif
  21 #ifndef INT32_MAX
  22 #define INT32_MAX INT_MAX
  23 #endif
  24
  25
  26 #include "test.h"
  27
  28 #define GLOBAL_COUNT 100000
  29 static pairs_st *global_pairs;
  30 static char *global_keys[GLOBAL_COUNT];
  31 static size_t global_keys_length[GLOBAL_COUNT];
  32
  33 uint8_t init_test(memcached_st *not_used)
  34 {
  35   memcached_st memc;
  36
  37   (void)memcached_create(&memc);
  38   memcached_free(&memc);
  39
  40   return 0;
  41 }
  42
  43 uint8_t allocation_test(memcached_st *not_used)
  44 {
  45   memcached_st *memc;
  46   memc= memcached_create(NULL);
  47   assert(memc);
  48   memcached_free(memc);
  49
  50   return 0;
  51 }
  52
  53 uint8_t clone_test(memcached_st *memc)
  54 {
  55   /* All null? */
  56   {
  57     memcached_st *clone;
  58     clone= memcached_clone(NULL, NULL);
  59     assert(clone);
  60     memcached_free(clone);
  61   }
  62
  63   /* Can we init from null? */
  64   {
  65     memcached_st *clone;
  66     clone= memcached_clone(NULL, memc);
  67     assert(clone);
  68     memcached_free(clone);
  69   }
  70
  71   /* Can we init from struct? */
  72   {
  73     memcached_st declared_clone;
  74     memcached_st *clone;
  75     clone= memcached_clone(&declared_clone, NULL);
  76     assert(clone);
  77     memcached_free(clone);
  78   }
  79
  80   /* Can we init from struct? */
  81   {
  82     memcached_st declared_clone;
  83     memcached_st *clone;
  84     clone= memcached_clone(&declared_clone, memc);
  85     assert(clone);
  86     memcached_free(clone);
  87   }
  88
  89   return 0;
  90 }
  91
  92 uint8_t connection_test(memcached_st *memc)
  93 {
  94   memcached_return rc;
  95
  96   rc= memcached_server_add(memc, "localhost", 0);
  97   assert(rc == MEMCACHED_SUCCESS);
  98
  99   return 0;
 100 }
 101
 102 uint8_t error_test(memcached_st *memc)
 103 {
 104   memcached_return rc;
 105
 106   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
 107   {
 108     printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
 109   }
 110
 111   return 0;
 112 }
 113
 114 uint8_t set_test(memcached_st *memc)
 115 {
 116   memcached_return rc;
 117   char *key= "foo";
 118   char *value= "when we sanitize";
 119
 120   rc= memcached_set(memc, key, strlen(key),
 121                     value, strlen(value),
 122                     (time_t)0, (uint32_t)0);
 123   assert(rc == MEMCACHED_SUCCESS);
 124
 125   return 0;
 126 }
 127
 128 uint8_t append_test(memcached_st *memc)
 129 {
 130   memcached_return rc;
 131   char *key= "fig";
 132   char *value= "we";
 133   size_t value_length;
 134   uint32_t flags;
 135
 136   rc= memcached_flush(memc, 0);
 137   assert(rc == MEMCACHED_SUCCESS);
 138
 139   rc= memcached_set(memc, key, strlen(key),
 140                     value, strlen(value),
 141                     (time_t)0, (uint32_t)0);
 142   assert(rc == MEMCACHED_SUCCESS);
 143
 144   rc= memcached_append(memc, key, strlen(key),
 145                        " the", strlen(" the"),
 146                        (time_t)0, (uint32_t)0);
 147   assert(rc == MEMCACHED_SUCCESS);
 148
 149   rc= memcached_append(memc, key, strlen(key),
 150                        " people", strlen(" people"),
 151                        (time_t)0, (uint32_t)0);
 152   assert(rc == MEMCACHED_SUCCESS);
 153
 154   value= memcached_get(memc, key, strlen(key),
 155                        &value_length, &flags, &rc);
 156   assert(!memcmp(value, "we the people", strlen("we the people")));
 157   assert(strlen("we the people") == value_length);
 158   assert(rc == MEMCACHED_SUCCESS);
 159   free(value);
 160
 161   return 0;
 162 }
 163
 164 uint8_t append_binary_test(memcached_st *memc)
 165 {
 166   memcached_return rc;
 167   char *key= "numbers";
 168   unsigned int *store_ptr;
 169   unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
 170   char *value;
 171   size_t value_length;
 172   uint32_t flags;
 173   unsigned int x;
 174
 175   rc= memcached_flush(memc, 0);
 176   assert(rc == MEMCACHED_SUCCESS);
 177
 178   rc= memcached_set(memc,
 179                     key, strlen(key),
 180                     NULL, 0,
 181                     (time_t)0, (uint32_t)0);
 182   assert(rc == MEMCACHED_SUCCESS);
 183
 184   for (x= 0; store_list[x] ; x++)
 185   {
 186     rc= memcached_append(memc,
 187                          key, strlen(key),
 188                          (char *)&store_list[x], sizeof(unsigned int),
 189                          (time_t)0, (uint32_t)0);
 190     assert(rc == MEMCACHED_SUCCESS);
 191   }
 192
 193   value= memcached_get(memc, key, strlen(key),
 194                        &value_length, &flags, &rc);
 195   assert((value_length == (sizeof(unsigned int) * x)));
 196   assert(rc == MEMCACHED_SUCCESS);
 197
 198   store_ptr= (unsigned int *)value;
 199   x= 0;
 200   while ((size_t)store_ptr < (size_t)(value + value_length))
 201   {
 202     assert(*store_ptr == store_list[x++]);
 203     store_ptr++;
 204   }
 205   free(value);
 206
 207   return 0;
 208 }
 209
 210 uint8_t cas2_test(memcached_st *memc)
 211 {
 212   memcached_return rc;
 213   char *keys[]= {"fudge", "son", "food"};
 214   size_t key_length[]= {5, 3, 4};
 215   char *value= "we the people";
 216   size_t value_length= strlen("we the people");
 217   unsigned int x;
 218   memcached_result_st results_obj;
 219   memcached_result_st *results;
 220   unsigned int set= 1;
 221
 222   rc= memcached_flush(memc, 0);
 223   assert(rc == MEMCACHED_SUCCESS);
 224
 225   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
 226
 227   for (x= 0; x < 3; x++)
 228   {
 229     rc= memcached_set(memc, keys[x], key_length[x],
 230                       keys[x], key_length[x],
 231                       (time_t)50, (uint32_t)9);
 232     assert(rc == MEMCACHED_SUCCESS);
 233   }
 234
 235   rc= memcached_mget(memc, keys, key_length, 3);
 236
 237   results= memcached_result_create(memc, &results_obj);
 238
 239   results= memcached_fetch_result(memc, &results_obj, &rc);
 240   assert(results);
 241   assert(results->cas);
 242   assert(rc == MEMCACHED_SUCCESS);
 243   WATCHPOINT_ASSERT(memcached_result_cas(results));
 244
 245   assert(!memcmp(value, "we the people", strlen("we the people")));
 246   assert(strlen("we the people") == value_length);
 247   assert(rc == MEMCACHED_SUCCESS);
 248
 249   memcached_result_free(&results_obj);
 250
 251   return 0;
 252 }
 253
 254 uint8_t cas_test(memcached_st *memc)
 255 {
 256   memcached_return rc;
 257   char *key= "fun";
 258   size_t key_length= strlen("fun");
 259   char *value= "we the people";
 260   size_t value_length= strlen("we the people");
 261   memcached_result_st results_obj;
 262   memcached_result_st *results;
 263   unsigned int set= 1;
 264
 265   rc= memcached_flush(memc, 0);
 266   assert(rc == MEMCACHED_SUCCESS);
 267
 268   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
 269
 270   rc= memcached_set(memc, key, strlen(key),
 271                     value, strlen(value),
 272                     (time_t)0, (uint32_t)0);
 273   assert(rc == MEMCACHED_SUCCESS);
 274
 275   rc= memcached_mget(memc, &key, &key_length, 1);
 276
 277   results= memcached_result_create(memc, &results_obj);
 278
 279   results= memcached_fetch_result(memc, &results_obj, &rc);
 280   assert(results);
 281   assert(rc == MEMCACHED_SUCCESS);
 282   WATCHPOINT_ASSERT(memcached_result_cas(results));
 283
 284   assert(!memcmp(value, "we the people", strlen("we the people")));
 285   assert(strlen("we the people") == value_length);
 286   assert(rc == MEMCACHED_SUCCESS);
 287
 288   memcached_result_free(&results_obj);
 289
 290   return 0;
 291 }
 292
 293 uint8_t prepend_test(memcached_st *memc)
 294 {
 295   memcached_return rc;
 296   char *key= "fig";
 297   char *value= "people";
 298   size_t value_length;
 299   uint32_t flags;
 300
 301   rc= memcached_flush(memc, 0);
 302   assert(rc == MEMCACHED_SUCCESS);
 303
 304   rc= memcached_set(memc, key, strlen(key),
 305                     value, strlen(value),
 306                     (time_t)0, (uint32_t)0);
 307   assert(rc == MEMCACHED_SUCCESS);
 308
 309   rc= memcached_prepend(memc, key, strlen(key),
 310                        "the ", strlen("the "),
 311                        (time_t)0, (uint32_t)0);
 312   assert(rc == MEMCACHED_SUCCESS);
 313
 314   rc= memcached_prepend(memc, key, strlen(key),
 315                        "we ", strlen("we "),
 316                        (time_t)0, (uint32_t)0);
 317   assert(rc == MEMCACHED_SUCCESS);
 318
 319   value= memcached_get(memc, key, strlen(key),
 320                        &value_length, &flags, &rc);
 321   assert(!memcmp(value, "we the people", strlen("we the people")));
 322   assert(strlen("we the people") == value_length);
 323   assert(rc == MEMCACHED_SUCCESS);
 324   free(value);
 325
 326   return 0;
 327 }
 328
 329 /*
 330   Set the value, then quit to make sure it is flushed.
 331   Come back in and test that add fails.
 332 */
 333 uint8_t add_test(memcached_st *memc)
 334 {
 335   memcached_return rc;
 336   char *key= "foo";
 337   char *value= "when we sanitize";
 338
 339   rc= memcached_set(memc, key, strlen(key),
 340                     value, strlen(value),
 341                     (time_t)0, (uint32_t)0);
 342   assert(rc == MEMCACHED_SUCCESS);
 343   memcached_quit(memc);
 344   rc= memcached_add(memc, key, strlen(key),
 345                     value, strlen(value),
 346                     (time_t)0, (uint32_t)0);
 347   assert(rc == MEMCACHED_NOTSTORED);
 348
 349   return 0;
 350 }
 351
 352 uint8_t add_wrapper(memcached_st *memc)
 353 {
 354   unsigned int x;
 355
 356   for (x= 0; x < 10000; x++)
 357     add_test(memc);
 358
 359   return 0;
 360 }
 361
 362 uint8_t replace_test(memcached_st *memc)
 363 {
 364   memcached_return rc;
 365   char *key= "foo";
 366   char *value= "when we sanitize";
 367
 368   rc= memcached_replace(memc, key, strlen(key),
 369                     value, strlen(value),
 370                     (time_t)0, (uint32_t)0);
 371   assert(rc == MEMCACHED_SUCCESS);
 372
 373   return 0;
 374 }
 375
 376 uint8_t delete_test(memcached_st *memc)
 377 {
 378   memcached_return rc;
 379   char *key= "foo";
 380   char *value= "when we sanitize";
 381
 382   rc= memcached_set(memc, key, strlen(key),
 383                     value, strlen(value),
 384                     (time_t)0, (uint32_t)0);
 385   assert(rc == MEMCACHED_SUCCESS);
 386
 387   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 388   assert(rc == MEMCACHED_SUCCESS);
 389
 390   return 0;
 391 }
 392
 393 uint8_t flush_test(memcached_st *memc)
 394 {
 395   memcached_return rc;
 396
 397   rc= memcached_flush(memc, 0);
 398   assert(rc == MEMCACHED_SUCCESS);
 399
 400   return 0;
 401 }
 402
 403 uint8_t get_test(memcached_st *memc)
 404 {
 405   memcached_return rc;
 406   char *key= "foo";
 407   char *string;
 408   size_t string_length;
 409   uint32_t flags;
 410
 411   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 412   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND);
 413
 414   string= memcached_get(memc, key, strlen(key),
 415                         &string_length, &flags, &rc);
 416
 417   assert(rc == MEMCACHED_NOTFOUND);
 418   assert(string_length ==  0);
 419   assert(!string);
 420
 421   return 0;
 422 }
 423
 424 uint8_t get_test2(memcached_st *memc)
 425 {
 426   memcached_return rc;
 427   char *key= "foo";
 428   char *value= "when we sanitize";
 429   char *string;
 430   size_t string_length;
 431   uint32_t flags;
 432
 433   rc= memcached_set(memc, key, strlen(key),
 434                     value, strlen(value),
 435                     (time_t)0, (uint32_t)0);
 436   assert(rc == MEMCACHED_SUCCESS);
 437
 438   string= memcached_get(memc, key, strlen(key),
 439                         &string_length, &flags, &rc);
 440
 441   assert(string);
 442   assert(rc == MEMCACHED_SUCCESS);
 443   assert(string_length == strlen(value));
 444   assert(!memcmp(string, value, string_length));
 445
 446   free(string);
 447
 448   return 0;
 449 }
 450
 451 uint8_t set_test2(memcached_st *memc)
 452 {
 453   memcached_return rc;
 454   char *key= "foo";
 455   char *value= "train in the brain";
 456   size_t value_length= strlen(value);
 457   unsigned int x;
 458
 459   for (x= 0; x < 10; x++)
 460   {
 461     rc= memcached_set(memc, key, strlen(key),
 462                       value, value_length,
 463                       (time_t)0, (uint32_t)0);
 464     assert(rc == MEMCACHED_SUCCESS);
 465   }
 466
 467   return 0;
 468 }
 469
 470 uint8_t set_test3(memcached_st *memc)
 471 {
 472   memcached_return rc;
 473   char *key= "foo";
 474   char *value;
 475   size_t value_length= 8191;
 476   unsigned int x;
 477
 478   value = (char*)malloc(value_length);
 479   assert(value);
 480
 481   for (x= 0; x < value_length; x++)
 482     value[x] = (char) (x % 127);
 483
 484   for (x= 0; x < 1; x++)
 485   {
 486     rc= memcached_set(memc, key, strlen(key),
 487                       value, value_length,
 488                       (time_t)0, (uint32_t)0);
 489     assert(rc == MEMCACHED_SUCCESS);
 490   }
 491
 492   free(value);
 493
 494   return 0;
 495 }
 496
 497 uint8_t get_test3(memcached_st *memc)
 498 {
 499   memcached_return rc;
 500   char *key= "foo";
 501   char *value;
 502   size_t value_length= 8191;
 503   char *string;
 504   size_t string_length;
 505   uint32_t flags;
 506   int x;
 507
 508   value = (char*)malloc(value_length);
 509   assert(value);
 510
 511   for (x= 0; x < value_length; x++)
 512     value[x] = (char) (x % 127);
 513
 514   rc= memcached_set(memc, key, strlen(key),
 515                     value, value_length,
 516                     (time_t)0, (uint32_t)0);
 517   assert(rc == MEMCACHED_SUCCESS);
 518
 519   string= memcached_get(memc, key, strlen(key),
 520                         &string_length, &flags, &rc);
 521
 522   assert(rc == MEMCACHED_SUCCESS);
 523   assert(string);
 524   assert(string_length == value_length);
 525   assert(!memcmp(string, value, string_length));
 526
 527   free(string);
 528   free(value);
 529
 530   return 0;
 531 }
 532
 533 uint8_t get_test4(memcached_st *memc)
 534 {
 535   memcached_return rc;
 536   char *key= "foo";
 537   char *value;
 538   size_t value_length= 8191;
 539   char *string;
 540   size_t string_length;
 541   uint32_t flags;
 542   int x;
 543
 544   value = (char*)malloc(value_length);
 545   assert(value);
 546
 547   for (x= 0; x < value_length; x++)
 548     value[x] = (char) (x % 127);
 549
 550   rc= memcached_set(memc, key, strlen(key),
 551                     value, value_length,
 552                     (time_t)0, (uint32_t)0);
 553   assert(rc == MEMCACHED_SUCCESS);
 554
 555   for (x= 0; x < 10; x++)
 556   {
 557     string= memcached_get(memc, key, strlen(key),
 558                           &string_length, &flags, &rc);
 559
 560     assert(rc == MEMCACHED_SUCCESS);
 561     assert(string);
 562     assert(string_length == value_length);
 563     assert(!memcmp(string, value, string_length));
 564     free(string);
 565   }
 566
 567   free(value);
 568
 569   return 0;
 570 }
 571
 572 /* Do not copy the style of this code, I just access hosts to testthis function */
 573 uint8_t stats_servername_test(memcached_st *memc)
 574 {
 575   memcached_return rc;
 576   memcached_stat_st stat;
 577   rc= memcached_stat_servername(&stat, NULL,
 578                                  memc->hosts[0].hostname,
 579                                  memc->hosts[0].port);
 580
 581   return 0;
 582 }
 583
 584 uint8_t increment_test(memcached_st *memc)
 585 {
 586   uint64_t new_number;
 587   memcached_return rc;
 588   char *key= "number";
 589   char *value= "0";
 590
 591   rc= memcached_set(memc, key, strlen(key),
 592                     value, strlen(value),
 593                     (time_t)0, (uint32_t)0);
 594   assert(rc == MEMCACHED_SUCCESS);
 595
 596   rc= memcached_increment(memc, key, strlen(key),
 597                           1, &new_number);
 598   assert(rc == MEMCACHED_SUCCESS);
 599   assert(new_number == 1);
 600
 601   rc= memcached_increment(memc, key, strlen(key),
 602                           1, &new_number);
 603   assert(rc == MEMCACHED_SUCCESS);
 604   assert(new_number == 2);
 605
 606   return 0;
 607 }
 608
 609 uint8_t decrement_test(memcached_st *memc)
 610 {
 611   uint64_t new_number;
 612   memcached_return rc;
 613   char *key= "number";
 614   char *value= "3";
 615
 616   rc= memcached_set(memc, key, strlen(key),
 617                     value, strlen(value),
 618                     (time_t)0, (uint32_t)0);
 619   assert(rc == MEMCACHED_SUCCESS);
 620
 621   rc= memcached_decrement(memc, key, strlen(key),
 622                           1, &new_number);
 623   assert(rc == MEMCACHED_SUCCESS);
 624   assert(new_number == 2);
 625
 626   rc= memcached_decrement(memc, key, strlen(key),
 627                           1, &new_number);
 628   assert(rc == MEMCACHED_SUCCESS);
 629   assert(new_number == 1);
 630
 631   return 0;
 632 }
 633
 634 uint8_t quit_test(memcached_st *memc)
 635 {
 636   memcached_return rc;
 637   char *key= "fudge";
 638   char *value= "sanford and sun";
 639
 640   rc= memcached_set(memc, key, strlen(key),
 641                     value, strlen(value),
 642                     (time_t)10, (uint32_t)3);
 643   assert(rc == MEMCACHED_SUCCESS);
 644   memcached_quit(memc);
 645
 646   rc= memcached_set(memc, key, strlen(key),
 647                     value, strlen(value),
 648                     (time_t)50, (uint32_t)9);
 649   assert(rc == MEMCACHED_SUCCESS);
 650
 651   return 0;
 652 }
 653
 654 uint8_t mget_result_test(memcached_st *memc)
 655 {
 656   memcached_return rc;
 657   char *keys[]= {"fudge", "son", "food"};
 658   size_t key_length[]= {5, 3, 4};
 659   unsigned int x;
 660
 661   memcached_result_st results_obj;
 662   memcached_result_st *results;
 663
 664   results= memcached_result_create(memc, &results_obj);
 665   assert(results);
 666   assert(&results_obj == results);
 667
 668   /* We need to empty the server before continueing test */
 669   rc= memcached_flush(memc, 0);
 670   assert(rc == MEMCACHED_SUCCESS);
 671
 672   rc= memcached_mget(memc, keys, key_length, 3);
 673   assert(rc == MEMCACHED_SUCCESS);
 674
 675   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 676   {
 677     assert(results);
 678   }
 679
 680   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 681   assert(!results);
 682   assert(rc == MEMCACHED_END);
 683
 684   for (x= 0; x < 3; x++)
 685   {
 686     rc= memcached_set(memc, keys[x], key_length[x],
 687                       keys[x], key_length[x],
 688                       (time_t)50, (uint32_t)9);
 689     assert(rc == MEMCACHED_SUCCESS);
 690   }
 691
 692   rc= memcached_mget(memc, keys, key_length, 3);
 693   assert(rc == MEMCACHED_SUCCESS);
 694
 695   while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
 696   {
 697     assert(results);
 698     assert(&results_obj == results);
 699     assert(rc == MEMCACHED_SUCCESS);
 700     assert(memcached_result_key_length(results) == memcached_result_length(results));
 701     assert(!memcmp(memcached_result_key_value(results),
 702                    memcached_result_value(results),
 703                    memcached_result_length(results)));
 704   }
 705
 706   memcached_result_free(&results_obj);
 707
 708   return 0;
 709 }
 710
 711 uint8_t mget_result_alloc_test(memcached_st *memc)
 712 {
 713   memcached_return rc;
 714   char *keys[]= {"fudge", "son", "food"};
 715   size_t key_length[]= {5, 3, 4};
 716   unsigned int x;
 717
 718   memcached_result_st *results;
 719
 720   /* We need to empty the server before continueing test */
 721   rc= memcached_flush(memc, 0);
 722   assert(rc == MEMCACHED_SUCCESS);
 723
 724   rc= memcached_mget(memc, keys, key_length, 3);
 725   assert(rc == MEMCACHED_SUCCESS);
 726
 727   while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
 728   {
 729     assert(results);
 730   }
 731   assert(!results);
 732   assert(rc == MEMCACHED_END);
 733
 734   for (x= 0; x < 3; x++)
 735   {
 736     rc= memcached_set(memc, keys[x], key_length[x],
 737                       keys[x], key_length[x],
 738                       (time_t)50, (uint32_t)9);
 739     assert(rc == MEMCACHED_SUCCESS);
 740   }
 741
 742   rc= memcached_mget(memc, keys, key_length, 3);
 743   assert(rc == MEMCACHED_SUCCESS);
 744
 745   x= 0;
 746   while ((results= memcached_fetch_result(memc, NULL, &rc)))
 747   {
 748     assert(results);
 749     assert(rc == MEMCACHED_SUCCESS);
 750     assert(memcached_result_key_length(results) == memcached_result_length(results));
 751     assert(!memcmp(memcached_result_key_value(results),
 752                    memcached_result_value(results),
 753                    memcached_result_length(results)));
 754     memcached_result_free(results);
 755     x++;
 756   }
 757
 758   return 0;
 759 }
 760
 761 uint8_t mget_test(memcached_st *memc)
 762 {
 763   memcached_return rc;
 764   char *keys[]= {"fudge", "son", "food"};
 765   size_t key_length[]= {5, 3, 4};
 766   unsigned int x;
 767   uint32_t flags;
 768
 769   char return_key[MEMCACHED_MAX_KEY];
 770   size_t return_key_length;
 771   char *return_value;
 772   size_t return_value_length;
 773
 774   /* We need to empty the server before continueing test */
 775   rc= memcached_flush(memc, 0);
 776   assert(rc == MEMCACHED_SUCCESS);
 777
 778   rc= memcached_mget(memc, keys, key_length, 3);
 779   assert(rc == MEMCACHED_SUCCESS);
 780
 781   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 782                       &return_value_length, &flags, &rc)) != NULL)
 783   {
 784     assert(return_value);
 785   }
 786   assert(!return_value);
 787   assert(return_value_length == 0);
 788   assert(rc == MEMCACHED_END);
 789
 790   for (x= 0; x < 3; x++)
 791   {
 792     rc= memcached_set(memc, keys[x], key_length[x],
 793                       keys[x], key_length[x],
 794                       (time_t)50, (uint32_t)9);
 795     assert(rc == MEMCACHED_SUCCESS);
 796   }
 797
 798   rc= memcached_mget(memc, keys, key_length, 3);
 799   assert(rc == MEMCACHED_SUCCESS);
 800
 801   x= 0;
 802   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 803                                         &return_value_length, &flags, &rc)))
 804   {
 805     assert(return_value);
 806     assert(rc == MEMCACHED_SUCCESS);
 807     assert(return_key_length == return_value_length);
 808     assert(!memcmp(return_value, return_key, return_value_length));
 809     free(return_value);
 810     x++;
 811   }
 812
 813   return 0;
 814 }
 815
 816 uint8_t get_stats_keys(memcached_st *memc)
 817 {
 818  char **list;
 819  char **ptr;
 820  memcached_stat_st stat;
 821  memcached_return rc;
 822
 823  list= memcached_stat_get_keys(memc, &stat, &rc);
 824  assert(rc == MEMCACHED_SUCCESS);
 825  for (ptr= list; *ptr; ptr++)
 826    printf("Found key %s\n", *ptr);
 827  fflush(stdout);
 828
 829  free(list);
 830
 831  return 0;
 832 }
 833
 834 uint8_t get_stats(memcached_st *memc)
 835 {
 836  unsigned int x;
 837  char **list;
 838  char **ptr;
 839  memcached_return rc;
 840  memcached_stat_st *stat;
 841
 842  stat= memcached_stat(memc, NULL, &rc);
 843  assert(rc == MEMCACHED_SUCCESS);
 844
 845  assert(rc == MEMCACHED_SUCCESS);
 846  assert(stat);
 847
 848  for (x= 0; x < memcached_server_count(memc); x++)
 849  {
 850    list= memcached_stat_get_keys(memc, stat+x, &rc);
 851    assert(rc == MEMCACHED_SUCCESS);
 852    for (ptr= list; *ptr; ptr++);
 853
 854    free(list);
 855  }
 856
 857  memcached_stat_free(NULL, stat);
 858
 859   return 0;
 860 }
 861
 862 uint8_t add_host_test(memcached_st *memc)
 863 {
 864   unsigned int x;
 865   memcached_server_st *servers;
 866   memcached_return rc;
 867   char servername[]= "0.example.com";
 868
 869   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 870   assert(servers);
 871   assert(1 == memcached_server_list_count(servers));
 872
 873   for (x= 2; x < 20; x++)
 874   {
 875     char buffer[SMALL_STRING_LEN];
 876
 877     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 878     servers= memcached_server_list_append(servers, buffer, 401,
 879                                      &rc);
 880     assert(rc == MEMCACHED_SUCCESS);
 881     assert(x == memcached_server_list_count(servers));
 882   }
 883
 884   rc= memcached_server_push(memc, servers);
 885   assert(rc == MEMCACHED_SUCCESS);
 886   rc= memcached_server_push(memc, servers);
 887   assert(rc == MEMCACHED_SUCCESS);
 888
 889   memcached_server_list_free(servers);
 890
 891   return 0;
 892 }
 893
 894 /* We don't test the behavior itself, we test the switches */
 895 uint8_t behavior_test(memcached_st *memc)
 896 {
 897   unsigned long long value;
 898   unsigned int set= 1;
 899
 900   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 901   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 902   assert(value == 1);
 903
 904   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 905   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 906   assert(value == 1);
 907
 908   set= MEMCACHED_HASH_MD5;
 909   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
 910   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 911   assert(value == MEMCACHED_HASH_MD5);
 912
 913   set= 0;
 914
 915   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 916   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 917   assert(value == 0);
 918
 919   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 920   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 921   assert(value == 0);
 922
 923   set= MEMCACHED_HASH_DEFAULT;
 924   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
 925   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 926   assert(value == MEMCACHED_HASH_DEFAULT);
 927
 928   set= MEMCACHED_HASH_CRC;
 929   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
 930   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 931   assert(value == MEMCACHED_HASH_CRC);
 932
 933   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
 934   assert(value > 0);
 935
 936   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 937   assert(value > 0);
 938
 939   return 0;
 940 }
 941
 942 /* Test case provided by Cal Haldenbrand */
 943 uint8_t user_supplied_bug1(memcached_st *memc)
 944 {
 945   unsigned int setter= 1;
 946   unsigned int x;
 947
 948   unsigned long long total= 0;
 949   int size= 0;
 950   char key[10];
 951   char randomstuff[6 * 1024];
 952   memcached_return rc;
 953
 954   memset(randomstuff, 0, 6 * 1024);
 955
 956   /* We just keep looking at the same values over and over */
 957   srandom(10);
 958
 959   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 960   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 961
 962
 963   /* add key */
 964   for (x= 0 ; total < 20 * 1024576 ; x++ )
 965   {
 966     unsigned int j= 0;
 967
 968     size= (rand() % ( 5 * 1024 ) ) + 400;
 969     memset(randomstuff, 0, 6 * 1024);
 970     assert(size < 6 * 1024); /* Being safe here */
 971
 972     for (j= 0 ; j < size ;j++)
 973       randomstuff[j] = (char) (rand() % 26) + 97;
 974
 975     total += size;
 976     sprintf(key, "%d", x);
 977     rc = memcached_set(memc, key, strlen(key),
 978                        randomstuff, strlen(randomstuff), 10, 0);
 979     /* If we fail, lets try again */
 980     if (rc != MEMCACHED_SUCCESS)
 981       rc = memcached_set(memc, key, strlen(key),
 982                          randomstuff, strlen(randomstuff), 10, 0);
 983     assert(rc == MEMCACHED_SUCCESS);
 984   }
 985
 986   return 0;
 987 }
 988
 989 /* Test case provided by Cal Haldenbrand */
 990 uint8_t user_supplied_bug2(memcached_st *memc)
 991 {
 992   int errors;
 993   unsigned int setter;
 994   unsigned int x;
 995   unsigned long long total;
 996
 997   setter= 1;
 998   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 999   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
1000 #ifdef NOT_YET
1001   setter = 20 * 1024576;
1002   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
1003   setter = 20 * 1024576;
1004   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
1005   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1006   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1007
1008   for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
1009 #endif
1010
1011   for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
1012   {
1013     memcached_return rc= MEMCACHED_SUCCESS;
1014     char buffer[SMALL_STRING_LEN];
1015     uint32_t flags= 0;
1016     size_t val_len= 0;
1017     char *getval;
1018
1019     memset(buffer, 0, SMALL_STRING_LEN);
1020
1021     snprintf(buffer, SMALL_STRING_LEN, "%u", x);
1022     getval= memcached_get(memc, buffer, strlen(buffer),
1023                            &val_len, &flags, &rc);
1024     if (rc != MEMCACHED_SUCCESS)
1025     {
1026       if (rc == MEMCACHED_NOTFOUND)
1027         errors++;
1028       else
1029         assert(0);
1030
1031       continue;
1032     }
1033     total+= val_len;
1034     errors= 0;
1035     free(getval);
1036   }
1037
1038   return 0;
1039 }
1040
1041 /* Do a large mget() over all the keys we think exist */
1042 #define KEY_COUNT 3000 // * 1024576
1043 uint8_t user_supplied_bug3(memcached_st *memc)
1044 {
1045   memcached_return rc;
1046   unsigned int setter;
1047   unsigned int x;
1048   char **keys;
1049   size_t key_lengths[KEY_COUNT];
1050
1051   setter= 1;
1052   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
1053   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
1054 #ifdef NOT_YET
1055   setter = 20 * 1024576;
1056   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
1057   setter = 20 * 1024576;
1058   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
1059   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1060   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1061 #endif
1062
1063   keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
1064   assert(keys);
1065   memset(keys, 0, (sizeof(char *) * KEY_COUNT));
1066   for (x= 0; x < KEY_COUNT; x++)
1067   {
1068     char buffer[30];
1069
1070     snprintf(buffer, 30, "%u", x);
1071     keys[x]= strdup(buffer);
1072     key_lengths[x]= strlen(keys[x]);
1073   }
1074
1075   rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
1076   assert(rc == MEMCACHED_SUCCESS);
1077
1078   /* Turn this into a help function */
1079   {
1080     char return_key[MEMCACHED_MAX_KEY];
1081     size_t return_key_length;
1082     char *return_value;
1083     size_t return_value_length;
1084     uint32_t flags;
1085
1086     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1087                                           &return_value_length, &flags, &rc)))
1088     {
1089       assert(return_value);
1090       assert(rc == MEMCACHED_SUCCESS);
1091       free(return_value);
1092     }
1093   }
1094
1095   for (x= 0; x < KEY_COUNT; x++)
1096     free(keys[x]);
1097   free(keys);
1098
1099   return 0;
1100 }
1101
1102 /* Make sure we behave properly if server list has no values */
1103 uint8_t user_supplied_bug4(memcached_st *memc)
1104 {
1105   memcached_return rc;
1106   char *keys[]= {"fudge", "son", "food"};
1107   size_t key_length[]= {5, 3, 4};
1108   unsigned int x;
1109   uint32_t flags;
1110   char return_key[MEMCACHED_MAX_KEY];
1111   size_t return_key_length;
1112   char *return_value;
1113   size_t return_value_length;
1114
1115   /* Here we free everything before running a bunch of mget tests */
1116   {
1117     memcached_server_list_free(memc->hosts);
1118     memc->hosts= NULL;
1119     memc->number_of_hosts= 0;
1120   }
1121
1122
1123   /* We need to empty the server before continueing test */
1124   rc= memcached_flush(memc, 0);
1125   assert(rc == MEMCACHED_NO_SERVERS);
1126
1127   rc= memcached_mget(memc, keys, key_length, 3);
1128   assert(rc == MEMCACHED_NO_SERVERS);
1129
1130   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1131                       &return_value_length, &flags, &rc)) != NULL)
1132   {
1133     assert(return_value);
1134   }
1135   assert(!return_value);
1136   assert(return_value_length == 0);
1137   assert(rc == MEMCACHED_NO_SERVERS);
1138
1139   for (x= 0; x < 3; x++)
1140   {
1141     rc= memcached_set(memc, keys[x], key_length[x],
1142                       keys[x], key_length[x],
1143                       (time_t)50, (uint32_t)9);
1144     assert(rc == MEMCACHED_NO_SERVERS);
1145   }
1146
1147   rc= memcached_mget(memc, keys, key_length, 3);
1148   assert(rc == MEMCACHED_NO_SERVERS);
1149
1150   x= 0;
1151   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1152                                         &return_value_length, &flags, &rc)))
1153   {
1154     assert(return_value);
1155     assert(rc == MEMCACHED_SUCCESS);
1156     assert(return_key_length == return_value_length);
1157     assert(!memcmp(return_value, return_key, return_value_length));
1158     free(return_value);
1159     x++;
1160   }
1161
1162   return 0;
1163 }
1164
1165 #define VALUE_SIZE_BUG5 1048064
1166 uint8_t user_supplied_bug5(memcached_st *memc)
1167 {
1168   memcached_return rc;
1169   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1170   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1171   char return_key[MEMCACHED_MAX_KEY];
1172   size_t return_key_length;
1173   char *value;
1174   size_t value_length;
1175   uint32_t flags;
1176   unsigned int count;
1177   unsigned int x;
1178   char insert_data[VALUE_SIZE_BUG5];
1179
1180   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1181     insert_data[x]= rand();
1182
1183   memcached_flush(memc, 0);
1184   value= memcached_get(memc, keys[0], key_length[0],
1185                         &value_length, &flags, &rc);
1186   assert(value == NULL);
1187   rc= memcached_mget(memc, keys, key_length, 4);
1188
1189   count= 0;
1190   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1191                                         &value_length, &flags, &rc)))
1192     count++;
1193   assert(count == 0);
1194
1195   for (x= 0; x < 4; x++)
1196   {
1197     rc= memcached_set(memc, keys[x], key_length[x],
1198                       insert_data, VALUE_SIZE_BUG5,
1199                       (time_t)0, (uint32_t)0);
1200     assert(rc == MEMCACHED_SUCCESS);
1201   }
1202
1203   for (x= 0; x < 10; x++)
1204   {
1205     value= memcached_get(memc, keys[0], key_length[0],
1206                          &value_length, &flags, &rc);
1207     assert(value);
1208     free(value);
1209
1210     rc= memcached_mget(memc, keys, key_length, 4);
1211     count= 0;
1212     while ((value= memcached_fetch(memc, return_key, &return_key_length,
1213                                           &value_length, &flags, &rc)))
1214     {
1215       count++;
1216       free(value);
1217     }
1218     assert(count == 4);
1219   }
1220
1221   return 0;
1222 }
1223
1224 uint8_t user_supplied_bug6(memcached_st *memc)
1225 {
1226   memcached_return rc;
1227   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1228   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1229   char return_key[MEMCACHED_MAX_KEY];
1230   size_t return_key_length;
1231   char *value;
1232   size_t value_length;
1233   uint32_t flags;
1234   unsigned int count;
1235   unsigned int x;
1236   char insert_data[VALUE_SIZE_BUG5];
1237
1238   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1239     insert_data[x]= rand();
1240
1241   memcached_flush(memc, 0);
1242   value= memcached_get(memc, keys[0], key_length[0],
1243                         &value_length, &flags, &rc);
1244   assert(value == NULL);
1245   assert(rc == MEMCACHED_NOTFOUND);
1246   rc= memcached_mget(memc, keys, key_length, 4);
1247   assert(rc == MEMCACHED_SUCCESS);
1248
1249   count= 0;
1250   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1251                                         &value_length, &flags, &rc)))
1252     count++;
1253   assert(count == 0);
1254   assert(rc == MEMCACHED_END);
1255
1256   for (x= 0; x < 4; x++)
1257   {
1258     rc= memcached_set(memc, keys[x], key_length[x],
1259                       insert_data, VALUE_SIZE_BUG5,
1260                       (time_t)0, (uint32_t)0);
1261     assert(rc == MEMCACHED_SUCCESS);
1262   }
1263
1264   for (x= 0; x < 2; x++)
1265   {
1266     value= memcached_get(memc, keys[0], key_length[0],
1267                          &value_length, &flags, &rc);
1268     assert(value);
1269     free(value);
1270
1271     rc= memcached_mget(memc, keys, key_length, 4);
1272     assert(rc == MEMCACHED_SUCCESS);
1273     count= 3;
1274     /* We test for purge of partial complete fetches */
1275     for (count= 3; count; count--)
1276     {
1277       value= memcached_fetch(memc, return_key, &return_key_length,
1278                              &value_length, &flags, &rc);
1279       assert(rc == MEMCACHED_SUCCESS);
1280       assert(!(memcmp(value, insert_data, value_length)));
1281       assert(value_length);
1282       free(value);
1283     }
1284   }
1285
1286   return 0;
1287 }
1288
1289 uint8_t user_supplied_bug8(memcached_st *memc)
1290 {
1291   memcached_return rc;
1292   memcached_st *mine;
1293   memcached_st *clone;
1294
1295   memcached_server_st *servers;
1296   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";
1297
1298   servers= memcached_servers_parse(server_list);
1299   assert(servers);
1300
1301   mine= memcached_create(NULL);
1302   rc= memcached_server_push(mine, servers);
1303   assert(rc == MEMCACHED_SUCCESS);
1304   memcached_server_list_free(servers);
1305
1306   assert(mine);
1307   clone= memcached_clone(NULL, mine);
1308
1309   memcached_quit(mine);
1310   memcached_quit(clone);
1311
1312
1313   memcached_free(mine);
1314   memcached_free(clone);
1315
1316   return 0;
1317 }
1318
1319 /* Test flag store/retrieve */
1320 uint8_t user_supplied_bug7(memcached_st *memc)
1321 {
1322   memcached_return rc;
1323   char *keys= "036790384900";
1324   size_t key_length=  strlen("036790384900");
1325   char return_key[MEMCACHED_MAX_KEY];
1326   size_t return_key_length;
1327   char *value;
1328   size_t value_length;
1329   uint32_t flags;
1330   unsigned int x;
1331   char insert_data[VALUE_SIZE_BUG5];
1332
1333   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1334     insert_data[x]= rand();
1335
1336   memcached_flush(memc, 0);
1337
1338   flags= 245;
1339   rc= memcached_set(memc, keys, key_length,
1340                     insert_data, VALUE_SIZE_BUG5,
1341                     (time_t)0, flags);
1342   assert(rc == MEMCACHED_SUCCESS);
1343
1344   flags= 0;
1345   value= memcached_get(memc, keys, key_length,
1346                         &value_length, &flags, &rc);
1347   assert(flags == 245);
1348   assert(value);
1349   free(value);
1350
1351   rc= memcached_mget(memc, &keys, &key_length, 1);
1352
1353   flags= 0;
1354   value= memcached_fetch(memc, return_key, &return_key_length,
1355                          &value_length, &flags, &rc);
1356   assert(flags == 245);
1357   assert(value);
1358   free(value);
1359
1360
1361   return 0;
1362 }
1363
1364 uint8_t user_supplied_bug9(memcached_st *memc)
1365 {
1366   memcached_return rc;
1367   char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1368   size_t key_length[3];
1369   unsigned int x;
1370   uint32_t flags;
1371   unsigned count= 0;
1372
1373   char return_key[MEMCACHED_MAX_KEY];
1374   size_t return_key_length;
1375   char *return_value;
1376   size_t return_value_length;
1377
1378
1379   key_length[0]= strlen("UDATA:edevil@sapo.pt");
1380   key_length[1]= strlen("fudge&*@#");
1381   key_length[2]= strlen("for^#@&$not");
1382
1383
1384   for (x= 0; x < 3; x++)
1385   {
1386     rc= memcached_set(memc, keys[x], key_length[x],
1387                       keys[x], key_length[x],
1388                       (time_t)50, (uint32_t)9);
1389     assert(rc == MEMCACHED_SUCCESS);
1390   }
1391
1392   rc= memcached_mget(memc, keys, key_length, 3);
1393   assert(rc == MEMCACHED_SUCCESS);
1394
1395   /* We need to empty the server before continueing test */
1396   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1397                       &return_value_length, &flags, &rc)) != NULL)
1398   {
1399     assert(return_value);
1400     free(return_value);
1401     count++;
1402   }
1403   assert(count == 3);
1404
1405   return 0;
1406 }
1407
1408 /* We are testing with aggressive timeout to get failures */
1409 uint8_t user_supplied_bug10(memcached_st *memc)
1410 {
1411   char *key= "foo";
1412   char *value;
1413   size_t value_length= 512;
1414   unsigned int x;
1415   int key_len= 3;
1416   memcached_return rc;
1417   unsigned int set= 1;
1418   memcached_st *mclone= memcached_clone(NULL, memc);
1419   int32_t timeout;
1420
1421   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
1422   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
1423   timeout= 2;
1424   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
1425
1426   value = (char*)malloc(value_length * sizeof(char));
1427
1428   for (x= 0; x < value_length; x++)
1429     value[x]= (char) (x % 127);
1430
1431   for (x= 1; x <= 100000; ++x)
1432   {
1433     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
1434
1435     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE);
1436
1437     if (rc == MEMCACHED_WRITE_FAILURE)
1438       x--;
1439   }
1440
1441   free(value);
1442   memcached_free(mclone);
1443
1444   return 0;
1445 }
1446
1447 /*
1448   We are looking failures in the async protocol
1449 */
1450 uint8_t user_supplied_bug11(memcached_st *memc)
1451 {
1452   char *key= "foo";
1453   char *value;
1454   size_t value_length= 512;
1455   unsigned int x;
1456   int key_len= 3;
1457   memcached_return rc;
1458   unsigned int set= 1;
1459   int32_t timeout;
1460   memcached_st *mclone= memcached_clone(NULL, memc);
1461
1462   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
1463   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
1464   timeout= -1;
1465   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
1466
1467   timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
1468
1469   assert(timeout == -1);
1470
1471   value = (char*)malloc(value_length * sizeof(char));
1472
1473   for (x= 0; x < value_length; x++)
1474     value[x]= (char) (x % 127);
1475
1476   for (x= 1; x <= 100000; ++x)
1477   {
1478     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
1479
1480     WATCHPOINT_IFERROR(rc);
1481     //assert(rc == MEMCACHED_SUCCESS);
1482   }
1483
1484   free(value);
1485   memcached_free(mclone);
1486
1487   return 0;
1488 }
1489
1490 uint8_t result_static(memcached_st *memc)
1491 {
1492   memcached_result_st result;
1493   memcached_result_st *result_ptr;
1494
1495   result_ptr= memcached_result_create(memc, &result);
1496   assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
1497   assert(result_ptr);
1498   memcached_result_free(&result);
1499
1500   return 0;
1501 }
1502
1503 uint8_t result_alloc(memcached_st *memc)
1504 {
1505   memcached_result_st *result;
1506
1507   result= memcached_result_create(memc, NULL);
1508   assert(result);
1509   memcached_result_free(result);
1510
1511   return 0;
1512 }
1513
1514 uint8_t string_static_null(memcached_st *memc)
1515 {
1516   memcached_string_st string;
1517   memcached_string_st *string_ptr;
1518
1519   string_ptr= memcached_string_create(memc, &string, 0);
1520   assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
1521   assert(string_ptr);
1522   memcached_string_free(&string);
1523
1524   return 0;
1525 }
1526
1527 uint8_t string_alloc_null(memcached_st *memc)
1528 {
1529   memcached_string_st *string;
1530
1531   string= memcached_string_create(memc, NULL, 0);
1532   assert(string);
1533   memcached_string_free(string);
1534
1535   return 0;
1536 }
1537
1538 uint8_t string_alloc_with_size(memcached_st *memc)
1539 {
1540   memcached_string_st *string;
1541
1542   string= memcached_string_create(memc, NULL, 1024);
1543   assert(string);
1544   memcached_string_free(string);
1545
1546   return 0;
1547 }
1548
1549 uint8_t string_alloc_with_size_toobig(memcached_st *memc)
1550 {
1551   memcached_string_st *string;
1552
1553   string= memcached_string_create(memc, NULL, INT64_MAX);
1554   assert(string == NULL);
1555
1556   return 0;
1557 }
1558
1559 uint8_t string_alloc_append(memcached_st *memc)
1560 {
1561   unsigned int x;
1562   char buffer[SMALL_STRING_LEN];
1563   memcached_string_st *string;
1564
1565   /* Ring the bell! */
1566   memset(buffer, 6, SMALL_STRING_LEN);
1567
1568   string= memcached_string_create(memc, NULL, 100);
1569   assert(string);
1570
1571   for (x= 0; x < 1024; x++)
1572   {
1573     memcached_return rc;
1574     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1575     assert(rc == MEMCACHED_SUCCESS);
1576   }
1577   memcached_string_free(string);
1578
1579   return 0;
1580 }
1581
1582 uint8_t string_alloc_append_toobig(memcached_st *memc)
1583 {
1584   memcached_return rc;
1585   unsigned int x;
1586   char buffer[SMALL_STRING_LEN];
1587   memcached_string_st *string;
1588
1589   /* Ring the bell! */
1590   memset(buffer, 6, SMALL_STRING_LEN);
1591
1592   string= memcached_string_create(memc, NULL, 100);
1593   assert(string);
1594
1595   for (x= 0; x < 1024; x++)
1596   {
1597     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1598     assert(rc == MEMCACHED_SUCCESS);
1599   }
1600   rc= memcached_string_append(string, buffer, INT64_MAX);
1601   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
1602   memcached_string_free(string);
1603
1604   return 0;
1605 }
1606
1607 uint8_t cleanup_pairs(memcached_st *memc)
1608 {
1609   pairs_free(global_pairs);
1610
1611   return 0;
1612 }
1613
1614 uint8_t generate_data(memcached_st *memc)
1615 {
1616   unsigned long long x;
1617   global_pairs= pairs_generate(GLOBAL_COUNT);
1618   execute_set(memc, global_pairs, GLOBAL_COUNT);
1619
1620   for (x= 0; x < GLOBAL_COUNT; x++)
1621   {
1622     global_keys[x]= global_pairs[x].key;
1623     global_keys_length[x]=  global_pairs[x].key_length;
1624   }
1625
1626   return 0;
1627 }
1628
1629 uint8_t get_read(memcached_st *memc)
1630 {
1631   unsigned int x;
1632   memcached_return rc;
1633
1634   {
1635     char *return_value;
1636     size_t return_value_length;
1637     uint32_t flags;
1638
1639     for (x= 0; x < GLOBAL_COUNT; x++)
1640     {
1641       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
1642                                   &return_value_length, &flags, &rc);
1643       /*
1644       assert(return_value);
1645       assert(rc == MEMCACHED_SUCCESS);
1646     */
1647       if (rc == MEMCACHED_SUCCESS && return_value)
1648         free(return_value);
1649     }
1650   }
1651
1652   return 0;
1653 }
1654
1655 uint8_t mget_read(memcached_st *memc)
1656 {
1657   memcached_return rc;
1658
1659   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1660   assert(rc == MEMCACHED_SUCCESS);
1661   /* Turn this into a help function */
1662   {
1663     char return_key[MEMCACHED_MAX_KEY];
1664     size_t return_key_length;
1665     char *return_value;
1666     size_t return_value_length;
1667     uint32_t flags;
1668
1669     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1670                                           &return_value_length, &flags, &rc)))
1671     {
1672       assert(return_value);
1673       assert(rc == MEMCACHED_SUCCESS);
1674       free(return_value);
1675     }
1676   }
1677
1678   return 0;
1679 }
1680
1681 uint8_t mget_read_result(memcached_st *memc)
1682 {
1683   memcached_return rc;
1684
1685   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1686   assert(rc == MEMCACHED_SUCCESS);
1687   /* Turn this into a help function */
1688   {
1689     memcached_result_st results_obj;
1690     memcached_result_st *results;
1691
1692     results= memcached_result_create(memc, &results_obj);
1693
1694     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1695     {
1696       assert(results);
1697       assert(rc == MEMCACHED_SUCCESS);
1698     }
1699
1700     memcached_result_free(&results_obj);
1701   }
1702
1703   return 0;
1704 }
1705
1706 uint8_t delete_generate(memcached_st *memc)
1707 {
1708   unsigned int x;
1709
1710   for (x= 0; x < GLOBAL_COUNT; x++)
1711   {
1712     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
1713   }
1714
1715   return 0;
1716 }
1717
1718 uint8_t mdelete_generate(memcached_st *memc)
1719 {
1720   memcached_return rc;
1721
1722   rc= memcached_mdelete(memc, global_keys, global_keys_length, GLOBAL_COUNT, 0);
1723
1724   return 0;
1725 }
1726
1727
1728 uint8_t free_data(memcached_st *memc)
1729 {
1730   pairs_free(global_pairs);
1731
1732   return 0;
1733 }
1734
1735 uint8_t add_host_test1(memcached_st *memc)
1736 {
1737   unsigned int x;
1738   memcached_return rc;
1739   char servername[]= "0.example.com";
1740   memcached_server_st *servers;
1741
1742   servers= memcached_server_list_append(NULL, servername, 400, &rc);
1743   assert(servers);
1744   assert(1 == memcached_server_list_count(servers));
1745
1746   for (x= 2; x < 20; x++)
1747   {
1748     char buffer[SMALL_STRING_LEN];
1749
1750     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1751     servers= memcached_server_list_append(servers, buffer, 401,
1752                                      &rc);
1753     assert(rc == MEMCACHED_SUCCESS);
1754     assert(x == memcached_server_list_count(servers));
1755   }
1756
1757   rc= memcached_server_push(memc, servers);
1758   assert(rc == MEMCACHED_SUCCESS);
1759   rc= memcached_server_push(memc, servers);
1760   assert(rc == MEMCACHED_SUCCESS);
1761
1762   memcached_server_list_free(servers);
1763
1764   return 0;
1765 }
1766
1767 memcached_return pre_nonblock(memcached_st *memc)
1768 {
1769   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1770
1771   return MEMCACHED_SUCCESS;
1772 }
1773
1774 memcached_return pre_md5(memcached_st *memc)
1775 {
1776   memcached_hash value= MEMCACHED_HASH_MD5;
1777   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1778
1779   return MEMCACHED_SUCCESS;
1780 }
1781
1782 memcached_return pre_crc(memcached_st *memc)
1783 {
1784   memcached_hash value= MEMCACHED_HASH_CRC;
1785   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1786
1787   return MEMCACHED_SUCCESS;
1788 }
1789
1790 memcached_return pre_hsieh(memcached_st *memc)
1791 {
1792   memcached_hash value= MEMCACHED_HASH_HSIEH;
1793   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1794
1795   return MEMCACHED_SUCCESS;
1796 }
1797
1798 memcached_return pre_hash_fnv1_64(memcached_st *memc)
1799 {
1800   memcached_hash value= MEMCACHED_HASH_FNV1_64;
1801   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1802
1803   return MEMCACHED_SUCCESS;
1804 }
1805
1806 memcached_return pre_hash_fnv1a_64(memcached_st *memc)
1807 {
1808   memcached_hash value= MEMCACHED_HASH_FNV1A_64;
1809   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1810
1811   return MEMCACHED_SUCCESS;
1812 }
1813
1814 memcached_return pre_hash_fnv1_32(memcached_st *memc)
1815 {
1816   memcached_hash value= MEMCACHED_HASH_FNV1_32;
1817   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1818
1819   return MEMCACHED_SUCCESS;
1820 }
1821
1822 memcached_return pre_hash_fnv1a_32(memcached_st *memc)
1823 {
1824   memcached_hash value= MEMCACHED_HASH_FNV1A_32;
1825   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1826
1827   return MEMCACHED_SUCCESS;
1828 }
1829
1830 memcached_return pre_hash_ketama(memcached_st *memc)
1831 {
1832   memcached_hash value= MEMCACHED_HASH_KETAMA;
1833   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1834
1835   return MEMCACHED_SUCCESS;
1836 }
1837
1838 memcached_return enable_consistent(memcached_st *memc)
1839 {
1840   memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;
1841   memcached_hash hash;
1842   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, &value);
1843   pre_hsieh(memc);
1844
1845   value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
1846   assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
1847
1848   hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1849   assert(hash == MEMCACHED_HASH_HSIEH);
1850
1851
1852   return MEMCACHED_SUCCESS;
1853 }
1854
1855 memcached_return enable_cas(memcached_st *memc)
1856 {
1857   unsigned int set= 1;
1858
1859   memcached_version(memc);
1860
1861   if (memc->hosts[0].major_version >= 1 &&
1862       memc->hosts[0].minor_version >= 2 &&
1863       memc->hosts[0].micro_version >= 4)
1864   {
1865     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
1866
1867     return MEMCACHED_SUCCESS;
1868   }
1869
1870   return MEMCACHED_FAILURE;
1871 }
1872
1873 memcached_return check_for_1_2_3(memcached_st *memc)
1874 {
1875   memcached_version(memc);
1876
1877   if (memc->hosts[0].major_version >= 1 &&
1878       memc->hosts[0].minor_version >= 2 &&
1879       memc->hosts[0].micro_version >= 4)
1880     return MEMCACHED_SUCCESS;
1881
1882   return MEMCACHED_FAILURE;
1883 }
1884
1885 memcached_return pre_unix_socket(memcached_st *memc)
1886 {
1887   memcached_return rc;
1888   struct stat buf;
1889
1890   memcached_server_list_free(memc->hosts);
1891   memc->hosts= NULL;
1892   memc->number_of_hosts= 0;
1893
1894   if (stat("/tmp/memcached.socket", &buf))
1895     return MEMCACHED_FAILURE;
1896
1897   rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");
1898
1899   return rc;
1900 }
1901
1902 memcached_return pre_udp(memcached_st *memc)
1903 {
1904   memcached_return rc;
1905
1906   memcached_server_list_free(memc->hosts);
1907   memc->hosts= NULL;
1908   memc->number_of_hosts= 0;
1909
1910   if (0)
1911     return MEMCACHED_FAILURE;
1912
1913   rc= memcached_server_add_udp(memc, "localhost", MEMCACHED_DEFAULT_PORT);
1914
1915   return rc;
1916 }
1917
1918 memcached_return pre_nodelay(memcached_st *memc)
1919 {
1920   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1921   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
1922
1923   return MEMCACHED_SUCCESS;
1924 }
1925
1926 memcached_return poll_timeout(memcached_st *memc)
1927 {
1928   int32_t timeout;
1929
1930   timeout= 100;
1931
1932   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
1933
1934   timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
1935
1936   assert(timeout == 100);
1937
1938   return MEMCACHED_SUCCESS;
1939 }
1940
1941
1942 /* Clean the server before beginning testing */
1943 test_st tests[] ={
1944   {"flush", 0, flush_test },
1945   {"init", 0, init_test },
1946   {"allocation", 0, allocation_test },
1947   {"clone_test", 0, clone_test },
1948   {"error", 0, error_test },
1949   {"set", 0, set_test },
1950   {"set2", 0, set_test2 },
1951   {"set3", 0, set_test3 },
1952   {"add", 1, add_test },
1953   {"replace", 0, replace_test },
1954   {"delete", 1, delete_test },
1955   {"get", 1, get_test },
1956   {"get2", 0, get_test2 },
1957   {"get3", 0, get_test3 },
1958   {"get4", 0, get_test4 },
1959   {"stats_servername", 0, stats_servername_test },
1960   {"increment", 0, increment_test },
1961   {"decrement", 0, decrement_test },
1962   {"quit", 0, quit_test },
1963   {"mget", 1, mget_test },
1964   {"mget_result", 1, mget_result_test },
1965   {"mget_result_alloc", 1, mget_result_alloc_test },
1966   {"get_stats", 0, get_stats },
1967   {"add_host_test", 0, add_host_test },
1968   {"get_stats_keys", 0, get_stats_keys },
1969   {"behavior_test", 0, get_stats_keys },
1970   {0, 0, 0}
1971 };
1972
1973 test_st async_tests[] ={
1974   {"add", 1, add_wrapper },
1975   {0, 0, 0}
1976 };
1977
1978 test_st string_tests[] ={
1979   {"string static with null", 0, string_static_null },
1980   {"string alloc with null", 0, string_alloc_null },
1981   {"string alloc with 1K", 0, string_alloc_with_size },
1982   {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
1983   {"string append", 0, string_alloc_append },
1984   {"string append failure (too big)", 0, string_alloc_append_toobig },
1985   {0, 0, 0}
1986 };
1987
1988 test_st result_tests[] ={
1989   {"result static", 0, result_static},
1990   {"result alloc", 0, result_alloc},
1991   {0, 0, 0}
1992 };
1993
1994 test_st version_1_2_3[] ={
1995   {"append", 0, append_test },
1996   {"prepend", 0, prepend_test },
1997   {"cas", 0, cas_test },
1998   {"cas2", 0, cas2_test },
1999   {"append_binary", 0, append_binary_test },
2000   {0, 0, 0}
2001 };
2002
2003 test_st user_tests[] ={
2004   {"user_supplied_bug1", 0, user_supplied_bug1 },
2005   {"user_supplied_bug2", 0, user_supplied_bug2 },
2006   {"user_supplied_bug3", 0, user_supplied_bug3 },
2007   {"user_supplied_bug4", 0, user_supplied_bug4 },
2008   {"user_supplied_bug5", 1, user_supplied_bug5 },
2009   {"user_supplied_bug6", 1, user_supplied_bug6 },
2010   {"user_supplied_bug7", 1, user_supplied_bug7 },
2011   {"user_supplied_bug8", 1, user_supplied_bug8 },
2012   {"user_supplied_bug9", 1, user_supplied_bug9 },
2013   {"user_supplied_bug10", 1, user_supplied_bug10 },
2014   {"user_supplied_bug11", 1, user_supplied_bug11 },
2015   {0, 0, 0}
2016 };
2017
2018 test_st generate_tests[] ={
2019   {"generate_data", 0, generate_data },
2020   {"get_read", 0, get_read },
2021   {"mget_read", 0, mget_read },
2022   {"mget_read_result", 0, mget_read_result },
2023   {"mdelete_generate", 0, mdelete_generate },
2024   {"delete_generate", 0, delete_generate },
2025   {"cleanup", 0, cleanup_pairs },
2026   {0, 0, 0}
2027 };
2028
2029
2030 collection_st collection[] ={
2031   {"block", 0, 0, tests},
2032   {"nonblock", pre_nonblock, 0, tests},
2033   {"nodelay", pre_nodelay, 0, tests},
2034   {"md5", pre_md5, 0, tests},
2035   {"crc", pre_crc, 0, tests},
2036   {"hsieh", pre_hsieh, 0, tests},
2037   {"fnv1_64", pre_hash_fnv1_64, 0, tests},
2038   {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
2039   {"fnv1_32", pre_hash_fnv1_32, 0, tests},
2040   {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
2041   {"ketama", pre_hash_ketama, 0, tests},
2042   {"unix_socket", pre_unix_socket, 0, tests},
2043   {"unix_socket_nodelay", pre_nodelay, 0, tests},
2044   {"poll_timeout", poll_timeout, 0, tests},
2045   {"gets", enable_cas, 0, tests},
2046   {"consistent", enable_consistent, 0, tests},
2047 //  {"udp", pre_udp, 0, tests},
2048   {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
2049   {"string", 0, 0, string_tests},
2050   {"result", 0, 0, result_tests},
2051   {"async", pre_nonblock, 0, async_tests},
2052   {"user", 0, 0, user_tests},
2053   {"generate", 0, 0, generate_tests},
2054   {"generate_hsieh", pre_hsieh, 0, generate_tests},
2055   {"generate_hsieh_consistent", enable_consistent, 0, generate_tests},
2056   {"generate_md5", pre_md5, 0, generate_tests},
2057   {"generate_nonblock", pre_nonblock, 0, generate_tests},
2058   {0, 0, 0, 0}
2059 };
2060
2061 collection_st *gets_collections(void)
2062 {
2063   return collection;
2064 }