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