git.m6w6.name Git - awesomized/libmemcached/blob - tests/test.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
  10 void init_test(memcached_st *not_used)
  11 {
  12   memcached_st memc;
  13
  14   (void)memcached_create(&memc);
  15   memcached_free(&memc);
  16 }
  17
  18 void allocation_test(memcached_st *not_used)
  19 {
  20   memcached_st *memc;
  21   memc= memcached_create(NULL);
  22   assert(memc);
  23   memcached_free(memc);
  24 }
  25
  26 void connection_test(memcached_st *memc)
  27 {
  28   memcached_return rc;
  29
  30   rc= memcached_server_add(memc, "localhost", 0);
  31   assert(rc == MEMCACHED_SUCCESS);
  32 }
  33
  34 void error_test(memcached_st *memc)
  35 {
  36   memcached_return rc;
  37
  38   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
  39   {
  40     printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
  41   }
  42 }
  43
  44 void set_test(memcached_st *memc)
  45 {
  46   memcached_return rc;
  47   char *key= "foo";
  48   char *value= "when we sanitize";
  49
  50   rc= memcached_set(memc, key, strlen(key),
  51                     value, strlen(value),
  52                     (time_t)0, (uint16_t)0);
  53   assert(rc == MEMCACHED_SUCCESS);
  54 }
  55
  56 void add_test(memcached_st *memc)
  57 {
  58   memcached_return rc;
  59   char *key= "foo";
  60   char *value= "when we sanitize";
  61
  62   rc= memcached_add(memc, key, strlen(key),
  63                     value, strlen(value),
  64                     (time_t)0, (uint16_t)0);
  65   assert(rc == MEMCACHED_NOTSTORED);
  66 }
  67
  68 void replace_test(memcached_st *memc)
  69 {
  70   memcached_return rc;
  71   char *key= "foo";
  72   char *value= "when we sanitize";
  73
  74   rc= memcached_replace(memc, key, strlen(key),
  75                     value, strlen(value),
  76                     (time_t)0, (uint16_t)0);
  77   assert(rc == MEMCACHED_SUCCESS);
  78 }
  79
  80 void delete_test(memcached_st *memc)
  81 {
  82   memcached_return rc;
  83   char *key= "foo";
  84   char *value= "when we sanitize";
  85
  86   rc= memcached_set(memc, key, strlen(key),
  87                     value, strlen(value),
  88                     (time_t)0, (uint16_t)0);
  89   assert(rc == MEMCACHED_SUCCESS);
  90
  91   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
  92   assert(rc == MEMCACHED_SUCCESS);
  93 }
  94
  95 void flush_test(memcached_st *memc)
  96 {
  97   memcached_return rc;
  98
  99   rc= memcached_flush(memc, 0);
 100   assert(rc == MEMCACHED_SUCCESS);
 101 }
 102
 103 void get_test(memcached_st *memc)
 104 {
 105   memcached_return rc;
 106   char *key= "foo";
 107   char *string;
 108   size_t string_length;
 109   uint16_t flags;
 110
 111   string= memcached_get(memc, key, strlen(key),
 112                         &string_length, &flags, &rc);
 113
 114   assert(rc == MEMCACHED_NOTFOUND);
 115   assert(string_length ==  0);
 116   assert(!string);
 117 }
 118
 119 void get_test2(memcached_st *memc)
 120 {
 121   memcached_return rc;
 122   char *key= "foo";
 123   char *value= "when we sanitize";
 124   char *string;
 125   size_t string_length;
 126   uint16_t flags;
 127
 128   rc= memcached_set(memc, key, strlen(key),
 129                     value, strlen(value),
 130                     (time_t)0, (uint16_t)0);
 131   assert(rc == MEMCACHED_SUCCESS);
 132
 133   string= memcached_get(memc, key, strlen(key),
 134                         &string_length, &flags, &rc);
 135
 136   assert(string);
 137   assert(rc == MEMCACHED_SUCCESS);
 138   assert(string_length == strlen(value));
 139   assert(!memcmp(string, value, string_length));
 140
 141   free(string);
 142 }
 143
 144 void set_test2(memcached_st *memc)
 145 {
 146   memcached_return rc;
 147   char *key= "foo";
 148   char *value= "train in the brain";
 149   size_t value_length= strlen(value);
 150   unsigned int x;
 151
 152   for (x= 0; x < 10; x++)
 153   {
 154     rc= memcached_set(memc, key, strlen(key),
 155                       value, value_length,
 156                       (time_t)0, (uint16_t)0);
 157     assert(rc == MEMCACHED_SUCCESS);
 158   }
 159 }
 160
 161 void set_test3(memcached_st *memc)
 162 {
 163   memcached_return rc;
 164   char *key= "foo";
 165   char *value;
 166   size_t value_length= 8191;
 167   unsigned int x;
 168
 169   value = (char*)malloc(value_length);
 170   assert(value);
 171
 172   for (x= 0; x < value_length; x++)
 173     value[x] = (char) (x % 127);
 174
 175   for (x= 0; x < 1; x++)
 176   {
 177     rc= memcached_set(memc, key, strlen(key),
 178                       value, value_length,
 179                       (time_t)0, (uint16_t)0);
 180     assert(rc == MEMCACHED_SUCCESS);
 181   }
 182
 183   free(value);
 184 }
 185
 186 void get_test3(memcached_st *memc)
 187 {
 188   memcached_return rc;
 189   char *key= "foo";
 190   char *value;
 191   size_t value_length= 8191;
 192   char *string;
 193   size_t string_length;
 194   uint16_t flags;
 195   int x;
 196
 197   value = (char*)malloc(value_length);
 198   assert(value);
 199
 200   for (x= 0; x < value_length; x++)
 201     value[x] = (char) (x % 127);
 202
 203   rc= memcached_set(memc, key, strlen(key),
 204                     value, value_length,
 205                     (time_t)0, (uint16_t)0);
 206   assert(rc == MEMCACHED_SUCCESS);
 207
 208   string= memcached_get(memc, key, strlen(key),
 209                         &string_length, &flags, &rc);
 210
 211   assert(rc == MEMCACHED_SUCCESS);
 212   assert(string);
 213   assert(string_length == value_length);
 214   assert(!memcmp(string, value, string_length));
 215
 216   free(string);
 217   free(value);
 218 }
 219
 220 void get_test4(memcached_st *memc)
 221 {
 222   memcached_return rc;
 223   char *key= "foo";
 224   char *value;
 225   size_t value_length= 8191;
 226   char *string;
 227   size_t string_length;
 228   uint16_t flags;
 229   int x;
 230
 231   value = (char*)malloc(value_length);
 232   assert(value);
 233
 234   for (x= 0; x < value_length; x++)
 235     value[x] = (char) (x % 127);
 236
 237   rc= memcached_set(memc, key, strlen(key),
 238                     value, value_length,
 239                     (time_t)0, (uint16_t)0);
 240   assert(rc == MEMCACHED_SUCCESS);
 241
 242   for (x= 0; x < 10; x++)
 243   {
 244     string= memcached_get(memc, key, strlen(key),
 245                           &string_length, &flags, &rc);
 246
 247     assert(rc == MEMCACHED_SUCCESS);
 248     assert(string);
 249     assert(string_length == value_length);
 250     assert(!memcmp(string, value, string_length));
 251     free(string);
 252   }
 253
 254   free(value);
 255 }
 256
 257 void stats_servername_test(memcached_st *memc)
 258 {
 259   memcached_return rc;
 260   memcached_stat_st stat;
 261   rc= memcached_stat_servername(&stat, NULL,
 262                                  "localhost",
 263                                  MEMCACHED_DEFAULT_PORT);
 264 }
 265
 266 void increment_test(memcached_st *memc)
 267 {
 268   unsigned int new_number;
 269   memcached_return rc;
 270   char *key= "number";
 271   char *value= "0";
 272
 273   rc= memcached_set(memc, key, strlen(key),
 274                     value, strlen(value),
 275                     (time_t)0, (uint16_t)0);
 276   assert(rc == MEMCACHED_SUCCESS);
 277
 278   rc= memcached_increment(memc, key, strlen(key),
 279                           1, &new_number);
 280   assert(rc == MEMCACHED_SUCCESS);
 281   assert(new_number == 1);
 282
 283   rc= memcached_increment(memc, key, strlen(key),
 284                           1, &new_number);
 285   assert(rc == MEMCACHED_SUCCESS);
 286   assert(new_number == 2);
 287 }
 288
 289 void decrement_test(memcached_st *memc)
 290 {
 291   unsigned int new_number;
 292   memcached_return rc;
 293   char *key= "number";
 294   char *value= "3";
 295
 296   rc= memcached_set(memc, key, strlen(key),
 297                     value, strlen(value),
 298                     (time_t)0, (uint16_t)0);
 299   assert(rc == MEMCACHED_SUCCESS);
 300
 301   rc= memcached_decrement(memc, key, strlen(key),
 302                           1, &new_number);
 303   assert(rc == MEMCACHED_SUCCESS);
 304   assert(new_number == 2);
 305
 306   rc= memcached_decrement(memc, key, strlen(key),
 307                           1, &new_number);
 308   assert(rc == MEMCACHED_SUCCESS);
 309   assert(new_number == 1);
 310 }
 311
 312 void quit_test(memcached_st *memc)
 313 {
 314   memcached_return rc;
 315   char *key= "fudge";
 316   char *value= "sanford and sun";
 317
 318   rc= memcached_set(memc, key, strlen(key),
 319                     value, strlen(value),
 320                     (time_t)10, (uint16_t)3);
 321   assert(rc == MEMCACHED_SUCCESS);
 322   memcached_quit(memc);
 323
 324   rc= memcached_set(memc, key, strlen(key),
 325                     value, strlen(value),
 326                     (time_t)50, (uint16_t)9);
 327   assert(rc == MEMCACHED_SUCCESS);
 328 }
 329
 330 void mget_test(memcached_st *memc)
 331 {
 332   memcached_return rc;
 333   char *keys[]= {"fudge", "son", "food"};
 334   size_t key_length[]= {5, 3, 4};
 335   unsigned int x;
 336   uint16_t flags;
 337
 338   char return_key[MEMCACHED_MAX_KEY];
 339   size_t return_key_length;
 340   char *return_value;
 341   size_t return_value_length;
 342
 343   /* We need to empty the server before continueing test */
 344   rc= memcached_flush(memc, 0);
 345   assert(rc == MEMCACHED_SUCCESS);
 346
 347   rc= memcached_mget(memc, keys, key_length, 3);
 348   assert(rc == MEMCACHED_SUCCESS);
 349
 350   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 351                       &return_value_length, &flags, &rc)) != NULL)
 352   {
 353     assert(return_value);
 354   }
 355   assert(!return_value);
 356   assert(return_value_length == 0);
 357   assert(rc == MEMCACHED_NOTFOUND);
 358
 359   for (x= 0; x < 3; x++)
 360   {
 361     rc= memcached_set(memc, keys[x], key_length[x],
 362                       keys[x], key_length[x],
 363                       (time_t)50, (uint16_t)9);
 364     assert(rc == MEMCACHED_SUCCESS);
 365   }
 366
 367   rc= memcached_mget(memc, keys, key_length, 3);
 368   assert(rc == MEMCACHED_SUCCESS);
 369
 370   x= 0;
 371   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 372                                         &return_value_length, &flags, &rc)))
 373   {
 374     assert(return_value);
 375     assert(rc == MEMCACHED_SUCCESS);
 376     assert(return_key_length == return_value_length);
 377     assert(!memcmp(return_value, return_key, return_value_length));
 378     free(return_value);
 379     x++;
 380   }
 381 }
 382
 383 void get_stats_keys(memcached_st *memc)
 384 {
 385  char **list;
 386  char **ptr;
 387  memcached_stat_st stat;
 388  memcached_return rc;
 389
 390  list= memcached_stat_get_keys(memc, &stat, &rc);
 391  assert(rc == MEMCACHED_SUCCESS);
 392  for (ptr= list; *ptr; ptr++)
 393    printf("Found key %s\n", *ptr);
 394
 395  free(list);
 396 }
 397
 398 void get_stats(memcached_st *memc)
 399 {
 400  unsigned int x;
 401  char **list;
 402  char **ptr;
 403  memcached_return rc;
 404  memcached_stat_st *stat;
 405
 406  stat= memcached_stat(memc, NULL, &rc);
 407  assert(rc == MEMCACHED_SUCCESS);
 408
 409  assert(rc == MEMCACHED_SUCCESS);
 410  assert(stat);
 411
 412  for (x= 0; x < memcached_server_count(memc); x++)
 413  {
 414    list= memcached_stat_get_keys(memc, &stat[x], &rc);
 415    assert(rc == MEMCACHED_SUCCESS);
 416    for (ptr= list; *ptr; ptr++)
 417      printf("Found key %s\n", *ptr);
 418
 419    free(list);
 420  }
 421
 422  free(stat);
 423 }
 424
 425 void add_host_test(memcached_st *memc)
 426 {
 427   unsigned int x;
 428   memcached_server_st *servers;
 429   memcached_return rc;
 430   char servername[]= "0.example.com";
 431
 432   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 433   assert(servers);
 434   assert(1 == memcached_server_list_count(servers));
 435
 436   for (x= 2; x < 20; x++)
 437   {
 438     char buffer[SMALL_STRING_LEN];
 439
 440     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 441     servers= memcached_server_list_append(servers, buffer, 401,
 442                                      &rc);
 443     assert(rc == MEMCACHED_SUCCESS);
 444     assert(x == memcached_server_list_count(servers));
 445   }
 446
 447   rc= memcached_server_push(memc, servers);
 448   assert(rc == MEMCACHED_SUCCESS);
 449   rc= memcached_server_push(memc, servers);
 450   assert(rc == MEMCACHED_SUCCESS);
 451
 452   memcached_server_list_free(servers);
 453 }
 454
 455 /* We don't test the behavior itself, we test the switches */
 456 void behavior_test(memcached_st *memc)
 457 {
 458   unsigned long long value;
 459   unsigned int set= 1;
 460
 461   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 462   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 463   assert(value == 1);
 464
 465   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 466   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 467   assert(value == 1);
 468
 469   set= 0;
 470
 471   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 472   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 473   assert(value == 0);
 474
 475   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 476   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 477   assert(value == 0);
 478 }
 479
 480 void add_host_test1(memcached_st *memc)
 481 {
 482   unsigned int x;
 483   memcached_return rc;
 484   char servername[]= "0.example.com";
 485   memcached_server_st *servers;
 486
 487   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 488   assert(servers);
 489   assert(1 == memcached_server_list_count(servers));
 490
 491   for (x= 2; x < 20; x++)
 492   {
 493     char buffer[SMALL_STRING_LEN];
 494
 495     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 496     servers= memcached_server_list_append(servers, buffer, 401,
 497                                      &rc);
 498     assert(rc == MEMCACHED_SUCCESS);
 499     assert(x == memcached_server_list_count(servers));
 500   }
 501
 502   rc= memcached_server_push(memc, servers);
 503   assert(rc == MEMCACHED_SUCCESS);
 504   rc= memcached_server_push(memc, servers);
 505   assert(rc == MEMCACHED_SUCCESS);
 506
 507   memcached_server_list_free(servers);
 508 }
 509
 510 typedef struct test_st test_st;
 511
 512 struct test_st {
 513   char *function_name;
 514   unsigned int requires_flush;
 515   void (*function)(memcached_st *memc);
 516 };
 517
 518 int main(int argc, char *argv[])
 519 {
 520   unsigned int x;
 521   char *server_list;
 522   memcached_server_st *servers;
 523
 524   if (!(server_list= getenv("MEMCACHED_SERVERS")))
 525     server_list= "localhost";
 526
 527   printf("servers %s\n", server_list);
 528
 529   servers= memcached_servers_parse(server_list);
 530   assert(servers);
 531
 532   /* Clean the server before beginning testing */
 533   test_st tests[] ={
 534     {"flush", 0, flush_test },
 535     {"init", 0, init_test },
 536     {"allocation", 0, allocation_test },
 537     {"error", 0, error_test },
 538     {"set", 0, set_test },
 539     {"set2", 0, set_test2 },
 540     {"set3", 0, set_test3 },
 541     {"add", 0, add_test },
 542     {"replace", 0, replace_test },
 543     {"delete", 1, delete_test },
 544     {"get", 0, get_test },
 545     {"get2", 0, get_test2 },
 546     {"get3", 0, get_test3 },
 547     {"get4", 0, get_test4 },
 548     {"stats_servername", 0, stats_servername_test },
 549     {"increment", 0, increment_test },
 550     {"decrement", 0, decrement_test },
 551     {"quit", 0, quit_test },
 552     {"mget", 0, mget_test },
 553     {"get_stats", 0, get_stats },
 554     {"add_host_test", 0, add_host_test },
 555     {"get_stats_keys", 0, get_stats_keys },
 556     {"behavior_test", 0, get_stats_keys },
 557     {0, 0, 0}
 558   };
 559
 560   fprintf(stderr, "\nBlock tests\n\n");
 561   for (x= 0; tests[x].function_name; x++)
 562   {
 563     memcached_st *memc;
 564     memcached_return rc;
 565     memc= memcached_create(NULL);
 566     assert(memc);
 567
 568     rc= memcached_server_push(memc, servers);
 569     assert(rc == MEMCACHED_SUCCESS);
 570
 571     fprintf(stderr, "Testing %s", tests[x].function_name);
 572     tests[x].function(memc);
 573     fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
 574     assert(memc);
 575     memcached_free(memc);
 576   }
 577
 578   fprintf(stderr, "\nNonblock tests\n\n");
 579   for (x= 0; tests[x].function_name; x++)
 580   {
 581     memcached_st *memc;
 582     memcached_return rc;
 583     memc= memcached_create(NULL);
 584     assert(memc);
 585
 586     rc= memcached_server_push(memc, servers);
 587     assert(rc == MEMCACHED_SUCCESS);
 588
 589     fprintf(stderr, "Testing %s", tests[x].function_name);
 590     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
 591     tests[x].function(memc);
 592     fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
 593     assert(memc);
 594     memcached_free(memc);
 595   }
 596
 597   fprintf(stderr, "\nTCP Nodelay tests\n\n");
 598   for (x= 0; tests[x].function_name; x++)
 599   {
 600     memcached_st *memc;
 601     memcached_return rc;
 602     memc= memcached_create(NULL);
 603     assert(memc);
 604
 605     rc= memcached_server_push(memc, servers);
 606     assert(rc == MEMCACHED_SUCCESS);
 607
 608     fprintf(stderr, "Testing %s", tests[x].function_name);
 609     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
 610     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
 611     tests[x].function(memc);
 612     fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
 613     assert(memc);
 614     memcached_free(memc);
 615   }
 616
 617   fprintf(stderr, "\nMD5 Hashing\n\n");
 618   for (x= 0; tests[x].function_name; x++)
 619   {
 620     memcached_st *memc;
 621     memcached_return rc;
 622     memc= memcached_create(NULL);
 623     assert(memc);
 624
 625     rc= memcached_server_push(memc, servers);
 626     assert(rc == MEMCACHED_SUCCESS);
 627
 628     fprintf(stderr, "Testing %s", tests[x].function_name);
 629     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, NULL);
 630     tests[x].function(memc);
 631     fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
 632     assert(memc);
 633     memcached_free(memc);
 634   }
 635
 636   /* Clean up whatever we might have left */
 637   {
 638     memcached_st *memc;
 639     memc= memcached_create(NULL);
 640     assert(memc);
 641     flush_test(memc);
 642     memcached_free(memc);
 643   }
 644   return 0;
 645 }