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