git.m6w6.name Git - m6w6/libmemcached/blob - tests/parser.cc

   1 /*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
   2  *
   3  *  Gearmand client and server library.
   4  *
   5  *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
   6  *  All rights reserved.
   7  *
   8  *  Redistribution and use in source and binary forms, with or without
   9  *  modification, are permitted provided that the following conditions are
  10  *  met:
  11  *
  12  *      * Redistributions of source code must retain the above copyright
  13  *  notice, this list of conditions and the following disclaimer.
  14  *
  15  *      * Redistributions in binary form must reproduce the above
  16  *  copyright notice, this list of conditions and the following disclaimer
  17  *  in the documentation and/or other materials provided with the
  18  *  distribution.
  19  *
  20  *      * The names of its contributors may not be used to endorse or
  21  *  promote products derived from this software without specific prior
  22  *  written permission.
  23  *
  24  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  27  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  28  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  29  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  30  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  31  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  32  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  33  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  34  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  */
  37
  38 #include <config.h>
  39
  40 #include <libmemcached/memcached.h>
  41
  42 #include "tests/parser.h"
  43 #include "tests/print.h"
  44
  45 enum scanner_type_t
  46 {
  47   NIL,
  48   UNSIGNED,
  49   SIGNED,
  50   ARRAY
  51 };
  52
  53
  54 struct scanner_string_st {
  55   const char *c_str;
  56   size_t size;
  57 };
  58
  59 static inline scanner_string_st scanner_string(const char *arg, size_t arg_size)
  60 {
  61   scanner_string_st local= { arg, arg_size };
  62   return local;
  63 }
  64
  65 #define make_scanner_string(X) scanner_string((X), static_cast<size_t>(sizeof(X) - 1))
  66
  67 static struct scanner_string_st scanner_string_null= { 0, 0};
  68
  69 struct scanner_variable_t {
  70   enum scanner_type_t type;
  71   struct scanner_string_st option;
  72   struct scanner_string_st result;
  73   test_return_t (*check_func)(memcached_st *memc, const scanner_string_st &hostname);
  74 };
  75
  76 // Check and make sure the first host is what we expect it to be
  77 static test_return_t __check_host(memcached_st *memc, const scanner_string_st &hostname)
  78 {
  79   memcached_server_instance_st instance=
  80     memcached_server_instance_by_position(memc, 0);
  81
  82   test_true(instance);
  83
  84   const char *first_hostname = memcached_server_name(instance);
  85   test_true(first_hostname);
  86   test_strcmp(first_hostname, hostname.c_str);
  87
  88   return TEST_SUCCESS;
  89 }
  90
  91 // Check and make sure the prefix_key is what we expect it to be
  92 static test_return_t __check_prefix_key(memcached_st *memc, const scanner_string_st &hostname)
  93 {
  94   memcached_server_instance_st instance=
  95     memcached_server_instance_by_position(memc, 0);
  96
  97   test_true(instance);
  98
  99   const char *first_hostname = memcached_server_name(instance);
 100   test_true(first_hostname);
 101   test_strcmp(first_hostname, hostname.c_str);
 102
 103   return TEST_SUCCESS;
 104 }
 105
 106 static test_return_t __check_IO_MSG_WATERMARK(memcached_st *memc, const scanner_string_st &value)
 107 {
 108   uint64_t value_number;
 109
 110   value_number= atoll(value.c_str);
 111
 112   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == value_number);
 113   return TEST_SUCCESS;
 114 }
 115
 116 static test_return_t __check_AUTO_EJECT_HOSTS(memcached_st *memc, const scanner_string_st &value)
 117 {
 118   (void)value;
 119   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS));
 120   return TEST_SUCCESS;
 121 }
 122
 123 static test_return_t __check_CACHE_LOOKUPS(memcached_st *memc, const scanner_string_st &value)
 124 {
 125   (void)value;
 126   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS));
 127   return TEST_SUCCESS;
 128 }
 129
 130 static test_return_t __check_NOREPLY(memcached_st *memc, const scanner_string_st &value)
 131 {
 132   (void)value;
 133   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY));
 134   return TEST_SUCCESS;
 135 }
 136
 137 static test_return_t __check_VERIFY_KEY(memcached_st *memc, const scanner_string_st &value)
 138 {
 139   (void)value;
 140   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY));
 141   return TEST_SUCCESS;
 142 }
 143
 144 static test_return_t __check_distribution_RANDOM(memcached_st *memc, const scanner_string_st &value)
 145 {
 146   (void)value;
 147   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION) == MEMCACHED_DISTRIBUTION_RANDOM);
 148   return TEST_SUCCESS;
 149 }
 150
 151 scanner_variable_t test_server_strings[]= {
 152   { ARRAY, make_scanner_string("--server=localhost"), make_scanner_string("localhost"), __check_host },
 153   { ARRAY, make_scanner_string("--server=10.0.2.1"), make_scanner_string("10.0.2.1"), __check_host },
 154   { ARRAY, make_scanner_string("--server=example.com"), make_scanner_string("example.com"), __check_host },
 155   { ARRAY, make_scanner_string("--server=localhost:30"), make_scanner_string("localhost"), __check_host },
 156   { ARRAY, make_scanner_string("--server=10.0.2.1:20"), make_scanner_string("10.0.2.1"), __check_host },
 157   { ARRAY, make_scanner_string("--server=example.com:1024"), make_scanner_string("example.com"), __check_host },
 158   { NIL, scanner_string_null, scanner_string_null, NULL }
 159 };
 160
 161 scanner_variable_t test_servers_strings[]= {
 162   { ARRAY, make_scanner_string("--servers=localhost:11221,localhost:11222,localhost:11223,localhost:11224,localhost:11225"), scanner_string_null, NULL },
 163   { ARRAY, make_scanner_string("--servers=a.example.com:81,localhost:82,b.example.com"), scanner_string_null, NULL },
 164   { ARRAY, make_scanner_string("--servers=localhost,localhost:80"), scanner_string_null, NULL },
 165   { NIL, scanner_string_null, scanner_string_null, NULL}
 166 };
 167
 168
 169 scanner_variable_t bad_test_strings[]= {
 170   { ARRAY, make_scanner_string("-servers=localhost:11221,localhost:11222,localhost:11223,localhost:11224,localhost:11225"), scanner_string_null, NULL },
 171   { ARRAY, make_scanner_string("-- servers=a.example.com:81,localhost:82,b.example.com"), scanner_string_null, NULL },
 172   { ARRAY, make_scanner_string("--servers=localhost+80"), scanner_string_null, NULL},
 173   { NIL, scanner_string_null, scanner_string_null, NULL}
 174 };
 175
 176 scanner_variable_t test_number_options[]= {
 177   { ARRAY,  make_scanner_string("--CONNECT_TIMEOUT=456"), scanner_string_null, NULL },
 178   { ARRAY,  make_scanner_string("--IO_MSG_WATERMARK=456"), make_scanner_string("456"), __check_IO_MSG_WATERMARK },
 179   { ARRAY,  make_scanner_string("--IO_BYTES_WATERMARK=456"), scanner_string_null, NULL },
 180   { ARRAY,  make_scanner_string("--IO_KEY_PREFETCH=456"), scanner_string_null, NULL },
 181   { ARRAY,  make_scanner_string("--NUMBER_OF_REPLICAS=456"), scanner_string_null, NULL },
 182   { ARRAY,  make_scanner_string("--POLL_TIMEOUT=456"), scanner_string_null, NULL },
 183   { ARRAY,  make_scanner_string("--RCV_TIMEOUT=456"), scanner_string_null, NULL },
 184   { ARRAY,  make_scanner_string("--RETRY_TIMEOUT=456"), scanner_string_null, NULL },
 185   { ARRAY,  make_scanner_string("--SERVER_FAILURE_LIMIT=456"), scanner_string_null, NULL },
 186   { ARRAY,  make_scanner_string("--SND_TIMEOUT=456"), scanner_string_null, NULL },
 187   { ARRAY,  make_scanner_string("--SOCKET_RECV_SIZE=456"), scanner_string_null, NULL },
 188   { ARRAY,  make_scanner_string("--SOCKET_SEND_SIZE=456"), scanner_string_null, NULL },
 189   { NIL, scanner_string_null, scanner_string_null, NULL}
 190 };
 191
 192 scanner_variable_t test_boolean_options[]= {
 193   { ARRAY,  make_scanner_string("--AUTO_EJECT_HOSTS"), scanner_string_null, __check_AUTO_EJECT_HOSTS },
 194   { ARRAY,  make_scanner_string("--BINARY_PROTOCOL"), scanner_string_null, NULL },
 195   { ARRAY,  make_scanner_string("--BUFFER_REQUESTS"), scanner_string_null, NULL },
 196   { ARRAY,  make_scanner_string("--CACHE_LOOKUPS"), scanner_string_null, __check_CACHE_LOOKUPS },
 197   { ARRAY,  make_scanner_string("--CORK"), scanner_string_null, NULL },
 198   { ARRAY,  make_scanner_string("--HASH_WITH_PREFIX_KEY"), scanner_string_null, NULL },
 199   { ARRAY,  make_scanner_string("--KETAMA"), scanner_string_null, NULL },
 200   { ARRAY,  make_scanner_string("--KETAMA_WEIGHTED"), scanner_string_null, NULL },
 201   { ARRAY,  make_scanner_string("--NOREPLY"), scanner_string_null, __check_NOREPLY },
 202   { ARRAY,  make_scanner_string("--RANDOMIZE_REPLICA_READ"), scanner_string_null, NULL },
 203   { ARRAY,  make_scanner_string("--SORT_HOSTS"), scanner_string_null, NULL },
 204   { ARRAY,  make_scanner_string("--SUPPORT_CAS"), scanner_string_null, NULL },
 205   { ARRAY,  make_scanner_string("--TCP_NODELAY"), scanner_string_null, NULL },
 206   { ARRAY,  make_scanner_string("--TCP_KEEPALIVE"), scanner_string_null, NULL },
 207   { ARRAY,  make_scanner_string("--TCP_KEEPIDLE"), scanner_string_null, NULL },
 208   { ARRAY,  make_scanner_string("--USE_UDP"), scanner_string_null, NULL },
 209   { ARRAY,  make_scanner_string("--VERIFY_KEY"), scanner_string_null, __check_VERIFY_KEY },
 210   { NIL, scanner_string_null, scanner_string_null, NULL}
 211 };
 212
 213 scanner_variable_t prefix_key_strings[]= {
 214   { ARRAY, make_scanner_string("--PREFIX_KEY=foo"), make_scanner_string("foo"), __check_prefix_key },
 215   { ARRAY, make_scanner_string("--PREFIX-KEY=\"foo\""), make_scanner_string("foo"), __check_prefix_key },
 216   { ARRAY, make_scanner_string("--PREFIX-KEY=\"This is a very long key\""), make_scanner_string("This is a very long key"), __check_prefix_key },
 217   { NIL, scanner_string_null, scanner_string_null, NULL}
 218 };
 219
 220 scanner_variable_t distribution_strings[]= {
 221   { ARRAY,  make_scanner_string("--DISTRIBUTION=consistent"), scanner_string_null, NULL },
 222   { ARRAY,  make_scanner_string("--DISTRIBUTION=random"), scanner_string_null, __check_distribution_RANDOM },
 223   { ARRAY,  make_scanner_string("--DISTRIBUTION=modula"), scanner_string_null, NULL },
 224   { NIL, scanner_string_null, scanner_string_null, NULL}
 225 };
 226
 227 scanner_variable_t hash_strings[]= {
 228   { ARRAY,  make_scanner_string("--HASH=MD5"), scanner_string_null, NULL },
 229   { ARRAY,  make_scanner_string("--HASH=CRC"), scanner_string_null, NULL },
 230   { ARRAY,  make_scanner_string("--HASH=FNV1_64"), scanner_string_null, NULL },
 231   { ARRAY,  make_scanner_string("--HASH=FNV1A_64"), scanner_string_null, NULL },
 232   { ARRAY,  make_scanner_string("--HASH=FNV1_32"), scanner_string_null, NULL },
 233   { ARRAY,  make_scanner_string("--HASH=FNV1A_32"), scanner_string_null, NULL },
 234   { ARRAY,  make_scanner_string("--HASH=MURMUR"), scanner_string_null, NULL },
 235   { ARRAY,  make_scanner_string("--HASH=JENKINS"), scanner_string_null, NULL },
 236   { NIL, scanner_string_null, scanner_string_null, NULL}
 237 };
 238
 239
 240 static test_return_t _test_option(scanner_variable_t *scanner, bool test_true= true)
 241 {
 242   (void)test_true;
 243   memcached_st *memc;
 244   memc= memcached_create(NULL);
 245
 246   for (scanner_variable_t *ptr= scanner; ptr->type != NIL; ptr++)
 247   {
 248     memcached_return_t rc;
 249     rc= memcached_parse_configuration(memc, ptr->option.c_str, ptr->option.size);
 250     if (test_true)
 251     {
 252       test_true_got(rc == MEMCACHED_SUCCESS, memcached_last_error_message(memc));
 253
 254       if (ptr->check_func)
 255       {
 256         (*ptr->check_func)(memc, ptr->result);
 257       }
 258     }
 259     else
 260     {
 261       test_false_with(rc == MEMCACHED_SUCCESS, ptr->option.c_str);
 262     }
 263     memcached_reset(memc);
 264   }
 265   memcached_free(memc);
 266
 267   return TEST_SUCCESS;
 268 }
 269
 270 test_return_t server_test(memcached_st *junk)
 271 {
 272   (void)junk;
 273   return _test_option(test_server_strings);
 274 }
 275
 276 test_return_t servers_test(memcached_st *junk)
 277 {
 278   (void)junk;
 279
 280   test_return_t rc;
 281   if ((rc= _test_option(test_server_strings)) != TEST_SUCCESS)
 282   {
 283     return rc;
 284   }
 285
 286 #if 0
 287     memcached_server_fn callbacks[1];
 288     callbacks[0]= server_print_callback;
 289     memcached_server_cursor(memc, callbacks, NULL,  1);
 290 #endif
 291
 292   if ((rc= _test_option(bad_test_strings, false)) != TEST_SUCCESS)
 293   {
 294     return rc;
 295   }
 296
 297   return TEST_SUCCESS;
 298 }
 299
 300 test_return_t parser_number_options_test(memcached_st *junk)
 301 {
 302   (void)junk;
 303   return _test_option(test_number_options);
 304 }
 305
 306 test_return_t parser_boolean_options_test(memcached_st *junk)
 307 {
 308   (void)junk;
 309   return _test_option(test_boolean_options);
 310 }
 311
 312 test_return_t behavior_parser_test(memcached_st *junk)
 313 {
 314   (void)junk;
 315   return TEST_SUCCESS;
 316 }
 317
 318 test_return_t parser_hash_test(memcached_st *junk)
 319 {
 320   (void)junk;
 321   return _test_option(hash_strings);
 322 }
 323
 324 test_return_t parser_distribution_test(memcached_st *junk)
 325 {
 326   (void)junk;
 327   return _test_option(distribution_strings);
 328 }
 329
 330 test_return_t parser_key_prefix_test(memcached_st *junk)
 331 {
 332   (void)junk;
 333   return _test_option(distribution_strings);
 334 }
 335
 336 test_return_t memcached_parse_configure_file_test(memcached_st *junk)
 337 {
 338   (void)junk;
 339   memcached_st memc;
 340   memcached_st *memc_ptr= memcached_create(&memc);
 341
 342   test_true(memc_ptr);
 343
 344   memcached_return_t rc= memcached_parse_configure_file(memc_ptr, memcached_string_with_size("support/example.cnf"));
 345   test_true_got(rc == MEMCACHED_SUCCESS, memcached_last_error_message(memc_ptr) ? memcached_last_error_message(memc_ptr) : memcached_strerror(NULL, rc));
 346   memcached_free(memc_ptr);
 347
 348   return TEST_SUCCESS;
 349 }
 350
 351 test_return_t memcached_create_with_options_with_filename(memcached_st *junk)
 352 {
 353   (void)junk;
 354
 355   memcached_st *memc_ptr;
 356   memc_ptr= memcached_create_with_options(STRING_WITH_LEN("--CONFIGURE-FILE=\"support/example.cnf\""));
 357   test_true(memc_ptr);
 358   memcached_free(memc_ptr);
 359
 360   return TEST_SUCCESS;
 361 }
 362
 363 test_return_t libmemcached_check_configuration_with_filename_test(memcached_st *junk)
 364 {
 365   (void)junk;
 366   memcached_return_t rc;
 367
 368   rc= libmemcached_check_configuration(STRING_WITH_LEN("--CONFIGURE-FILE=\"support/example.cnf\""), NULL, 0);
 369   test_true(rc == MEMCACHED_SUCCESS);
 370
 371   rc= libmemcached_check_configuration(STRING_WITH_LEN("--CONFIGURE-FILE=support/example.cnf"), NULL, 0);
 372   test_false(rc == MEMCACHED_SUCCESS);
 373
 374   rc= libmemcached_check_configuration(STRING_WITH_LEN("--CONFIGURE-FILE=\"bad-path/example.cnf\""), NULL, 0);
 375   test_true_got(rc == MEMCACHED_ERRNO, memcached_strerror(NULL, rc));
 376
 377   return TEST_SUCCESS;
 378 }
 379
 380 test_return_t libmemcached_check_configuration_test(memcached_st *junk)
 381 {
 382   (void)junk;
 383
 384   memcached_return_t rc;
 385
 386   rc= libmemcached_check_configuration(STRING_WITH_LEN("--server=localhost"), NULL, 0);
 387   test_true(rc == MEMCACHED_SUCCESS);
 388
 389   rc= libmemcached_check_configuration(STRING_WITH_LEN("--dude=localhost"), NULL, 0);
 390   test_false(rc == MEMCACHED_SUCCESS);
 391   test_true(rc == MEMCACHED_PARSE_ERROR);
 392
 393   return TEST_SUCCESS;
 394 }
 395
 396 test_return_t memcached_create_with_options_test(memcached_st *junk)
 397 {
 398   (void)junk;
 399
 400   memcached_st *memc_ptr;
 401   memc_ptr= memcached_create_with_options(STRING_WITH_LEN("--server=localhost"));
 402   test_true(memc_ptr);
 403   memcached_free(memc_ptr);
 404
 405   memc_ptr= memcached_create_with_options(STRING_WITH_LEN("--dude=localhost"));
 406   test_false(memc_ptr);
 407
 408   return TEST_SUCCESS;
 409 }