git.m6w6.name Git - awesomized/libmemcached/blob - tests/libmemcached-1.0/encoding_key.cc

   1 /*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
   2  *
   3  *  Libmemcached Client and Server
   4  *
   5  *  Copyright (C) 2012 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 #include <libtest/test.hpp>
  40
  41 #include <libmemcached-1.0/memcached.h>
  42 #include <libmemcachedutil-1.0/util.h>
  43
  44 #include "tests/libmemcached-1.0/encoding_key.h"
  45
  46 using namespace libtest;
  47
  48 test_return_t memcached_set_encoding_key_TEST(memcached_st* memc)
  49 {
  50   test_compare(MEMCACHED_SUCCESS, memcached_set_encoding_key(memc, test_literal_param(__func__)));
  51
  52   return TEST_SUCCESS;
  53 }
  54
  55 test_return_t memcached_set_encoding_key_set_get_TEST(memcached_st* memc)
  56 {
  57   memcached_st *memc_no_crypt= memcached_clone(NULL, memc);
  58   test_true(memc_no_crypt);
  59   test_compare(MEMCACHED_SUCCESS, memcached_set_encoding_key(memc, test_literal_param(__func__)));
  60
  61   test_compare(MEMCACHED_SUCCESS, memcached_set(memc,
  62                                                 test_literal_param(__func__), // Key
  63                                                 test_literal_param(__func__), // Value
  64                                                 time_t(0),
  65                                                 uint32_t(0)));
  66
  67   {
  68     memcached_return_t rc;
  69     size_t value_length;
  70     char *value;
  71     test_true((value= memcached_get(memc,
  72                                     test_literal_param(__func__), // Key
  73                                     &value_length, NULL, &rc)));
  74     test_compare(MEMCACHED_SUCCESS, rc);
  75     test_compare(test_literal_param_size(__func__), value_length);
  76     test_memcmp(__func__, value, value_length);
  77
  78     size_t raw_value_length;
  79     char *raw_value;
  80     test_true((raw_value= memcached_get(memc_no_crypt,
  81                                         test_literal_param(__func__), // Key
  82                                         &raw_value_length, NULL, &rc)));
  83     test_compare(MEMCACHED_SUCCESS, rc);
  84     test_ne_compare(value_length, raw_value_length);
  85     test_ne_compare(0, memcmp(value, raw_value, raw_value_length));
  86
  87     free(value);
  88     free(raw_value);
  89   }
  90
  91   memcached_free(memc_no_crypt);
  92
  93   return TEST_SUCCESS;
  94 }
  95
  96 test_return_t memcached_set_encoding_key_add_get_TEST(memcached_st* memc)
  97 {
  98   test_compare(MEMCACHED_SUCCESS, memcached_set_encoding_key(memc, test_literal_param(__func__)));
  99
 100   test_compare(MEMCACHED_SUCCESS, memcached_add(memc,
 101                                                      test_literal_param(__func__), // Key
 102                                                      test_literal_param(__func__), // Value
 103                                                      time_t(0),
 104                                                      uint32_t(0)));
 105
 106   {
 107     memcached_return_t rc;
 108     size_t value_length;
 109     char *value;
 110     test_true((value= memcached_get(memc,
 111                                     test_literal_param(__func__), // Key
 112                                     &value_length, NULL, &rc)));
 113     test_compare(MEMCACHED_SUCCESS, rc);
 114     test_compare(test_literal_param_size(__func__), value_length);
 115     test_memcmp(__func__, value, value_length);
 116     free(value);
 117   }
 118
 119   return TEST_SUCCESS;
 120 }
 121
 122 test_return_t memcached_set_encoding_key_replace_get_TEST(memcached_st* memc)
 123 {
 124   test_compare(MEMCACHED_SUCCESS, memcached_set_encoding_key(memc, test_literal_param(__func__)));
 125
 126   // First we add the key
 127   {
 128     test_compare(MEMCACHED_SUCCESS, memcached_add(memc,
 129                                                   test_literal_param(__func__), // Key
 130                                                   test_literal_param(__func__), // Value
 131                                                   time_t(0),
 132                                                   uint32_t(0)));
 133
 134     memcached_return_t rc;
 135     size_t value_length;
 136     char *value;
 137     test_true((value= memcached_get(memc,
 138                                     test_literal_param(__func__), // Key
 139                                     &value_length, NULL, &rc)));
 140     test_compare(MEMCACHED_SUCCESS, rc);
 141     test_compare(test_literal_param_size(__func__), value_length);
 142     test_memcmp(__func__, value, value_length);
 143     free(value);
 144   }
 145
 146   // Then we replace the key
 147   {
 148     libtest::vchar_t new_value;
 149     vchar::make(new_value);
 150
 151     test_compare(MEMCACHED_SUCCESS, memcached_replace(memc,
 152                                                       test_literal_param(__func__), // Key
 153                                                       vchar_param(new_value), // Value
 154                                                       time_t(0),
 155                                                       uint32_t(0)));
 156
 157     memcached_return_t rc;
 158     size_t value_length;
 159     char *value;
 160     test_true((value= memcached_get(memc,
 161                                     test_literal_param(__func__), // Key
 162                                     &value_length, NULL, &rc)));
 163     test_compare(MEMCACHED_SUCCESS, rc);
 164     test_compare(new_value.size(), value_length);
 165     test_compare(0, vchar::compare(new_value, value, value_length));
 166     free(value);
 167   }
 168
 169   return TEST_SUCCESS;
 170 }
 171
 172 test_return_t memcached_set_encoding_key_increment_TEST(memcached_st* memc)
 173 {
 174   test_compare(MEMCACHED_SUCCESS, memcached_set_encoding_key(memc, test_literal_param(__func__)));
 175
 176   test_compare(MEMCACHED_NOT_SUPPORTED, memcached_increment(memc,
 177                                                             test_literal_param(__func__), // Key
 178                                                             uint32_t(0),
 179                                                             NULL));
 180
 181   return TEST_SUCCESS;
 182 }
 183
 184 test_return_t memcached_set_encoding_key_decrement_TEST(memcached_st* memc)
 185 {
 186   test_compare(MEMCACHED_SUCCESS, memcached_set_encoding_key(memc, test_literal_param(__func__)));
 187
 188   test_compare(MEMCACHED_NOT_SUPPORTED, memcached_decrement(memc,
 189                                                             test_literal_param(__func__), // Key
 190                                                             uint32_t(0),
 191                                                             NULL));
 192
 193   return TEST_SUCCESS;
 194 }
 195
 196 test_return_t memcached_set_encoding_key_increment_with_initial_TEST(memcached_st* memc)
 197 {
 198   test_compare(MEMCACHED_SUCCESS, memcached_set_encoding_key(memc, test_literal_param(__func__)));
 199
 200   test_compare(MEMCACHED_NOT_SUPPORTED, memcached_increment_with_initial(memc,
 201                                                                          test_literal_param(__func__), // Key
 202                                                                          uint32_t(0),
 203                                                                          uint32_t(0),
 204                                                                          time_t(0),
 205                                                                          NULL));
 206
 207   return TEST_SUCCESS;
 208 }
 209
 210 test_return_t memcached_set_encoding_key_decrement_with_initial_TEST(memcached_st* memc)
 211 {
 212   test_compare(MEMCACHED_SUCCESS, memcached_set_encoding_key(memc, test_literal_param(__func__)));
 213
 214   test_compare(MEMCACHED_NOT_SUPPORTED, memcached_decrement_with_initial(memc,
 215                                                                          test_literal_param(__func__), // Key
 216                                                                          uint32_t(0),
 217                                                                          uint32_t(0),
 218                                                                          time_t(0),
 219                                                                          NULL));
 220
 221   return TEST_SUCCESS;
 222 }
 223
 224 test_return_t memcached_set_encoding_key_append_TEST(memcached_st* memc)
 225 {
 226   test_compare(MEMCACHED_SUCCESS, memcached_set_encoding_key(memc, test_literal_param(__func__)));
 227
 228   test_compare(MEMCACHED_NOT_SUPPORTED, memcached_append(memc,
 229                                                          test_literal_param(__func__), // Key
 230                                                          test_literal_param(__func__), // Value
 231                                                          time_t(0),
 232                                                          uint32_t(0)));
 233
 234   return TEST_SUCCESS;
 235 }
 236
 237 test_return_t memcached_set_encoding_key_prepend_TEST(memcached_st* memc)
 238 {
 239   test_compare(MEMCACHED_SUCCESS, memcached_set_encoding_key(memc, test_literal_param(__func__)));
 240
 241   test_compare(MEMCACHED_NOT_SUPPORTED, memcached_prepend(memc,
 242                                                          test_literal_param(__func__), // Key
 243                                                          test_literal_param(__func__), // Value
 244                                                          time_t(0),
 245                                                          uint32_t(0)));
 246
 247   return TEST_SUCCESS;
 248 }
 249
 250 test_return_t memcached_set_encoding_key_set_get_clone_TEST(memcached_st* memc)
 251 {
 252   memcached_st *memc_no_crypt= memcached_clone(NULL, memc);
 253   test_true(memc_no_crypt);
 254
 255   test_compare(MEMCACHED_SUCCESS, memcached_set_encoding_key(memc, test_literal_param(__func__)));
 256
 257   memcached_st *memc_crypt= memcached_clone(NULL, memc);
 258   test_true(memc_crypt);
 259
 260   test_compare(MEMCACHED_SUCCESS, memcached_set(memc,
 261                                                      test_literal_param(__func__), // Key
 262                                                      test_literal_param(__func__), // Value
 263                                                      time_t(0),
 264                                                      uint32_t(0)));
 265
 266   {
 267     memcached_return_t rc;
 268     size_t value_length;
 269     char *value;
 270     test_true((value= memcached_get(memc,
 271                                     test_literal_param(__func__), // Key
 272                                     &value_length, NULL, &rc)));
 273     test_compare(MEMCACHED_SUCCESS, rc);
 274     test_compare(test_literal_param_size(__func__), value_length);
 275     test_memcmp(__func__, value, value_length);
 276
 277     /*
 278       Check to make sure that the raw value is not the original.
 279     */
 280     size_t raw_value_length;
 281     char *raw_value;
 282     test_true((raw_value= memcached_get(memc_no_crypt,
 283                                         test_literal_param(__func__), // Key
 284                                         &raw_value_length, NULL, &rc)));
 285     test_compare(MEMCACHED_SUCCESS, rc);
 286     test_ne_compare(test_literal_param_size(__func__), raw_value_length);
 287     test_ne_compare(0, memcmp(__func__, raw_value, raw_value_length));
 288
 289     /*
 290       Now we will use our clone, and make sure the encrypted values are the same.
 291     */
 292     size_t second_value_length;
 293     char *second_value;
 294     test_true((second_value= memcached_get(memc_crypt,
 295                                            test_literal_param(__func__), // Key
 296                                            &second_value_length, NULL, &rc)));
 297     test_compare(MEMCACHED_SUCCESS, rc);
 298     test_compare(value_length, second_value_length);
 299     test_compare(0, memcmp(value, second_value, second_value_length));
 300     test_compare(test_literal_param_size(__func__), second_value_length);
 301     test_compare(value_length, second_value_length);
 302     test_memcmp(__func__, second_value, second_value_length);
 303     test_memcmp(value, second_value, second_value_length);
 304
 305     free(value);
 306     free(raw_value);
 307     free(second_value);
 308   }
 309
 310   memcached_free(memc_no_crypt);
 311   memcached_free(memc_crypt);
 312
 313   return TEST_SUCCESS;
 314 }
 315
 316 test_return_t memcached_set_encoding_key_set_grow_key_TEST(memcached_st* memc)
 317 {
 318   memcached_st *memc_no_crypt= memcached_clone(NULL, memc);
 319   test_true(memc_no_crypt);
 320   test_compare(MEMCACHED_SUCCESS, memcached_set_encoding_key(memc, test_literal_param(__func__)));
 321
 322   size_t payload_size[] = { 100, 1000, 10000, 1000000, 1000000, 0 };
 323   libtest::vchar_t payload;
 324   for (size_t *ptr= payload_size; *ptr; ptr++)
 325   {
 326     payload.reserve(*ptr);
 327     for (size_t x= payload.size(); x < *ptr; x++)
 328     {
 329       payload.push_back(rand());
 330     }
 331
 332     {
 333       memcached_return_t rc= memcached_set(memc,
 334                                            test_literal_param(__func__), // Key
 335                                            &payload[0], payload.size(), // Value
 336                                            time_t(0),
 337                                            uint32_t(0));
 338
 339       // If we run out of space on the server, we just end the test early.
 340       if (rc == MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE)
 341       {
 342         break;
 343       }
 344       test_compare(MEMCACHED_SUCCESS, rc);
 345     }
 346
 347     {
 348       memcached_return_t rc;
 349       size_t value_length;
 350       char *value;
 351       test_true((value= memcached_get(memc,
 352                                       test_literal_param(__func__), // Key
 353                                       &value_length, NULL, &rc)));
 354       test_compare(MEMCACHED_SUCCESS, rc);
 355       test_compare(payload.size(), value_length);
 356       test_memcmp(&payload[0], value, value_length);
 357
 358       size_t raw_value_length;
 359       char *raw_value;
 360       test_true((raw_value= memcached_get(memc_no_crypt,
 361                                           test_literal_param(__func__), // Key
 362                                           &raw_value_length, NULL, &rc)));
 363       test_compare(MEMCACHED_SUCCESS, rc);
 364       test_ne_compare(payload.size(), raw_value_length);
 365       test_ne_compare(0, memcmp(&payload[0], raw_value, raw_value_length));
 366
 367       free(value);
 368       free(raw_value);
 369     }
 370   }
 371
 372   memcached_free(memc_no_crypt);
 373
 374   return TEST_SUCCESS;
 375 }