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