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

   1 /*
   2   Sample test application.
   3 */
   4 #include <assert.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <sys/time.h>
   9 #include <sys/types.h>
  10 #include <sys/stat.h>
  11 #include <unistd.h>
  12 #include <time.h>
  13 #include "server.h"
  14 #include "../clients/generator.h"
  15 #include "../clients/execute.h"
  16
  17 #ifndef INT64_MAX
  18 #define INT64_MAX LONG_MAX
  19 #endif
  20 #ifndef INT32_MAX
  21 #define INT32_MAX INT_MAX
  22 #endif
  23
  24
  25 #include "test.h"
  26
  27 #define GLOBAL_COUNT 100000
  28 #define GLOBAL2_COUNT 1000
  29 static uint32_t global_count;
  30
  31 static pairs_st *global_pairs;
  32 static char *global_keys[GLOBAL_COUNT];
  33 static size_t global_keys_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 server_sort_test(memcached_st *ptr)
  63 {
  64   memcached_server_st *server_list;
  65   memcached_return rc;
  66
  67   memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
  68
  69   server_list= memcached_server_list_append(NULL, "arg", 0, &rc);
  70   assert(server_list);
  71
  72   server_list= memcached_server_list_append(server_list, "localhost", 0, &rc);
  73   assert(server_list);
  74
  75   server_list= memcached_server_list_append(server_list, "c", 0, &rc);
  76   assert(server_list);
  77
  78   server_list= memcached_server_list_append(server_list, "abba", 0, &rc);
  79   assert(server_list);
  80
  81   free(server_list);
  82
  83   return 0;
  84 }
  85
  86 uint8_t allocation_test(memcached_st *not_used)
  87 {
  88   memcached_st *memc;
  89   memc= memcached_create(NULL);
  90   assert(memc);
  91   memcached_free(memc);
  92
  93   return 0;
  94 }
  95
  96 uint8_t clone_test(memcached_st *memc)
  97 {
  98   /* All null? */
  99   {
 100     memcached_st *clone;
 101     clone= memcached_clone(NULL, NULL);
 102     assert(clone);
 103     memcached_free(clone);
 104   }
 105
 106   /* Can we init from null? */
 107   {
 108     memcached_st *clone;
 109     clone= memcached_clone(NULL, memc);
 110     assert(clone);
 111     memcached_free(clone);
 112   }
 113
 114   /* Can we init from struct? */
 115   {
 116     memcached_st declared_clone;
 117     memcached_st *clone;
 118     clone= memcached_clone(&declared_clone, NULL);
 119     assert(clone);
 120     memcached_free(clone);
 121   }
 122
 123   /* Can we init from struct? */
 124   {
 125     memcached_st declared_clone;
 126     memcached_st *clone;
 127     clone= memcached_clone(&declared_clone, memc);
 128     assert(clone);
 129     memcached_free(clone);
 130   }
 131
 132   return 0;
 133 }
 134
 135 uint8_t connection_test(memcached_st *memc)
 136 {
 137   memcached_return rc;
 138
 139   rc= memcached_server_add(memc, "localhost", 0);
 140   assert(rc == MEMCACHED_SUCCESS);
 141
 142   return 0;
 143 }
 144
 145 uint8_t error_test(memcached_st *memc)
 146 {
 147   memcached_return rc;
 148
 149   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
 150   {
 151     printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
 152   }
 153
 154   return 0;
 155 }
 156
 157 uint8_t set_test(memcached_st *memc)
 158 {
 159   memcached_return rc;
 160   char *key= "foo";
 161   char *value= "when we sanitize";
 162
 163   rc= memcached_set(memc, key, strlen(key),
 164                     value, strlen(value),
 165                     (time_t)0, (uint32_t)0);
 166   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 167
 168   return 0;
 169 }
 170
 171 uint8_t append_test(memcached_st *memc)
 172 {
 173   memcached_return rc;
 174   char *key= "fig";
 175   char *value= "we";
 176   size_t value_length;
 177   uint32_t flags;
 178
 179   rc= memcached_flush(memc, 0);
 180   assert(rc == MEMCACHED_SUCCESS);
 181
 182   rc= memcached_set(memc, key, strlen(key),
 183                     value, strlen(value),
 184                     (time_t)0, (uint32_t)0);
 185   assert(rc == MEMCACHED_SUCCESS);
 186
 187   rc= memcached_append(memc, key, strlen(key),
 188                        " the", strlen(" the"),
 189                        (time_t)0, (uint32_t)0);
 190   assert(rc == MEMCACHED_SUCCESS);
 191
 192   rc= memcached_append(memc, key, strlen(key),
 193                        " people", strlen(" people"),
 194                        (time_t)0, (uint32_t)0);
 195   assert(rc == MEMCACHED_SUCCESS);
 196
 197   value= memcached_get(memc, key, strlen(key),
 198                        &value_length, &flags, &rc);
 199   assert(!memcmp(value, "we the people", strlen("we the people")));
 200   assert(strlen("we the people") == value_length);
 201   assert(rc == MEMCACHED_SUCCESS);
 202   free(value);
 203
 204   return 0;
 205 }
 206
 207 uint8_t append_binary_test(memcached_st *memc)
 208 {
 209   memcached_return rc;
 210   char *key= "numbers";
 211   unsigned int *store_ptr;
 212   unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
 213   char *value;
 214   size_t value_length;
 215   uint32_t flags;
 216   unsigned int x;
 217
 218   rc= memcached_flush(memc, 0);
 219   assert(rc == MEMCACHED_SUCCESS);
 220
 221   rc= memcached_set(memc,
 222                     key, strlen(key),
 223                     NULL, 0,
 224                     (time_t)0, (uint32_t)0);
 225   assert(rc == MEMCACHED_SUCCESS);
 226
 227   for (x= 0; store_list[x] ; x++)
 228   {
 229     rc= memcached_append(memc,
 230                          key, strlen(key),
 231                          (char *)&store_list[x], sizeof(unsigned int),
 232                          (time_t)0, (uint32_t)0);
 233     assert(rc == MEMCACHED_SUCCESS);
 234   }
 235
 236   value= memcached_get(memc, key, strlen(key),
 237                        &value_length, &flags, &rc);
 238   assert((value_length == (sizeof(unsigned int) * x)));
 239   assert(rc == MEMCACHED_SUCCESS);
 240
 241   store_ptr= (unsigned int *)value;
 242   x= 0;
 243   while ((size_t)store_ptr < (size_t)(value + value_length))
 244   {
 245     assert(*store_ptr == store_list[x++]);
 246     store_ptr++;
 247   }
 248   free(value);
 249
 250   return 0;
 251 }
 252
 253 uint8_t cas2_test(memcached_st *memc)
 254 {
 255   memcached_return rc;
 256   char *keys[]= {"fudge", "son", "food"};
 257   size_t key_length[]= {5, 3, 4};
 258   char *value= "we the people";
 259   size_t value_length= strlen("we the people");
 260   unsigned int x;
 261   memcached_result_st results_obj;
 262   memcached_result_st *results;
 263   unsigned int set= 1;
 264
 265   rc= memcached_flush(memc, 0);
 266   assert(rc == MEMCACHED_SUCCESS);
 267
 268   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
 269
 270   for (x= 0; x < 3; x++)
 271   {
 272     rc= memcached_set(memc, keys[x], key_length[x],
 273                       keys[x], key_length[x],
 274                       (time_t)50, (uint32_t)9);
 275     assert(rc == MEMCACHED_SUCCESS);
 276   }
 277
 278   rc= memcached_mget(memc, keys, key_length, 3);
 279
 280   results= memcached_result_create(memc, &results_obj);
 281
 282   results= memcached_fetch_result(memc, &results_obj, &rc);
 283   assert(results);
 284   assert(results->cas);
 285   assert(rc == MEMCACHED_SUCCESS);
 286   WATCHPOINT_ASSERT(memcached_result_cas(results));
 287
 288   assert(!memcmp(value, "we the people", strlen("we the people")));
 289   assert(strlen("we the people") == value_length);
 290   assert(rc == MEMCACHED_SUCCESS);
 291
 292   memcached_result_free(&results_obj);
 293
 294   return 0;
 295 }
 296
 297 uint8_t cas_test(memcached_st *memc)
 298 {
 299   memcached_return rc;
 300   char *key= "fun";
 301   size_t key_length= strlen("fun");
 302   char *value= "we the people";
 303   size_t value_length= strlen("we the people");
 304   memcached_result_st results_obj;
 305   memcached_result_st *results;
 306   unsigned int set= 1;
 307
 308   rc= memcached_flush(memc, 0);
 309   assert(rc == MEMCACHED_SUCCESS);
 310
 311   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
 312
 313   rc= memcached_set(memc, key, strlen(key),
 314                     value, strlen(value),
 315                     (time_t)0, (uint32_t)0);
 316   assert(rc == MEMCACHED_SUCCESS);
 317
 318   rc= memcached_mget(memc, &key, &key_length, 1);
 319
 320   results= memcached_result_create(memc, &results_obj);
 321
 322   results= memcached_fetch_result(memc, &results_obj, &rc);
 323   assert(results);
 324   assert(rc == MEMCACHED_SUCCESS);
 325   WATCHPOINT_ASSERT(memcached_result_cas(results));
 326
 327   assert(!memcmp(value, "we the people", strlen("we the people")));
 328   assert(strlen("we the people") == value_length);
 329   assert(rc == MEMCACHED_SUCCESS);
 330
 331   rc= memcached_cas(memc, key, key_length,
 332                     "change the value", strlen("change the value"),
 333                     0, 0, memcached_result_cas(results));
 334
 335   assert(rc == MEMCACHED_SUCCESS);
 336
 337   rc= memcached_cas(memc, key, key_length,
 338                     "change the value", strlen("change the value"),
 339                     0, 0, 23);
 340
 341   assert(rc == MEMCACHED_DATA_EXISTS);
 342
 343
 344   memcached_result_free(&results_obj);
 345
 346   return 0;
 347 }
 348
 349 uint8_t prepend_test(memcached_st *memc)
 350 {
 351   memcached_return rc;
 352   char *key= "fig";
 353   char *value= "people";
 354   size_t value_length;
 355   uint32_t flags;
 356
 357   rc= memcached_flush(memc, 0);
 358   assert(rc == MEMCACHED_SUCCESS);
 359
 360   rc= memcached_set(memc, key, strlen(key),
 361                     value, strlen(value),
 362                     (time_t)0, (uint32_t)0);
 363   assert(rc == MEMCACHED_SUCCESS);
 364
 365   rc= memcached_prepend(memc, key, strlen(key),
 366                        "the ", strlen("the "),
 367                        (time_t)0, (uint32_t)0);
 368   assert(rc == MEMCACHED_SUCCESS);
 369
 370   rc= memcached_prepend(memc, key, strlen(key),
 371                        "we ", strlen("we "),
 372                        (time_t)0, (uint32_t)0);
 373   assert(rc == MEMCACHED_SUCCESS);
 374
 375   value= memcached_get(memc, key, strlen(key),
 376                        &value_length, &flags, &rc);
 377   assert(!memcmp(value, "we the people", strlen("we the people")));
 378   assert(strlen("we the people") == value_length);
 379   assert(rc == MEMCACHED_SUCCESS);
 380   free(value);
 381
 382   return 0;
 383 }
 384
 385 /*
 386   Set the value, then quit to make sure it is flushed.
 387   Come back in and test that add fails.
 388 */
 389 uint8_t add_test(memcached_st *memc)
 390 {
 391   memcached_return rc;
 392   char *key= "foo";
 393   char *value= "when we sanitize";
 394   unsigned long long setting_value;
 395
 396   setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 397
 398   rc= memcached_set(memc, key, strlen(key),
 399                     value, strlen(value),
 400                     (time_t)0, (uint32_t)0);
 401   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 402   memcached_quit(memc);
 403   rc= memcached_add(memc, key, strlen(key),
 404                     value, strlen(value),
 405                     (time_t)0, (uint32_t)0);
 406
 407   /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
 408   if (setting_value)
 409     assert(rc == MEMCACHED_NOTSTORED || MEMCACHED_STORED);
 410   else
 411     assert(rc == MEMCACHED_NOTSTORED);
 412
 413   return 0;
 414 }
 415
 416 uint8_t add_wrapper(memcached_st *memc)
 417 {
 418   unsigned int x;
 419
 420   for (x= 0; x < 10000; x++)
 421     add_test(memc);
 422
 423   return 0;
 424 }
 425
 426 uint8_t replace_test(memcached_st *memc)
 427 {
 428   memcached_return rc;
 429   char *key= "foo";
 430   char *value= "when we sanitize";
 431   char *original= "first we insert some data";
 432
 433   rc= memcached_set(memc, key, strlen(key),
 434                     original, strlen(original),
 435                     (time_t)0, (uint32_t)0);
 436   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 437
 438   rc= memcached_replace(memc, key, strlen(key),
 439                     value, strlen(value),
 440                     (time_t)0, (uint32_t)0);
 441   assert(rc == MEMCACHED_SUCCESS);
 442
 443   return 0;
 444 }
 445
 446 uint8_t delete_test(memcached_st *memc)
 447 {
 448   memcached_return rc;
 449   char *key= "foo";
 450   char *value= "when we sanitize";
 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 || rc == MEMCACHED_BUFFERED);
 456
 457   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 458   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 459
 460   return 0;
 461 }
 462
 463 uint8_t flush_test(memcached_st *memc)
 464 {
 465   memcached_return rc;
 466
 467   rc= memcached_flush(memc, 0);
 468   assert(rc == MEMCACHED_SUCCESS);
 469
 470   return 0;
 471 }
 472
 473 memcached_return server_function(memcached_st *ptr, memcached_server_st *server, void *context)
 474 {
 475   /* Do Nothing */
 476
 477   return MEMCACHED_SUCCESS;
 478 }
 479
 480 uint8_t memcached_server_cursor_test(memcached_st *memc)
 481 {
 482   char *context= "foo bad";
 483   memcached_server_function callbacks[1];
 484
 485   callbacks[0]= server_function;
 486   memcached_server_cursor(memc, callbacks, context,  1);
 487
 488   return 0;
 489 }
 490
 491 uint8_t bad_key_test(memcached_st *memc)
 492 {
 493   memcached_return rc;
 494   char *key= "foo bad";
 495   char *string;
 496   size_t string_length;
 497   uint32_t flags;
 498   memcached_st *clone;
 499   unsigned int set= 1;
 500
 501   clone= memcached_clone(NULL, memc);
 502   assert(clone);
 503
 504   (void)memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 505
 506   string= memcached_get(clone, key, strlen(key),
 507                         &string_length, &flags, &rc);
 508   assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 509   assert(string_length ==  0);
 510   assert(!string);
 511
 512   set= 0;
 513   (void)memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 514   string= memcached_get(clone, key, strlen(key),
 515                         &string_length, &flags, &rc);
 516   assert(rc == MEMCACHED_NOTFOUND);
 517   assert(string_length ==  0);
 518   assert(!string);
 519
 520   memcached_free(clone);
 521
 522   return 0;
 523 }
 524
 525 #define READ_THROUGH_VALUE "set for me"
 526 memcached_return read_through_trigger(memcached_st *memc,
 527                                       char *key, size_t key_length,
 528                                       memcached_result_st *result)
 529 {
 530
 531   return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
 532 }
 533
 534 uint8_t read_through(memcached_st *memc)
 535 {
 536   memcached_return rc;
 537   char *key= "foo";
 538   char *string;
 539   size_t string_length;
 540   uint32_t flags;
 541
 542   string= memcached_get(memc, key, strlen(key),
 543                         &string_length, &flags, &rc);
 544
 545   assert(rc == MEMCACHED_NOTFOUND);
 546   assert(string_length ==  0);
 547   assert(!string);
 548
 549   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, read_through_trigger);
 550   assert(rc == MEMCACHED_SUCCESS);
 551
 552   string= memcached_get(memc, key, strlen(key),
 553                         &string_length, &flags, &rc);
 554
 555   assert(rc == MEMCACHED_SUCCESS);
 556   assert(string_length ==  strlen(READ_THROUGH_VALUE));
 557   assert(!strcmp(READ_THROUGH_VALUE, string));
 558
 559   string= memcached_get(memc, key, strlen(key),
 560                         &string_length, &flags, &rc);
 561
 562   assert(rc == MEMCACHED_SUCCESS);
 563   assert(string_length ==  strlen(READ_THROUGH_VALUE));
 564   assert(!strcmp(READ_THROUGH_VALUE, string));
 565
 566   return 0;
 567 }
 568
 569 uint8_t get_test(memcached_st *memc)
 570 {
 571   memcached_return rc;
 572   char *key= "foo";
 573   char *string;
 574   size_t string_length;
 575   uint32_t flags;
 576
 577   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 578   assert(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);
 579
 580   string= memcached_get(memc, key, strlen(key),
 581                         &string_length, &flags, &rc);
 582
 583   assert(rc == MEMCACHED_NOTFOUND);
 584   assert(string_length ==  0);
 585   assert(!string);
 586
 587   return 0;
 588 }
 589
 590 uint8_t get_test2(memcached_st *memc)
 591 {
 592   memcached_return rc;
 593   char *key= "foo";
 594   char *value= "when we sanitize";
 595   char *string;
 596   size_t string_length;
 597   uint32_t flags;
 598
 599   rc= memcached_set(memc, key, strlen(key),
 600                     value, strlen(value),
 601                     (time_t)0, (uint32_t)0);
 602   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 603
 604   string= memcached_get(memc, key, strlen(key),
 605                         &string_length, &flags, &rc);
 606
 607   assert(string);
 608   assert(rc == MEMCACHED_SUCCESS);
 609   assert(string_length == strlen(value));
 610   assert(!memcmp(string, value, string_length));
 611
 612   free(string);
 613
 614   return 0;
 615 }
 616
 617 uint8_t set_test2(memcached_st *memc)
 618 {
 619   memcached_return rc;
 620   char *key= "foo";
 621   char *value= "train in the brain";
 622   size_t value_length= strlen(value);
 623   unsigned int x;
 624
 625   for (x= 0; x < 10; x++)
 626   {
 627     rc= memcached_set(memc, key, strlen(key),
 628                       value, value_length,
 629                       (time_t)0, (uint32_t)0);
 630     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 631   }
 632
 633   return 0;
 634 }
 635
 636 uint8_t set_test3(memcached_st *memc)
 637 {
 638   memcached_return rc;
 639   char *key= "foo";
 640   char *value;
 641   size_t value_length= 8191;
 642   unsigned int x;
 643
 644   value = (char*)malloc(value_length);
 645   assert(value);
 646
 647   for (x= 0; x < value_length; x++)
 648     value[x] = (char) (x % 127);
 649
 650   for (x= 0; x < 1; x++)
 651   {
 652     rc= memcached_set(memc, key, strlen(key),
 653                       value, value_length,
 654                       (time_t)0, (uint32_t)0);
 655     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 656   }
 657
 658   free(value);
 659
 660   return 0;
 661 }
 662
 663 uint8_t get_test3(memcached_st *memc)
 664 {
 665   memcached_return rc;
 666   char *key= "foo";
 667   char *value;
 668   size_t value_length= 8191;
 669   char *string;
 670   size_t string_length;
 671   uint32_t flags;
 672   int x;
 673
 674   value = (char*)malloc(value_length);
 675   assert(value);
 676
 677   for (x= 0; x < value_length; x++)
 678     value[x] = (char) (x % 127);
 679
 680   rc= memcached_set(memc, key, strlen(key),
 681                     value, value_length,
 682                     (time_t)0, (uint32_t)0);
 683   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 684
 685   string= memcached_get(memc, key, strlen(key),
 686                         &string_length, &flags, &rc);
 687
 688   assert(rc == MEMCACHED_SUCCESS);
 689   assert(string);
 690   assert(string_length == value_length);
 691   assert(!memcmp(string, value, string_length));
 692
 693   free(string);
 694   free(value);
 695
 696   return 0;
 697 }
 698
 699 uint8_t get_test4(memcached_st *memc)
 700 {
 701   memcached_return rc;
 702   char *key= "foo";
 703   char *value;
 704   size_t value_length= 8191;
 705   char *string;
 706   size_t string_length;
 707   uint32_t flags;
 708   int x;
 709
 710   value = (char*)malloc(value_length);
 711   assert(value);
 712
 713   for (x= 0; x < value_length; x++)
 714     value[x] = (char) (x % 127);
 715
 716   rc= memcached_set(memc, key, strlen(key),
 717                     value, value_length,
 718                     (time_t)0, (uint32_t)0);
 719   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 720
 721   for (x= 0; x < 10; x++)
 722   {
 723     string= memcached_get(memc, key, strlen(key),
 724                           &string_length, &flags, &rc);
 725
 726     assert(rc == MEMCACHED_SUCCESS);
 727     assert(string);
 728     assert(string_length == value_length);
 729     assert(!memcmp(string, value, string_length));
 730     free(string);
 731   }
 732
 733   free(value);
 734
 735   return 0;
 736 }
 737
 738 /* Do not copy the style of this code, I just access hosts to testthis function */
 739 uint8_t stats_servername_test(memcached_st *memc)
 740 {
 741   memcached_return rc;
 742   memcached_stat_st stat;
 743   rc= memcached_stat_servername(&stat, NULL,
 744                                  memc->hosts[0].hostname,
 745                                  memc->hosts[0].port);
 746
 747   return 0;
 748 }
 749
 750 uint8_t increment_test(memcached_st *memc)
 751 {
 752   uint64_t new_number;
 753   memcached_return rc;
 754   char *key= "number";
 755   char *value= "0";
 756
 757   rc= memcached_set(memc, key, strlen(key),
 758                     value, strlen(value),
 759                     (time_t)0, (uint32_t)0);
 760   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 761
 762   rc= memcached_increment(memc, key, strlen(key),
 763                           1, &new_number);
 764   assert(rc == MEMCACHED_SUCCESS);
 765   assert(new_number == 1);
 766
 767   rc= memcached_increment(memc, key, strlen(key),
 768                           1, &new_number);
 769   assert(rc == MEMCACHED_SUCCESS);
 770   assert(new_number == 2);
 771
 772   return 0;
 773 }
 774
 775 uint8_t decrement_test(memcached_st *memc)
 776 {
 777   uint64_t new_number;
 778   memcached_return rc;
 779   char *key= "number";
 780   char *value= "3";
 781
 782   rc= memcached_set(memc, key, strlen(key),
 783                     value, strlen(value),
 784                     (time_t)0, (uint32_t)0);
 785   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 786
 787   rc= memcached_decrement(memc, key, strlen(key),
 788                           1, &new_number);
 789   assert(rc == MEMCACHED_SUCCESS);
 790   assert(new_number == 2);
 791
 792   rc= memcached_decrement(memc, key, strlen(key),
 793                           1, &new_number);
 794   assert(rc == MEMCACHED_SUCCESS);
 795   assert(new_number == 1);
 796
 797   return 0;
 798 }
 799
 800 uint8_t quit_test(memcached_st *memc)
 801 {
 802   memcached_return rc;
 803   char *key= "fudge";
 804   char *value= "sanford and sun";
 805
 806   rc= memcached_set(memc, key, strlen(key),
 807                     value, strlen(value),
 808                     (time_t)10, (uint32_t)3);
 809   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 810   memcached_quit(memc);
 811
 812   rc= memcached_set(memc, key, strlen(key),
 813                     value, strlen(value),
 814                     (time_t)50, (uint32_t)9);
 815   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 816
 817   return 0;
 818 }
 819
 820 uint8_t mget_result_test(memcached_st *memc)
 821 {
 822   memcached_return rc;
 823   char *keys[]= {"fudge", "son", "food"};
 824   size_t key_length[]= {5, 3, 4};
 825   unsigned int x;
 826
 827   memcached_result_st results_obj;
 828   memcached_result_st *results;
 829
 830   results= memcached_result_create(memc, &results_obj);
 831   assert(results);
 832   assert(&results_obj == results);
 833
 834   /* We need to empty the server before continueing test */
 835   rc= memcached_flush(memc, 0);
 836   assert(rc == MEMCACHED_SUCCESS);
 837
 838   rc= memcached_mget(memc, keys, key_length, 3);
 839   assert(rc == MEMCACHED_SUCCESS);
 840
 841   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 842   {
 843     assert(results);
 844   }
 845
 846   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 847   assert(!results);
 848   assert(rc == MEMCACHED_END);
 849
 850   for (x= 0; x < 3; x++)
 851   {
 852     rc= memcached_set(memc, keys[x], key_length[x],
 853                       keys[x], key_length[x],
 854                       (time_t)50, (uint32_t)9);
 855     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 856   }
 857
 858   rc= memcached_mget(memc, keys, key_length, 3);
 859   assert(rc == MEMCACHED_SUCCESS);
 860
 861   while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
 862   {
 863     assert(results);
 864     assert(&results_obj == results);
 865     assert(rc == MEMCACHED_SUCCESS);
 866     assert(memcached_result_key_length(results) == memcached_result_length(results));
 867     assert(!memcmp(memcached_result_key_value(results),
 868                    memcached_result_value(results),
 869                    memcached_result_length(results)));
 870   }
 871
 872   memcached_result_free(&results_obj);
 873
 874   return 0;
 875 }
 876
 877 uint8_t mget_result_alloc_test(memcached_st *memc)
 878 {
 879   memcached_return rc;
 880   char *keys[]= {"fudge", "son", "food"};
 881   size_t key_length[]= {5, 3, 4};
 882   unsigned int x;
 883
 884   memcached_result_st *results;
 885
 886   /* We need to empty the server before continueing test */
 887   rc= memcached_flush(memc, 0);
 888   assert(rc == MEMCACHED_SUCCESS);
 889
 890   rc= memcached_mget(memc, keys, key_length, 3);
 891   assert(rc == MEMCACHED_SUCCESS);
 892
 893   while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
 894   {
 895     assert(results);
 896   }
 897   assert(!results);
 898   assert(rc == MEMCACHED_END);
 899
 900   for (x= 0; x < 3; x++)
 901   {
 902     rc= memcached_set(memc, keys[x], key_length[x],
 903                       keys[x], key_length[x],
 904                       (time_t)50, (uint32_t)9);
 905     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 906   }
 907
 908   rc= memcached_mget(memc, keys, key_length, 3);
 909   assert(rc == MEMCACHED_SUCCESS);
 910
 911   x= 0;
 912   while ((results= memcached_fetch_result(memc, NULL, &rc)))
 913   {
 914     assert(results);
 915     assert(rc == MEMCACHED_SUCCESS);
 916     assert(memcached_result_key_length(results) == memcached_result_length(results));
 917     assert(!memcmp(memcached_result_key_value(results),
 918                    memcached_result_value(results),
 919                    memcached_result_length(results)));
 920     memcached_result_free(results);
 921     x++;
 922   }
 923
 924   return 0;
 925 }
 926
 927 /* Count the results */
 928 unsigned int callback_counter(memcached_st *ptr, memcached_result_st *result, void *context)
 929 {
 930   unsigned int *counter= (unsigned int *)context;
 931
 932   *counter= *counter + 1;
 933
 934   return 0;
 935 }
 936
 937 uint8_t mget_result_function(memcached_st *memc)
 938 {
 939   memcached_return rc;
 940   char *keys[]= {"fudge", "son", "food"};
 941   size_t key_length[]= {5, 3, 4};
 942   unsigned int x;
 943   unsigned int counter;
 944   memcached_execute_function callbacks[1];
 945
 946   /* We need to empty the server before continueing test */
 947   rc= memcached_flush(memc, 0);
 948   for (x= 0; x < 3; x++)
 949   {
 950     rc= memcached_set(memc, keys[x], key_length[x],
 951                       keys[x], key_length[x],
 952                       (time_t)50, (uint32_t)9);
 953     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 954   }
 955
 956   rc= memcached_mget(memc, keys, key_length, 3);
 957   assert(rc == MEMCACHED_SUCCESS);
 958
 959   callbacks[0]= &callback_counter;
 960   counter= 0;
 961   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
 962
 963   assert(counter == 3);
 964
 965   return 0;
 966 }
 967
 968 uint8_t mget_test(memcached_st *memc)
 969 {
 970   memcached_return rc;
 971   char *keys[]= {"fudge", "son", "food"};
 972   size_t key_length[]= {5, 3, 4};
 973   unsigned int x;
 974   uint32_t flags;
 975
 976   char return_key[MEMCACHED_MAX_KEY];
 977   size_t return_key_length;
 978   char *return_value;
 979   size_t return_value_length;
 980
 981   /* We need to empty the server before continueing test */
 982   rc= memcached_flush(memc, 0);
 983   assert(rc == MEMCACHED_SUCCESS);
 984
 985   rc= memcached_mget(memc, keys, key_length, 3);
 986   assert(rc == MEMCACHED_SUCCESS);
 987
 988   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 989                       &return_value_length, &flags, &rc)) != NULL)
 990   {
 991     assert(return_value);
 992   }
 993   assert(!return_value);
 994   assert(return_value_length == 0);
 995   assert(rc == MEMCACHED_END);
 996
 997   for (x= 0; x < 3; x++)
 998   {
 999     rc= memcached_set(memc, keys[x], key_length[x],
1000                       keys[x], key_length[x],
1001                       (time_t)50, (uint32_t)9);
1002     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1003   }
1004
1005   rc= memcached_mget(memc, keys, key_length, 3);
1006   assert(rc == MEMCACHED_SUCCESS);
1007
1008   x= 0;
1009   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1010                                         &return_value_length, &flags, &rc)))
1011   {
1012     assert(return_value);
1013     assert(rc == MEMCACHED_SUCCESS);
1014     assert(return_key_length == return_value_length);
1015     assert(!memcmp(return_value, return_key, return_value_length));
1016     free(return_value);
1017     x++;
1018   }
1019
1020   return 0;
1021 }
1022
1023 uint8_t get_stats_keys(memcached_st *memc)
1024 {
1025  char **list;
1026  char **ptr;
1027  memcached_stat_st stat;
1028  memcached_return rc;
1029
1030  list= memcached_stat_get_keys(memc, &stat, &rc);
1031  assert(rc == MEMCACHED_SUCCESS);
1032  for (ptr= list; *ptr; ptr++)
1033    assert(*ptr);
1034  fflush(stdout);
1035
1036  free(list);
1037
1038  return 0;
1039 }
1040
1041 uint8_t version_string_test(memcached_st *memc)
1042 {
1043   const char *version_string;
1044
1045   version_string= memcached_lib_version();
1046
1047   assert(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING));
1048
1049   return 0;
1050 }
1051
1052 uint8_t get_stats(memcached_st *memc)
1053 {
1054  unsigned int x;
1055  char **list;
1056  char **ptr;
1057  memcached_return rc;
1058  memcached_stat_st *stat;
1059
1060  stat= memcached_stat(memc, NULL, &rc);
1061  assert(rc == MEMCACHED_SUCCESS);
1062
1063  assert(rc == MEMCACHED_SUCCESS);
1064  assert(stat);
1065
1066  for (x= 0; x < memcached_server_count(memc); x++)
1067  {
1068    list= memcached_stat_get_keys(memc, stat+x, &rc);
1069    assert(rc == MEMCACHED_SUCCESS);
1070    for (ptr= list; *ptr; ptr++);
1071
1072    free(list);
1073  }
1074
1075  memcached_stat_free(NULL, stat);
1076
1077   return 0;
1078 }
1079
1080 uint8_t add_host_test(memcached_st *memc)
1081 {
1082   unsigned int x;
1083   memcached_server_st *servers;
1084   memcached_return rc;
1085   char servername[]= "0.example.com";
1086
1087   servers= memcached_server_list_append(NULL, servername, 400, &rc);
1088   assert(servers);
1089   assert(1 == memcached_server_list_count(servers));
1090
1091   for (x= 2; x < 20; x++)
1092   {
1093     char buffer[SMALL_STRING_LEN];
1094
1095     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1096     servers= memcached_server_list_append(servers, buffer, 401,
1097                                      &rc);
1098     assert(rc == MEMCACHED_SUCCESS);
1099     assert(x == memcached_server_list_count(servers));
1100   }
1101
1102   rc= memcached_server_push(memc, servers);
1103   assert(rc == MEMCACHED_SUCCESS);
1104   rc= memcached_server_push(memc, servers);
1105   assert(rc == MEMCACHED_SUCCESS);
1106
1107   memcached_server_list_free(servers);
1108
1109   return 0;
1110 }
1111
1112 memcached_return clone_test_callback(memcached_st *parent, memcached_st *clone)
1113 {
1114   return MEMCACHED_SUCCESS;
1115 }
1116
1117 memcached_return cleanup_test_callback(memcached_st *ptr)
1118 {
1119   return MEMCACHED_SUCCESS;
1120 }
1121
1122 uint8_t callback_test(memcached_st *memc)
1123 {
1124   /* Test User Data */
1125   {
1126     int x= 5;
1127     int *test_ptr;
1128     memcached_return rc;
1129
1130     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x);
1131     assert(rc == MEMCACHED_SUCCESS);
1132     test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
1133     assert(*test_ptr == x);
1134   }
1135
1136   /* Test Clone Callback */
1137   {
1138     memcached_clone_func temp_function;
1139     memcached_return rc;
1140
1141     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, clone_test_callback);
1142     assert(rc == MEMCACHED_SUCCESS);
1143     temp_function= (memcached_clone_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1144     assert(temp_function == clone_test_callback);
1145   }
1146
1147   /* Test Cleanup Callback */
1148   {
1149     memcached_cleanup_func temp_function;
1150     memcached_return rc;
1151
1152     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, cleanup_test_callback);
1153     assert(rc == MEMCACHED_SUCCESS);
1154     temp_function= (memcached_cleanup_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1155     assert(temp_function == cleanup_test_callback);
1156   }
1157
1158   return 0;
1159 }
1160
1161 /* We don't test the behavior itself, we test the switches */
1162 uint8_t behavior_test(memcached_st *memc)
1163 {
1164   unsigned long long value;
1165   unsigned int set= 1;
1166
1167   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1168   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1169   assert(value == 1);
1170
1171   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1172   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1173   assert(value == 1);
1174
1175   set= MEMCACHED_HASH_MD5;
1176   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1177   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1178   assert(value == MEMCACHED_HASH_MD5);
1179
1180   set= 0;
1181
1182   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1183   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1184   assert(value == 0);
1185
1186   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1187   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1188   assert(value == 0);
1189
1190   set= MEMCACHED_HASH_DEFAULT;
1191   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1192   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1193   assert(value == MEMCACHED_HASH_DEFAULT);
1194
1195   set= MEMCACHED_HASH_CRC;
1196   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1197   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1198   assert(value == MEMCACHED_HASH_CRC);
1199
1200   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1201   assert(value > 0);
1202
1203   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1204   assert(value > 0);
1205
1206   return 0;
1207 }
1208
1209 /* Test case provided by Cal Haldenbrand */
1210 uint8_t user_supplied_bug1(memcached_st *memc)
1211 {
1212   unsigned int setter= 1;
1213   unsigned int x;
1214
1215   unsigned long long total= 0;
1216   int size= 0;
1217   char key[10];
1218   char randomstuff[6 * 1024];
1219   memcached_return rc;
1220
1221   memset(randomstuff, 0, 6 * 1024);
1222
1223   /* We just keep looking at the same values over and over */
1224   srandom(10);
1225
1226   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1227   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1228
1229
1230   /* add key */
1231   for (x= 0 ; total < 20 * 1024576 ; x++ )
1232   {
1233     unsigned int j= 0;
1234
1235     size= (rand() % ( 5 * 1024 ) ) + 400;
1236     memset(randomstuff, 0, 6 * 1024);
1237     assert(size < 6 * 1024); /* Being safe here */
1238
1239     for (j= 0 ; j < size ;j++)
1240       randomstuff[j] = (char) (rand() % 26) + 97;
1241
1242     total += size;
1243     sprintf(key, "%d", x);
1244     rc = memcached_set(memc, key, strlen(key),
1245                        randomstuff, strlen(randomstuff), 10, 0);
1246     /* If we fail, lets try again */
1247     if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
1248       rc = memcached_set(memc, key, strlen(key),
1249                          randomstuff, strlen(randomstuff), 10, 0);
1250     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1251   }
1252
1253   return 0;
1254 }
1255
1256 /* Test case provided by Cal Haldenbrand */
1257 uint8_t user_supplied_bug2(memcached_st *memc)
1258 {
1259   int errors;
1260   unsigned int setter;
1261   unsigned int x;
1262   unsigned long long total;
1263
1264   setter= 1;
1265   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1266   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1267 #ifdef NOT_YET
1268   setter = 20 * 1024576;
1269   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
1270   setter = 20 * 1024576;
1271   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
1272   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1273   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1274
1275   for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
1276 #endif
1277
1278   for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
1279   {
1280     memcached_return rc= MEMCACHED_SUCCESS;
1281     char buffer[SMALL_STRING_LEN];
1282     uint32_t flags= 0;
1283     size_t val_len= 0;
1284     char *getval;
1285
1286     memset(buffer, 0, SMALL_STRING_LEN);
1287
1288     snprintf(buffer, SMALL_STRING_LEN, "%u", x);
1289     getval= memcached_get(memc, buffer, strlen(buffer),
1290                            &val_len, &flags, &rc);
1291     if (rc != MEMCACHED_SUCCESS)
1292     {
1293       if (rc == MEMCACHED_NOTFOUND)
1294         errors++;
1295       else
1296       {
1297         WATCHPOINT_ERROR(rc);
1298         assert(0);
1299       }
1300
1301       continue;
1302     }
1303     total+= val_len;
1304     errors= 0;
1305     free(getval);
1306   }
1307
1308   return 0;
1309 }
1310
1311 /* Do a large mget() over all the keys we think exist */
1312 #define KEY_COUNT 3000 // * 1024576
1313 uint8_t user_supplied_bug3(memcached_st *memc)
1314 {
1315   memcached_return rc;
1316   unsigned int setter;
1317   unsigned int x;
1318   char **keys;
1319   size_t key_lengths[KEY_COUNT];
1320
1321   setter= 1;
1322   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1323   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1324 #ifdef NOT_YET
1325   setter = 20 * 1024576;
1326   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
1327   setter = 20 * 1024576;
1328   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
1329   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1330   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1331 #endif
1332
1333   keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
1334   assert(keys);
1335   memset(keys, 0, (sizeof(char *) * KEY_COUNT));
1336   for (x= 0; x < KEY_COUNT; x++)
1337   {
1338     char buffer[30];
1339
1340     snprintf(buffer, 30, "%u", x);
1341     keys[x]= strdup(buffer);
1342     key_lengths[x]= strlen(keys[x]);
1343   }
1344
1345   rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
1346   assert(rc == MEMCACHED_SUCCESS);
1347
1348   /* Turn this into a help function */
1349   {
1350     char return_key[MEMCACHED_MAX_KEY];
1351     size_t return_key_length;
1352     char *return_value;
1353     size_t return_value_length;
1354     uint32_t flags;
1355
1356     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1357                                           &return_value_length, &flags, &rc)))
1358     {
1359       assert(return_value);
1360       assert(rc == MEMCACHED_SUCCESS);
1361       free(return_value);
1362     }
1363   }
1364
1365   for (x= 0; x < KEY_COUNT; x++)
1366     free(keys[x]);
1367   free(keys);
1368
1369   return 0;
1370 }
1371
1372 /* Make sure we behave properly if server list has no values */
1373 uint8_t user_supplied_bug4(memcached_st *memc)
1374 {
1375   memcached_return rc;
1376   char *keys[]= {"fudge", "son", "food"};
1377   size_t key_length[]= {5, 3, 4};
1378   unsigned int x;
1379   uint32_t flags;
1380   char return_key[MEMCACHED_MAX_KEY];
1381   size_t return_key_length;
1382   char *return_value;
1383   size_t return_value_length;
1384
1385   /* Here we free everything before running a bunch of mget tests */
1386   {
1387     memcached_server_list_free(memc->hosts);
1388     memc->hosts= NULL;
1389     memc->number_of_hosts= 0;
1390   }
1391
1392
1393   /* We need to empty the server before continueing test */
1394   rc= memcached_flush(memc, 0);
1395   assert(rc == MEMCACHED_NO_SERVERS);
1396
1397   rc= memcached_mget(memc, keys, key_length, 3);
1398   assert(rc == MEMCACHED_NO_SERVERS);
1399
1400   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1401                       &return_value_length, &flags, &rc)) != NULL)
1402   {
1403     assert(return_value);
1404   }
1405   assert(!return_value);
1406   assert(return_value_length == 0);
1407   assert(rc == MEMCACHED_NO_SERVERS);
1408
1409   for (x= 0; x < 3; x++)
1410   {
1411     rc= memcached_set(memc, keys[x], key_length[x],
1412                       keys[x], key_length[x],
1413                       (time_t)50, (uint32_t)9);
1414     assert(rc == MEMCACHED_NO_SERVERS);
1415   }
1416
1417   rc= memcached_mget(memc, keys, key_length, 3);
1418   assert(rc == MEMCACHED_NO_SERVERS);
1419
1420   x= 0;
1421   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1422                                         &return_value_length, &flags, &rc)))
1423   {
1424     assert(return_value);
1425     assert(rc == MEMCACHED_SUCCESS);
1426     assert(return_key_length == return_value_length);
1427     assert(!memcmp(return_value, return_key, return_value_length));
1428     free(return_value);
1429     x++;
1430   }
1431
1432   return 0;
1433 }
1434
1435 #define VALUE_SIZE_BUG5 1048064
1436 uint8_t user_supplied_bug5(memcached_st *memc)
1437 {
1438   memcached_return rc;
1439   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1440   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1441   char return_key[MEMCACHED_MAX_KEY];
1442   size_t return_key_length;
1443   char *value;
1444   size_t value_length;
1445   uint32_t flags;
1446   unsigned int count;
1447   unsigned int x;
1448   char insert_data[VALUE_SIZE_BUG5];
1449
1450   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1451     insert_data[x]= rand();
1452
1453   memcached_flush(memc, 0);
1454   value= memcached_get(memc, keys[0], key_length[0],
1455                         &value_length, &flags, &rc);
1456   assert(value == NULL);
1457   rc= memcached_mget(memc, keys, key_length, 4);
1458
1459   count= 0;
1460   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1461                                         &value_length, &flags, &rc)))
1462     count++;
1463   assert(count == 0);
1464
1465   for (x= 0; x < 4; x++)
1466   {
1467     rc= memcached_set(memc, keys[x], key_length[x],
1468                       insert_data, VALUE_SIZE_BUG5,
1469                       (time_t)0, (uint32_t)0);
1470     assert(rc == MEMCACHED_SUCCESS);
1471   }
1472
1473   for (x= 0; x < 10; x++)
1474   {
1475     value= memcached_get(memc, keys[0], key_length[0],
1476                          &value_length, &flags, &rc);
1477     assert(value);
1478     free(value);
1479
1480     rc= memcached_mget(memc, keys, key_length, 4);
1481     count= 0;
1482     while ((value= memcached_fetch(memc, return_key, &return_key_length,
1483                                           &value_length, &flags, &rc)))
1484     {
1485       count++;
1486       free(value);
1487     }
1488     assert(count == 4);
1489   }
1490
1491   return 0;
1492 }
1493
1494 uint8_t user_supplied_bug6(memcached_st *memc)
1495 {
1496   memcached_return rc;
1497   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1498   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1499   char return_key[MEMCACHED_MAX_KEY];
1500   size_t return_key_length;
1501   char *value;
1502   size_t value_length;
1503   uint32_t flags;
1504   unsigned int count;
1505   unsigned int x;
1506   char insert_data[VALUE_SIZE_BUG5];
1507
1508   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1509     insert_data[x]= rand();
1510
1511   memcached_flush(memc, 0);
1512   value= memcached_get(memc, keys[0], key_length[0],
1513                         &value_length, &flags, &rc);
1514   assert(value == NULL);
1515   assert(rc == MEMCACHED_NOTFOUND);
1516   rc= memcached_mget(memc, keys, key_length, 4);
1517   assert(rc == MEMCACHED_SUCCESS);
1518
1519   count= 0;
1520   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1521                                         &value_length, &flags, &rc)))
1522     count++;
1523   assert(count == 0);
1524   assert(rc == MEMCACHED_END);
1525
1526   for (x= 0; x < 4; x++)
1527   {
1528     rc= memcached_set(memc, keys[x], key_length[x],
1529                       insert_data, VALUE_SIZE_BUG5,
1530                       (time_t)0, (uint32_t)0);
1531     assert(rc == MEMCACHED_SUCCESS);
1532   }
1533
1534   for (x= 0; x < 2; x++)
1535   {
1536     value= memcached_get(memc, keys[0], key_length[0],
1537                          &value_length, &flags, &rc);
1538     assert(value);
1539     free(value);
1540
1541     rc= memcached_mget(memc, keys, key_length, 4);
1542     assert(rc == MEMCACHED_SUCCESS);
1543     count= 3;
1544     /* We test for purge of partial complete fetches */
1545     for (count= 3; count; count--)
1546     {
1547       value= memcached_fetch(memc, return_key, &return_key_length,
1548                              &value_length, &flags, &rc);
1549       assert(rc == MEMCACHED_SUCCESS);
1550       assert(!(memcmp(value, insert_data, value_length)));
1551       assert(value_length);
1552       free(value);
1553     }
1554   }
1555
1556   return 0;
1557 }
1558
1559 uint8_t user_supplied_bug8(memcached_st *memc)
1560 {
1561   memcached_return rc;
1562   memcached_st *mine;
1563   memcached_st *clone;
1564
1565   memcached_server_st *servers;
1566   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";
1567
1568   servers= memcached_servers_parse(server_list);
1569   assert(servers);
1570
1571   mine= memcached_create(NULL);
1572   rc= memcached_server_push(mine, servers);
1573   assert(rc == MEMCACHED_SUCCESS);
1574   memcached_server_list_free(servers);
1575
1576   assert(mine);
1577   clone= memcached_clone(NULL, mine);
1578
1579   memcached_quit(mine);
1580   memcached_quit(clone);
1581
1582
1583   memcached_free(mine);
1584   memcached_free(clone);
1585
1586   return 0;
1587 }
1588
1589 /* Test flag store/retrieve */
1590 uint8_t user_supplied_bug7(memcached_st *memc)
1591 {
1592   memcached_return rc;
1593   char *keys= "036790384900";
1594   size_t key_length=  strlen("036790384900");
1595   char return_key[MEMCACHED_MAX_KEY];
1596   size_t return_key_length;
1597   char *value;
1598   size_t value_length;
1599   uint32_t flags;
1600   unsigned int x;
1601   char insert_data[VALUE_SIZE_BUG5];
1602
1603   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1604     insert_data[x]= rand();
1605
1606   memcached_flush(memc, 0);
1607
1608   flags= 245;
1609   rc= memcached_set(memc, keys, key_length,
1610                     insert_data, VALUE_SIZE_BUG5,
1611                     (time_t)0, flags);
1612   assert(rc == MEMCACHED_SUCCESS);
1613
1614   flags= 0;
1615   value= memcached_get(memc, keys, key_length,
1616                         &value_length, &flags, &rc);
1617   assert(flags == 245);
1618   assert(value);
1619   free(value);
1620
1621   rc= memcached_mget(memc, &keys, &key_length, 1);
1622
1623   flags= 0;
1624   value= memcached_fetch(memc, return_key, &return_key_length,
1625                          &value_length, &flags, &rc);
1626   assert(flags == 245);
1627   assert(value);
1628   free(value);
1629
1630
1631   return 0;
1632 }
1633
1634 uint8_t user_supplied_bug9(memcached_st *memc)
1635 {
1636   memcached_return rc;
1637   char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1638   size_t key_length[3];
1639   unsigned int x;
1640   uint32_t flags;
1641   unsigned count= 0;
1642
1643   char return_key[MEMCACHED_MAX_KEY];
1644   size_t return_key_length;
1645   char *return_value;
1646   size_t return_value_length;
1647
1648
1649   key_length[0]= strlen("UDATA:edevil@sapo.pt");
1650   key_length[1]= strlen("fudge&*@#");
1651   key_length[2]= strlen("for^#@&$not");
1652
1653
1654   for (x= 0; x < 3; x++)
1655   {
1656     rc= memcached_set(memc, keys[x], key_length[x],
1657                       keys[x], key_length[x],
1658                       (time_t)50, (uint32_t)9);
1659     assert(rc == MEMCACHED_SUCCESS);
1660   }
1661
1662   rc= memcached_mget(memc, keys, key_length, 3);
1663   assert(rc == MEMCACHED_SUCCESS);
1664
1665   /* We need to empty the server before continueing test */
1666   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1667                       &return_value_length, &flags, &rc)) != NULL)
1668   {
1669     assert(return_value);
1670     free(return_value);
1671     count++;
1672   }
1673   assert(count == 3);
1674
1675   return 0;
1676 }
1677
1678 /* We are testing with aggressive timeout to get failures */
1679 uint8_t user_supplied_bug10(memcached_st *memc)
1680 {
1681   char *key= "foo";
1682   char *value;
1683   size_t value_length= 512;
1684   unsigned int x;
1685   int key_len= 3;
1686   memcached_return rc;
1687   unsigned int set= 1;
1688   memcached_st *mclone= memcached_clone(NULL, memc);
1689   int32_t timeout;
1690
1691   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1692   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1693   timeout= 2;
1694   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
1695
1696   value = (char*)malloc(value_length * sizeof(char));
1697
1698   for (x= 0; x < value_length; x++)
1699     value[x]= (char) (x % 127);
1700
1701   for (x= 1; x <= 100000; ++x)
1702   {
1703     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
1704
1705     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_BUFFERED);
1706
1707     if (rc == MEMCACHED_WRITE_FAILURE)
1708       x--;
1709   }
1710
1711   free(value);
1712   memcached_free(mclone);
1713
1714   return 0;
1715 }
1716
1717 /*
1718   We are looking failures in the async protocol
1719 */
1720 uint8_t user_supplied_bug11(memcached_st *memc)
1721 {
1722   char *key= "foo";
1723   char *value;
1724   size_t value_length= 512;
1725   unsigned int x;
1726   int key_len= 3;
1727   memcached_return rc;
1728   unsigned int set= 1;
1729   int32_t timeout;
1730   memcached_st *mclone= memcached_clone(NULL, memc);
1731
1732   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1733   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1734   timeout= -1;
1735   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
1736
1737   timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
1738
1739   assert(timeout == -1);
1740
1741   value = (char*)malloc(value_length * sizeof(char));
1742
1743   for (x= 0; x < value_length; x++)
1744     value[x]= (char) (x % 127);
1745
1746   for (x= 1; x <= 100000; ++x)
1747   {
1748     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
1749   }
1750
1751   free(value);
1752   memcached_free(mclone);
1753
1754   return 0;
1755 }
1756
1757 /*
1758   Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
1759 */
1760 uint8_t user_supplied_bug12(memcached_st *memc)
1761 {
1762   memcached_return rc;
1763   uint32_t flags;
1764   size_t value_length;
1765   char *value;
1766   uint64_t number_value;
1767
1768   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
1769                         &value_length, &flags, &rc);
1770   assert(value == NULL);
1771   assert(rc == MEMCACHED_NOTFOUND);
1772
1773   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
1774                           1, &number_value);
1775
1776   assert(value == NULL);
1777   assert(rc == MEMCACHED_NOTFOUND);
1778
1779   rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
1780
1781   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
1782                         &value_length, &flags, &rc);
1783   assert(value);
1784   assert(rc == MEMCACHED_SUCCESS);
1785   free(value);
1786
1787   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
1788                           1, &number_value);
1789   assert(number_value == 2);
1790   assert(rc == MEMCACHED_SUCCESS);
1791
1792   return 0;
1793 }
1794
1795 /*
1796   Bug found where command total one more than MEMCACHED_MAX_BUFFER
1797   set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
1798  */
1799 uint8_t user_supplied_bug13(memcached_st *memc)
1800 {
1801   char key[] = "key34567890";
1802   char *overflow;
1803   memcached_return rc;
1804   size_t overflowSize;
1805
1806   char commandFirst[]= "set key34567890 0 0 ";
1807   char commandLast[] = " \r\n"; /* first line of command sent to server */
1808   size_t commandLength;
1809   size_t testSize;
1810
1811   commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
1812
1813   overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
1814
1815   for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
1816   {
1817     overflow= malloc(testSize);
1818     assert(overflow != NULL);
1819
1820     memset(overflow, 'x', testSize);
1821     rc= memcached_set(memc, key, strlen(key),
1822                       overflow, testSize, 0, 0);
1823     assert(rc == MEMCACHED_SUCCESS);
1824     free(overflow);
1825   }
1826
1827   return 0;
1828 }
1829
1830
1831 /*
1832   Test values of many different sizes
1833   Bug found where command total one more than MEMCACHED_MAX_BUFFER
1834   set key34567890 0 0 8169 \r\n
1835   is sent followed by buffer of size 8169, followed by 8169
1836  */
1837 uint8_t user_supplied_bug14(memcached_st *memc)
1838 {
1839   int setter= 1;
1840   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1841   memcached_return rc;
1842   char *key= "foo";
1843   char *value;
1844   size_t value_length= 18000;
1845   char *string;
1846   size_t string_length;
1847   uint32_t flags;
1848   unsigned int x;
1849   size_t current_length;
1850
1851   value = (char*)malloc(value_length);
1852   assert(value);
1853
1854   for (x= 0; x < value_length; x++)
1855     value[x] = (char) (x % 127);
1856
1857   for (current_length= 0; current_length < value_length; current_length++)
1858   {
1859     rc= memcached_set(memc, key, strlen(key),
1860                       value, current_length,
1861                       (time_t)0, (uint32_t)0);
1862     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1863
1864     string= memcached_get(memc, key, strlen(key),
1865                           &string_length, &flags, &rc);
1866
1867     assert(rc == MEMCACHED_SUCCESS);
1868     if (current_length > 0)
1869       assert(string);
1870     assert(string_length == current_length);
1871     assert(!memcmp(string, value, string_length));
1872
1873     free(string);
1874   }
1875
1876   free(value);
1877
1878   return 0;
1879 }
1880
1881 /*
1882   Look for zero length value problems
1883   */
1884 uint8_t user_supplied_bug15(memcached_st *memc)
1885 {
1886   uint32_t x;
1887   memcached_return rc;
1888   char *key= "mykey";
1889   char *value;
1890   size_t length;
1891   uint32_t flags;
1892
1893   for (x= 0; x < 2; x++)
1894   {
1895     rc= memcached_set(memc, key, strlen(key),
1896                       NULL, 0,
1897                       (time_t)0, (uint32_t)0);
1898
1899     assert(rc == MEMCACHED_SUCCESS);
1900
1901     value= memcached_get(memc, key, strlen(key),
1902                          &length, &flags, &rc);
1903
1904     assert(rc == MEMCACHED_SUCCESS);
1905     assert(value == NULL);
1906     assert(length == 0);
1907     assert(flags == 0);
1908
1909     value= memcached_get(memc, key, strlen(key),
1910                          &length, &flags, &rc);
1911
1912     assert(rc == MEMCACHED_SUCCESS);
1913     assert(value == NULL);
1914     assert(length == 0);
1915     assert(flags == 0);
1916   }
1917
1918   return 0;
1919 }
1920
1921 uint8_t result_static(memcached_st *memc)
1922 {
1923   memcached_result_st result;
1924   memcached_result_st *result_ptr;
1925
1926   result_ptr= memcached_result_create(memc, &result);
1927   assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
1928   assert(result_ptr);
1929   memcached_result_free(&result);
1930
1931   return 0;
1932 }
1933
1934 uint8_t result_alloc(memcached_st *memc)
1935 {
1936   memcached_result_st *result;
1937
1938   result= memcached_result_create(memc, NULL);
1939   assert(result);
1940   memcached_result_free(result);
1941
1942   return 0;
1943 }
1944
1945 uint8_t string_static_null(memcached_st *memc)
1946 {
1947   memcached_string_st string;
1948   memcached_string_st *string_ptr;
1949
1950   string_ptr= memcached_string_create(memc, &string, 0);
1951   assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
1952   assert(string_ptr);
1953   memcached_string_free(&string);
1954
1955   return 0;
1956 }
1957
1958 uint8_t string_alloc_null(memcached_st *memc)
1959 {
1960   memcached_string_st *string;
1961
1962   string= memcached_string_create(memc, NULL, 0);
1963   assert(string);
1964   memcached_string_free(string);
1965
1966   return 0;
1967 }
1968
1969 uint8_t string_alloc_with_size(memcached_st *memc)
1970 {
1971   memcached_string_st *string;
1972
1973   string= memcached_string_create(memc, NULL, 1024);
1974   assert(string);
1975   memcached_string_free(string);
1976
1977   return 0;
1978 }
1979
1980 uint8_t string_alloc_with_size_toobig(memcached_st *memc)
1981 {
1982   memcached_string_st *string;
1983
1984   string= memcached_string_create(memc, NULL, INT64_MAX);
1985   assert(string == NULL);
1986
1987   return 0;
1988 }
1989
1990 uint8_t string_alloc_append(memcached_st *memc)
1991 {
1992   unsigned int x;
1993   char buffer[SMALL_STRING_LEN];
1994   memcached_string_st *string;
1995
1996   /* Ring the bell! */
1997   memset(buffer, 6, SMALL_STRING_LEN);
1998
1999   string= memcached_string_create(memc, NULL, 100);
2000   assert(string);
2001
2002   for (x= 0; x < 1024; x++)
2003   {
2004     memcached_return rc;
2005     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
2006     assert(rc == MEMCACHED_SUCCESS);
2007   }
2008   memcached_string_free(string);
2009
2010   return 0;
2011 }
2012
2013 uint8_t string_alloc_append_toobig(memcached_st *memc)
2014 {
2015   memcached_return rc;
2016   unsigned int x;
2017   char buffer[SMALL_STRING_LEN];
2018   memcached_string_st *string;
2019
2020   /* Ring the bell! */
2021   memset(buffer, 6, SMALL_STRING_LEN);
2022
2023   string= memcached_string_create(memc, NULL, 100);
2024   assert(string);
2025
2026   for (x= 0; x < 1024; x++)
2027   {
2028     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
2029     assert(rc == MEMCACHED_SUCCESS);
2030   }
2031   rc= memcached_string_append(string, buffer, INT64_MAX);
2032   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
2033   memcached_string_free(string);
2034
2035   return 0;
2036 }
2037
2038 uint8_t cleanup_pairs(memcached_st *memc)
2039 {
2040   pairs_free(global_pairs);
2041
2042   return 0;
2043 }
2044
2045 uint8_t generate_pairs(memcached_st *memc)
2046 {
2047   unsigned long long x;
2048   global_pairs= pairs_generate(GLOBAL_COUNT, 400);
2049   global_count= GLOBAL_COUNT;
2050
2051   for (x= 0; x < global_count; x++)
2052   {
2053     global_keys[x]= global_pairs[x].key;
2054     global_keys_length[x]=  global_pairs[x].key_length;
2055   }
2056
2057   return 0;
2058 }
2059
2060 uint8_t generate_large_pairs(memcached_st *memc)
2061 {
2062   unsigned long long x;
2063   global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
2064   global_count= GLOBAL2_COUNT;
2065
2066   for (x= 0; x < global_count; x++)
2067   {
2068     global_keys[x]= global_pairs[x].key;
2069     global_keys_length[x]=  global_pairs[x].key_length;
2070   }
2071
2072   return 0;
2073 }
2074
2075 uint8_t generate_data(memcached_st *memc)
2076 {
2077   execute_set(memc, global_pairs, global_count);
2078
2079   return 0;
2080 }
2081
2082 uint8_t generate_buffer_data(memcached_st *memc)
2083 {
2084   int latch= 0;
2085
2086   latch= 1;
2087   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
2088   generate_data(memc);
2089
2090   return 0;
2091 }
2092
2093 uint8_t get_read(memcached_st *memc)
2094 {
2095   unsigned int x;
2096   memcached_return rc;
2097
2098   {
2099     char *return_value;
2100     size_t return_value_length;
2101     uint32_t flags;
2102
2103     for (x= 0; x < global_count; x++)
2104     {
2105       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
2106                                   &return_value_length, &flags, &rc);
2107       /*
2108       assert(return_value);
2109       assert(rc == MEMCACHED_SUCCESS);
2110     */
2111       if (rc == MEMCACHED_SUCCESS && return_value)
2112         free(return_value);
2113     }
2114   }
2115
2116   return 0;
2117 }
2118
2119 uint8_t mget_read(memcached_st *memc)
2120 {
2121   memcached_return rc;
2122
2123   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2124   assert(rc == MEMCACHED_SUCCESS);
2125   /* Turn this into a help function */
2126   {
2127     char return_key[MEMCACHED_MAX_KEY];
2128     size_t return_key_length;
2129     char *return_value;
2130     size_t return_value_length;
2131     uint32_t flags;
2132
2133     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2134                                           &return_value_length, &flags, &rc)))
2135     {
2136       assert(return_value);
2137       assert(rc == MEMCACHED_SUCCESS);
2138       free(return_value);
2139     }
2140   }
2141
2142   return 0;
2143 }
2144
2145 uint8_t mget_read_result(memcached_st *memc)
2146 {
2147   memcached_return rc;
2148
2149   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2150   assert(rc == MEMCACHED_SUCCESS);
2151   /* Turn this into a help function */
2152   {
2153     memcached_result_st results_obj;
2154     memcached_result_st *results;
2155
2156     results= memcached_result_create(memc, &results_obj);
2157
2158     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
2159     {
2160       assert(results);
2161       assert(rc == MEMCACHED_SUCCESS);
2162     }
2163
2164     memcached_result_free(&results_obj);
2165   }
2166
2167   return 0;
2168 }
2169
2170 uint8_t mget_read_function(memcached_st *memc)
2171 {
2172   memcached_return rc;
2173   unsigned int counter;
2174   unsigned int (*callbacks[1])(memcached_st *, memcached_result_st *, void *);
2175
2176   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2177   assert(rc == MEMCACHED_SUCCESS);
2178
2179   callbacks[0]= &callback_counter;
2180   counter= 0;
2181   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
2182
2183   return 0;
2184 }
2185
2186 uint8_t delete_generate(memcached_st *memc)
2187 {
2188   unsigned int x;
2189
2190   for (x= 0; x < global_count; x++)
2191   {
2192     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2193   }
2194
2195   return 0;
2196 }
2197
2198 uint8_t delete_buffer_generate(memcached_st *memc)
2199 {
2200   int latch= 0;
2201   unsigned int x;
2202
2203   latch= 1;
2204   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
2205
2206   for (x= 0; x < global_count; x++)
2207   {
2208     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2209   }
2210
2211   return 0;
2212 }
2213
2214 uint8_t free_data(memcached_st *memc)
2215 {
2216   pairs_free(global_pairs);
2217
2218   return 0;
2219 }
2220
2221 uint8_t add_host_test1(memcached_st *memc)
2222 {
2223   unsigned int x;
2224   memcached_return rc;
2225   char servername[]= "0.example.com";
2226   memcached_server_st *servers;
2227
2228   servers= memcached_server_list_append(NULL, servername, 400, &rc);
2229   assert(servers);
2230   assert(1 == memcached_server_list_count(servers));
2231
2232   for (x= 2; x < 20; x++)
2233   {
2234     char buffer[SMALL_STRING_LEN];
2235
2236     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
2237     servers= memcached_server_list_append(servers, buffer, 401,
2238                                      &rc);
2239     assert(rc == MEMCACHED_SUCCESS);
2240     assert(x == memcached_server_list_count(servers));
2241   }
2242
2243   rc= memcached_server_push(memc, servers);
2244   assert(rc == MEMCACHED_SUCCESS);
2245   rc= memcached_server_push(memc, servers);
2246   assert(rc == MEMCACHED_SUCCESS);
2247
2248   memcached_server_list_free(servers);
2249
2250   return 0;
2251 }
2252
2253 memcached_return pre_nonblock(memcached_st *memc)
2254 {
2255   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
2256
2257   return MEMCACHED_SUCCESS;
2258 }
2259
2260 memcached_return pre_murmur(memcached_st *memc)
2261 {
2262   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
2263
2264   return MEMCACHED_SUCCESS;
2265 }
2266
2267 memcached_return pre_md5(memcached_st *memc)
2268 {
2269   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5);
2270
2271   return MEMCACHED_SUCCESS;
2272 }
2273
2274 memcached_return pre_crc(memcached_st *memc)
2275 {
2276   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_CRC);
2277
2278   return MEMCACHED_SUCCESS;
2279 }
2280
2281 memcached_return pre_hsieh(memcached_st *memc)
2282 {
2283   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH);
2284
2285   return MEMCACHED_SUCCESS;
2286 }
2287
2288 memcached_return pre_hash_fnv1_64(memcached_st *memc)
2289 {
2290   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_64);
2291
2292   return MEMCACHED_SUCCESS;
2293 }
2294
2295 memcached_return pre_hash_fnv1a_64(memcached_st *memc)
2296 {
2297   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64);
2298
2299   return MEMCACHED_SUCCESS;
2300 }
2301
2302 memcached_return pre_hash_fnv1_32(memcached_st *memc)
2303 {
2304   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_32);
2305
2306   return MEMCACHED_SUCCESS;
2307 }
2308
2309 memcached_return pre_hash_fnv1a_32(memcached_st *memc)
2310 {
2311   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_32);
2312
2313   return MEMCACHED_SUCCESS;
2314 }
2315
2316 memcached_return pre_hash_ketama(memcached_st *memc)
2317 {
2318   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_KETAMA);
2319
2320   return MEMCACHED_SUCCESS;
2321 }
2322
2323 void my_free(memcached_st *ptr, void *mem)
2324 {
2325   free(mem);
2326 }
2327
2328 void *my_malloc(memcached_st *ptr, const size_t size)
2329 {
2330   return malloc(size);
2331 }
2332
2333 void *my_realloc(memcached_st *ptr, void *mem, const size_t size)
2334 {
2335   return realloc(mem, size);
2336 }
2337
2338 memcached_return set_memory_alloc(memcached_st *memc)
2339 {
2340   {
2341     memcached_malloc_function test_ptr;
2342     memcached_return rc;
2343
2344     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &my_malloc);
2345     assert(rc == MEMCACHED_SUCCESS);
2346     test_ptr= (memcached_malloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
2347     assert(rc == MEMCACHED_SUCCESS);
2348     assert(test_ptr == my_malloc);
2349   }
2350
2351   {
2352     memcached_realloc_function test_ptr;
2353     memcached_return rc;
2354
2355     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &my_realloc);
2356     assert(rc == MEMCACHED_SUCCESS);
2357     test_ptr= (memcached_realloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
2358     assert(rc == MEMCACHED_SUCCESS);
2359     assert(test_ptr == my_realloc);
2360   }
2361
2362   {
2363     memcached_free_function test_ptr;
2364     memcached_return rc;
2365
2366     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, my_free);
2367     assert(rc == MEMCACHED_SUCCESS);
2368     test_ptr= (memcached_free_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
2369     assert(rc == MEMCACHED_SUCCESS);
2370     assert(test_ptr == my_free);
2371   }
2372
2373   return MEMCACHED_SUCCESS;
2374 }
2375
2376 memcached_return enable_consistent(memcached_st *memc)
2377 {
2378   memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;
2379   memcached_hash hash;
2380   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
2381   pre_hsieh(memc);
2382
2383   value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
2384   assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
2385
2386   hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
2387   assert(hash == MEMCACHED_HASH_HSIEH);
2388
2389
2390   return MEMCACHED_SUCCESS;
2391 }
2392
2393 memcached_return enable_cas(memcached_st *memc)
2394 {
2395   unsigned int set= 1;
2396
2397   memcached_version(memc);
2398
2399   if (memc->hosts[0].major_version >= 1 &&
2400       memc->hosts[0].minor_version >= 2 &&
2401       memc->hosts[0].micro_version >= 4)
2402   {
2403     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
2404
2405     return MEMCACHED_SUCCESS;
2406   }
2407
2408   return MEMCACHED_FAILURE;
2409 }
2410
2411 memcached_return check_for_1_2_3(memcached_st *memc)
2412 {
2413   memcached_version(memc);
2414
2415   if (memc->hosts[0].major_version >= 1 &&
2416       memc->hosts[0].minor_version >= 2 &&
2417       memc->hosts[0].micro_version >= 4)
2418     return MEMCACHED_SUCCESS;
2419
2420   return MEMCACHED_FAILURE;
2421 }
2422
2423 memcached_return pre_unix_socket(memcached_st *memc)
2424 {
2425   memcached_return rc;
2426   struct stat buf;
2427
2428   memcached_server_list_free(memc->hosts);
2429   memc->hosts= NULL;
2430   memc->number_of_hosts= 0;
2431
2432   if (stat("/tmp/memcached.socket", &buf))
2433     return MEMCACHED_FAILURE;
2434
2435   rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");
2436
2437   return rc;
2438 }
2439
2440 memcached_return pre_udp(memcached_st *memc)
2441 {
2442   memcached_return rc;
2443
2444   memcached_server_list_free(memc->hosts);
2445   memc->hosts= NULL;
2446   memc->number_of_hosts= 0;
2447
2448   if (0)
2449     return MEMCACHED_FAILURE;
2450
2451   rc= memcached_server_add_udp(memc, "localhost", MEMCACHED_DEFAULT_PORT);
2452
2453   return rc;
2454 }
2455
2456 memcached_return pre_nodelay(memcached_st *memc)
2457 {
2458   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
2459   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
2460
2461   return MEMCACHED_SUCCESS;
2462 }
2463
2464 memcached_return poll_timeout(memcached_st *memc)
2465 {
2466   int32_t timeout;
2467
2468   timeout= 100;
2469
2470   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
2471
2472   timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
2473
2474   assert(timeout == 100);
2475
2476   return MEMCACHED_SUCCESS;
2477 }
2478
2479
2480 /* Clean the server before beginning testing */
2481 test_st tests[] ={
2482   {"flush", 0, flush_test },
2483   {"init", 0, init_test },
2484   {"allocation", 0, allocation_test },
2485   {"server_list_null_test", 0, server_list_null_test},
2486   {"server_sort", 0, server_sort_test},
2487   {"clone_test", 0, clone_test },
2488   {"error", 0, error_test },
2489   {"set", 0, set_test },
2490   {"set2", 0, set_test2 },
2491   {"set3", 0, set_test3 },
2492   {"add", 1, add_test },
2493   {"replace", 1, replace_test },
2494   {"delete", 1, delete_test },
2495   {"get", 1, get_test },
2496   {"get2", 0, get_test2 },
2497   {"get3", 0, get_test3 },
2498   {"get4", 0, get_test4 },
2499   {"stats_servername", 0, stats_servername_test },
2500   {"increment", 0, increment_test },
2501   {"decrement", 0, decrement_test },
2502   {"quit", 0, quit_test },
2503   {"mget", 1, mget_test },
2504   {"mget_result", 1, mget_result_test },
2505   {"mget_result_alloc", 1, mget_result_alloc_test },
2506   {"mget_result_function", 1, mget_result_function },
2507   {"get_stats", 0, get_stats },
2508   {"add_host_test", 0, add_host_test },
2509   {"get_stats_keys", 0, get_stats_keys },
2510   {"behavior_test", 0, get_stats_keys },
2511   {"callback_test", 0, get_stats_keys },
2512   {"version_string_test", 0, version_string_test},
2513   {"bad_key", 1, bad_key_test },
2514   {"memcached_server_cursor", 1, memcached_server_cursor_test },
2515   {"read_through", 1, read_through },
2516   {0, 0, 0}
2517 };
2518
2519 test_st async_tests[] ={
2520   {"add", 1, add_wrapper },
2521   {0, 0, 0}
2522 };
2523
2524 test_st string_tests[] ={
2525   {"string static with null", 0, string_static_null },
2526   {"string alloc with null", 0, string_alloc_null },
2527   {"string alloc with 1K", 0, string_alloc_with_size },
2528   {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
2529   {"string append", 0, string_alloc_append },
2530   {"string append failure (too big)", 0, string_alloc_append_toobig },
2531   {0, 0, 0}
2532 };
2533
2534 test_st result_tests[] ={
2535   {"result static", 0, result_static},
2536   {"result alloc", 0, result_alloc},
2537   {0, 0, 0}
2538 };
2539
2540 test_st version_1_2_3[] ={
2541   {"append", 0, append_test },
2542   {"prepend", 0, prepend_test },
2543   {"cas", 0, cas_test },
2544   {"cas2", 0, cas2_test },
2545   {"append_binary", 0, append_binary_test },
2546   {0, 0, 0}
2547 };
2548
2549 test_st user_tests[] ={
2550   {"user_supplied_bug1", 0, user_supplied_bug1 },
2551   {"user_supplied_bug2", 0, user_supplied_bug2 },
2552   {"user_supplied_bug3", 0, user_supplied_bug3 },
2553   {"user_supplied_bug4", 0, user_supplied_bug4 },
2554   {"user_supplied_bug5", 1, user_supplied_bug5 },
2555   {"user_supplied_bug6", 1, user_supplied_bug6 },
2556   {"user_supplied_bug7", 1, user_supplied_bug7 },
2557   {"user_supplied_bug8", 1, user_supplied_bug8 },
2558   {"user_supplied_bug9", 1, user_supplied_bug9 },
2559   {"user_supplied_bug10", 1, user_supplied_bug10 },
2560   {"user_supplied_bug11", 1, user_supplied_bug11 },
2561   {"user_supplied_bug12", 1, user_supplied_bug12 },
2562   {"user_supplied_bug13", 1, user_supplied_bug13 },
2563   {"user_supplied_bug14", 1, user_supplied_bug14 },
2564   {"user_supplied_bug15", 1, user_supplied_bug15 },
2565   {0, 0, 0}
2566 };
2567
2568 test_st generate_tests[] ={
2569   {"generate_pairs", 1, generate_pairs },
2570   {"generate_data", 1, generate_data },
2571   {"get_read", 0, get_read },
2572   {"delete_generate", 0, delete_generate },
2573   {"generate_buffer_data", 1, generate_buffer_data },
2574   {"delete_buffer", 0, delete_buffer_generate},
2575   {"generate_data", 1, generate_data },
2576   {"mget_read", 0, mget_read },
2577   {"mget_read_result", 0, mget_read_result },
2578   {"mget_read_function", 0, mget_read_function },
2579   {"cleanup", 1, cleanup_pairs },
2580   {"generate_large_pairs", 1, generate_large_pairs },
2581   {"generate_data", 1, generate_data },
2582   {"generate_buffer_data", 1, generate_buffer_data },
2583   {"cleanup", 1, cleanup_pairs },
2584   {0, 0, 0}
2585 };
2586
2587
2588 collection_st collection[] ={
2589   {"block", 0, 0, tests},
2590   {"nonblock", pre_nonblock, 0, tests},
2591   {"nodelay", pre_nodelay, 0, tests},
2592   {"md5", pre_md5, 0, tests},
2593   {"crc", pre_crc, 0, tests},
2594   {"hsieh", pre_hsieh, 0, tests},
2595   {"fnv1_64", pre_hash_fnv1_64, 0, tests},
2596   {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
2597   {"fnv1_32", pre_hash_fnv1_32, 0, tests},
2598   {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
2599   {"ketama", pre_hash_ketama, 0, tests},
2600   {"unix_socket", pre_unix_socket, 0, tests},
2601   {"unix_socket_nodelay", pre_nodelay, 0, tests},
2602   {"poll_timeout", poll_timeout, 0, tests},
2603   {"gets", enable_cas, 0, tests},
2604   {"consistent", enable_consistent, 0, tests},
2605   {"memory_allocators", set_memory_alloc, 0, tests},
2606 //  {"udp", pre_udp, 0, tests},
2607   {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
2608   {"string", 0, 0, string_tests},
2609   {"result", 0, 0, result_tests},
2610   {"async", pre_nonblock, 0, async_tests},
2611   {"user", 0, 0, user_tests},
2612   {"generate", 0, 0, generate_tests},
2613   {"generate_hsieh", pre_hsieh, 0, generate_tests},
2614   {"generate_hsieh_consistent", enable_consistent, 0, generate_tests},
2615   {"generate_md5", pre_md5, 0, generate_tests},
2616   {"generate_murmur", pre_murmur, 0, generate_tests},
2617   {"generate_nonblock", pre_nonblock, 0, generate_tests},
2618   {0, 0, 0, 0}
2619 };
2620
2621 #define SERVERS_TO_CREATE 5
2622
2623 void *world_create(void)
2624 {
2625   server_startup_st *construct;
2626
2627   construct= (server_startup_st *)malloc(sizeof(server_startup_st));
2628   memset(construct, 0, sizeof(server_startup_st));
2629   construct->count= SERVERS_TO_CREATE;
2630   construct->udp= 0;
2631   server_startup(construct);
2632
2633   return construct;
2634 }
2635
2636 void world_destroy(void *p)
2637 {
2638   server_startup_st *construct= (server_startup_st *)p;
2639   memcached_server_st *servers= (memcached_server_st *)construct->servers;
2640   memcached_server_list_free(servers);
2641
2642   server_shutdown(construct);
2643   free(construct);
2644 }
2645
2646 void get_world(world_st *world)
2647 {
2648   world->collections= collection;
2649   world->create= world_create;
2650   world->destroy= world_destroy;
2651 }