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

   1 /*
   2   Sample test application.
   3 */
   4 #include <assert.h>
   5 #include <memcached.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <sys/time.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <unistd.h>
  13 #include <time.h>
  14 #include "../lib/common.h"
  15 #include "../src/generator.h"
  16 #include "../src/execute.h"
  17
  18 #include "test.h"
  19
  20 #define GLOBAL_COUNT 100000
  21 static pairs_st *global_pairs;
  22 static char *global_keys[GLOBAL_COUNT];
  23 static size_t global_keys_length[GLOBAL_COUNT];
  24
  25 uint8_t init_test(memcached_st *not_used)
  26 {
  27   memcached_st memc;
  28
  29   (void)memcached_create(&memc);
  30   memcached_free(&memc);
  31
  32   return 0;
  33 }
  34
  35 uint8_t allocation_test(memcached_st *not_used)
  36 {
  37   memcached_st *memc;
  38   memc= memcached_create(NULL);
  39   assert(memc);
  40   memcached_free(memc);
  41
  42   return 0;
  43 }
  44
  45 uint8_t clone_test(memcached_st *memc)
  46 {
  47   /* All null? */
  48   {
  49     memcached_st *clone;
  50     clone= memcached_clone(NULL, NULL);
  51     assert(clone);
  52     memcached_free(clone);
  53   }
  54
  55   /* Can we init from null? */
  56   {
  57     memcached_st *clone;
  58     clone= memcached_clone(NULL, memc);
  59     assert(clone);
  60     memcached_free(clone);
  61   }
  62
  63   /* Can we init from struct? */
  64   {
  65     memcached_st declared_clone;
  66     memcached_st *clone;
  67     clone= memcached_clone(&declared_clone, NULL);
  68     assert(clone);
  69     memcached_free(clone);
  70   }
  71
  72   /* Can we init from struct? */
  73   {
  74     memcached_st declared_clone;
  75     memcached_st *clone;
  76     clone= memcached_clone(&declared_clone, memc);
  77     assert(clone);
  78     memcached_free(clone);
  79   }
  80
  81   return 0;
  82 }
  83
  84 uint8_t connection_test(memcached_st *memc)
  85 {
  86   memcached_return rc;
  87
  88   rc= memcached_server_add(memc, "localhost", 0);
  89   assert(rc == MEMCACHED_SUCCESS);
  90
  91   return 0;
  92 }
  93
  94 uint8_t error_test(memcached_st *memc)
  95 {
  96   memcached_return rc;
  97
  98   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
  99   {
 100     printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
 101   }
 102
 103   return 0;
 104 }
 105
 106 uint8_t set_test(memcached_st *memc)
 107 {
 108   memcached_return rc;
 109   char *key= "foo";
 110   char *value= "when we sanitize";
 111
 112   rc= memcached_set(memc, key, strlen(key),
 113                     value, strlen(value),
 114                     (time_t)0, (uint16_t)0);
 115   assert(rc == MEMCACHED_SUCCESS);
 116
 117   return 0;
 118 }
 119
 120 uint8_t add_test(memcached_st *memc)
 121 {
 122   memcached_return rc;
 123   char *key= "foo";
 124   char *value= "when we sanitize";
 125
 126   rc= memcached_add(memc, key, strlen(key),
 127                     value, strlen(value),
 128                     (time_t)0, (uint16_t)0);
 129   assert(rc == MEMCACHED_NOTSTORED);
 130
 131   return 0;
 132 }
 133
 134 uint8_t replace_test(memcached_st *memc)
 135 {
 136   memcached_return rc;
 137   char *key= "foo";
 138   char *value= "when we sanitize";
 139
 140   rc= memcached_replace(memc, key, strlen(key),
 141                     value, strlen(value),
 142                     (time_t)0, (uint16_t)0);
 143   assert(rc == MEMCACHED_SUCCESS);
 144
 145   return 0;
 146 }
 147
 148 uint8_t delete_test(memcached_st *memc)
 149 {
 150   memcached_return rc;
 151   char *key= "foo";
 152   char *value= "when we sanitize";
 153
 154   rc= memcached_set(memc, key, strlen(key),
 155                     value, strlen(value),
 156                     (time_t)0, (uint16_t)0);
 157   assert(rc == MEMCACHED_SUCCESS);
 158
 159   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 160   assert(rc == MEMCACHED_SUCCESS);
 161
 162   return 0;
 163 }
 164
 165 uint8_t flush_test(memcached_st *memc)
 166 {
 167   memcached_return rc;
 168
 169   rc= memcached_flush(memc, 0);
 170   assert(rc == MEMCACHED_SUCCESS);
 171
 172   return 0;
 173 }
 174
 175 uint8_t get_test(memcached_st *memc)
 176 {
 177   memcached_return rc;
 178   char *key= "foo";
 179   char *string;
 180   size_t string_length;
 181   uint16_t flags;
 182
 183   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 184   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND);
 185
 186   string= memcached_get(memc, key, strlen(key),
 187                         &string_length, &flags, &rc);
 188
 189   assert(rc == MEMCACHED_NOTFOUND);
 190   assert(string_length ==  0);
 191   assert(!string);
 192
 193   return 0;
 194 }
 195
 196 uint8_t get_test2(memcached_st *memc)
 197 {
 198   memcached_return rc;
 199   char *key= "foo";
 200   char *value= "when we sanitize";
 201   char *string;
 202   size_t string_length;
 203   uint16_t flags;
 204
 205   rc= memcached_set(memc, key, strlen(key),
 206                     value, strlen(value),
 207                     (time_t)0, (uint16_t)0);
 208   assert(rc == MEMCACHED_SUCCESS);
 209
 210   string= memcached_get(memc, key, strlen(key),
 211                         &string_length, &flags, &rc);
 212
 213   assert(string);
 214   assert(rc == MEMCACHED_SUCCESS);
 215   assert(string_length == strlen(value));
 216   assert(!memcmp(string, value, string_length));
 217
 218   free(string);
 219
 220   return 0;
 221 }
 222
 223 uint8_t set_test2(memcached_st *memc)
 224 {
 225   memcached_return rc;
 226   char *key= "foo";
 227   char *value= "train in the brain";
 228   size_t value_length= strlen(value);
 229   unsigned int x;
 230
 231   for (x= 0; x < 10; x++)
 232   {
 233     rc= memcached_set(memc, key, strlen(key),
 234                       value, value_length,
 235                       (time_t)0, (uint16_t)0);
 236     assert(rc == MEMCACHED_SUCCESS);
 237   }
 238
 239   return 0;
 240 }
 241
 242 uint8_t set_test3(memcached_st *memc)
 243 {
 244   memcached_return rc;
 245   char *key= "foo";
 246   char *value;
 247   size_t value_length= 8191;
 248   unsigned int x;
 249
 250   value = (char*)malloc(value_length);
 251   assert(value);
 252
 253   for (x= 0; x < value_length; x++)
 254     value[x] = (char) (x % 127);
 255
 256   for (x= 0; x < 1; x++)
 257   {
 258     rc= memcached_set(memc, key, strlen(key),
 259                       value, value_length,
 260                       (time_t)0, (uint16_t)0);
 261     assert(rc == MEMCACHED_SUCCESS);
 262   }
 263
 264   free(value);
 265
 266   return 0;
 267 }
 268
 269 uint8_t get_test3(memcached_st *memc)
 270 {
 271   memcached_return rc;
 272   char *key= "foo";
 273   char *value;
 274   size_t value_length= 8191;
 275   char *string;
 276   size_t string_length;
 277   uint16_t flags;
 278   int x;
 279
 280   value = (char*)malloc(value_length);
 281   assert(value);
 282
 283   for (x= 0; x < value_length; x++)
 284     value[x] = (char) (x % 127);
 285
 286   rc= memcached_set(memc, key, strlen(key),
 287                     value, value_length,
 288                     (time_t)0, (uint16_t)0);
 289   assert(rc == MEMCACHED_SUCCESS);
 290
 291   string= memcached_get(memc, key, strlen(key),
 292                         &string_length, &flags, &rc);
 293
 294   assert(rc == MEMCACHED_SUCCESS);
 295   assert(string);
 296   assert(string_length == value_length);
 297   assert(!memcmp(string, value, string_length));
 298
 299   free(string);
 300   free(value);
 301
 302   return 0;
 303 }
 304
 305 uint8_t get_test4(memcached_st *memc)
 306 {
 307   memcached_return rc;
 308   char *key= "foo";
 309   char *value;
 310   size_t value_length= 8191;
 311   char *string;
 312   size_t string_length;
 313   uint16_t flags;
 314   int x;
 315
 316   value = (char*)malloc(value_length);
 317   assert(value);
 318
 319   for (x= 0; x < value_length; x++)
 320     value[x] = (char) (x % 127);
 321
 322   rc= memcached_set(memc, key, strlen(key),
 323                     value, value_length,
 324                     (time_t)0, (uint16_t)0);
 325   assert(rc == MEMCACHED_SUCCESS);
 326
 327   for (x= 0; x < 10; x++)
 328   {
 329     string= memcached_get(memc, key, strlen(key),
 330                           &string_length, &flags, &rc);
 331
 332     assert(rc == MEMCACHED_SUCCESS);
 333     assert(string);
 334     assert(string_length == value_length);
 335     assert(!memcmp(string, value, string_length));
 336     free(string);
 337   }
 338
 339   free(value);
 340
 341   return 0;
 342 }
 343
 344 uint8_t stats_servername_test(memcached_st *memc)
 345 {
 346   memcached_return rc;
 347   memcached_stat_st stat;
 348   rc= memcached_stat_servername(&stat, NULL,
 349                                  "localhost",
 350                                  MEMCACHED_DEFAULT_PORT);
 351
 352   return 0;
 353 }
 354
 355 uint8_t increment_test(memcached_st *memc)
 356 {
 357   uint64_t new_number;
 358   memcached_return rc;
 359   char *key= "number";
 360   char *value= "0";
 361
 362   rc= memcached_set(memc, key, strlen(key),
 363                     value, strlen(value),
 364                     (time_t)0, (uint16_t)0);
 365   assert(rc == MEMCACHED_SUCCESS);
 366
 367   rc= memcached_increment(memc, key, strlen(key),
 368                           1, &new_number);
 369   assert(rc == MEMCACHED_SUCCESS);
 370   assert(new_number == 1);
 371
 372   rc= memcached_increment(memc, key, strlen(key),
 373                           1, &new_number);
 374   assert(rc == MEMCACHED_SUCCESS);
 375   assert(new_number == 2);
 376
 377   return 0;
 378 }
 379
 380 uint8_t decrement_test(memcached_st *memc)
 381 {
 382   uint64_t new_number;
 383   memcached_return rc;
 384   char *key= "number";
 385   char *value= "3";
 386
 387   rc= memcached_set(memc, key, strlen(key),
 388                     value, strlen(value),
 389                     (time_t)0, (uint16_t)0);
 390   assert(rc == MEMCACHED_SUCCESS);
 391
 392   rc= memcached_decrement(memc, key, strlen(key),
 393                           1, &new_number);
 394   assert(rc == MEMCACHED_SUCCESS);
 395   assert(new_number == 2);
 396
 397   rc= memcached_decrement(memc, key, strlen(key),
 398                           1, &new_number);
 399   assert(rc == MEMCACHED_SUCCESS);
 400   assert(new_number == 1);
 401
 402   return 0;
 403 }
 404
 405 uint8_t quit_test(memcached_st *memc)
 406 {
 407   memcached_return rc;
 408   char *key= "fudge";
 409   char *value= "sanford and sun";
 410
 411   rc= memcached_set(memc, key, strlen(key),
 412                     value, strlen(value),
 413                     (time_t)10, (uint16_t)3);
 414   assert(rc == MEMCACHED_SUCCESS);
 415   memcached_quit(memc);
 416
 417   rc= memcached_set(memc, key, strlen(key),
 418                     value, strlen(value),
 419                     (time_t)50, (uint16_t)9);
 420   assert(rc == MEMCACHED_SUCCESS);
 421
 422   return 0;
 423 }
 424
 425 uint8_t mget_result_test(memcached_st *memc)
 426 {
 427   memcached_return rc;
 428   char *keys[]= {"fudge", "son", "food"};
 429   size_t key_length[]= {5, 3, 4};
 430   unsigned int x;
 431
 432   memcached_result_st results_obj;
 433   memcached_result_st *results;
 434
 435   results= memcached_result_create(memc, &results_obj);
 436   assert(results);
 437   assert(&results_obj == results);
 438
 439   /* We need to empty the server before continueing test */
 440   rc= memcached_flush(memc, 0);
 441   assert(rc == MEMCACHED_SUCCESS);
 442
 443   rc= memcached_mget(memc, keys, key_length, 3);
 444   assert(rc == MEMCACHED_SUCCESS);
 445
 446   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 447   {
 448     assert(results);
 449   }
 450   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 451   assert(!results);
 452   assert(rc == MEMCACHED_NOTFOUND);
 453
 454   for (x= 0; x < 3; x++)
 455   {
 456     rc= memcached_set(memc, keys[x], key_length[x],
 457                       keys[x], key_length[x],
 458                       (time_t)50, (uint16_t)9);
 459     assert(rc == MEMCACHED_SUCCESS);
 460   }
 461
 462   rc= memcached_mget(memc, keys, key_length, 3);
 463   assert(rc == MEMCACHED_SUCCESS);
 464
 465   while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
 466   {
 467     assert(results);
 468     assert(&results_obj == results);
 469     assert(rc == MEMCACHED_SUCCESS);
 470     assert(memcached_result_key_length(results) == memcached_result_length(results));
 471     assert(!memcmp(memcached_result_key_value(results),
 472                    memcached_result_value(results),
 473                    memcached_result_length(results)));
 474   }
 475
 476   memcached_result_free(&results_obj);
 477
 478   return 0;
 479 }
 480
 481 uint8_t mget_result_alloc_test(memcached_st *memc)
 482 {
 483   memcached_return rc;
 484   char *keys[]= {"fudge", "son", "food"};
 485   size_t key_length[]= {5, 3, 4};
 486   unsigned int x;
 487
 488   memcached_result_st *results;
 489
 490   /* We need to empty the server before continueing test */
 491   rc= memcached_flush(memc, 0);
 492   assert(rc == MEMCACHED_SUCCESS);
 493
 494   rc= memcached_mget(memc, keys, key_length, 3);
 495   assert(rc == MEMCACHED_SUCCESS);
 496
 497   while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
 498   {
 499     assert(results);
 500   }
 501   assert(!results);
 502   assert(rc == MEMCACHED_NOTFOUND);
 503
 504   for (x= 0; x < 3; x++)
 505   {
 506     rc= memcached_set(memc, keys[x], key_length[x],
 507                       keys[x], key_length[x],
 508                       (time_t)50, (uint16_t)9);
 509     assert(rc == MEMCACHED_SUCCESS);
 510   }
 511
 512   rc= memcached_mget(memc, keys, key_length, 3);
 513   assert(rc == MEMCACHED_SUCCESS);
 514
 515   x= 0;
 516   while ((results= memcached_fetch_result(memc, NULL, &rc)))
 517   {
 518     assert(results);
 519     assert(rc == MEMCACHED_SUCCESS);
 520     assert(memcached_result_key_length(results) == memcached_result_length(results));
 521     assert(!memcmp(memcached_result_key_value(results),
 522                    memcached_result_value(results),
 523                    memcached_result_length(results)));
 524     memcached_result_free(results);
 525     x++;
 526   }
 527
 528   return 0;
 529 }
 530
 531 uint8_t mget_test(memcached_st *memc)
 532 {
 533   memcached_return rc;
 534   char *keys[]= {"fudge", "son", "food"};
 535   size_t key_length[]= {5, 3, 4};
 536   unsigned int x;
 537   uint16_t flags;
 538
 539   char return_key[MEMCACHED_MAX_KEY];
 540   size_t return_key_length;
 541   char *return_value;
 542   size_t return_value_length;
 543
 544   /* We need to empty the server before continueing test */
 545   rc= memcached_flush(memc, 0);
 546   assert(rc == MEMCACHED_SUCCESS);
 547
 548   rc= memcached_mget(memc, keys, key_length, 3);
 549   assert(rc == MEMCACHED_SUCCESS);
 550
 551   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 552                       &return_value_length, &flags, &rc)) != NULL)
 553   {
 554     assert(return_value);
 555   }
 556   assert(!return_value);
 557   assert(return_value_length == 0);
 558   assert(rc == MEMCACHED_NOTFOUND);
 559
 560   for (x= 0; x < 3; x++)
 561   {
 562     rc= memcached_set(memc, keys[x], key_length[x],
 563                       keys[x], key_length[x],
 564                       (time_t)50, (uint16_t)9);
 565     assert(rc == MEMCACHED_SUCCESS);
 566   }
 567
 568   rc= memcached_mget(memc, keys, key_length, 3);
 569   assert(rc == MEMCACHED_SUCCESS);
 570
 571   x= 0;
 572   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 573                                         &return_value_length, &flags, &rc)))
 574   {
 575     assert(return_value);
 576     assert(rc == MEMCACHED_SUCCESS);
 577     assert(return_key_length == return_value_length);
 578     assert(!memcmp(return_value, return_key, return_value_length));
 579     free(return_value);
 580     x++;
 581   }
 582
 583   return 0;
 584 }
 585
 586 uint8_t get_stats_keys(memcached_st *memc)
 587 {
 588  char **list;
 589  char **ptr;
 590  memcached_stat_st stat;
 591  memcached_return rc;
 592
 593  list= memcached_stat_get_keys(memc, &stat, &rc);
 594  assert(rc == MEMCACHED_SUCCESS);
 595  for (ptr= list; *ptr; ptr++)
 596    printf("Found key %s\n", *ptr);
 597  fflush(stdout);
 598
 599  free(list);
 600
 601  return 0;
 602 }
 603
 604 uint8_t get_stats(memcached_st *memc)
 605 {
 606  unsigned int x;
 607  char **list;
 608  char **ptr;
 609  memcached_return rc;
 610  memcached_stat_st *stat;
 611
 612  stat= memcached_stat(memc, NULL, &rc);
 613  assert(rc == MEMCACHED_SUCCESS);
 614
 615  assert(rc == MEMCACHED_SUCCESS);
 616  assert(stat);
 617
 618  for (x= 0; x < memcached_server_count(memc); x++)
 619  {
 620    list= memcached_stat_get_keys(memc, &stat[x], &rc);
 621    assert(rc == MEMCACHED_SUCCESS);
 622    for (ptr= list; *ptr; ptr++)
 623      printf("Found key %s\n", *ptr);
 624
 625    free(list);
 626  }
 627
 628  memcached_stat_free(NULL, stat);
 629
 630   return 0;
 631 }
 632
 633 uint8_t add_host_test(memcached_st *memc)
 634 {
 635   unsigned int x;
 636   memcached_server_st *servers;
 637   memcached_return rc;
 638   char servername[]= "0.example.com";
 639
 640   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 641   assert(servers);
 642   assert(1 == memcached_server_list_count(servers));
 643
 644   for (x= 2; x < 20; x++)
 645   {
 646     char buffer[SMALL_STRING_LEN];
 647
 648     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 649     servers= memcached_server_list_append(servers, buffer, 401,
 650                                      &rc);
 651     assert(rc == MEMCACHED_SUCCESS);
 652     assert(x == memcached_server_list_count(servers));
 653   }
 654
 655   rc= memcached_server_push(memc, servers);
 656   assert(rc == MEMCACHED_SUCCESS);
 657   rc= memcached_server_push(memc, servers);
 658   assert(rc == MEMCACHED_SUCCESS);
 659
 660   memcached_server_list_free(servers);
 661
 662   return 0;
 663 }
 664
 665 /* We don't test the behavior itself, we test the switches */
 666 uint8_t behavior_test(memcached_st *memc)
 667 {
 668   unsigned long long value;
 669   unsigned int set= 1;
 670
 671   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 672   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 673   assert(value == 1);
 674
 675   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 676   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 677   assert(value == 1);
 678
 679   set= MEMCACHED_HASH_MD5;
 680   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
 681   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 682   assert(value == MEMCACHED_HASH_MD5);
 683
 684   set= 0;
 685
 686   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 687   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 688   assert(value == 0);
 689
 690   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 691   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 692   assert(value == 0);
 693
 694   set= MEMCACHED_HASH_DEFAULT;
 695   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
 696   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 697   assert(value == MEMCACHED_HASH_DEFAULT);
 698
 699   set= MEMCACHED_HASH_CRC;
 700   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
 701   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 702   assert(value == MEMCACHED_HASH_CRC);
 703
 704   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
 705   assert(value > 0);
 706
 707   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 708   assert(value > 0);
 709
 710   return 0;
 711 }
 712
 713 /* Test case provided by Cal Haldenbrand */
 714 uint8_t user_supplied_bug1(memcached_st *memc)
 715 {
 716   unsigned int setter= 1;
 717   unsigned int x;
 718
 719   unsigned long long total= 0;
 720   int size= 0;
 721   char key[10];
 722   char randomstuff[6 * 1024];
 723   memcached_return rc;
 724
 725   memset(randomstuff, 0, 6 * 1024);
 726
 727   /* We just keep looking at the same values over and over */
 728   srandom(10);
 729
 730   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 731   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 732
 733
 734   /* add key */
 735   for (x= 0 ; total < 20 * 1024576 ; x++ )
 736   {
 737     unsigned int j= 0;
 738
 739     size= (rand() % ( 5 * 1024 ) ) + 400;
 740     memset(randomstuff, 0, 6 * 1024);
 741     assert(size < 6 * 1024); /* Being safe here */
 742
 743     for (j= 0 ; j < size ;j++)
 744       randomstuff[j] = (char) (rand() % 26) + 97;
 745
 746     total += size;
 747     sprintf(key, "%d", x);
 748     rc = memcached_set(memc, key, strlen(key),
 749                        randomstuff, strlen(randomstuff), 10, 0);
 750     /* If we fail, lets try again */
 751     if (rc != MEMCACHED_SUCCESS)
 752       rc = memcached_set(memc, key, strlen(key),
 753                          randomstuff, strlen(randomstuff), 10, 0);
 754     assert(rc == MEMCACHED_SUCCESS);
 755   }
 756
 757   return 0;
 758 }
 759
 760 /* Test case provided by Cal Haldenbrand */
 761 uint8_t user_supplied_bug2(memcached_st *memc)
 762 {
 763   int errors;
 764   unsigned int setter;
 765   unsigned int x;
 766   unsigned long long total;
 767
 768   setter= 1;
 769   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 770   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 771 #ifdef NOT_YET
 772   setter = 20 * 1024576;
 773   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
 774   setter = 20 * 1024576;
 775   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
 776   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
 777   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 778
 779   for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
 780 #endif
 781
 782   for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
 783   {
 784     memcached_return rc= MEMCACHED_SUCCESS;
 785     char buffer[SMALL_STRING_LEN];
 786     uint16_t flags= 0;
 787     size_t val_len= 0;
 788     char *getval;
 789
 790     memset(buffer, 0, SMALL_STRING_LEN);
 791
 792     snprintf(buffer, SMALL_STRING_LEN, "%u", x);
 793     getval= memcached_get(memc, buffer, strlen(buffer),
 794                            &val_len, &flags, &rc);
 795     if (rc != MEMCACHED_SUCCESS)
 796     {
 797       if (rc == MEMCACHED_NOTFOUND)
 798         errors++;
 799       else
 800         assert(0);
 801
 802       continue;
 803     }
 804     total+= val_len;
 805     errors= 0;
 806     free(getval);
 807   }
 808
 809   return 0;
 810 }
 811
 812 /* Do a large mget() over all the keys we think exist */
 813 #define KEY_COUNT 3000 // * 1024576
 814 uint8_t user_supplied_bug3(memcached_st *memc)
 815 {
 816   memcached_return rc;
 817   unsigned int setter;
 818   unsigned int x;
 819   char **keys;
 820   size_t key_lengths[KEY_COUNT];
 821
 822   setter= 1;
 823   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 824   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 825 #ifdef NOT_YET
 826   setter = 20 * 1024576;
 827   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
 828   setter = 20 * 1024576;
 829   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
 830   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
 831   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 832 #endif
 833
 834   keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
 835   assert(keys);
 836   memset(keys, 0, (sizeof(char *) * KEY_COUNT));
 837   for (x= 0; x < KEY_COUNT; x++)
 838   {
 839     char buffer[30];
 840
 841     snprintf(buffer, 30, "%u", x);
 842     keys[x]= strdup(buffer);
 843     key_lengths[x]= strlen(keys[x]);
 844   }
 845
 846   rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
 847   assert(rc == MEMCACHED_SUCCESS);
 848
 849   /* Turn this into a help function */
 850   {
 851     char return_key[MEMCACHED_MAX_KEY];
 852     size_t return_key_length;
 853     char *return_value;
 854     size_t return_value_length;
 855     uint16_t flags;
 856
 857     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 858                                           &return_value_length, &flags, &rc)))
 859     {
 860       assert(return_value);
 861       assert(rc == MEMCACHED_SUCCESS);
 862       free(return_value);
 863     }
 864   }
 865
 866   for (x= 0; x < KEY_COUNT; x++)
 867     free(keys[x]);
 868   free(keys);
 869
 870   return 0;
 871 }
 872
 873 /* Make sure we behave properly if server list has no values */
 874 uint8_t user_supplied_bug4(memcached_st *memc)
 875 {
 876   memcached_return rc;
 877   char *keys[]= {"fudge", "son", "food"};
 878   size_t key_length[]= {5, 3, 4};
 879   unsigned int x;
 880   uint16_t flags;
 881
 882   /* Here we free everything before running a bunch of mget tests */
 883   {
 884     memcached_server_list_free(memc->hosts);
 885     memc->hosts= NULL;
 886     memc->number_of_hosts= 0;
 887   }
 888
 889   char return_key[MEMCACHED_MAX_KEY];
 890   size_t return_key_length;
 891   char *return_value;
 892   size_t return_value_length;
 893
 894   /* We need to empty the server before continueing test */
 895   rc= memcached_flush(memc, 0);
 896   assert(rc == MEMCACHED_NO_SERVERS);
 897
 898   rc= memcached_mget(memc, keys, key_length, 3);
 899   assert(rc == MEMCACHED_NO_SERVERS);
 900
 901   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 902                       &return_value_length, &flags, &rc)) != NULL)
 903   {
 904     assert(return_value);
 905   }
 906   assert(!return_value);
 907   assert(return_value_length == 0);
 908   assert(rc == MEMCACHED_NO_SERVERS);
 909
 910   for (x= 0; x < 3; x++)
 911   {
 912     rc= memcached_set(memc, keys[x], key_length[x],
 913                       keys[x], key_length[x],
 914                       (time_t)50, (uint16_t)9);
 915     assert(rc == MEMCACHED_NO_SERVERS);
 916   }
 917
 918   rc= memcached_mget(memc, keys, key_length, 3);
 919   assert(rc == MEMCACHED_NO_SERVERS);
 920
 921   x= 0;
 922   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 923                                         &return_value_length, &flags, &rc)))
 924   {
 925     assert(return_value);
 926     assert(rc == MEMCACHED_SUCCESS);
 927     assert(return_key_length == return_value_length);
 928     assert(!memcmp(return_value, return_key, return_value_length));
 929     free(return_value);
 930     x++;
 931   }
 932
 933   return 0;
 934 }
 935
 936 uint8_t result_static(memcached_st *memc)
 937 {
 938   memcached_result_st result;
 939   memcached_result_st *result_ptr;
 940
 941   result_ptr= memcached_result_create(memc, &result);
 942   assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
 943   assert(result_ptr);
 944   memcached_result_free(&result);
 945
 946   return 0;
 947 }
 948
 949 uint8_t result_alloc(memcached_st *memc)
 950 {
 951   memcached_result_st *result;
 952
 953   result= memcached_result_create(memc, NULL);
 954   assert(result);
 955   memcached_result_free(result);
 956
 957   return 0;
 958 }
 959
 960 uint8_t string_static_null(memcached_st *memc)
 961 {
 962   memcached_string_st string;
 963   memcached_string_st *string_ptr;
 964
 965   string_ptr= memcached_string_create(memc, &string, 0);
 966   assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
 967   assert(string_ptr);
 968   memcached_string_free(&string);
 969
 970   return 0;
 971 }
 972
 973 uint8_t string_alloc_null(memcached_st *memc)
 974 {
 975   memcached_string_st *string;
 976
 977   string= memcached_string_create(memc, NULL, 0);
 978   assert(string);
 979   memcached_string_free(string);
 980
 981   return 0;
 982 }
 983
 984 uint8_t string_alloc_with_size(memcached_st *memc)
 985 {
 986   memcached_string_st *string;
 987
 988   string= memcached_string_create(memc, NULL, 1024);
 989   assert(string);
 990   memcached_string_free(string);
 991
 992   return 0;
 993 }
 994
 995 uint8_t string_alloc_with_size_toobig(memcached_st *memc)
 996 {
 997   memcached_string_st *string;
 998
 999   string= memcached_string_create(memc, NULL, INT64_MAX);
1000   assert(string == NULL);
1001
1002   return 0;
1003 }
1004
1005 uint8_t string_alloc_append(memcached_st *memc)
1006 {
1007   unsigned int x;
1008   char buffer[SMALL_STRING_LEN];
1009   memcached_string_st *string;
1010
1011   /* Ring the bell! */
1012   memset(buffer, 6, SMALL_STRING_LEN);
1013
1014   string= memcached_string_create(memc, NULL, 100);
1015   assert(string);
1016
1017   for (x= 0; x < 1024; x++)
1018   {
1019     memcached_return rc;
1020     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1021     assert(rc == MEMCACHED_SUCCESS);
1022   }
1023   memcached_string_free(string);
1024
1025   return 0;
1026 }
1027
1028 uint8_t string_alloc_append_toobig(memcached_st *memc)
1029 {
1030   memcached_return rc;
1031   unsigned int x;
1032   char buffer[SMALL_STRING_LEN];
1033   memcached_string_st *string;
1034
1035   /* Ring the bell! */
1036   memset(buffer, 6, SMALL_STRING_LEN);
1037
1038   string= memcached_string_create(memc, NULL, 100);
1039   assert(string);
1040
1041   for (x= 0; x < 1024; x++)
1042   {
1043     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1044     assert(rc == MEMCACHED_SUCCESS);
1045   }
1046   rc= memcached_string_append(string, buffer, INT64_MAX);
1047   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
1048   memcached_string_free(string);
1049
1050   return 0;
1051 }
1052
1053 uint8_t generate_data(memcached_st *memc)
1054 {
1055   unsigned long long x;
1056   global_pairs= pairs_generate(GLOBAL_COUNT);
1057   execute_set(memc, global_pairs, GLOBAL_COUNT);
1058
1059   for (x= 0; x < GLOBAL_COUNT; x++)
1060   {
1061     global_keys[x]= global_pairs[x].key;
1062     global_keys_length[x]=  global_pairs[x].key_length;
1063   }
1064
1065   return 0;
1066 }
1067
1068 uint8_t get_read(memcached_st *memc)
1069 {
1070   unsigned int x;
1071   memcached_return rc;
1072
1073   {
1074     char *return_value;
1075     size_t return_value_length;
1076     uint16_t flags;
1077
1078     for (x= 0; x < GLOBAL_COUNT; x++)
1079     {
1080       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
1081                                   &return_value_length, &flags, &rc);
1082       /*
1083       assert(return_value);
1084       assert(rc == MEMCACHED_SUCCESS);
1085     */
1086       if (rc == MEMCACHED_SUCCESS && return_value)
1087         free(return_value);
1088     }
1089   }
1090
1091   return 0;
1092 }
1093
1094 uint8_t mget_read(memcached_st *memc)
1095 {
1096   memcached_return rc;
1097
1098   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1099   assert(rc == MEMCACHED_SUCCESS);
1100   /* Turn this into a help function */
1101   {
1102     char return_key[MEMCACHED_MAX_KEY];
1103     size_t return_key_length;
1104     char *return_value;
1105     size_t return_value_length;
1106     uint16_t flags;
1107
1108     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1109                                           &return_value_length, &flags, &rc)))
1110     {
1111       assert(return_value);
1112       assert(rc == MEMCACHED_SUCCESS);
1113       free(return_value);
1114     }
1115   }
1116
1117   return 0;
1118 }
1119
1120 uint8_t mget_read_result(memcached_st *memc)
1121 {
1122   memcached_return rc;
1123
1124   rc= memcached_mget(memc, global_keys, global_keys_length, GLOBAL_COUNT);
1125   assert(rc == MEMCACHED_SUCCESS);
1126   /* Turn this into a help function */
1127   {
1128     memcached_result_st results_obj;
1129     memcached_result_st *results;
1130
1131     results= memcached_result_create(memc, &results_obj);
1132
1133     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1134     {
1135       assert(results);
1136       assert(rc == MEMCACHED_SUCCESS);
1137     }
1138
1139     memcached_result_free(&results_obj);
1140   }
1141
1142   return 0;
1143 }
1144
1145 uint8_t free_data(memcached_st *memc)
1146 {
1147   pairs_free(global_pairs);
1148
1149   return 0;
1150 }
1151
1152 uint8_t add_host_test1(memcached_st *memc)
1153 {
1154   unsigned int x;
1155   memcached_return rc;
1156   char servername[]= "0.example.com";
1157   memcached_server_st *servers;
1158
1159   servers= memcached_server_list_append(NULL, servername, 400, &rc);
1160   assert(servers);
1161   assert(1 == memcached_server_list_count(servers));
1162
1163   for (x= 2; x < 20; x++)
1164   {
1165     char buffer[SMALL_STRING_LEN];
1166
1167     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1168     servers= memcached_server_list_append(servers, buffer, 401,
1169                                      &rc);
1170     assert(rc == MEMCACHED_SUCCESS);
1171     assert(x == memcached_server_list_count(servers));
1172   }
1173
1174   rc= memcached_server_push(memc, servers);
1175   assert(rc == MEMCACHED_SUCCESS);
1176   rc= memcached_server_push(memc, servers);
1177   assert(rc == MEMCACHED_SUCCESS);
1178
1179   memcached_server_list_free(servers);
1180
1181   return 0;
1182 }
1183
1184 memcached_return pre_nonblock(memcached_st *memc)
1185 {
1186   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1187
1188   return MEMCACHED_SUCCESS;
1189 }
1190
1191 memcached_return pre_md5(memcached_st *memc)
1192 {
1193   memcached_hash value= MEMCACHED_HASH_MD5;
1194   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1195
1196   return MEMCACHED_SUCCESS;
1197 }
1198
1199 memcached_return pre_crc(memcached_st *memc)
1200 {
1201   memcached_hash value= MEMCACHED_HASH_CRC;
1202   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1203
1204   return MEMCACHED_SUCCESS;
1205 }
1206
1207 memcached_return pre_hash_fnv1_64(memcached_st *memc)
1208 {
1209   memcached_hash value= MEMCACHED_HASH_FNV1_64;
1210   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1211
1212   return MEMCACHED_SUCCESS;
1213 }
1214
1215 memcached_return pre_hash_fnv1a_64(memcached_st *memc)
1216 {
1217   memcached_hash value= MEMCACHED_HASH_FNV1A_64;
1218   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1219
1220   return MEMCACHED_SUCCESS;
1221 }
1222
1223 memcached_return pre_hash_fnv1_32(memcached_st *memc)
1224 {
1225   memcached_hash value= MEMCACHED_HASH_FNV1_32;
1226   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1227
1228   return MEMCACHED_SUCCESS;
1229 }
1230
1231 memcached_return pre_hash_fnv1a_32(memcached_st *memc)
1232 {
1233   memcached_hash value= MEMCACHED_HASH_FNV1A_32;
1234   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1235
1236   return MEMCACHED_SUCCESS;
1237 }
1238
1239 memcached_return pre_hash_ketama(memcached_st *memc)
1240 {
1241   memcached_hash value= MEMCACHED_HASH_KETAMA;
1242   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
1243
1244   return MEMCACHED_SUCCESS;
1245 }
1246
1247 memcached_return pre_unix_socket(memcached_st *memc)
1248 {
1249   memcached_return rc;
1250   struct stat buf;
1251
1252   memcached_server_list_free(memc->hosts);
1253   memc->hosts= NULL;
1254   memc->number_of_hosts= 0;
1255
1256   if (stat("/tmp/memcached.socket", &buf))
1257     return MEMCACHED_FAILURE;
1258
1259   rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");
1260
1261   return rc;
1262 }
1263
1264 memcached_return pre_nodelay(memcached_st *memc)
1265 {
1266   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
1267   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
1268
1269   return MEMCACHED_SUCCESS;
1270 }
1271
1272
1273 /* Clean the server before beginning testing */
1274 test_st tests[] ={
1275   {"flush", 0, flush_test },
1276   {"init", 0, init_test },
1277   {"allocation", 0, allocation_test },
1278   {"clone_test", 0, clone_test },
1279   {"error", 0, error_test },
1280   {"set", 0, set_test },
1281   {"set2", 0, set_test2 },
1282   {"set3", 0, set_test3 },
1283   {"add", 0, add_test },
1284   {"replace", 0, replace_test },
1285   {"delete", 1, delete_test },
1286   {"get", 1, get_test },
1287   {"get2", 0, get_test2 },
1288   {"get3", 0, get_test3 },
1289   {"get4", 0, get_test4 },
1290   {"stats_servername", 0, stats_servername_test },
1291   {"increment", 0, increment_test },
1292   {"decrement", 0, decrement_test },
1293   {"quit", 0, quit_test },
1294   {"mget", 1, mget_test },
1295   {"mget_result", 1, mget_result_test },
1296   {"mget_result_alloc", 1, mget_result_alloc_test },
1297   {"get_stats", 0, get_stats },
1298   {"add_host_test", 0, add_host_test },
1299   {"get_stats_keys", 0, get_stats_keys },
1300   {"behavior_test", 0, get_stats_keys },
1301   {0, 0, 0}
1302 };
1303
1304 test_st string_tests[] ={
1305   {"string static with null", 0, string_static_null },
1306   {"string alloc with null", 0, string_alloc_null },
1307   {"string alloc with 1K", 0, string_alloc_with_size },
1308   {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
1309   {"string append", 0, string_alloc_append },
1310   {"string append failure (too big)", 0, string_alloc_append_toobig },
1311   {0, 0, 0}
1312 };
1313
1314 test_st result_tests[] ={
1315   {"result static", 0, result_static},
1316   {"result alloc", 0, result_alloc},
1317   {0, 0, 0}
1318 };
1319
1320 test_st user_tests[] ={
1321   {"user_supplied_bug1", 0, user_supplied_bug1 },
1322   {"user_supplied_bug2", 0, user_supplied_bug2 },
1323   {"user_supplied_bug3", 0, user_supplied_bug3 },
1324   {"user_supplied_bug4", 0, user_supplied_bug4 },
1325   {0, 0, 0}
1326 };
1327
1328 test_st generate_tests[] ={
1329   {"generate_data", 0, generate_data },
1330   {"get_read", 0, get_read },
1331   {"mget_read", 0, mget_read },
1332   {"mget_read_result", 0, mget_read_result },
1333   {0, 0, 0}
1334 };
1335
1336
1337 collection_st collection[] ={
1338   {"block", 0, 0, tests},
1339   {"nonblock", pre_nonblock, 0, tests},
1340   {"nodelay", pre_nodelay, 0, tests},
1341   {"md5", pre_md5, 0, tests},
1342   {"crc", pre_crc, 0, tests},
1343   {"fnv1_64", pre_hash_fnv1_64, 0, tests},
1344   {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
1345   {"fnv1_32", pre_hash_fnv1_32, 0, tests},
1346   {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
1347   {"ketama", pre_hash_ketama, 0, tests},
1348   {"unix_socket", pre_unix_socket, 0, tests},
1349   {"unix_socket_nodelay", pre_nodelay, 0, tests},
1350   {"string", 0, 0, string_tests},
1351   {"result", 0, 0, result_tests},
1352   {"user", 0, 0, user_tests},
1353   {"generate", 0, 0, generate_tests},
1354   {0, 0, 0, 0}
1355 };
1356
1357 collection_st *gets_collections(void)
1358 {
1359   return collection;
1360 }