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

   1 /*
   2   Sample test application.
   3 */
   4 #include <assert.h>
   5 #include <memcached.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <sys/time.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <unistd.h>
  13 #include <time.h>
  14 #include "../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 uint8_t user_supplied_bug10(memcached_st *memc)
1391 {
1392   char *key= "foo";
1393   char *value;
1394   size_t value_length= 512;
1395   unsigned int x;
1396   int key_len= 3;
1397   memcached_return rc;
1398   unsigned int set= 1;
1399   memcached_st *mclone= memcached_clone(NULL, memc);
1400
1401   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
1402   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
1403
1404   value = (char*)malloc(value_length * sizeof(char));
1405
1406   for (x= 0; x < value_length; x++)
1407     value[x]= (char) (x % 127);
1408
1409   for (x= 1; x <= 100000; ++x)
1410   {
1411     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
1412
1413     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE);
1414
1415     if (rc == MEMCACHED_WRITE_FAILURE)
1416       x--;
1417   }
1418
1419   free(value);
1420   memcached_free(mclone);
1421
1422   return 0;
1423 }
1424
1425 uint8_t result_static(memcached_st *memc)
1426 {
1427   memcached_result_st result;
1428   memcached_result_st *result_ptr;
1429
1430   result_ptr= memcached_result_create(memc, &result);
1431   assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
1432   assert(result_ptr);
1433   memcached_result_free(&result);
1434
1435   return 0;
1436 }
1437
1438 uint8_t result_alloc(memcached_st *memc)
1439 {
1440   memcached_result_st *result;
1441
1442   result= memcached_result_create(memc, NULL);
1443   assert(result);
1444   memcached_result_free(result);
1445
1446   return 0;
1447 }
1448
1449 uint8_t string_static_null(memcached_st *memc)
1450 {
1451   memcached_string_st string;
1452   memcached_string_st *string_ptr;
1453
1454   string_ptr= memcached_string_create(memc, &string, 0);
1455   assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
1456   assert(string_ptr);
1457   memcached_string_free(&string);
1458
1459   return 0;
1460 }
1461
1462 uint8_t string_alloc_null(memcached_st *memc)
1463 {
1464   memcached_string_st *string;
1465
1466   string= memcached_string_create(memc, NULL, 0);
1467   assert(string);
1468   memcached_string_free(string);
1469
1470   return 0;
1471 }
1472
1473 uint8_t string_alloc_with_size(memcached_st *memc)
1474 {
1475   memcached_string_st *string;
1476
1477   string= memcached_string_create(memc, NULL, 1024);
1478   assert(string);
1479   memcached_string_free(string);
1480
1481   return 0;
1482 }
1483
1484 uint8_t string_alloc_with_size_toobig(memcached_st *memc)
1485 {
1486   memcached_string_st *string;
1487
1488   string= memcached_string_create(memc, NULL, INT64_MAX);
1489   assert(string == NULL);
1490
1491   return 0;
1492 }
1493
1494 uint8_t string_alloc_append(memcached_st *memc)
1495 {
1496   unsigned int x;
1497   char buffer[SMALL_STRING_LEN];
1498   memcached_string_st *string;
1499
1500   /* Ring the bell! */
1501   memset(buffer, 6, SMALL_STRING_LEN);
1502
1503   string= memcached_string_create(memc, NULL, 100);
1504   assert(string);
1505
1506   for (x= 0; x < 1024; x++)
1507   {
1508     memcached_return rc;
1509     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1510     assert(rc == MEMCACHED_SUCCESS);
1511   }
1512   memcached_string_free(string);
1513
1514   return 0;
1515 }
1516
1517 uint8_t string_alloc_append_toobig(memcached_st *memc)
1518 {
1519   memcached_return rc;
1520   unsigned int x;
1521   char buffer[SMALL_STRING_LEN];
1522   memcached_string_st *string;
1523
1524   /* Ring the bell! */
1525   memset(buffer, 6, SMALL_STRING_LEN);
1526
1527   string= memcached_string_create(memc, NULL, 100);
1528   assert(string);
1529
1530   for (x= 0; x < 1024; x++)
1531   {
1532     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1533     assert(rc == MEMCACHED_SUCCESS);
1534   }
1535   rc= memcached_string_append(string, buffer, INT64_MAX);
1536   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
1537   memcached_string_free(string);
1538
1539   return 0;
1540 }
1541
1542 uint8_t cleanup_pairs(memcached_st *memc)
1543 {
1544   pairs_free(global_pairs);
1545
1546   return 0;
1547 }
1548
1549 uint8_t generate_data(memcached_st *memc)
1550 {
1551   unsigned long long x;
1552   global_pairs= pairs_generate(GLOBAL_COUNT);
1553   execute_set(memc, global_pairs, GLOBAL_COUNT);
1554
1555   for (x= 0; x < GLOBAL_COUNT; x++)
1556   {
1557     global_keys[x]= global_pairs[x].key;
1558     global_keys_length[x]=  global_pairs[x].key_length;
1559   }
1560
1561   return 0;
1562 }
1563
1564 uint8_t get_read(memcached_st *memc)
1565 {
1566   unsigned int x;
1567   memcached_return rc;
1568
1569   {
1570     char *return_value;
1571     size_t return_value_length;
1572     uint16_t flags;
1573
1574     for (x= 0; x < GLOBAL_COUNT; x++)
1575     {
1576       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
1577                                   &return_value_length, &flags, &rc);
1578       /*
1579       assert(return_value);
1580       assert(rc == MEMCACHED_SUCCESS);
1581     */
1582       if (rc == MEMCACHED_SUCCESS && return_value)
1583         free(return_value);
1584     }
1585   }
1586
1587   return 0;
1588 }
1589
1590 uint8_t mget_read(memcached_st *memc)
1591 {
1592   memcached_return rc;
1593
1594   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1595   assert(rc == MEMCACHED_SUCCESS);
1596   /* Turn this into a help function */
1597   {
1598     char return_key[MEMCACHED_MAX_KEY];
1599     size_t return_key_length;
1600     char *return_value;
1601     size_t return_value_length;
1602     uint16_t flags;
1603
1604     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1605                                           &return_value_length, &flags, &rc)))
1606     {
1607       assert(return_value);
1608       assert(rc == MEMCACHED_SUCCESS);
1609       free(return_value);
1610     }
1611   }
1612
1613   return 0;
1614 }
1615
1616 uint8_t mget_read_result(memcached_st *memc)
1617 {
1618   memcached_return rc;
1619
1620   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1621   assert(rc == MEMCACHED_SUCCESS);
1622   /* Turn this into a help function */
1623   {
1624     memcached_result_st results_obj;
1625     memcached_result_st *results;
1626
1627     results= memcached_result_create(memc, &results_obj);
1628
1629     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1630     {
1631       assert(results);
1632       assert(rc == MEMCACHED_SUCCESS);
1633     }
1634
1635     memcached_result_free(&results_obj);
1636   }
1637
1638   return 0;
1639 }
1640
1641 uint8_t free_data(memcached_st *memc)
1642 {
1643   pairs_free(global_pairs);
1644
1645   return 0;
1646 }
1647
1648 uint8_t add_host_test1(memcached_st *memc)
1649 {
1650   unsigned int x;
1651   memcached_return rc;
1652   char servername[]= "0.example.com";
1653   memcached_server_st *servers;
1654
1655   servers= memcached_server_list_append(NULL, servername, 400, &rc);
1656   assert(servers);
1657   assert(1 == memcached_server_list_count(servers));
1658
1659   for (x= 2; x < 20; x++)
1660   {
1661     char buffer[SMALL_STRING_LEN];
1662
1663     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1664     servers= memcached_server_list_append(servers, buffer, 401,
1665                                      &rc);
1666     assert(rc == MEMCACHED_SUCCESS);
1667     assert(x == memcached_server_list_count(servers));
1668   }
1669
1670   rc= memcached_server_push(memc, servers);
1671   assert(rc == MEMCACHED_SUCCESS);
1672   rc= memcached_server_push(memc, servers);
1673   assert(rc == MEMCACHED_SUCCESS);
1674
1675   memcached_server_list_free(servers);
1676
1677   return 0;
1678 }
1679
1680 memcached_return pre_nonblock(memcached_st *memc)
1681 {
1682   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1683
1684   return MEMCACHED_SUCCESS;
1685 }
1686
1687 memcached_return pre_md5(memcached_st *memc)
1688 {
1689   memcached_hash value= MEMCACHED_HASH_MD5;
1690   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1691
1692   return MEMCACHED_SUCCESS;
1693 }
1694
1695 memcached_return pre_crc(memcached_st *memc)
1696 {
1697   memcached_hash value= MEMCACHED_HASH_CRC;
1698   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1699
1700   return MEMCACHED_SUCCESS;
1701 }
1702
1703 memcached_return pre_hsieh(memcached_st *memc)
1704 {
1705   memcached_hash value= MEMCACHED_HASH_HSIEH;
1706   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1707
1708   return MEMCACHED_SUCCESS;
1709 }
1710
1711 memcached_return pre_hash_fnv1_64(memcached_st *memc)
1712 {
1713   memcached_hash value= MEMCACHED_HASH_FNV1_64;
1714   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1715
1716   return MEMCACHED_SUCCESS;
1717 }
1718
1719 memcached_return pre_hash_fnv1a_64(memcached_st *memc)
1720 {
1721   memcached_hash value= MEMCACHED_HASH_FNV1A_64;
1722   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1723
1724   return MEMCACHED_SUCCESS;
1725 }
1726
1727 memcached_return pre_hash_fnv1_32(memcached_st *memc)
1728 {
1729   memcached_hash value= MEMCACHED_HASH_FNV1_32;
1730   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1731
1732   return MEMCACHED_SUCCESS;
1733 }
1734
1735 memcached_return pre_hash_fnv1a_32(memcached_st *memc)
1736 {
1737   memcached_hash value= MEMCACHED_HASH_FNV1A_32;
1738   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1739
1740   return MEMCACHED_SUCCESS;
1741 }
1742
1743 memcached_return pre_hash_ketama(memcached_st *memc)
1744 {
1745   memcached_hash value= MEMCACHED_HASH_KETAMA;
1746   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1747
1748   return MEMCACHED_SUCCESS;
1749 }
1750
1751 memcached_return enable_consistent(memcached_st *memc)
1752 {
1753   memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;
1754   memcached_hash hash;
1755   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, &value);
1756   pre_hsieh(memc);
1757
1758   value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
1759   assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
1760
1761   hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1762   assert(hash == MEMCACHED_HASH_HSIEH);
1763
1764
1765   return MEMCACHED_SUCCESS;
1766 }
1767
1768 memcached_return enable_cas(memcached_st *memc)
1769 {
1770   unsigned int set= 1;
1771
1772   memcached_version(memc);
1773
1774   if (memc->hosts[0].major_version >= 1 &&
1775       memc->hosts[0].minor_version >= 2 &&
1776       memc->hosts[0].micro_version >= 4)
1777   {
1778     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
1779
1780     return MEMCACHED_SUCCESS;
1781   }
1782
1783   return MEMCACHED_FAILURE;
1784 }
1785
1786 memcached_return check_for_1_2_3(memcached_st *memc)
1787 {
1788   memcached_version(memc);
1789
1790   if (memc->hosts[0].major_version >= 1 &&
1791       memc->hosts[0].minor_version >= 2 &&
1792       memc->hosts[0].micro_version >= 4)
1793     return MEMCACHED_SUCCESS;
1794
1795   return MEMCACHED_FAILURE;
1796 }
1797
1798 memcached_return pre_unix_socket(memcached_st *memc)
1799 {
1800   memcached_return rc;
1801   struct stat buf;
1802
1803   memcached_server_list_free(memc->hosts);
1804   memc->hosts= NULL;
1805   memc->number_of_hosts= 0;
1806
1807   if (stat("/tmp/memcached.socket", &buf))
1808     return MEMCACHED_FAILURE;
1809
1810   rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");
1811
1812   return rc;
1813 }
1814
1815 memcached_return pre_udp(memcached_st *memc)
1816 {
1817   memcached_return rc;
1818
1819   memcached_server_list_free(memc->hosts);
1820   memc->hosts= NULL;
1821   memc->number_of_hosts= 0;
1822
1823   if (0)
1824     return MEMCACHED_FAILURE;
1825
1826   rc= memcached_server_add_udp(memc, "localhost", MEMCACHED_DEFAULT_PORT);
1827
1828   return rc;
1829 }
1830
1831 memcached_return pre_nodelay(memcached_st *memc)
1832 {
1833   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1834   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
1835
1836   return MEMCACHED_SUCCESS;
1837 }
1838
1839 memcached_return poll_timeout(memcached_st *memc)
1840 {
1841   int32_t timeout;
1842
1843   timeout= 100;
1844
1845   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
1846
1847   timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
1848
1849   assert(timeout == 100);
1850
1851   return MEMCACHED_SUCCESS;
1852 }
1853
1854
1855 /* Clean the server before beginning testing */
1856 test_st tests[] ={
1857   {"flush", 0, flush_test },
1858   {"init", 0, init_test },
1859   {"allocation", 0, allocation_test },
1860   {"clone_test", 0, clone_test },
1861   {"error", 0, error_test },
1862   {"set", 0, set_test },
1863   {"set2", 0, set_test2 },
1864   {"set3", 0, set_test3 },
1865   {"add", 1, add_test },
1866   {"replace", 0, replace_test },
1867   {"delete", 1, delete_test },
1868   {"get", 1, get_test },
1869   {"get2", 0, get_test2 },
1870   {"get3", 0, get_test3 },
1871   {"get4", 0, get_test4 },
1872   {"stats_servername", 0, stats_servername_test },
1873   {"increment", 0, increment_test },
1874   {"decrement", 0, decrement_test },
1875   {"quit", 0, quit_test },
1876   {"mget", 1, mget_test },
1877   {"mget_result", 1, mget_result_test },
1878   {"mget_result_alloc", 1, mget_result_alloc_test },
1879   {"get_stats", 0, get_stats },
1880   {"add_host_test", 0, add_host_test },
1881   {"get_stats_keys", 0, get_stats_keys },
1882   {"behavior_test", 0, get_stats_keys },
1883   {0, 0, 0}
1884 };
1885
1886 test_st string_tests[] ={
1887   {"string static with null", 0, string_static_null },
1888   {"string alloc with null", 0, string_alloc_null },
1889   {"string alloc with 1K", 0, string_alloc_with_size },
1890   {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
1891   {"string append", 0, string_alloc_append },
1892   {"string append failure (too big)", 0, string_alloc_append_toobig },
1893   {0, 0, 0}
1894 };
1895
1896 test_st result_tests[] ={
1897   {"result static", 0, result_static},
1898   {"result alloc", 0, result_alloc},
1899   {0, 0, 0}
1900 };
1901
1902 test_st version_1_2_3[] ={
1903   {"append", 0, append_test },
1904   {"prepend", 0, prepend_test },
1905   {"cas", 0, cas_test },
1906   {"cas2", 0, cas2_test },
1907   {"append_binary", 0, append_binary_test },
1908   {0, 0, 0}
1909 };
1910
1911 test_st user_tests[] ={
1912   {"user_supplied_bug1", 0, user_supplied_bug1 },
1913   {"user_supplied_bug2", 0, user_supplied_bug2 },
1914   {"user_supplied_bug3", 0, user_supplied_bug3 },
1915   {"user_supplied_bug4", 0, user_supplied_bug4 },
1916   {"user_supplied_bug5", 1, user_supplied_bug5 },
1917   {"user_supplied_bug6", 1, user_supplied_bug6 },
1918   {"user_supplied_bug7", 1, user_supplied_bug7 },
1919   {"user_supplied_bug8", 1, user_supplied_bug8 },
1920   {"user_supplied_bug9", 1, user_supplied_bug9 },
1921   {"user_supplied_bug10", 1, user_supplied_bug10 },
1922   {0, 0, 0}
1923 };
1924
1925 test_st generate_tests[] ={
1926   {"generate_data", 0, generate_data },
1927   {"get_read", 0, get_read },
1928   {"mget_read", 0, mget_read },
1929   {"mget_read_result", 0, mget_read_result },
1930   {"cleanup", 0, cleanup_pairs },
1931   {0, 0, 0}
1932 };
1933
1934
1935 collection_st collection[] ={
1936   {"block", 0, 0, tests},
1937   {"nonblock", pre_nonblock, 0, tests},
1938   {"nodelay", pre_nodelay, 0, tests},
1939   {"md5", pre_md5, 0, tests},
1940   {"crc", pre_crc, 0, tests},
1941   {"hsieh", pre_hsieh, 0, tests},
1942   {"fnv1_64", pre_hash_fnv1_64, 0, tests},
1943   {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
1944   {"fnv1_32", pre_hash_fnv1_32, 0, tests},
1945   {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
1946   {"ketama", pre_hash_ketama, 0, tests},
1947   {"unix_socket", pre_unix_socket, 0, tests},
1948   {"unix_socket_nodelay", pre_nodelay, 0, tests},
1949   {"poll_timeout", poll_timeout, 0, tests},
1950   {"gets", enable_cas, 0, tests},
1951   {"consistent", enable_consistent, 0, tests},
1952 //  {"udp", pre_udp, 0, tests},
1953   {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
1954   {"string", 0, 0, string_tests},
1955   {"result", 0, 0, result_tests},
1956   {"user", 0, 0, user_tests},
1957   {"generate", 0, 0, generate_tests},
1958   {"generate_hsieh", pre_hsieh, 0, generate_tests},
1959   {"generate_hsieh_consistent", enable_consistent, 0, generate_tests},
1960   {"generate_md5", pre_md5, 0, generate_tests},
1961   {"generate_nonblock", pre_nonblock, 0, generate_tests},
1962   {0, 0, 0, 0}
1963 };
1964
1965 collection_st *gets_collections(void)
1966 {
1967   return collection;
1968 }