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 10000
  28 #define GLOBAL2_COUNT 100
  29 #define SERVERS_TO_CREATE 5
  30 static uint32_t global_count;
  31
  32 static pairs_st *global_pairs;
  33 static char *global_keys[GLOBAL_COUNT];
  34 static size_t global_keys_length[GLOBAL_COUNT];
  35
  36 static test_return  init_test(memcached_st *not_used __attribute__((unused)))
  37 {
  38   memcached_st memc;
  39
  40   (void)memcached_create(&memc);
  41   memcached_free(&memc);
  42
  43   return 0;
  44 }
  45
  46 static test_return  server_list_null_test(memcached_st *ptr __attribute__((unused)))
  47 {
  48   memcached_server_st *server_list;
  49   memcached_return rc;
  50
  51   server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, NULL);
  52   assert(server_list == NULL);
  53
  54   server_list= memcached_server_list_append_with_weight(NULL, "localhost", 0, 0, NULL);
  55   assert(server_list == NULL);
  56
  57   server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, &rc);
  58   assert(server_list == NULL);
  59
  60   return 0;
  61 }
  62
  63 #define TEST_PORT_COUNT 7
  64 uint32_t test_ports[TEST_PORT_COUNT];
  65
  66 static memcached_return  server_display_function(memcached_st *ptr __attribute__((unused)), memcached_server_st *server, void *context)
  67 {
  68   /* Do Nothing */
  69   uint32_t bigger= *((uint32_t *)(context));
  70   assert(bigger <= server->port);
  71   *((uint32_t *)(context))= server->port;
  72
  73   return MEMCACHED_SUCCESS;
  74 }
  75
  76 static test_return  server_sort_test(memcached_st *ptr __attribute__((unused)))
  77 {
  78   uint32_t x;
  79   uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */
  80   memcached_return rc;
  81   memcached_server_function callbacks[1];
  82   memcached_st *local_memc;
  83
  84   local_memc= memcached_create(NULL);
  85   assert(local_memc);
  86   memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
  87
  88   for (x= 0; x < TEST_PORT_COUNT; x++)
  89   {
  90     test_ports[x]= random() % 64000;
  91     rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
  92     assert(local_memc->number_of_hosts == x + 1);
  93     assert(local_memc->hosts[0].count == x+1);
  94     assert(rc == MEMCACHED_SUCCESS);
  95   }
  96
  97   callbacks[0]= server_display_function;
  98   memcached_server_cursor(local_memc, callbacks, (void *)&bigger,  1);
  99
 100
 101   memcached_free(local_memc);
 102
 103   return 0;
 104 }
 105
 106 static test_return  server_sort2_test(memcached_st *ptr __attribute__((unused)))
 107 {
 108   uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */
 109   memcached_return rc;
 110   memcached_server_function callbacks[1];
 111   memcached_st *local_memc;
 112
 113   local_memc= memcached_create(NULL);
 114   assert(local_memc);
 115   rc= memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
 116   assert(rc == MEMCACHED_SUCCESS);
 117
 118   rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
 119   assert(rc == MEMCACHED_SUCCESS);
 120   assert(local_memc->hosts[0].port == 43043);
 121
 122   rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
 123   assert(rc == MEMCACHED_SUCCESS);
 124   assert(local_memc->hosts[0].port == 43042);
 125   assert(local_memc->hosts[1].port == 43043);
 126
 127   callbacks[0]= server_display_function;
 128   memcached_server_cursor(local_memc, callbacks, (void *)&bigger,  1);
 129
 130
 131   memcached_free(local_memc);
 132
 133   return 0;
 134 }
 135
 136 static memcached_return  server_display_unsort_function(memcached_st *ptr __attribute__((unused)), memcached_server_st *server, void *context)
 137 {
 138   /* Do Nothing */
 139   uint32_t x= *((uint32_t *)(context));
 140
 141   assert(test_ports[x] == server->port);
 142   *((uint32_t *)(context))= ++x;
 143
 144   return MEMCACHED_SUCCESS;
 145 }
 146
 147 static test_return  server_unsort_test(memcached_st *ptr __attribute__((unused)))
 148 {
 149   uint32_t x;
 150   uint32_t counter= 0; /* Prime the value for the assert in server_display_function */
 151   uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */
 152   memcached_return rc;
 153   memcached_server_function callbacks[1];
 154   memcached_st *local_memc;
 155
 156   local_memc= memcached_create(NULL);
 157   assert(local_memc);
 158
 159   for (x= 0; x < TEST_PORT_COUNT; x++)
 160   {
 161     test_ports[x]= random() % 64000;
 162     rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
 163     assert(local_memc->number_of_hosts == x+1);
 164     assert(local_memc->hosts[0].count == x+1);
 165     assert(rc == MEMCACHED_SUCCESS);
 166   }
 167
 168   callbacks[0]= server_display_unsort_function;
 169   memcached_server_cursor(local_memc, callbacks, (void *)&counter,  1);
 170
 171   /* Now we sort old data! */
 172   memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
 173   callbacks[0]= server_display_function;
 174   memcached_server_cursor(local_memc, callbacks, (void *)&bigger,  1);
 175
 176
 177   memcached_free(local_memc);
 178
 179   return 0;
 180 }
 181
 182 static test_return  allocation_test(memcached_st *not_used __attribute__((unused)))
 183 {
 184   memcached_st *memc;
 185   memc= memcached_create(NULL);
 186   assert(memc);
 187   memcached_free(memc);
 188
 189   return 0;
 190 }
 191
 192 static test_return  clone_test(memcached_st *memc)
 193 {
 194   /* All null? */
 195   {
 196     memcached_st *clone;
 197     clone= memcached_clone(NULL, NULL);
 198     assert(clone);
 199     memcached_free(clone);
 200   }
 201
 202   /* Can we init from null? */
 203   {
 204     memcached_st *clone;
 205     clone= memcached_clone(NULL, memc);
 206     assert(clone);
 207     memcached_free(clone);
 208   }
 209
 210   /* Can we init from struct? */
 211   {
 212     memcached_st declared_clone;
 213     memcached_st *clone;
 214     memset(&declared_clone, 0 , sizeof(memcached_st));
 215     clone= memcached_clone(&declared_clone, NULL);
 216     assert(clone);
 217     memcached_free(clone);
 218   }
 219
 220   /* Can we init from struct? */
 221   {
 222     memcached_st declared_clone;
 223     memcached_st *clone;
 224     memset(&declared_clone, 0 , sizeof(memcached_st));
 225     clone= memcached_clone(&declared_clone, memc);
 226     assert(clone);
 227     memcached_free(clone);
 228   }
 229
 230   return 0;
 231 }
 232
 233 static test_return  connection_test(memcached_st *memc)
 234 {
 235   memcached_return rc;
 236
 237   rc= memcached_server_add_with_weight(memc, "localhost", 0, 0);
 238   assert(rc == MEMCACHED_SUCCESS);
 239
 240   return 0;
 241 }
 242
 243 static test_return  error_test(memcached_st *memc)
 244 {
 245   memcached_return rc;
 246
 247   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
 248   {
 249     printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
 250   }
 251
 252   return 0;
 253 }
 254
 255 static test_return  set_test(memcached_st *memc)
 256 {
 257   memcached_return rc;
 258   char *key= "foo";
 259   char *value= "when we sanitize";
 260
 261   rc= memcached_set(memc, key, strlen(key),
 262                     value, strlen(value),
 263                     (time_t)0, (uint32_t)0);
 264   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 265
 266   return 0;
 267 }
 268
 269 static test_return  append_test(memcached_st *memc)
 270 {
 271   memcached_return rc;
 272   char *key= "fig";
 273   char *value= "we";
 274   size_t value_length;
 275   uint32_t flags;
 276
 277   rc= memcached_flush(memc, 0);
 278   assert(rc == MEMCACHED_SUCCESS);
 279
 280   rc= memcached_set(memc, key, strlen(key),
 281                     value, strlen(value),
 282                     (time_t)0, (uint32_t)0);
 283   assert(rc == MEMCACHED_SUCCESS);
 284
 285   rc= memcached_append(memc, key, strlen(key),
 286                        " the", strlen(" the"),
 287                        (time_t)0, (uint32_t)0);
 288   assert(rc == MEMCACHED_SUCCESS);
 289
 290   rc= memcached_append(memc, key, strlen(key),
 291                        " people", strlen(" people"),
 292                        (time_t)0, (uint32_t)0);
 293   assert(rc == MEMCACHED_SUCCESS);
 294
 295   value= memcached_get(memc, key, strlen(key),
 296                        &value_length, &flags, &rc);
 297   assert(!memcmp(value, "we the people", strlen("we the people")));
 298   assert(strlen("we the people") == value_length);
 299   assert(rc == MEMCACHED_SUCCESS);
 300   free(value);
 301
 302   return 0;
 303 }
 304
 305 static test_return  append_binary_test(memcached_st *memc)
 306 {
 307   memcached_return rc;
 308   char *key= "numbers";
 309   unsigned int *store_ptr;
 310   unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
 311   char *value;
 312   size_t value_length;
 313   uint32_t flags;
 314   unsigned int x;
 315
 316   rc= memcached_flush(memc, 0);
 317   assert(rc == MEMCACHED_SUCCESS);
 318
 319   rc= memcached_set(memc,
 320                     key, strlen(key),
 321                     NULL, 0,
 322                     (time_t)0, (uint32_t)0);
 323   assert(rc == MEMCACHED_SUCCESS);
 324
 325   for (x= 0; store_list[x] ; x++)
 326   {
 327     rc= memcached_append(memc,
 328                          key, strlen(key),
 329                          (char *)&store_list[x], sizeof(unsigned int),
 330                          (time_t)0, (uint32_t)0);
 331     assert(rc == MEMCACHED_SUCCESS);
 332   }
 333
 334   value= memcached_get(memc, key, strlen(key),
 335                        &value_length, &flags, &rc);
 336   assert((value_length == (sizeof(unsigned int) * x)));
 337   assert(rc == MEMCACHED_SUCCESS);
 338
 339   store_ptr= (unsigned int *)value;
 340   x= 0;
 341   while ((size_t)store_ptr < (size_t)(value + value_length))
 342   {
 343     assert(*store_ptr == store_list[x++]);
 344     store_ptr++;
 345   }
 346   free(value);
 347
 348   return 0;
 349 }
 350
 351 static test_return  cas2_test(memcached_st *memc)
 352 {
 353   memcached_return rc;
 354   char *keys[]= {"fudge", "son", "food"};
 355   size_t key_length[]= {5, 3, 4};
 356   char *value= "we the people";
 357   size_t value_length= strlen("we the people");
 358   unsigned int x;
 359   memcached_result_st results_obj;
 360   memcached_result_st *results;
 361   unsigned int set= 1;
 362
 363   rc= memcached_flush(memc, 0);
 364   assert(rc == MEMCACHED_SUCCESS);
 365
 366   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
 367
 368   for (x= 0; x < 3; x++)
 369   {
 370     rc= memcached_set(memc, keys[x], key_length[x],
 371                       keys[x], key_length[x],
 372                       (time_t)50, (uint32_t)9);
 373     assert(rc == MEMCACHED_SUCCESS);
 374   }
 375
 376   rc= memcached_mget(memc, keys, key_length, 3);
 377
 378   results= memcached_result_create(memc, &results_obj);
 379
 380   results= memcached_fetch_result(memc, &results_obj, &rc);
 381   assert(results);
 382   assert(results->cas);
 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   memcached_result_free(&results_obj);
 391
 392   return 0;
 393 }
 394
 395 static test_return  cas_test(memcached_st *memc)
 396 {
 397   memcached_return rc;
 398   const char *key= "fun";
 399   size_t key_length= strlen(key);
 400   const char *value= "we the people";
 401   char* keys[2] = { (char*)key, NULL };
 402   size_t keylengths[2] = { strlen(key), 0 };
 403   size_t value_length= strlen(value);
 404   const char *value2= "change the value";
 405   size_t value2_length= strlen(value2);
 406
 407   memcached_result_st results_obj;
 408   memcached_result_st *results;
 409   unsigned int set= 1;
 410
 411   rc= memcached_flush(memc, 0);
 412   assert(rc == MEMCACHED_SUCCESS);
 413
 414   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
 415
 416   rc= memcached_set(memc, key, strlen(key),
 417                     value, strlen(value),
 418                     (time_t)0, (uint32_t)0);
 419   assert(rc == MEMCACHED_SUCCESS);
 420
 421   rc= memcached_mget(memc, keys, keylengths, 1);
 422
 423   results= memcached_result_create(memc, &results_obj);
 424
 425   results= memcached_fetch_result(memc, &results_obj, &rc);
 426   assert(results);
 427   assert(rc == MEMCACHED_SUCCESS);
 428   WATCHPOINT_ASSERT(memcached_result_cas(results));
 429   assert(!memcmp(value, memcached_result_value(results), value_length));
 430   assert(strlen(memcached_result_value(results)) == value_length);
 431   assert(rc == MEMCACHED_SUCCESS);
 432   uint64_t cas = memcached_result_cas(results);
 433
 434   #if 0
 435   results= memcached_fetch_result(memc, &results_obj, &rc);
 436   assert(rc == MEMCACHED_END);
 437   assert(results == NULL);
 438 #endif
 439
 440   rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
 441   assert(rc == MEMCACHED_SUCCESS);
 442
 443   /*
 444    * The item will have a new cas value, so try to set it again with the old
 445    * value. This should fail!
 446    */
 447   rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
 448   assert(rc == MEMCACHED_DATA_EXISTS);
 449
 450   memcached_result_free(&results_obj);
 451
 452   return 0;
 453 }
 454
 455 static test_return  prepend_test(memcached_st *memc)
 456 {
 457   memcached_return rc;
 458   char *key= "fig";
 459   char *value= "people";
 460   size_t value_length;
 461   uint32_t flags;
 462
 463   rc= memcached_flush(memc, 0);
 464   assert(rc == MEMCACHED_SUCCESS);
 465
 466   rc= memcached_set(memc, key, strlen(key),
 467                     value, strlen(value),
 468                     (time_t)0, (uint32_t)0);
 469   assert(rc == MEMCACHED_SUCCESS);
 470
 471   rc= memcached_prepend(memc, key, strlen(key),
 472                        "the ", strlen("the "),
 473                        (time_t)0, (uint32_t)0);
 474   assert(rc == MEMCACHED_SUCCESS);
 475
 476   rc= memcached_prepend(memc, key, strlen(key),
 477                        "we ", strlen("we "),
 478                        (time_t)0, (uint32_t)0);
 479   assert(rc == MEMCACHED_SUCCESS);
 480
 481   value= memcached_get(memc, key, strlen(key),
 482                        &value_length, &flags, &rc);
 483   assert(!memcmp(value, "we the people", strlen("we the people")));
 484   assert(strlen("we the people") == value_length);
 485   assert(rc == MEMCACHED_SUCCESS);
 486   free(value);
 487
 488   return 0;
 489 }
 490
 491 /*
 492   Set the value, then quit to make sure it is flushed.
 493   Come back in and test that add fails.
 494 */
 495 static test_return  add_test(memcached_st *memc)
 496 {
 497   memcached_return rc;
 498   char *key= "foo";
 499   char *value= "when we sanitize";
 500   unsigned long long setting_value;
 501
 502   setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 503
 504   rc= memcached_set(memc, key, strlen(key),
 505                     value, strlen(value),
 506                     (time_t)0, (uint32_t)0);
 507   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 508   memcached_quit(memc);
 509   rc= memcached_add(memc, key, strlen(key),
 510                     value, strlen(value),
 511                     (time_t)0, (uint32_t)0);
 512
 513   /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
 514   if (setting_value)
 515     assert(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);
 516   else
 517     assert(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_DATA_EXISTS);
 518
 519   return 0;
 520 }
 521
 522 static test_return  add_wrapper(memcached_st *memc)
 523 {
 524   unsigned int x;
 525
 526   for (x= 0; x < 10000; x++)
 527     add_test(memc);
 528
 529   return 0;
 530 }
 531
 532 static test_return  replace_test(memcached_st *memc)
 533 {
 534   memcached_return rc;
 535   char *key= "foo";
 536   char *value= "when we sanitize";
 537   char *original= "first we insert some data";
 538
 539   rc= memcached_set(memc, key, strlen(key),
 540                     original, strlen(original),
 541                     (time_t)0, (uint32_t)0);
 542   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 543
 544   rc= memcached_replace(memc, key, strlen(key),
 545                     value, strlen(value),
 546                     (time_t)0, (uint32_t)0);
 547   assert(rc == MEMCACHED_SUCCESS);
 548
 549   return 0;
 550 }
 551
 552 static test_return  delete_test(memcached_st *memc)
 553 {
 554   memcached_return rc;
 555   char *key= "foo";
 556   char *value= "when we sanitize";
 557
 558   rc= memcached_set(memc, key, strlen(key),
 559                     value, strlen(value),
 560                     (time_t)0, (uint32_t)0);
 561   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 562
 563   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 564   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 565
 566   return 0;
 567 }
 568
 569 static test_return  flush_test(memcached_st *memc)
 570 {
 571   memcached_return rc;
 572
 573   rc= memcached_flush(memc, 0);
 574   assert(rc == MEMCACHED_SUCCESS);
 575
 576   return 0;
 577 }
 578
 579 static memcached_return  server_function(memcached_st *ptr __attribute__((unused)),
 580                                          memcached_server_st *server __attribute__((unused)),
 581                                          void *context __attribute__((unused)))
 582 {
 583   /* Do Nothing */
 584
 585   return MEMCACHED_SUCCESS;
 586 }
 587
 588 static test_return  memcached_server_cursor_test(memcached_st *memc)
 589 {
 590   char *context= "foo bad";
 591   memcached_server_function callbacks[1];
 592
 593   callbacks[0]= server_function;
 594   memcached_server_cursor(memc, callbacks, context,  1);
 595
 596   return 0;
 597 }
 598
 599 static test_return  bad_key_test(memcached_st *memc)
 600 {
 601   memcached_return rc;
 602   char *key= "foo bad";
 603   char *string;
 604   size_t string_length;
 605   uint32_t flags;
 606   memcached_st *clone;
 607   unsigned int set= 1;
 608   size_t max_keylen= 0xffff;
 609
 610   clone= memcached_clone(NULL, memc);
 611   assert(clone);
 612
 613   rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 614   assert(rc == MEMCACHED_SUCCESS);
 615
 616   /* All keys are valid in the binary protocol (except for length) */
 617   if (memcached_behavior_get(clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0)
 618   {
 619     string= memcached_get(clone, key, strlen(key),
 620                           &string_length, &flags, &rc);
 621     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 622     assert(string_length ==  0);
 623     assert(!string);
 624
 625     set= 0;
 626     rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 627     assert(rc == MEMCACHED_SUCCESS);
 628     string= memcached_get(clone, key, strlen(key),
 629                           &string_length, &flags, &rc);
 630     assert(rc == MEMCACHED_NOTFOUND);
 631     assert(string_length ==  0);
 632     assert(!string);
 633
 634     /* Test multi key for bad keys */
 635     char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
 636     size_t key_lengths[] = { 7, 7, 7 };
 637     set= 1;
 638     rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 639     assert(rc == MEMCACHED_SUCCESS);
 640
 641     rc= memcached_mget(clone, keys, key_lengths, 3);
 642     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 643
 644     rc= memcached_mget_by_key(clone, "foo daddy", 9, keys, key_lengths, 1);
 645     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 646
 647     max_keylen= 250;
 648
 649     /* The following test should be moved to the end of this function when the
 650        memcached server is updated to allow max size length of the keys in the
 651        binary protocol
 652     */
 653     rc= memcached_callback_set(clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
 654     assert(rc == MEMCACHED_SUCCESS);
 655
 656     char *longkey= malloc(max_keylen + 1);
 657     if (longkey != NULL)
 658     {
 659       memset(longkey, 'a', max_keylen + 1);
 660       string= memcached_get(clone, longkey, max_keylen,
 661                             &string_length, &flags, &rc);
 662       assert(rc == MEMCACHED_NOTFOUND);
 663       assert(string_length ==  0);
 664       assert(!string);
 665
 666       string= memcached_get(clone, longkey, max_keylen + 1,
 667                             &string_length, &flags, &rc);
 668       assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 669       assert(string_length ==  0);
 670       assert(!string);
 671
 672       free(longkey);
 673     }
 674   }
 675
 676   /* Make sure zero length keys are marked as bad */
 677   set= 1;
 678   rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 679   assert(rc == MEMCACHED_SUCCESS);
 680   string= memcached_get(clone, key, 0,
 681                         &string_length, &flags, &rc);
 682   assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 683   assert(string_length ==  0);
 684   assert(!string);
 685
 686   memcached_free(clone);
 687
 688   return 0;
 689 }
 690
 691 #define READ_THROUGH_VALUE "set for me"
 692 static memcached_return  read_through_trigger(memcached_st *memc __attribute__((unused)),
 693                                       char *key __attribute__((unused)),
 694                                       size_t key_length __attribute__((unused)),
 695                                       memcached_result_st *result)
 696 {
 697
 698   return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
 699 }
 700
 701 static test_return  read_through(memcached_st *memc)
 702 {
 703   memcached_return rc;
 704   char *key= "foo";
 705   char *string;
 706   size_t string_length;
 707   uint32_t flags;
 708
 709   string= memcached_get(memc, key, strlen(key),
 710                         &string_length, &flags, &rc);
 711
 712   assert(rc == MEMCACHED_NOTFOUND);
 713   assert(string_length ==  0);
 714   assert(!string);
 715
 716   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, (void *)read_through_trigger);
 717   assert(rc == MEMCACHED_SUCCESS);
 718
 719   string= memcached_get(memc, key, strlen(key),
 720                         &string_length, &flags, &rc);
 721
 722   assert(rc == MEMCACHED_SUCCESS);
 723   assert(string_length ==  strlen(READ_THROUGH_VALUE));
 724   assert(!strcmp(READ_THROUGH_VALUE, string));
 725   free(string);
 726
 727   string= memcached_get(memc, key, strlen(key),
 728                         &string_length, &flags, &rc);
 729
 730   assert(rc == MEMCACHED_SUCCESS);
 731   assert(string_length ==  strlen(READ_THROUGH_VALUE));
 732   assert(!strcmp(READ_THROUGH_VALUE, string));
 733   free(string);
 734
 735   return 0;
 736 }
 737
 738 static memcached_return  delete_trigger(memcached_st *ptr __attribute__((unused)),
 739                                         const char *key,
 740                                         size_t key_length __attribute__((unused)))
 741 {
 742   assert(key);
 743
 744   return MEMCACHED_SUCCESS;
 745 }
 746
 747 static test_return  delete_through(memcached_st *memc)
 748 {
 749   memcached_trigger_delete_key callback;
 750   memcached_return rc;
 751
 752   callback= delete_trigger;
 753
 754   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, (void*)callback);
 755   assert(rc == MEMCACHED_SUCCESS);
 756
 757   return 0;
 758 }
 759
 760 static test_return  get_test(memcached_st *memc)
 761 {
 762   memcached_return rc;
 763   char *key= "foo";
 764   char *string;
 765   size_t string_length;
 766   uint32_t flags;
 767
 768   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 769   assert(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);
 770
 771   string= memcached_get(memc, key, strlen(key),
 772                         &string_length, &flags, &rc);
 773
 774   assert(rc == MEMCACHED_NOTFOUND);
 775   assert(string_length ==  0);
 776   assert(!string);
 777
 778   return 0;
 779 }
 780
 781 static test_return  get_test2(memcached_st *memc)
 782 {
 783   memcached_return rc;
 784   char *key= "foo";
 785   char *value= "when we sanitize";
 786   char *string;
 787   size_t string_length;
 788   uint32_t flags;
 789
 790   rc= memcached_set(memc, key, strlen(key),
 791                     value, strlen(value),
 792                     (time_t)0, (uint32_t)0);
 793   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 794
 795   string= memcached_get(memc, key, strlen(key),
 796                         &string_length, &flags, &rc);
 797
 798   assert(string);
 799   assert(rc == MEMCACHED_SUCCESS);
 800   assert(string_length == strlen(value));
 801   assert(!memcmp(string, value, string_length));
 802
 803   free(string);
 804
 805   return 0;
 806 }
 807
 808 static test_return  set_test2(memcached_st *memc)
 809 {
 810   memcached_return rc;
 811   char *key= "foo";
 812   char *value= "train in the brain";
 813   size_t value_length= strlen(value);
 814   unsigned int x;
 815
 816   for (x= 0; x < 10; x++)
 817   {
 818     rc= memcached_set(memc, key, strlen(key),
 819                       value, value_length,
 820                       (time_t)0, (uint32_t)0);
 821     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 822   }
 823
 824   return 0;
 825 }
 826
 827 static test_return  set_test3(memcached_st *memc)
 828 {
 829   memcached_return rc;
 830   char *key= "foo";
 831   char *value;
 832   size_t value_length= 8191;
 833   unsigned int x;
 834
 835   value = (char*)malloc(value_length);
 836   assert(value);
 837
 838   for (x= 0; x < value_length; x++)
 839     value[x] = (char) (x % 127);
 840
 841   for (x= 0; x < 1; x++)
 842   {
 843     rc= memcached_set(memc, key, strlen(key),
 844                       value, value_length,
 845                       (time_t)0, (uint32_t)0);
 846     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 847   }
 848
 849   free(value);
 850
 851   return 0;
 852 }
 853
 854 static test_return  get_test3(memcached_st *memc)
 855 {
 856   memcached_return rc;
 857   char *key= "foo";
 858   char *value;
 859   size_t value_length= 8191;
 860   char *string;
 861   size_t string_length;
 862   uint32_t flags;
 863   uint32_t x;
 864
 865   value = (char*)malloc(value_length);
 866   assert(value);
 867
 868   for (x= 0; x < value_length; x++)
 869     value[x] = (char) (x % 127);
 870
 871   rc= memcached_set(memc, key, strlen(key),
 872                     value, value_length,
 873                     (time_t)0, (uint32_t)0);
 874   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 875
 876   string= memcached_get(memc, key, strlen(key),
 877                         &string_length, &flags, &rc);
 878
 879   assert(rc == MEMCACHED_SUCCESS);
 880   assert(string);
 881   assert(string_length == value_length);
 882   assert(!memcmp(string, value, string_length));
 883
 884   free(string);
 885   free(value);
 886
 887   return 0;
 888 }
 889
 890 static test_return  get_test4(memcached_st *memc)
 891 {
 892   memcached_return rc;
 893   char *key= "foo";
 894   char *value;
 895   size_t value_length= 8191;
 896   char *string;
 897   size_t string_length;
 898   uint32_t flags;
 899   uint32_t x;
 900
 901   value = (char*)malloc(value_length);
 902   assert(value);
 903
 904   for (x= 0; x < value_length; x++)
 905     value[x] = (char) (x % 127);
 906
 907   rc= memcached_set(memc, key, strlen(key),
 908                     value, value_length,
 909                     (time_t)0, (uint32_t)0);
 910   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 911
 912   for (x= 0; x < 10; x++)
 913   {
 914     string= memcached_get(memc, key, strlen(key),
 915                           &string_length, &flags, &rc);
 916
 917     assert(rc == MEMCACHED_SUCCESS);
 918     assert(string);
 919     assert(string_length == value_length);
 920     assert(!memcmp(string, value, string_length));
 921     free(string);
 922   }
 923
 924   free(value);
 925
 926   return 0;
 927 }
 928
 929 /* Do not copy the style of this code, I just access hosts to testthis function */
 930 static test_return  stats_servername_test(memcached_st *memc)
 931 {
 932   memcached_return rc;
 933   memcached_stat_st stat;
 934   rc= memcached_stat_servername(&stat, NULL,
 935                                  memc->hosts[0].hostname,
 936                                  memc->hosts[0].port);
 937
 938   return 0;
 939 }
 940
 941 static test_return  increment_test(memcached_st *memc)
 942 {
 943   uint64_t new_number;
 944   memcached_return rc;
 945   char *key= "number";
 946   char *value= "0";
 947
 948   rc= memcached_set(memc, key, strlen(key),
 949                     value, strlen(value),
 950                     (time_t)0, (uint32_t)0);
 951   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 952
 953   rc= memcached_increment(memc, key, strlen(key),
 954                           1, &new_number);
 955   assert(rc == MEMCACHED_SUCCESS);
 956   assert(new_number == 1);
 957
 958   rc= memcached_increment(memc, key, strlen(key),
 959                           1, &new_number);
 960   assert(rc == MEMCACHED_SUCCESS);
 961   assert(new_number == 2);
 962
 963   return 0;
 964 }
 965
 966 static test_return  decrement_test(memcached_st *memc)
 967 {
 968   uint64_t new_number;
 969   memcached_return rc;
 970   char *key= "number";
 971   char *value= "3";
 972
 973   rc= memcached_set(memc, key, strlen(key),
 974                     value, strlen(value),
 975                     (time_t)0, (uint32_t)0);
 976   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 977
 978   rc= memcached_decrement(memc, key, strlen(key),
 979                           1, &new_number);
 980   assert(rc == MEMCACHED_SUCCESS);
 981   assert(new_number == 2);
 982
 983   rc= memcached_decrement(memc, key, strlen(key),
 984                           1, &new_number);
 985   assert(rc == MEMCACHED_SUCCESS);
 986   assert(new_number == 1);
 987
 988   return 0;
 989 }
 990
 991 static test_return  quit_test(memcached_st *memc)
 992 {
 993   memcached_return rc;
 994   char *key= "fudge";
 995   char *value= "sanford and sun";
 996
 997   rc= memcached_set(memc, key, strlen(key),
 998                     value, strlen(value),
 999                     (time_t)10, (uint32_t)3);
1000   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1001   memcached_quit(memc);
1002
1003   rc= memcached_set(memc, key, strlen(key),
1004                     value, strlen(value),
1005                     (time_t)50, (uint32_t)9);
1006   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1007
1008   return 0;
1009 }
1010
1011 static test_return  mget_result_test(memcached_st *memc)
1012 {
1013   memcached_return rc;
1014   char *keys[]= {"fudge", "son", "food"};
1015   size_t key_length[]= {5, 3, 4};
1016   unsigned int x;
1017
1018   memcached_result_st results_obj;
1019   memcached_result_st *results;
1020
1021   results= memcached_result_create(memc, &results_obj);
1022   assert(results);
1023   assert(&results_obj == results);
1024
1025   /* We need to empty the server before continueing test */
1026   rc= memcached_flush(memc, 0);
1027   assert(rc == MEMCACHED_SUCCESS);
1028
1029   rc= memcached_mget(memc, keys, key_length, 3);
1030   assert(rc == MEMCACHED_SUCCESS);
1031
1032   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
1033   {
1034     assert(results);
1035   }
1036
1037   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
1038   assert(!results);
1039   assert(rc == MEMCACHED_END);
1040
1041   for (x= 0; x < 3; x++)
1042   {
1043     rc= memcached_set(memc, keys[x], key_length[x],
1044                       keys[x], key_length[x],
1045                       (time_t)50, (uint32_t)9);
1046     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1047   }
1048
1049   rc= memcached_mget(memc, keys, key_length, 3);
1050   assert(rc == MEMCACHED_SUCCESS);
1051
1052   while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1053   {
1054     assert(results);
1055     assert(&results_obj == results);
1056     assert(rc == MEMCACHED_SUCCESS);
1057     assert(memcached_result_key_length(results) == memcached_result_length(results));
1058     assert(!memcmp(memcached_result_key_value(results),
1059                    memcached_result_value(results),
1060                    memcached_result_length(results)));
1061   }
1062
1063   memcached_result_free(&results_obj);
1064
1065   return 0;
1066 }
1067
1068 static test_return  mget_result_alloc_test(memcached_st *memc)
1069 {
1070   memcached_return rc;
1071   char *keys[]= {"fudge", "son", "food"};
1072   size_t key_length[]= {5, 3, 4};
1073   unsigned int x;
1074
1075   memcached_result_st *results;
1076
1077   /* We need to empty the server before continueing test */
1078   rc= memcached_flush(memc, 0);
1079   assert(rc == MEMCACHED_SUCCESS);
1080
1081   rc= memcached_mget(memc, keys, key_length, 3);
1082   assert(rc == MEMCACHED_SUCCESS);
1083
1084   while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
1085   {
1086     assert(results);
1087   }
1088   assert(!results);
1089   assert(rc == MEMCACHED_END);
1090
1091   for (x= 0; x < 3; x++)
1092   {
1093     rc= memcached_set(memc, keys[x], key_length[x],
1094                       keys[x], key_length[x],
1095                       (time_t)50, (uint32_t)9);
1096     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1097   }
1098
1099   rc= memcached_mget(memc, keys, key_length, 3);
1100   assert(rc == MEMCACHED_SUCCESS);
1101
1102   x= 0;
1103   while ((results= memcached_fetch_result(memc, NULL, &rc)))
1104   {
1105     assert(results);
1106     assert(rc == MEMCACHED_SUCCESS);
1107     assert(memcached_result_key_length(results) == memcached_result_length(results));
1108     assert(!memcmp(memcached_result_key_value(results),
1109                    memcached_result_value(results),
1110                    memcached_result_length(results)));
1111     memcached_result_free(results);
1112     x++;
1113   }
1114
1115   return 0;
1116 }
1117
1118 /* Count the results */
1119 static memcached_return callback_counter(memcached_st *ptr __attribute__((unused)),
1120                                      memcached_result_st *result __attribute__((unused)),
1121                                      void *context)
1122 {
1123   unsigned int *counter= (unsigned int *)context;
1124
1125   *counter= *counter + 1;
1126
1127   return MEMCACHED_SUCCESS;
1128 }
1129
1130 static test_return  mget_result_function(memcached_st *memc)
1131 {
1132   memcached_return rc;
1133   char *keys[]= {"fudge", "son", "food"};
1134   size_t key_length[]= {5, 3, 4};
1135   unsigned int x;
1136   unsigned int counter;
1137   memcached_execute_function callbacks[1];
1138
1139   /* We need to empty the server before continueing test */
1140   rc= memcached_flush(memc, 0);
1141   for (x= 0; x < 3; x++)
1142   {
1143     rc= memcached_set(memc, keys[x], key_length[x],
1144                       keys[x], key_length[x],
1145                       (time_t)50, (uint32_t)9);
1146     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1147   }
1148
1149   rc= memcached_mget(memc, keys, key_length, 3);
1150   assert(rc == MEMCACHED_SUCCESS);
1151
1152   callbacks[0]= &callback_counter;
1153   counter= 0;
1154   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
1155
1156   assert(counter == 3);
1157
1158   return 0;
1159 }
1160
1161 static test_return  mget_test(memcached_st *memc)
1162 {
1163   memcached_return rc;
1164   char *keys[]= {"fudge", "son", "food"};
1165   size_t key_length[]= {5, 3, 4};
1166   unsigned int x;
1167   uint32_t flags;
1168
1169   char return_key[MEMCACHED_MAX_KEY];
1170   size_t return_key_length;
1171   char *return_value;
1172   size_t return_value_length;
1173
1174   /* We need to empty the server before continueing test */
1175   rc= memcached_flush(memc, 0);
1176   assert(rc == MEMCACHED_SUCCESS);
1177
1178   rc= memcached_mget(memc, keys, key_length, 3);
1179   assert(rc == MEMCACHED_SUCCESS);
1180
1181   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1182                       &return_value_length, &flags, &rc)) != NULL)
1183   {
1184     assert(return_value);
1185   }
1186   assert(!return_value);
1187   assert(return_value_length == 0);
1188   assert(rc == MEMCACHED_END);
1189
1190   for (x= 0; x < 3; x++)
1191   {
1192     rc= memcached_set(memc, keys[x], key_length[x],
1193                       keys[x], key_length[x],
1194                       (time_t)50, (uint32_t)9);
1195     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1196   }
1197
1198   rc= memcached_mget(memc, keys, key_length, 3);
1199   assert(rc == MEMCACHED_SUCCESS);
1200
1201   x= 0;
1202   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1203                                         &return_value_length, &flags, &rc)))
1204   {
1205     assert(return_value);
1206     assert(rc == MEMCACHED_SUCCESS);
1207     assert(return_key_length == return_value_length);
1208     assert(!memcmp(return_value, return_key, return_value_length));
1209     free(return_value);
1210     x++;
1211   }
1212
1213   return 0;
1214 }
1215
1216 static test_return  get_stats_keys(memcached_st *memc)
1217 {
1218  char **list;
1219  char **ptr;
1220  memcached_stat_st stat;
1221  memcached_return rc;
1222
1223  list= memcached_stat_get_keys(memc, &stat, &rc);
1224  assert(rc == MEMCACHED_SUCCESS);
1225  for (ptr= list; *ptr; ptr++)
1226    assert(*ptr);
1227  fflush(stdout);
1228
1229  free(list);
1230
1231  return 0;
1232 }
1233
1234 static test_return  version_string_test(memcached_st *memc __attribute__((unused)))
1235 {
1236   const char *version_string;
1237
1238   version_string= memcached_lib_version();
1239
1240   assert(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING));
1241
1242   return 0;
1243 }
1244
1245 static test_return  get_stats(memcached_st *memc)
1246 {
1247  unsigned int x;
1248  char **list;
1249  char **ptr;
1250  memcached_return rc;
1251  memcached_stat_st *stat;
1252
1253  stat= memcached_stat(memc, NULL, &rc);
1254  assert(rc == MEMCACHED_SUCCESS);
1255
1256  assert(rc == MEMCACHED_SUCCESS);
1257  assert(stat);
1258
1259  for (x= 0; x < memcached_server_count(memc); x++)
1260  {
1261    list= memcached_stat_get_keys(memc, stat+x, &rc);
1262    assert(rc == MEMCACHED_SUCCESS);
1263    for (ptr= list; *ptr; ptr++);
1264
1265    free(list);
1266  }
1267
1268  memcached_stat_free(NULL, stat);
1269
1270   return 0;
1271 }
1272
1273 static test_return  add_host_test(memcached_st *memc)
1274 {
1275   unsigned int x;
1276   memcached_server_st *servers;
1277   memcached_return rc;
1278   char servername[]= "0.example.com";
1279
1280   servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
1281   assert(servers);
1282   assert(1 == memcached_server_list_count(servers));
1283
1284   for (x= 2; x < 20; x++)
1285   {
1286     char buffer[SMALL_STRING_LEN];
1287
1288     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1289     servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
1290                                      &rc);
1291     assert(rc == MEMCACHED_SUCCESS);
1292     assert(x == memcached_server_list_count(servers));
1293   }
1294
1295   rc= memcached_server_push(memc, servers);
1296   assert(rc == MEMCACHED_SUCCESS);
1297   rc= memcached_server_push(memc, servers);
1298   assert(rc == MEMCACHED_SUCCESS);
1299
1300   memcached_server_list_free(servers);
1301
1302   return 0;
1303 }
1304
1305 static memcached_return  clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *clone __attribute__((unused)))
1306 {
1307   return MEMCACHED_SUCCESS;
1308 }
1309
1310 static memcached_return  cleanup_test_callback(memcached_st *ptr __attribute__((unused)))
1311 {
1312   return MEMCACHED_SUCCESS;
1313 }
1314
1315 static test_return  callback_test(memcached_st *memc)
1316 {
1317   /* Test User Data */
1318   {
1319     int x= 5;
1320     int *test_ptr;
1321     memcached_return rc;
1322
1323     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x);
1324     assert(rc == MEMCACHED_SUCCESS);
1325     test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
1326     assert(*test_ptr == x);
1327   }
1328
1329   /* Test Clone Callback */
1330   {
1331     memcached_clone_func temp_function;
1332     memcached_return rc;
1333
1334     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, (void*)clone_test_callback);
1335     assert(rc == MEMCACHED_SUCCESS);
1336     temp_function= (memcached_clone_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1337     assert(temp_function == clone_test_callback);
1338   }
1339
1340   /* Test Cleanup Callback */
1341   {
1342     memcached_cleanup_func temp_function;
1343     memcached_return rc;
1344
1345     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, (void*)cleanup_test_callback);
1346     assert(rc == MEMCACHED_SUCCESS);
1347     temp_function= (memcached_cleanup_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1348     assert(temp_function == cleanup_test_callback);
1349   }
1350
1351   return 0;
1352 }
1353
1354 /* We don't test the behavior itself, we test the switches */
1355 static test_return  behavior_test(memcached_st *memc)
1356 {
1357   uint64_t value;
1358   uint32_t set= 1;
1359
1360   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1361   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1362   assert(value == 1);
1363
1364   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1365   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1366   assert(value == 1);
1367
1368   set= MEMCACHED_HASH_MD5;
1369   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1370   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1371   assert(value == MEMCACHED_HASH_MD5);
1372
1373   set= 0;
1374
1375   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1376   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1377   assert(value == 0);
1378
1379   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1380   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1381   assert(value == 0);
1382
1383   set= MEMCACHED_HASH_DEFAULT;
1384   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1385   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1386   assert(value == MEMCACHED_HASH_DEFAULT);
1387
1388   set= MEMCACHED_HASH_CRC;
1389   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1390   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1391   assert(value == MEMCACHED_HASH_CRC);
1392
1393   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1394   assert(value > 0);
1395
1396   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1397   assert(value > 0);
1398
1399   return 0;
1400 }
1401
1402 /* Test case provided by Cal Haldenbrand */
1403 static test_return  user_supplied_bug1(memcached_st *memc)
1404 {
1405   unsigned int setter= 1;
1406   unsigned int x;
1407
1408   unsigned long long total= 0;
1409   uint32_t size= 0;
1410   char key[10];
1411   char randomstuff[6 * 1024];
1412   memcached_return rc;
1413
1414   memset(randomstuff, 0, 6 * 1024);
1415
1416   /* We just keep looking at the same values over and over */
1417   srandom(10);
1418
1419   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1420   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1421
1422
1423   /* add key */
1424   for (x= 0 ; total < 20 * 1024576 ; x++ )
1425   {
1426     unsigned int j= 0;
1427
1428     size= (rand() % ( 5 * 1024 ) ) + 400;
1429     memset(randomstuff, 0, 6 * 1024);
1430     assert(size < 6 * 1024); /* Being safe here */
1431
1432     for (j= 0 ; j < size ;j++)
1433       randomstuff[j] = (char) (rand() % 26) + 97;
1434
1435     total += size;
1436     sprintf(key, "%d", x);
1437     rc = memcached_set(memc, key, strlen(key),
1438                        randomstuff, strlen(randomstuff), 10, 0);
1439     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1440     /* If we fail, lets try again */
1441     if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
1442       rc = memcached_set(memc, key, strlen(key),
1443                          randomstuff, strlen(randomstuff), 10, 0);
1444     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1445   }
1446
1447   return 0;
1448 }
1449
1450 /* Test case provided by Cal Haldenbrand */
1451 static test_return  user_supplied_bug2(memcached_st *memc)
1452 {
1453   int errors;
1454   unsigned int setter;
1455   unsigned int x;
1456   unsigned long long total;
1457
1458   setter= 1;
1459   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1460   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1461 #ifdef NOT_YET
1462   setter = 20 * 1024576;
1463   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
1464   setter = 20 * 1024576;
1465   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
1466   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1467   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1468
1469   for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
1470 #endif
1471
1472   for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
1473   {
1474     memcached_return rc= MEMCACHED_SUCCESS;
1475     char buffer[SMALL_STRING_LEN];
1476     uint32_t flags= 0;
1477     size_t val_len= 0;
1478     char *getval;
1479
1480     memset(buffer, 0, SMALL_STRING_LEN);
1481
1482     snprintf(buffer, SMALL_STRING_LEN, "%u", x);
1483     getval= memcached_get(memc, buffer, strlen(buffer),
1484                            &val_len, &flags, &rc);
1485     if (rc != MEMCACHED_SUCCESS)
1486     {
1487       if (rc == MEMCACHED_NOTFOUND)
1488         errors++;
1489       else
1490       {
1491         WATCHPOINT_ERROR(rc);
1492         assert(0);
1493       }
1494
1495       continue;
1496     }
1497     total+= val_len;
1498     errors= 0;
1499     free(getval);
1500   }
1501
1502   return 0;
1503 }
1504
1505 /* Do a large mget() over all the keys we think exist */
1506 #define KEY_COUNT 3000 // * 1024576
1507 static test_return  user_supplied_bug3(memcached_st *memc)
1508 {
1509   memcached_return rc;
1510   unsigned int setter;
1511   unsigned int x;
1512   char **keys;
1513   size_t key_lengths[KEY_COUNT];
1514
1515   setter= 1;
1516   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1517   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1518 #ifdef NOT_YET
1519   setter = 20 * 1024576;
1520   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
1521   setter = 20 * 1024576;
1522   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
1523   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1524   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1525 #endif
1526
1527   keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
1528   assert(keys);
1529   memset(keys, 0, (sizeof(char *) * KEY_COUNT));
1530   for (x= 0; x < KEY_COUNT; x++)
1531   {
1532     char buffer[30];
1533
1534     snprintf(buffer, 30, "%u", x);
1535     keys[x]= strdup(buffer);
1536     key_lengths[x]= strlen(keys[x]);
1537   }
1538
1539   rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
1540   assert(rc == MEMCACHED_SUCCESS);
1541
1542   /* Turn this into a help function */
1543   {
1544     char return_key[MEMCACHED_MAX_KEY];
1545     size_t return_key_length;
1546     char *return_value;
1547     size_t return_value_length;
1548     uint32_t flags;
1549
1550     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1551                                           &return_value_length, &flags, &rc)))
1552     {
1553       assert(return_value);
1554       assert(rc == MEMCACHED_SUCCESS);
1555       free(return_value);
1556     }
1557   }
1558
1559   for (x= 0; x < KEY_COUNT; x++)
1560     free(keys[x]);
1561   free(keys);
1562
1563   return 0;
1564 }
1565
1566 /* Make sure we behave properly if server list has no values */
1567 static test_return  user_supplied_bug4(memcached_st *memc)
1568 {
1569   memcached_return rc;
1570   char *keys[]= {"fudge", "son", "food"};
1571   size_t key_length[]= {5, 3, 4};
1572   unsigned int x;
1573   uint32_t flags;
1574   char return_key[MEMCACHED_MAX_KEY];
1575   size_t return_key_length;
1576   char *return_value;
1577   size_t return_value_length;
1578
1579   /* Here we free everything before running a bunch of mget tests */
1580   {
1581     memcached_server_list_free(memc->hosts);
1582     memc->hosts= NULL;
1583     memc->number_of_hosts= 0;
1584   }
1585
1586
1587   /* We need to empty the server before continueing test */
1588   rc= memcached_flush(memc, 0);
1589   assert(rc == MEMCACHED_NO_SERVERS);
1590
1591   rc= memcached_mget(memc, keys, key_length, 3);
1592   assert(rc == MEMCACHED_NO_SERVERS);
1593
1594   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1595                       &return_value_length, &flags, &rc)) != NULL)
1596   {
1597     assert(return_value);
1598   }
1599   assert(!return_value);
1600   assert(return_value_length == 0);
1601   assert(rc == MEMCACHED_NO_SERVERS);
1602
1603   for (x= 0; x < 3; x++)
1604   {
1605     rc= memcached_set(memc, keys[x], key_length[x],
1606                       keys[x], key_length[x],
1607                       (time_t)50, (uint32_t)9);
1608     assert(rc == MEMCACHED_NO_SERVERS);
1609   }
1610
1611   rc= memcached_mget(memc, keys, key_length, 3);
1612   assert(rc == MEMCACHED_NO_SERVERS);
1613
1614   x= 0;
1615   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1616                                         &return_value_length, &flags, &rc)))
1617   {
1618     assert(return_value);
1619     assert(rc == MEMCACHED_SUCCESS);
1620     assert(return_key_length == return_value_length);
1621     assert(!memcmp(return_value, return_key, return_value_length));
1622     free(return_value);
1623     x++;
1624   }
1625
1626   return 0;
1627 }
1628
1629 #define VALUE_SIZE_BUG5 1048064
1630 static test_return  user_supplied_bug5(memcached_st *memc)
1631 {
1632   memcached_return rc;
1633   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1634   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1635   char return_key[MEMCACHED_MAX_KEY];
1636   size_t return_key_length;
1637   char *value;
1638   size_t value_length;
1639   uint32_t flags;
1640   unsigned int count;
1641   unsigned int x;
1642   char insert_data[VALUE_SIZE_BUG5];
1643
1644   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1645     insert_data[x]= rand();
1646
1647   memcached_flush(memc, 0);
1648   value= memcached_get(memc, keys[0], key_length[0],
1649                         &value_length, &flags, &rc);
1650   assert(value == NULL);
1651   rc= memcached_mget(memc, keys, key_length, 4);
1652
1653   count= 0;
1654   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1655                                         &value_length, &flags, &rc)))
1656     count++;
1657   assert(count == 0);
1658
1659   for (x= 0; x < 4; x++)
1660   {
1661     rc= memcached_set(memc, keys[x], key_length[x],
1662                       insert_data, VALUE_SIZE_BUG5,
1663                       (time_t)0, (uint32_t)0);
1664     assert(rc == MEMCACHED_SUCCESS);
1665   }
1666
1667   for (x= 0; x < 10; x++)
1668   {
1669     value= memcached_get(memc, keys[0], key_length[0],
1670                          &value_length, &flags, &rc);
1671     assert(value);
1672     free(value);
1673
1674     rc= memcached_mget(memc, keys, key_length, 4);
1675     count= 0;
1676     while ((value= memcached_fetch(memc, return_key, &return_key_length,
1677                                           &value_length, &flags, &rc)))
1678     {
1679       count++;
1680       free(value);
1681     }
1682     assert(count == 4);
1683   }
1684
1685   return 0;
1686 }
1687
1688 static test_return  user_supplied_bug6(memcached_st *memc)
1689 {
1690   memcached_return rc;
1691   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1692   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1693   char return_key[MEMCACHED_MAX_KEY];
1694   size_t return_key_length;
1695   char *value;
1696   size_t value_length;
1697   uint32_t flags;
1698   unsigned int count;
1699   unsigned int x;
1700   char insert_data[VALUE_SIZE_BUG5];
1701
1702   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1703     insert_data[x]= rand();
1704
1705   memcached_flush(memc, 0);
1706   value= memcached_get(memc, keys[0], key_length[0],
1707                         &value_length, &flags, &rc);
1708   assert(value == NULL);
1709   assert(rc == MEMCACHED_NOTFOUND);
1710   rc= memcached_mget(memc, keys, key_length, 4);
1711   assert(rc == MEMCACHED_SUCCESS);
1712
1713   count= 0;
1714   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1715                                         &value_length, &flags, &rc)))
1716     count++;
1717   assert(count == 0);
1718   assert(rc == MEMCACHED_END);
1719
1720   for (x= 0; x < 4; x++)
1721   {
1722     rc= memcached_set(memc, keys[x], key_length[x],
1723                       insert_data, VALUE_SIZE_BUG5,
1724                       (time_t)0, (uint32_t)0);
1725     assert(rc == MEMCACHED_SUCCESS);
1726   }
1727
1728   for (x= 0; x < 2; x++)
1729   {
1730     value= memcached_get(memc, keys[0], key_length[0],
1731                          &value_length, &flags, &rc);
1732     assert(value);
1733     free(value);
1734
1735     rc= memcached_mget(memc, keys, key_length, 4);
1736     assert(rc == MEMCACHED_SUCCESS);
1737     count= 3;
1738     /* We test for purge of partial complete fetches */
1739     for (count= 3; count; count--)
1740     {
1741       value= memcached_fetch(memc, return_key, &return_key_length,
1742                              &value_length, &flags, &rc);
1743       assert(rc == MEMCACHED_SUCCESS);
1744       assert(!(memcmp(value, insert_data, value_length)));
1745       assert(value_length);
1746       free(value);
1747     }
1748   }
1749
1750   return 0;
1751 }
1752
1753 static test_return  user_supplied_bug8(memcached_st *memc __attribute__((unused)))
1754 {
1755   memcached_return rc;
1756   memcached_st *mine;
1757   memcached_st *clone;
1758
1759   memcached_server_st *servers;
1760   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";
1761
1762   servers= memcached_servers_parse(server_list);
1763   assert(servers);
1764
1765   mine= memcached_create(NULL);
1766   rc= memcached_server_push(mine, servers);
1767   assert(rc == MEMCACHED_SUCCESS);
1768   memcached_server_list_free(servers);
1769
1770   assert(mine);
1771   clone= memcached_clone(NULL, mine);
1772
1773   memcached_quit(mine);
1774   memcached_quit(clone);
1775
1776
1777   memcached_free(mine);
1778   memcached_free(clone);
1779
1780   return 0;
1781 }
1782
1783 /* Test flag store/retrieve */
1784 static test_return  user_supplied_bug7(memcached_st *memc)
1785 {
1786   memcached_return rc;
1787   char *keys= "036790384900";
1788   size_t key_length=  strlen("036790384900");
1789   char return_key[MEMCACHED_MAX_KEY];
1790   size_t return_key_length;
1791   char *value;
1792   size_t value_length;
1793   uint32_t flags;
1794   unsigned int x;
1795   char insert_data[VALUE_SIZE_BUG5];
1796
1797   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1798     insert_data[x]= rand();
1799
1800   memcached_flush(memc, 0);
1801
1802   flags= 245;
1803   rc= memcached_set(memc, keys, key_length,
1804                     insert_data, VALUE_SIZE_BUG5,
1805                     (time_t)0, flags);
1806   assert(rc == MEMCACHED_SUCCESS);
1807
1808   flags= 0;
1809   value= memcached_get(memc, keys, key_length,
1810                         &value_length, &flags, &rc);
1811   assert(flags == 245);
1812   assert(value);
1813   free(value);
1814
1815   rc= memcached_mget(memc, &keys, &key_length, 1);
1816
1817   flags= 0;
1818   value= memcached_fetch(memc, return_key, &return_key_length,
1819                          &value_length, &flags, &rc);
1820   assert(flags == 245);
1821   assert(value);
1822   free(value);
1823
1824
1825   return 0;
1826 }
1827
1828 static test_return  user_supplied_bug9(memcached_st *memc)
1829 {
1830   memcached_return rc;
1831   char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1832   size_t key_length[3];
1833   unsigned int x;
1834   uint32_t flags;
1835   unsigned count= 0;
1836
1837   char return_key[MEMCACHED_MAX_KEY];
1838   size_t return_key_length;
1839   char *return_value;
1840   size_t return_value_length;
1841
1842
1843   key_length[0]= strlen("UDATA:edevil@sapo.pt");
1844   key_length[1]= strlen("fudge&*@#");
1845   key_length[2]= strlen("for^#@&$not");
1846
1847
1848   for (x= 0; x < 3; x++)
1849   {
1850     rc= memcached_set(memc, keys[x], key_length[x],
1851                       keys[x], key_length[x],
1852                       (time_t)50, (uint32_t)9);
1853     assert(rc == MEMCACHED_SUCCESS);
1854   }
1855
1856   rc= memcached_mget(memc, keys, key_length, 3);
1857   assert(rc == MEMCACHED_SUCCESS);
1858
1859   /* We need to empty the server before continueing test */
1860   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1861                       &return_value_length, &flags, &rc)) != NULL)
1862   {
1863     assert(return_value);
1864     free(return_value);
1865     count++;
1866   }
1867   assert(count == 3);
1868
1869   return 0;
1870 }
1871
1872 /* We are testing with aggressive timeout to get failures */
1873 static test_return  user_supplied_bug10(memcached_st *memc)
1874 {
1875   char *key= "foo";
1876   char *value;
1877   size_t value_length= 512;
1878   unsigned int x;
1879   int key_len= 3;
1880   memcached_return rc;
1881   unsigned int set= 1;
1882   memcached_st *mclone= memcached_clone(NULL, memc);
1883   int32_t timeout;
1884
1885   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1886   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1887   timeout= 2;
1888   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
1889
1890   value = (char*)malloc(value_length * sizeof(char));
1891
1892   for (x= 0; x < value_length; x++)
1893     value[x]= (char) (x % 127);
1894
1895   for (x= 1; x <= 100000; ++x)
1896   {
1897     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
1898
1899     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_BUFFERED);
1900
1901     if (rc == MEMCACHED_WRITE_FAILURE)
1902       x--;
1903   }
1904
1905   free(value);
1906   memcached_free(mclone);
1907
1908   return 0;
1909 }
1910
1911 /*
1912   We are looking failures in the async protocol
1913 */
1914 static test_return  user_supplied_bug11(memcached_st *memc)
1915 {
1916   char *key= "foo";
1917   char *value;
1918   size_t value_length= 512;
1919   unsigned int x;
1920   int key_len= 3;
1921   memcached_return rc;
1922   unsigned int set= 1;
1923   int32_t timeout;
1924   memcached_st *mclone= memcached_clone(NULL, memc);
1925
1926   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1927   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1928   timeout= -1;
1929   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
1930
1931   timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
1932
1933   assert(timeout == -1);
1934
1935   value = (char*)malloc(value_length * sizeof(char));
1936
1937   for (x= 0; x < value_length; x++)
1938     value[x]= (char) (x % 127);
1939
1940   for (x= 1; x <= 100000; ++x)
1941   {
1942     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
1943   }
1944
1945   free(value);
1946   memcached_free(mclone);
1947
1948   return 0;
1949 }
1950
1951 /*
1952   Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
1953 */
1954 static test_return  user_supplied_bug12(memcached_st *memc)
1955 {
1956   memcached_return rc;
1957   uint32_t flags;
1958   size_t value_length;
1959   char *value;
1960   uint64_t number_value;
1961
1962   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
1963                         &value_length, &flags, &rc);
1964   assert(value == NULL);
1965   assert(rc == MEMCACHED_NOTFOUND);
1966
1967   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
1968                           1, &number_value);
1969
1970   assert(value == NULL);
1971   /* The binary protocol will set the key if it doesn't exist */
1972   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
1973     assert(rc == MEMCACHED_SUCCESS);
1974   else
1975     assert(rc == MEMCACHED_NOTFOUND);
1976
1977   rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
1978
1979   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
1980                         &value_length, &flags, &rc);
1981   assert(value);
1982   assert(rc == MEMCACHED_SUCCESS);
1983   free(value);
1984
1985   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
1986                           1, &number_value);
1987   assert(number_value == 2);
1988   assert(rc == MEMCACHED_SUCCESS);
1989
1990   return 0;
1991 }
1992
1993 /*
1994   Bug found where command total one more than MEMCACHED_MAX_BUFFER
1995   set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
1996  */
1997 static test_return  user_supplied_bug13(memcached_st *memc)
1998 {
1999   char key[] = "key34567890";
2000   char *overflow;
2001   memcached_return rc;
2002   size_t overflowSize;
2003
2004   char commandFirst[]= "set key34567890 0 0 ";
2005   char commandLast[] = " \r\n"; /* first line of command sent to server */
2006   size_t commandLength;
2007   size_t testSize;
2008
2009   commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
2010
2011   overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
2012
2013   for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
2014   {
2015     overflow= malloc(testSize);
2016     assert(overflow != NULL);
2017
2018     memset(overflow, 'x', testSize);
2019     rc= memcached_set(memc, key, strlen(key),
2020                       overflow, testSize, 0, 0);
2021     assert(rc == MEMCACHED_SUCCESS);
2022     free(overflow);
2023   }
2024
2025   return 0;
2026 }
2027
2028
2029 /*
2030   Test values of many different sizes
2031   Bug found where command total one more than MEMCACHED_MAX_BUFFER
2032   set key34567890 0 0 8169 \r\n
2033   is sent followed by buffer of size 8169, followed by 8169
2034  */
2035 static test_return  user_supplied_bug14(memcached_st *memc)
2036 {
2037   int setter= 1;
2038   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
2039   memcached_return rc;
2040   char *key= "foo";
2041   char *value;
2042   size_t value_length= 18000;
2043   char *string;
2044   size_t string_length;
2045   uint32_t flags;
2046   unsigned int x;
2047   size_t current_length;
2048
2049   value = (char*)malloc(value_length);
2050   assert(value);
2051
2052   for (x= 0; x < value_length; x++)
2053     value[x] = (char) (x % 127);
2054
2055   for (current_length= 0; current_length < value_length; current_length++)
2056   {
2057     rc= memcached_set(memc, key, strlen(key),
2058                       value, current_length,
2059                       (time_t)0, (uint32_t)0);
2060     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
2061
2062     string= memcached_get(memc, key, strlen(key),
2063                           &string_length, &flags, &rc);
2064
2065     assert(rc == MEMCACHED_SUCCESS);
2066     assert(string_length == current_length);
2067     assert(!memcmp(string, value, string_length));
2068
2069     free(string);
2070   }
2071
2072   free(value);
2073
2074   return 0;
2075 }
2076
2077 /*
2078   Look for zero length value problems
2079   */
2080 static test_return  user_supplied_bug15(memcached_st *memc)
2081 {
2082   uint32_t x;
2083   memcached_return rc;
2084   char *key= "mykey";
2085   char *value;
2086   size_t length;
2087   uint32_t flags;
2088
2089   for (x= 0; x < 2; x++)
2090   {
2091     rc= memcached_set(memc, key, strlen(key),
2092                       NULL, 0,
2093                       (time_t)0, (uint32_t)0);
2094
2095     assert(rc == MEMCACHED_SUCCESS);
2096
2097     value= memcached_get(memc, key, strlen(key),
2098                          &length, &flags, &rc);
2099
2100     assert(rc == MEMCACHED_SUCCESS);
2101     assert(value == NULL);
2102     assert(length == 0);
2103     assert(flags == 0);
2104
2105     value= memcached_get(memc, key, strlen(key),
2106                          &length, &flags, &rc);
2107
2108     assert(rc == MEMCACHED_SUCCESS);
2109     assert(value == NULL);
2110     assert(length == 0);
2111     assert(flags == 0);
2112   }
2113
2114   return 0;
2115 }
2116
2117 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2118 static test_return  user_supplied_bug16(memcached_st *memc)
2119 {
2120   memcached_return rc;
2121   char *key= "mykey";
2122   char *value;
2123   size_t length;
2124   uint32_t flags;
2125
2126   rc= memcached_set(memc, key, strlen(key),
2127                     NULL, 0,
2128                     (time_t)0, UINT32_MAX);
2129
2130   assert(rc == MEMCACHED_SUCCESS);
2131
2132   value= memcached_get(memc, key, strlen(key),
2133                        &length, &flags, &rc);
2134
2135   assert(rc == MEMCACHED_SUCCESS);
2136   assert(value == NULL);
2137   assert(length == 0);
2138   assert(flags == UINT32_MAX);
2139
2140   return 0;
2141 }
2142
2143 /* Check the validity of chinese key*/
2144 static test_return  user_supplied_bug17(memcached_st *memc)
2145 {
2146     memcached_return rc;
2147     char *key= "豆瓣";
2148     char *value="我们在炎热抑郁的夏天无法停止豆瓣";
2149     char *value2;
2150     size_t length;
2151     uint32_t flags;
2152
2153     rc= memcached_set(memc, key, strlen(key),
2154             value, strlen(value),
2155             (time_t)0, 0);
2156
2157     assert(rc == MEMCACHED_SUCCESS);
2158
2159     value2= memcached_get(memc, key, strlen(key),
2160             &length, &flags, &rc);
2161
2162     assert(length==strlen(value));
2163     assert(rc == MEMCACHED_SUCCESS);
2164     assert(memcmp(value, value2, length)==0);
2165     free(value2);
2166
2167     return 0;
2168 }
2169
2170 /*
2171   From Andrei on IRC
2172 */
2173
2174 test_return user_supplied_bug19(memcached_st *memc)
2175 {
2176   memcached_st *m;
2177   memcached_server_st *s;
2178   memcached_return res;
2179
2180   (void)memc;
2181
2182   m= memcached_create(NULL);
2183   memcached_server_add_with_weight(m, "localhost", 11311, 100);
2184   memcached_server_add_with_weight(m, "localhost", 11312, 100);
2185
2186   s= memcached_server_by_key(m, "a", 1, &res);
2187   memcached_server_free(s);
2188
2189   memcached_free(m);
2190
2191   return 0;
2192 }
2193
2194 /* CAS test from Andei */
2195 test_return user_supplied_bug20(memcached_st *memc)
2196 {
2197   memcached_return status;
2198   memcached_result_st *result, result_obj;
2199   char *key = "abc";
2200   size_t key_len = strlen("abc");
2201   char *value = "foobar";
2202   size_t value_len = strlen(value);
2203
2204   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
2205
2206   status = memcached_set(memc, key, key_len, value, value_len, (time_t)0, (uint32_t)0);
2207   assert(status == MEMCACHED_SUCCESS);
2208
2209   status = memcached_mget(memc, &key, &key_len, 1);
2210   assert(status == MEMCACHED_SUCCESS);
2211
2212   result= memcached_result_create(memc, &result_obj);
2213   assert(result);
2214
2215   memcached_result_create(memc, &result_obj);
2216   result= memcached_fetch_result(memc, &result_obj, &status);
2217
2218   assert(result);
2219   assert(status == MEMCACHED_SUCCESS);
2220
2221   memcached_result_free(result);
2222
2223   return 0;
2224 }
2225
2226 #include "ketama_test_cases.h"
2227 test_return user_supplied_bug18(memcached_st *trash)
2228 {
2229   memcached_return rc;
2230   int value;
2231   int i;
2232   memcached_server_st *server_pool;
2233   memcached_st *memc;
2234
2235   (void)trash;
2236
2237   memc= memcached_create(NULL);
2238   assert(memc);
2239
2240   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
2241   assert(rc == MEMCACHED_SUCCESS);
2242
2243   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
2244   assert(value == 1);
2245
2246   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
2247   assert(rc == MEMCACHED_SUCCESS);
2248
2249   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
2250   assert(value == MEMCACHED_HASH_MD5);
2251
2252   server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
2253   memcached_server_push(memc, server_pool);
2254
2255   /* verify that the server list was parsed okay. */
2256   assert(memc->number_of_hosts == 8);
2257   assert(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
2258   assert(server_pool[0].port == 11211);
2259   assert(server_pool[0].weight == 600);
2260   assert(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
2261   assert(server_pool[2].port == 11211);
2262   assert(server_pool[2].weight == 200);
2263   assert(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
2264   assert(server_pool[7].port == 11211);
2265   assert(server_pool[7].weight == 100);
2266
2267   /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2268    * us test the boundary wraparound.
2269    */
2270   assert(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
2271
2272   /* verify the standard ketama set. */
2273   for (i= 0; i < 99; i++)
2274   {
2275     uint32_t server_idx = memcached_generate_hash(memc, test_cases[i].key, strlen(test_cases[i].key));
2276     char *hostname = memc->hosts[server_idx].hostname;
2277     assert(strcmp(hostname, test_cases[i].server) == 0);
2278   }
2279
2280   memcached_server_list_free(server_pool);
2281   memcached_free(memc);
2282
2283   return 0;
2284 }
2285
2286 static test_return  result_static(memcached_st *memc)
2287 {
2288   memcached_result_st result;
2289   memcached_result_st *result_ptr;
2290
2291   result_ptr= memcached_result_create(memc, &result);
2292   assert(result.is_allocated == false);
2293   assert(result_ptr);
2294   memcached_result_free(&result);
2295
2296   return 0;
2297 }
2298
2299 static test_return  result_alloc(memcached_st *memc)
2300 {
2301   memcached_result_st *result;
2302
2303   result= memcached_result_create(memc, NULL);
2304   assert(result);
2305   memcached_result_free(result);
2306
2307   return 0;
2308 }
2309
2310 static test_return  string_static_null(memcached_st *memc)
2311 {
2312   memcached_string_st string;
2313   memcached_string_st *string_ptr;
2314
2315   string_ptr= memcached_string_create(memc, &string, 0);
2316   assert(string.is_allocated == false);
2317   assert(string_ptr);
2318   memcached_string_free(&string);
2319
2320   return 0;
2321 }
2322
2323 static test_return  string_alloc_null(memcached_st *memc)
2324 {
2325   memcached_string_st *string;
2326
2327   string= memcached_string_create(memc, NULL, 0);
2328   assert(string);
2329   memcached_string_free(string);
2330
2331   return 0;
2332 }
2333
2334 static test_return  string_alloc_with_size(memcached_st *memc)
2335 {
2336   memcached_string_st *string;
2337
2338   string= memcached_string_create(memc, NULL, 1024);
2339   assert(string);
2340   memcached_string_free(string);
2341
2342   return 0;
2343 }
2344
2345 static test_return  string_alloc_with_size_toobig(memcached_st *memc)
2346 {
2347   memcached_string_st *string;
2348
2349   string= memcached_string_create(memc, NULL, INT64_MAX);
2350   assert(string == NULL);
2351
2352   return 0;
2353 }
2354
2355 static test_return  string_alloc_append(memcached_st *memc)
2356 {
2357   unsigned int x;
2358   char buffer[SMALL_STRING_LEN];
2359   memcached_string_st *string;
2360
2361   /* Ring the bell! */
2362   memset(buffer, 6, SMALL_STRING_LEN);
2363
2364   string= memcached_string_create(memc, NULL, 100);
2365   assert(string);
2366
2367   for (x= 0; x < 1024; x++)
2368   {
2369     memcached_return rc;
2370     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
2371     assert(rc == MEMCACHED_SUCCESS);
2372   }
2373   memcached_string_free(string);
2374
2375   return 0;
2376 }
2377
2378 static test_return  string_alloc_append_toobig(memcached_st *memc)
2379 {
2380   memcached_return rc;
2381   unsigned int x;
2382   char buffer[SMALL_STRING_LEN];
2383   memcached_string_st *string;
2384
2385   /* Ring the bell! */
2386   memset(buffer, 6, SMALL_STRING_LEN);
2387
2388   string= memcached_string_create(memc, NULL, 100);
2389   assert(string);
2390
2391   for (x= 0; x < 1024; x++)
2392   {
2393     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
2394     assert(rc == MEMCACHED_SUCCESS);
2395   }
2396   rc= memcached_string_append(string, buffer, INT64_MAX);
2397   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
2398   memcached_string_free(string);
2399
2400   return 0;
2401 }
2402
2403 static test_return  cleanup_pairs(memcached_st *memc __attribute__((unused)))
2404 {
2405   pairs_free(global_pairs);
2406
2407   return 0;
2408 }
2409
2410 static test_return  generate_pairs(memcached_st *memc __attribute__((unused)))
2411 {
2412   unsigned long long x;
2413   global_pairs= pairs_generate(GLOBAL_COUNT, 400);
2414   global_count= GLOBAL_COUNT;
2415
2416   for (x= 0; x < global_count; x++)
2417   {
2418     global_keys[x]= global_pairs[x].key;
2419     global_keys_length[x]=  global_pairs[x].key_length;
2420   }
2421
2422   return 0;
2423 }
2424
2425 static test_return  generate_large_pairs(memcached_st *memc __attribute__((unused)))
2426 {
2427   unsigned long long x;
2428   global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
2429   global_count= GLOBAL2_COUNT;
2430
2431   for (x= 0; x < global_count; x++)
2432   {
2433     global_keys[x]= global_pairs[x].key;
2434     global_keys_length[x]=  global_pairs[x].key_length;
2435   }
2436
2437   return 0;
2438 }
2439
2440 static test_return  generate_data(memcached_st *memc)
2441 {
2442   execute_set(memc, global_pairs, global_count);
2443
2444   return 0;
2445 }
2446
2447 static test_return  generate_data_with_stats(memcached_st *memc)
2448 {
2449   memcached_stat_st *stat_p;
2450   memcached_return rc;
2451   uint32_t host_index= 0;
2452   execute_set(memc, global_pairs, global_count);
2453
2454   //TODO: hosts used size stats
2455   stat_p= memcached_stat(memc, NULL, &rc);
2456   assert(stat_p);
2457
2458   for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++)
2459   {
2460       printf("\nserver %u|%s|%u bytes: %llu\n", host_index, (memc->hosts)[host_index].hostname, (memc->hosts)[host_index].port, (unsigned long long)(stat_p + host_index)->bytes);
2461   }
2462
2463   memcached_stat_free(NULL, stat_p);
2464
2465   return 0;
2466 }
2467 static test_return  generate_buffer_data(memcached_st *memc)
2468 {
2469   int latch= 0;
2470
2471   latch= 1;
2472   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
2473   generate_data(memc);
2474
2475   return 0;
2476 }
2477
2478 static test_return  get_read_count(memcached_st *memc)
2479 {
2480   unsigned int x;
2481   memcached_return rc;
2482   memcached_st *clone;
2483
2484   clone= memcached_clone(NULL, memc);
2485   assert(clone);
2486
2487   memcached_server_add_with_weight(clone, "localhost", 6666, 0);
2488
2489   {
2490     char *return_value;
2491     size_t return_value_length;
2492     uint32_t flags;
2493     uint32_t count;
2494
2495     for (x= count= 0; x < global_count; x++)
2496     {
2497       return_value= memcached_get(clone, global_keys[x], global_keys_length[x],
2498                                   &return_value_length, &flags, &rc);
2499       if (rc == MEMCACHED_SUCCESS)
2500       {
2501         count++;
2502         if (return_value)
2503           free(return_value);
2504       }
2505     }
2506     fprintf(stderr, "\t%u -> %u", global_count, count);
2507   }
2508
2509   memcached_free(clone);
2510
2511   return 0;
2512 }
2513
2514 static test_return  get_read(memcached_st *memc)
2515 {
2516   unsigned int x;
2517   memcached_return rc;
2518
2519   {
2520     char *return_value;
2521     size_t return_value_length;
2522     uint32_t flags;
2523
2524     for (x= 0; x < global_count; x++)
2525     {
2526       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
2527                                   &return_value_length, &flags, &rc);
2528       /*
2529       assert(return_value);
2530       assert(rc == MEMCACHED_SUCCESS);
2531     */
2532       if (rc == MEMCACHED_SUCCESS && return_value)
2533         free(return_value);
2534     }
2535   }
2536
2537   return 0;
2538 }
2539
2540 static test_return  mget_read(memcached_st *memc)
2541 {
2542   memcached_return rc;
2543
2544   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2545   assert(rc == MEMCACHED_SUCCESS);
2546   /* Turn this into a help function */
2547   {
2548     char return_key[MEMCACHED_MAX_KEY];
2549     size_t return_key_length;
2550     char *return_value;
2551     size_t return_value_length;
2552     uint32_t flags;
2553
2554     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2555                                           &return_value_length, &flags, &rc)))
2556     {
2557       assert(return_value);
2558       assert(rc == MEMCACHED_SUCCESS);
2559       free(return_value);
2560     }
2561   }
2562
2563   return 0;
2564 }
2565
2566 static test_return  mget_read_result(memcached_st *memc)
2567 {
2568   memcached_return rc;
2569
2570   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2571   assert(rc == MEMCACHED_SUCCESS);
2572   /* Turn this into a help function */
2573   {
2574     memcached_result_st results_obj;
2575     memcached_result_st *results;
2576
2577     results= memcached_result_create(memc, &results_obj);
2578
2579     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
2580     {
2581       assert(results);
2582       assert(rc == MEMCACHED_SUCCESS);
2583     }
2584
2585     memcached_result_free(&results_obj);
2586   }
2587
2588   return 0;
2589 }
2590
2591 static test_return  mget_read_function(memcached_st *memc)
2592 {
2593   memcached_return rc;
2594   unsigned int counter;
2595   memcached_execute_function callbacks[1];
2596
2597   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2598   assert(rc == MEMCACHED_SUCCESS);
2599
2600   callbacks[0]= &callback_counter;
2601   counter= 0;
2602   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
2603
2604   return 0;
2605 }
2606
2607 static test_return  delete_generate(memcached_st *memc)
2608 {
2609   unsigned int x;
2610
2611   for (x= 0; x < global_count; x++)
2612   {
2613     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2614   }
2615
2616   return 0;
2617 }
2618
2619 static test_return  delete_buffer_generate(memcached_st *memc)
2620 {
2621   int latch= 0;
2622   unsigned int x;
2623
2624   latch= 1;
2625   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
2626
2627   for (x= 0; x < global_count; x++)
2628   {
2629     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2630   }
2631
2632   return 0;
2633 }
2634
2635 static test_return  free_data(memcached_st *memc __attribute__((unused)))
2636 {
2637   pairs_free(global_pairs);
2638
2639   return 0;
2640 }
2641
2642 static test_return  add_host_test1(memcached_st *memc)
2643 {
2644   unsigned int x;
2645   memcached_return rc;
2646   char servername[]= "0.example.com";
2647   memcached_server_st *servers;
2648
2649   servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
2650   assert(servers);
2651   assert(1 == memcached_server_list_count(servers));
2652
2653   for (x= 2; x < 20; x++)
2654   {
2655     char buffer[SMALL_STRING_LEN];
2656
2657     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
2658     servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
2659                                      &rc);
2660     assert(rc == MEMCACHED_SUCCESS);
2661     assert(x == memcached_server_list_count(servers));
2662   }
2663
2664   rc= memcached_server_push(memc, servers);
2665   assert(rc == MEMCACHED_SUCCESS);
2666   rc= memcached_server_push(memc, servers);
2667   assert(rc == MEMCACHED_SUCCESS);
2668
2669   memcached_server_list_free(servers);
2670
2671   return 0;
2672 }
2673
2674 static memcached_return  pre_nonblock(memcached_st *memc)
2675 {
2676   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
2677
2678   return MEMCACHED_SUCCESS;
2679 }
2680
2681 static memcached_return  pre_nonblock_binary(memcached_st *memc)
2682 {
2683   memcached_return rc= MEMCACHED_FAILURE;
2684   memcached_st *clone;
2685
2686   clone= memcached_clone(NULL, memc);
2687   assert(clone);
2688   // The memcached_version needs to be done on a clone, because the server
2689   // will not toggle protocol on an connection.
2690   memcached_version(clone);
2691
2692   if (clone->hosts[0].major_version >= 1 && clone->hosts[0].minor_version > 2)
2693   {
2694     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
2695     rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
2696     assert(rc == MEMCACHED_SUCCESS);
2697     assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
2698   }
2699
2700   memcached_free(clone);
2701   return rc;
2702 }
2703
2704 static memcached_return  pre_murmur(memcached_st *memc)
2705 {
2706   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
2707
2708   return MEMCACHED_SUCCESS;
2709 }
2710
2711 static memcached_return pre_jenkins(memcached_st *memc)
2712 {
2713   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_JENKINS);
2714
2715   return MEMCACHED_SUCCESS;
2716 }
2717
2718
2719 static memcached_return  pre_md5(memcached_st *memc)
2720 {
2721   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5);
2722
2723   return MEMCACHED_SUCCESS;
2724 }
2725
2726 static memcached_return  pre_crc(memcached_st *memc)
2727 {
2728   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_CRC);
2729
2730   return MEMCACHED_SUCCESS;
2731 }
2732
2733 static memcached_return  pre_hsieh(memcached_st *memc)
2734 {
2735   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH);
2736
2737   return MEMCACHED_SUCCESS;
2738 }
2739
2740 static memcached_return  pre_hash_fnv1_64(memcached_st *memc)
2741 {
2742   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_64);
2743
2744   return MEMCACHED_SUCCESS;
2745 }
2746
2747 static memcached_return  pre_hash_fnv1a_64(memcached_st *memc)
2748 {
2749   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64);
2750
2751   return MEMCACHED_SUCCESS;
2752 }
2753
2754 static memcached_return  pre_hash_fnv1_32(memcached_st *memc)
2755 {
2756   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_32);
2757
2758   return MEMCACHED_SUCCESS;
2759 }
2760
2761 static memcached_return  pre_hash_fnv1a_32(memcached_st *memc)
2762 {
2763   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_32);
2764
2765   return MEMCACHED_SUCCESS;
2766 }
2767
2768 static memcached_return  pre_behavior_ketama(memcached_st *memc)
2769 {
2770   memcached_return rc;
2771   uint64_t value;
2772
2773   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1);
2774   assert(rc == MEMCACHED_SUCCESS);
2775
2776   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);
2777   assert(value == 1);
2778
2779   return MEMCACHED_SUCCESS;
2780 }
2781
2782 static memcached_return  pre_behavior_ketama_weighted(memcached_st *memc)
2783 {
2784   memcached_return rc;
2785   uint64_t value;
2786
2787   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
2788   assert(rc == MEMCACHED_SUCCESS);
2789
2790   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
2791   assert(value == 1);
2792
2793   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
2794   assert(rc == MEMCACHED_SUCCESS);
2795
2796   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
2797   assert(value == MEMCACHED_HASH_MD5);
2798   return MEMCACHED_SUCCESS;
2799 }
2800
2801 static memcached_return  pre_binary(memcached_st *memc)
2802 {
2803   memcached_return rc= MEMCACHED_FAILURE;
2804   memcached_st *clone;
2805
2806   clone= memcached_clone(NULL, memc);
2807   assert(clone);
2808   // The memcached_version needs to be done on a clone, because the server
2809   // will not toggle protocol on an connection.
2810   memcached_version(clone);
2811
2812   if (clone->hosts[0].major_version >= 1 && clone->hosts[0].minor_version > 2)
2813   {
2814     rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
2815     assert(rc == MEMCACHED_SUCCESS);
2816     assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
2817   }
2818
2819   memcached_free(clone);
2820   return rc;
2821 }
2822
2823 static void my_free(memcached_st *ptr __attribute__((unused)), void *mem)
2824 {
2825   free(mem);
2826 }
2827
2828 static void *my_malloc(memcached_st *ptr __attribute__((unused)), const size_t size)
2829 {
2830   return malloc(size);
2831 }
2832
2833 static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, const size_t size)
2834 {
2835   return realloc(mem, size);
2836 }
2837
2838 static memcached_return set_prefix(memcached_st *memc)
2839 {
2840   memcached_return rc;
2841   const char *key= "mine";
2842   char *value;
2843
2844   /* Make sure be default none exists */
2845   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
2846   assert(rc == MEMCACHED_FAILURE);
2847
2848   /* Test a clean set */
2849   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
2850   assert(rc == MEMCACHED_SUCCESS);
2851
2852   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
2853   assert(memcmp(value, key, 4) == 0);
2854   assert(rc == MEMCACHED_SUCCESS);
2855
2856   /* Test that we can turn it off */
2857   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
2858   assert(rc == MEMCACHED_SUCCESS);
2859
2860   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
2861   assert(rc == MEMCACHED_FAILURE);
2862
2863   /* Now setup for main test */
2864   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
2865   assert(rc == MEMCACHED_SUCCESS);
2866
2867   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
2868   assert(rc == MEMCACHED_SUCCESS);
2869   assert(memcmp(value, key, 4) == 0);
2870
2871   /* Set to Zero, and then Set to something too large */
2872   {
2873     char *long_key;
2874     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
2875     assert(rc == MEMCACHED_SUCCESS);
2876
2877     value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
2878     assert(rc == MEMCACHED_FAILURE);
2879     assert(value == NULL);
2880
2881     /* Test a long key for failure */
2882     /* TODO, extend test to determine based on setting, what result should be */
2883     long_key= "Thisismorethentheallottednumberofcharacters";
2884     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
2885     //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
2886     assert(rc == MEMCACHED_SUCCESS);
2887
2888     /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
2889     long_key= "This is more then the allotted number of characters";
2890     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
2891     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
2892
2893     /* Test for a bad prefix, but with a short key */
2894     rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
2895     assert(rc == MEMCACHED_SUCCESS);
2896
2897     long_key= "dog cat";
2898     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
2899     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
2900   }
2901
2902   return MEMCACHED_SUCCESS;
2903 }
2904
2905 static memcached_return  set_memory_alloc(memcached_st *memc)
2906 {
2907   {
2908     memcached_malloc_function test_ptr;
2909     memcached_return rc;
2910
2911     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, (void*)&my_malloc);
2912     assert(rc == MEMCACHED_SUCCESS);
2913     test_ptr= (memcached_malloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
2914     assert(rc == MEMCACHED_SUCCESS);
2915     assert(test_ptr == my_malloc);
2916   }
2917
2918   {
2919     memcached_realloc_function test_ptr;
2920     memcached_return rc;
2921
2922     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, (void*)&my_realloc);
2923     assert(rc == MEMCACHED_SUCCESS);
2924     test_ptr= (memcached_realloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
2925     assert(rc == MEMCACHED_SUCCESS);
2926     assert(test_ptr == my_realloc);
2927   }
2928
2929   {
2930     memcached_free_function test_ptr;
2931     memcached_return rc;
2932
2933     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, (void*)my_free);
2934     assert(rc == MEMCACHED_SUCCESS);
2935     test_ptr= (memcached_free_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
2936     assert(rc == MEMCACHED_SUCCESS);
2937     assert(test_ptr == my_free);
2938   }
2939
2940   return MEMCACHED_SUCCESS;
2941 }
2942
2943 static memcached_return  enable_consistent(memcached_st *memc)
2944 {
2945   memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;
2946   memcached_hash hash;
2947   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
2948   pre_hsieh(memc);
2949
2950   value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
2951   assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
2952
2953   hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
2954   assert(hash == MEMCACHED_HASH_HSIEH);
2955
2956
2957   return MEMCACHED_SUCCESS;
2958 }
2959
2960 static memcached_return  enable_cas(memcached_st *memc)
2961 {
2962   unsigned int set= 1;
2963
2964   memcached_version(memc);
2965
2966   if ((memc->hosts[0].major_version >= 1 && (memc->hosts[0].minor_version == 2 && memc->hosts[0].micro_version >= 4))
2967       || memc->hosts[0].minor_version > 2)
2968   {
2969     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
2970
2971     return MEMCACHED_SUCCESS;
2972   }
2973
2974   return MEMCACHED_FAILURE;
2975 }
2976
2977 static memcached_return  check_for_1_2_3(memcached_st *memc)
2978 {
2979   memcached_version(memc);
2980
2981   if ((memc->hosts[0].major_version >= 1 && (memc->hosts[0].minor_version == 2 && memc->hosts[0].micro_version >= 4))
2982       || memc->hosts[0].minor_version > 2)
2983     return MEMCACHED_SUCCESS;
2984
2985   return MEMCACHED_FAILURE;
2986 }
2987
2988 static memcached_return  pre_unix_socket(memcached_st *memc)
2989 {
2990   memcached_return rc;
2991   struct stat buf;
2992
2993   memcached_server_list_free(memc->hosts);
2994   memc->hosts= NULL;
2995   memc->number_of_hosts= 0;
2996
2997   if (stat("/tmp/memcached.socket", &buf))
2998     return MEMCACHED_FAILURE;
2999
3000   rc= memcached_server_add_unix_socket_with_weight(memc, "/tmp/memcached.socket", 0);
3001
3002   return rc;
3003 }
3004
3005 static memcached_return  pre_nodelay(memcached_st *memc)
3006 {
3007   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
3008   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
3009
3010   return MEMCACHED_SUCCESS;
3011 }
3012
3013 static memcached_return  pre_settimer(memcached_st *memc)
3014 {
3015   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
3016   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
3017
3018   return MEMCACHED_SUCCESS;
3019 }
3020
3021 static memcached_return  poll_timeout(memcached_st *memc)
3022 {
3023   int32_t timeout;
3024
3025   timeout= 100;
3026
3027   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
3028
3029   timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
3030
3031   assert(timeout == 100);
3032
3033   return MEMCACHED_SUCCESS;
3034 }
3035
3036 static test_return noreply_test(memcached_st *memc)
3037 {
3038   memcached_return ret;
3039   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
3040   assert(ret == MEMCACHED_SUCCESS);
3041   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
3042   assert(ret == MEMCACHED_SUCCESS);
3043   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
3044   assert(ret == MEMCACHED_SUCCESS);
3045   assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY) == 1);
3046   assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS) == 1);
3047   assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS) == 1);
3048
3049   for (int count=0; count < 5; ++count)
3050   {
3051     for (int x=0; x < 100; ++x)
3052     {
3053       char key[10];
3054       size_t len=sprintf(key, "%d", x);
3055       switch (count)
3056       {
3057       case 0:
3058         ret=memcached_add(memc, key, len, key, len, 0, 0);
3059         break;
3060       case 1:
3061         ret=memcached_replace(memc, key, len, key, len, 0, 0);
3062         break;
3063       case 2:
3064         ret=memcached_set(memc, key, len, key, len, 0, 0);
3065         break;
3066       case 3:
3067         ret=memcached_append(memc, key, len, key, len, 0, 0);
3068         break;
3069       case 4:
3070         ret=memcached_prepend(memc, key, len, key, len, 0, 0);
3071         break;
3072       }
3073       assert(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED);
3074     }
3075
3076     /*
3077     ** NOTE: Don't ever do this in your code! this is not a supported use of the
3078     ** API and is _ONLY_ done this way to verify that the library works the
3079     ** way it is supposed to do!!!!
3080     */
3081     int no_msg=0;
3082     for (int x=0; x < memc->number_of_hosts; ++x)
3083       no_msg+=memc->hosts[x].cursor_active;
3084
3085     assert(no_msg == 0);
3086     assert(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
3087
3088     /*
3089      ** Now validate that all items was set properly!
3090      */
3091     for (int x=0; x < 100; ++x)
3092     {
3093       char key[10];
3094       size_t len=sprintf(key, "%d", x);
3095       size_t length;
3096       uint32_t flags;
3097       char* value=memcached_get(memc, key, strlen(key),
3098                                 &length, &flags, &ret);
3099       assert(ret == MEMCACHED_SUCCESS && value != NULL);
3100       switch (count)
3101       {
3102       case 0: /* FALLTHROUGH */
3103       case 1: /* FALLTHROUGH */
3104       case 2:
3105         assert(strncmp(value, key, len) == 0);
3106         assert(len == length);
3107         break;
3108       case 3:
3109         assert(length == len * 2);
3110         break;
3111       case 4:
3112         assert(length == len * 3);
3113         break;
3114       }
3115       free(value);
3116     }
3117   }
3118
3119   /* Try setting an illegal cas value (should not return an error to
3120    * the caller (because we don't expect a return message from the server)
3121    */
3122   char* keys[]= {"0"};
3123   size_t lengths[]= {1};
3124   size_t length;
3125   uint32_t flags;
3126   memcached_result_st results_obj;
3127   memcached_result_st *results;
3128   ret=memcached_mget(memc, keys, lengths, 1);
3129   assert(ret == MEMCACHED_SUCCESS);
3130
3131   results=memcached_result_create(memc, &results_obj);
3132   assert(results);
3133   results=memcached_fetch_result(memc, &results_obj, &ret);
3134   assert(results);
3135   assert(ret == MEMCACHED_SUCCESS);
3136   uint64_t cas= memcached_result_cas(results);
3137   memcached_result_free(&results_obj);
3138
3139   ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
3140   assert(ret == MEMCACHED_SUCCESS);
3141
3142   /*
3143    * The item will have a new cas value, so try to set it again with the old
3144    * value. This should fail!
3145    */
3146   ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
3147   assert(ret == MEMCACHED_SUCCESS);
3148   assert(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
3149   char* value=memcached_get(memc, keys[0], lengths[0], &length, &flags, &ret);
3150   assert(ret == MEMCACHED_SUCCESS && value != NULL);
3151   free(value);
3152
3153   return TEST_SUCCESS;
3154 }
3155
3156 static test_return analyzer_test(memcached_st *memc)
3157 {
3158   memcached_return rc;
3159   memcached_stat_st *stat;
3160   memcached_analysis_st *report;
3161
3162   stat= memcached_stat(memc, NULL, &rc);
3163   assert(rc == MEMCACHED_SUCCESS);
3164   assert(stat);
3165
3166   report= memcached_analyze(memc, stat, &rc);
3167   assert(rc == MEMCACHED_SUCCESS);
3168   assert(report);
3169
3170   free(report);
3171   memcached_stat_free(NULL, stat);
3172
3173   return TEST_SUCCESS;
3174 }
3175
3176 static void increment_request_id(uint16_t *id) {
3177   (*id)++;
3178   if ((*id & UDP_REQUEST_ID_THREAD_MASK) != 0)
3179     *id= 0;
3180 }
3181
3182 static uint16_t *get_udp_request_ids(memcached_st *memc)
3183 {
3184   uint16_t *ids= malloc(sizeof(uint16_t) * memc->number_of_hosts);
3185   assert(ids != NULL);
3186   unsigned int i;
3187   for (i= 0; i < memc->number_of_hosts; i++)
3188     ids[i]= get_udp_datagram_request_id((struct udp_datagram_header_st *) memc->hosts[i].write_buffer);
3189
3190   return ids;
3191 }
3192
3193 static test_return post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ids) {
3194   unsigned int i;
3195   memcached_server_st *cur_server = memc->hosts;
3196   uint16_t *cur_req_ids = get_udp_request_ids(memc);
3197   for (i= 0; i < memc->number_of_hosts; i++)
3198   {
3199     assert(cur_server[i].cursor_active == 0);
3200     assert(cur_req_ids[i] == expected_req_ids[i]);
3201   }
3202   free(expected_req_ids);
3203   free(cur_req_ids);
3204   return TEST_SUCCESS;
3205 }
3206
3207 /*
3208 ** There is a little bit of a hack here, instead of removing
3209 ** the servers, I just set num host to 0 and them add then new udp servers
3210 **/
3211 static memcached_return init_udp(memcached_st *memc)
3212 {
3213   memcached_version(memc);
3214   if (memc->hosts[0].major_version != 1 || memc->hosts[0].minor_version != 2)
3215     return MEMCACHED_FAILURE;
3216
3217   uint32_t num_hosts= memc->number_of_hosts;
3218   unsigned int i= 0;
3219   memcached_server_st servers[num_hosts];
3220   memcpy(servers, memc->hosts, sizeof(memcached_server_st) * num_hosts);
3221   memc->number_of_hosts= 0;
3222   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1);
3223   for (i= 0; i < num_hosts; i++)
3224   {
3225     assert(memcached_server_add_udp(memc, servers[i].hostname, servers[i].port) == MEMCACHED_SUCCESS);
3226     assert(memc->hosts[i].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
3227   }
3228   return MEMCACHED_SUCCESS;
3229 }
3230
3231 static memcached_return binary_init_udp(memcached_st *memc)
3232 {
3233   pre_binary(memc);
3234   return init_udp(memc);
3235 }
3236
3237 /* Make sure that I cant add a tcp server to a udp client */
3238 static test_return add_tcp_server_udp_client_test(memcached_st *memc)
3239 {
3240   memcached_server_st server;
3241   memcached_server_clone(&server, &memc->hosts[0]);
3242   assert(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
3243   assert(memcached_server_add(memc, server.hostname, server.port) == MEMCACHED_INVALID_HOST_PROTOCOL);
3244   return TEST_SUCCESS;
3245 }
3246
3247 /* Make sure that I cant add a udp server to a tcp client */
3248 static test_return add_udp_server_tcp_client_test(memcached_st *memc)
3249 {
3250   memcached_server_st server;
3251   memcached_server_clone(&server, &memc->hosts[0]);
3252   assert(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
3253
3254   memcached_st tcp_client;
3255   memcached_create(&tcp_client);
3256   assert(memcached_server_add_udp(&tcp_client, server.hostname, server.port) == MEMCACHED_INVALID_HOST_PROTOCOL);
3257   return TEST_SUCCESS;
3258 }
3259
3260 static test_return set_udp_behavior_test(memcached_st *memc)
3261 {
3262
3263   memcached_quit(memc);
3264   memc->number_of_hosts= 0;
3265   run_distribution(memc);
3266   assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1) == MEMCACHED_SUCCESS);
3267   assert(memc->flags & MEM_USE_UDP);
3268   assert(memc->flags & MEM_NOREPLY);;
3269
3270   assert(memc->number_of_hosts == 0);
3271
3272   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP,0);
3273   assert(!(memc->flags & MEM_USE_UDP));
3274   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY,0);
3275   assert(!(memc->flags & MEM_NOREPLY));
3276   return TEST_SUCCESS;
3277 }
3278
3279 static test_return udp_set_test(memcached_st *memc)
3280 {
3281   unsigned int i= 0;
3282   unsigned int num_iters= 1025; //request id rolls over at 1024
3283   for (i= 0; i < num_iters;i++)
3284   {
3285     memcached_return rc;
3286     char *key= "foo";
3287     char *value= "when we sanitize";
3288     uint16_t *expected_ids= get_udp_request_ids(memc);
3289     unsigned int server_key= memcached_generate_hash(memc,key,strlen(key));
3290     size_t init_offset= memc->hosts[server_key].write_buffer_offset;
3291     rc= memcached_set(memc, key, strlen(key),
3292                       value, strlen(value),
3293                       (time_t)0, (uint32_t)0);
3294     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
3295     /** NB, the check below assumes that if new write_ptr is less than
3296      *  the original write_ptr that we have flushed. For large payloads, this
3297      *  maybe an invalid assumption, but for the small payload we have it is OK
3298      */
3299     if (rc == MEMCACHED_SUCCESS ||
3300             memc->hosts[server_key].write_buffer_offset < init_offset)
3301       increment_request_id(&expected_ids[server_key]);
3302
3303     if (rc == MEMCACHED_SUCCESS) {
3304       assert(memc->hosts[server_key].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
3305     } else {
3306       assert(memc->hosts[server_key].write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
3307       assert(memc->hosts[server_key].write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
3308     }
3309     assert(post_udp_op_check(memc,expected_ids) == TEST_SUCCESS);
3310   }
3311   return TEST_SUCCESS;
3312 }
3313
3314 static test_return udp_buffered_set_test(memcached_st *memc)
3315 {
3316   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
3317   return udp_set_test(memc);
3318 }
3319
3320 static test_return udp_set_too_big_test(memcached_st *memc)
3321 {
3322   memcached_return rc;
3323   char *key= "bar";
3324   char value[MAX_UDP_DATAGRAM_LENGTH];
3325   uint16_t *expected_ids= get_udp_request_ids(memc);
3326   rc= memcached_set(memc, key, strlen(key),
3327                     value, MAX_UDP_DATAGRAM_LENGTH,
3328                     (time_t)0, (uint32_t)0);
3329   assert(rc == MEMCACHED_WRITE_FAILURE);
3330   return post_udp_op_check(memc,expected_ids);
3331 }
3332
3333 test_return udp_delete_test(memcached_st *memc)
3334 {
3335   unsigned int i= 0;
3336   unsigned int num_iters= 1025; //request id rolls over at 1024
3337   for (i= 0; i < num_iters;i++)
3338   {
3339     memcached_return rc;
3340     char *key= "foo";
3341     uint16_t *expected_ids=get_udp_request_ids(memc);
3342     unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
3343     size_t init_offset= memc->hosts[server_key].write_buffer_offset;
3344     rc= memcached_delete(memc, key, strlen(key), 0);
3345     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
3346     if (rc == MEMCACHED_SUCCESS || memc->hosts[server_key].write_buffer_offset < init_offset)
3347       increment_request_id(&expected_ids[server_key]);
3348     if (rc == MEMCACHED_SUCCESS)
3349       assert(memc->hosts[server_key].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
3350     else
3351     {
3352       assert(memc->hosts[server_key].write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
3353       assert(memc->hosts[server_key].write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
3354     }
3355     assert(post_udp_op_check(memc,expected_ids) == TEST_SUCCESS);
3356   }
3357   return TEST_SUCCESS;
3358 }
3359
3360 static test_return udp_buffered_delete_test(memcached_st *memc)
3361 {
3362   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
3363   return udp_delete_test(memc);
3364 }
3365
3366 test_return udp_verbosity_test(memcached_st *memc)
3367 {
3368   memcached_return rc;
3369   uint16_t *expected_ids= get_udp_request_ids(memc);
3370   unsigned int x;
3371   for (x= 0; x < memc->number_of_hosts;x++)
3372     increment_request_id(&expected_ids[x]);
3373
3374   rc= memcached_verbosity(memc,3);
3375   assert(rc == MEMCACHED_SUCCESS);
3376   return post_udp_op_check(memc,expected_ids);
3377 }
3378
3379 test_return udp_quit_test(memcached_st *memc)
3380 {
3381   uint16_t *expected_ids= get_udp_request_ids(memc);
3382   memcached_quit(memc);
3383   return post_udp_op_check(memc, expected_ids);
3384 }
3385
3386 test_return udp_flush_test(memcached_st *memc)
3387 {
3388   memcached_return rc;
3389   uint16_t *expected_ids= get_udp_request_ids(memc);
3390   unsigned int x;
3391   for (x= 0; x < memc->number_of_hosts;x++)
3392     increment_request_id(&expected_ids[x]);
3393
3394   rc= memcached_flush(memc,0);
3395   assert(rc == MEMCACHED_SUCCESS);
3396   return post_udp_op_check(memc,expected_ids);
3397 }
3398
3399 test_return udp_incr_test(memcached_st *memc)
3400 {
3401   memcached_return rc;
3402   char *key= "incr";
3403   char *value= "1";
3404   rc= memcached_set(memc, key, strlen(key),
3405                     value, strlen(value),
3406                     (time_t)0, (uint32_t)0);
3407
3408   assert(rc == MEMCACHED_SUCCESS);
3409   uint16_t *expected_ids= get_udp_request_ids(memc);
3410   unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
3411   increment_request_id(&expected_ids[server_key]);
3412   uint64_t newvalue;
3413   rc= memcached_increment(memc, key, strlen(key), 1, &newvalue);
3414   assert(rc == MEMCACHED_SUCCESS);
3415   return post_udp_op_check(memc, expected_ids);
3416 }
3417
3418 test_return udp_decr_test(memcached_st *memc)
3419 {
3420   memcached_return rc;
3421   char *key= "decr";
3422   char *value= "1";
3423   rc= memcached_set(memc, key, strlen(key),
3424                     value, strlen(value),
3425                     (time_t)0, (uint32_t)0);
3426
3427   assert(rc == MEMCACHED_SUCCESS);
3428   uint16_t *expected_ids= get_udp_request_ids(memc);
3429   unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
3430   increment_request_id(&expected_ids[server_key]);
3431   uint64_t newvalue;
3432   rc= memcached_decrement(memc, key, strlen(key), 1, &newvalue);
3433   assert(rc == MEMCACHED_SUCCESS);
3434   return post_udp_op_check(memc, expected_ids);
3435 }
3436
3437
3438 test_return udp_stat_test(memcached_st *memc)
3439 {
3440   memcached_stat_st * rv= NULL;
3441   memcached_return rc;
3442   char args[]= "";
3443   uint16_t *expected_ids = get_udp_request_ids(memc);
3444   rv = memcached_stat(memc, args, &rc);
3445   free(rv);
3446   assert(rc == MEMCACHED_NOT_SUPPORTED);
3447   return post_udp_op_check(memc, expected_ids);
3448 }
3449
3450 test_return udp_version_test(memcached_st *memc)
3451 {
3452   memcached_return rc;
3453   uint16_t *expected_ids = get_udp_request_ids(memc);
3454   rc = memcached_version(memc);
3455   assert(rc == MEMCACHED_NOT_SUPPORTED);
3456   return post_udp_op_check(memc, expected_ids);
3457 }
3458
3459 test_return udp_get_test(memcached_st *memc)
3460 {
3461   memcached_return rc;
3462   char *key= "foo";
3463   size_t vlen;
3464   uint16_t *expected_ids = get_udp_request_ids(memc);
3465   char *val= memcached_get(memc, key, strlen(key), &vlen, (uint32_t)0, &rc);
3466   assert(rc == MEMCACHED_NOT_SUPPORTED);
3467   assert(val == NULL);
3468   return post_udp_op_check(memc, expected_ids);
3469 }
3470
3471 test_return udp_mixed_io_test(memcached_st *memc)
3472 {
3473   test_st current_op;
3474   test_st mixed_io_ops [] ={
3475     {"udp_set_test", 0, udp_set_test},
3476     {"udp_set_too_big_test", 0, udp_set_too_big_test},
3477     {"udp_delete_test", 0, udp_delete_test},
3478     {"udp_verbosity_test", 0, udp_verbosity_test},
3479     {"udp_quit_test", 0, udp_quit_test},
3480     {"udp_flush_test", 0, udp_flush_test},
3481     {"udp_incr_test", 0, udp_incr_test},
3482     {"udp_decr_test", 0, udp_decr_test},
3483     {"udp_version_test", 0, udp_version_test}
3484   };
3485   unsigned int i= 0;
3486   for (i= 0; i < 500; i++)
3487   {
3488     current_op= mixed_io_ops[random() % 9];
3489     assert(current_op.function(memc) == TEST_SUCCESS);
3490   }
3491   return TEST_SUCCESS;
3492 }
3493
3494 test_st udp_setup_server_tests[] ={
3495   {"set_udp_behavior_test", 0, set_udp_behavior_test},
3496   {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test},
3497   {"add_udp_server_tcp_client_test", 0, add_udp_server_tcp_client_test},
3498   {0, 0, 0}
3499 };
3500
3501 test_st upd_io_tests[] ={
3502   {"udp_set_test", 0, udp_set_test},
3503   {"udp_buffered_set_test", 0, udp_buffered_set_test},
3504   {"udp_set_too_big_test", 0, udp_set_too_big_test},
3505   {"udp_delete_test", 0, udp_delete_test},
3506   {"udp_buffered_delete_test", 0, udp_buffered_delete_test},
3507   {"udp_verbosity_test", 0, udp_verbosity_test},
3508   {"udp_quit_test", 0, udp_quit_test},
3509   {"udp_flush_test", 0, udp_flush_test},
3510   {"udp_incr_test", 0, udp_incr_test},
3511   {"udp_decr_test", 0, udp_decr_test},
3512   {"udp_stat_test", 0, udp_stat_test},
3513   {"udp_version_test", 0, udp_version_test},
3514   {"udp_get_test", 0, udp_get_test},
3515   {"udp_mixed_io_test", 0, udp_mixed_io_test},
3516   {0, 0, 0}
3517 };
3518
3519 /* Clean the server before beginning testing */
3520 test_st tests[] ={
3521   {"flush", 0, flush_test },
3522   {"init", 0, init_test },
3523   {"allocation", 0, allocation_test },
3524   {"server_list_null_test", 0, server_list_null_test},
3525   {"server_unsort", 0, server_unsort_test},
3526   {"server_sort", 0, server_sort_test},
3527   {"server_sort2", 0, server_sort2_test},
3528   {"clone_test", 0, clone_test },
3529   {"error", 0, error_test },
3530   {"set", 0, set_test },
3531   {"set2", 0, set_test2 },
3532   {"set3", 0, set_test3 },
3533   {"add", 1, add_test },
3534   {"replace", 1, replace_test },
3535   {"delete", 1, delete_test },
3536   {"get", 1, get_test },
3537   {"get2", 0, get_test2 },
3538   {"get3", 0, get_test3 },
3539   {"get4", 0, get_test4 },
3540   {"stats_servername", 0, stats_servername_test },
3541   {"increment", 0, increment_test },
3542   {"decrement", 0, decrement_test },
3543   {"quit", 0, quit_test },
3544   {"mget", 1, mget_test },
3545   {"mget_result", 1, mget_result_test },
3546   {"mget_result_alloc", 1, mget_result_alloc_test },
3547   {"mget_result_function", 1, mget_result_function },
3548   {"get_stats", 0, get_stats },
3549   {"add_host_test", 0, add_host_test },
3550   {"add_host_test_1", 0, add_host_test1 },
3551   {"get_stats_keys", 0, get_stats_keys },
3552   {"behavior_test", 0, get_stats_keys },
3553   {"callback_test", 0, get_stats_keys },
3554   {"version_string_test", 0, version_string_test},
3555   {"bad_key", 1, bad_key_test },
3556   {"memcached_server_cursor", 1, memcached_server_cursor_test },
3557   {"read_through", 1, read_through },
3558   {"delete_through", 1, delete_through },
3559   {"noreply", 1, noreply_test},
3560   {"analyzer", 1, analyzer_test},
3561   {0, 0, 0}
3562 };
3563
3564 test_st async_tests[] ={
3565   {"add", 1, add_wrapper },
3566   {0, 0, 0}
3567 };
3568
3569 test_st string_tests[] ={
3570   {"string static with null", 0, string_static_null },
3571   {"string alloc with null", 0, string_alloc_null },
3572   {"string alloc with 1K", 0, string_alloc_with_size },
3573   {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
3574   {"string append", 0, string_alloc_append },
3575   {"string append failure (too big)", 0, string_alloc_append_toobig },
3576   {0, 0, 0}
3577 };
3578
3579 test_st result_tests[] ={
3580   {"result static", 0, result_static},
3581   {"result alloc", 0, result_alloc},
3582   {0, 0, 0}
3583 };
3584
3585 test_st version_1_2_3[] ={
3586   {"append", 0, append_test },
3587   {"prepend", 0, prepend_test },
3588   {"cas", 0, cas_test },
3589   {"cas2", 0, cas2_test },
3590   {"append_binary", 0, append_binary_test },
3591   {0, 0, 0}
3592 };
3593
3594 test_st user_tests[] ={
3595   {"user_supplied_bug1", 0, user_supplied_bug1 },
3596   {"user_supplied_bug2", 0, user_supplied_bug2 },
3597   {"user_supplied_bug3", 0, user_supplied_bug3 },
3598   {"user_supplied_bug4", 0, user_supplied_bug4 },
3599   {"user_supplied_bug5", 1, user_supplied_bug5 },
3600   {"user_supplied_bug6", 1, user_supplied_bug6 },
3601   {"user_supplied_bug7", 1, user_supplied_bug7 },
3602   {"user_supplied_bug8", 1, user_supplied_bug8 },
3603   {"user_supplied_bug9", 1, user_supplied_bug9 },
3604   {"user_supplied_bug10", 1, user_supplied_bug10 },
3605   {"user_supplied_bug11", 1, user_supplied_bug11 },
3606   {"user_supplied_bug12", 1, user_supplied_bug12 },
3607   {"user_supplied_bug13", 1, user_supplied_bug13 },
3608   {"user_supplied_bug14", 1, user_supplied_bug14 },
3609   {"user_supplied_bug15", 1, user_supplied_bug15 },
3610   {"user_supplied_bug16", 1, user_supplied_bug16 },
3611 #ifndef __sun
3612   /*
3613   ** It seems to be something weird with the character sets..
3614   ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
3615   ** guess I need to find out how this is supposed to work.. Perhaps I need
3616   ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
3617   ** so just disable the code for now...).
3618   */
3619   {"user_supplied_bug17", 1, user_supplied_bug17 },
3620 #endif
3621   {"user_supplied_bug18", 1, user_supplied_bug18 },
3622   {"user_supplied_bug19", 1, user_supplied_bug19 },
3623   {"user_supplied_bug20", 1, user_supplied_bug20 },
3624   {0, 0, 0}
3625 };
3626
3627 test_st generate_tests[] ={
3628   {"generate_pairs", 1, generate_pairs },
3629   {"generate_data", 1, generate_data },
3630   {"get_read", 0, get_read },
3631   {"delete_generate", 0, delete_generate },
3632   {"generate_buffer_data", 1, generate_buffer_data },
3633   {"delete_buffer", 0, delete_buffer_generate},
3634   {"generate_data", 1, generate_data },
3635   {"mget_read", 0, mget_read },
3636   {"mget_read_result", 0, mget_read_result },
3637   {"mget_read_function", 0, mget_read_function },
3638   {"cleanup", 1, cleanup_pairs },
3639   {"generate_large_pairs", 1, generate_large_pairs },
3640   {"generate_data", 1, generate_data },
3641   {"generate_buffer_data", 1, generate_buffer_data },
3642   {"cleanup", 1, cleanup_pairs },
3643   {0, 0, 0}
3644 };
3645
3646 test_st consistent_tests[] ={
3647   {"generate_pairs", 1, generate_pairs },
3648   {"generate_data", 1, generate_data },
3649   {"get_read", 0, get_read_count },
3650   {"cleanup", 1, cleanup_pairs },
3651   {0, 0, 0}
3652 };
3653
3654 test_st consistent_weighted_tests[] ={
3655   {"generate_pairs", 1, generate_pairs },
3656   {"generate_data", 1, generate_data_with_stats },
3657   {"get_read", 0, get_read_count },
3658   {"cleanup", 1, cleanup_pairs },
3659   {0, 0, 0}
3660 };
3661
3662 collection_st collection[] ={
3663   {"udp_setup", init_udp, 0, udp_setup_server_tests},
3664   {"udp_io", init_udp, 0, upd_io_tests},
3665   {"udp_binary_io", binary_init_udp, 0, upd_io_tests},
3666   {"block", 0, 0, tests},
3667   {"binary", pre_binary, 0, tests},
3668   {"nonblock", pre_nonblock, 0, tests},
3669   {"nodelay", pre_nodelay, 0, tests},
3670   {"settimer", pre_settimer, 0, tests},
3671   {"md5", pre_md5, 0, tests},
3672   {"crc", pre_crc, 0, tests},
3673   {"hsieh", pre_hsieh, 0, tests},
3674   {"jenkins", pre_jenkins, 0, tests},
3675   {"fnv1_64", pre_hash_fnv1_64, 0, tests},
3676   {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
3677   {"fnv1_32", pre_hash_fnv1_32, 0, tests},
3678   {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
3679   {"ketama", pre_behavior_ketama, 0, tests},
3680   {"unix_socket", pre_unix_socket, 0, tests},
3681   {"unix_socket_nodelay", pre_nodelay, 0, tests},
3682   {"poll_timeout", poll_timeout, 0, tests},
3683   {"gets", enable_cas, 0, tests},
3684   {"consistent", enable_consistent, 0, tests},
3685   {"memory_allocators", set_memory_alloc, 0, tests},
3686   {"prefix", set_prefix, 0, tests},
3687   {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
3688   {"string", 0, 0, string_tests},
3689   {"result", 0, 0, result_tests},
3690   {"async", pre_nonblock, 0, async_tests},
3691   {"async_binary", pre_nonblock_binary, 0, async_tests},
3692   {"user", 0, 0, user_tests},
3693   {"generate", 0, 0, generate_tests},
3694   {"generate_hsieh", pre_hsieh, 0, generate_tests},
3695   {"generate_ketama", pre_behavior_ketama, 0, generate_tests},
3696   {"generate_hsieh_consistent", enable_consistent, 0, generate_tests},
3697   {"generate_md5", pre_md5, 0, generate_tests},
3698   {"generate_murmur", pre_murmur, 0, generate_tests},
3699   {"generate_jenkins", pre_jenkins, 0, generate_tests},
3700   {"generate_nonblock", pre_nonblock, 0, generate_tests},
3701   {"consistent_not", 0, 0, consistent_tests},
3702   {"consistent_ketama", pre_behavior_ketama, 0, consistent_tests},
3703   {"consistent_ketama_weighted", pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
3704   {0, 0, 0, 0}
3705 };
3706
3707 #define SERVERS_TO_CREATE 5
3708
3709 /* Prototypes for functions we will pass to test framework */
3710 void *world_create(void);
3711 void world_destroy(void *p);
3712
3713 void *world_create(void)
3714 {
3715   server_startup_st *construct;
3716
3717   construct= (server_startup_st *)malloc(sizeof(server_startup_st));
3718   memset(construct, 0, sizeof(server_startup_st));
3719   construct->count= SERVERS_TO_CREATE;
3720   construct->udp= 0;
3721   server_startup(construct);
3722
3723   return construct;
3724 }
3725
3726
3727 void world_destroy(void *p)
3728 {
3729   server_startup_st *construct= (server_startup_st *)p;
3730   memcached_server_st *servers= (memcached_server_st *)construct->servers;
3731   memcached_server_list_free(servers);
3732
3733   server_shutdown(construct);
3734   free(construct);
3735 }
3736
3737 void get_world(world_st *world)
3738 {
3739   world->collections= collection;
3740   world->create= world_create;
3741   world->destroy= world_destroy;
3742 }