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