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

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