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