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