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