ceph/src/rocksdb/utilities/cassandra/cassandra_serialize_test.cc

   1 // Copyright (c) 2017-present, Facebook, Inc.  All rights reserved.
   2 //  This source code is licensed under both the GPLv2 (found in the
   3 //  COPYING file in the root directory) and Apache 2.0 License
   4 //  (found in the LICENSE.Apache file in the root directory).
   5
   6 #include "test_util/testharness.h"
   7 #include "utilities/cassandra/serialize.h"
   8
   9
  10 namespace ROCKSDB_NAMESPACE {
  11 namespace cassandra {
  12
  13 TEST(SerializeTest, SerializeI64) {
  14   std::string dest;
  15   Serialize<int64_t>(0, &dest);
  16   EXPECT_EQ(
  17       std::string(
  18           {'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00'}),
  19       dest);
  20
  21   dest.clear();
  22   Serialize<int64_t>(1, &dest);
  23   EXPECT_EQ(
  24       std::string(
  25           {'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x01'}),
  26       dest);
  27
  28
  29   dest.clear();
  30   Serialize<int64_t>(-1, &dest);
  31   EXPECT_EQ(
  32       std::string(
  33           {'\xff', '\xff', '\xff', '\xff', '\xff', '\xff', '\xff', '\xff'}),
  34       dest);
  35
  36   dest.clear();
  37   Serialize<int64_t>(9223372036854775807, &dest);
  38   EXPECT_EQ(
  39       std::string(
  40           {'\x7f', '\xff', '\xff', '\xff', '\xff', '\xff', '\xff', '\xff'}),
  41       dest);
  42
  43   dest.clear();
  44   Serialize<int64_t>(-9223372036854775807, &dest);
  45   EXPECT_EQ(
  46       std::string(
  47           {'\x80', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x01'}),
  48       dest);
  49 }
  50
  51 TEST(SerializeTest, DeserializeI64) {
  52   std::string dest;
  53   std::size_t offset = dest.size();
  54   Serialize<int64_t>(0, &dest);
  55   EXPECT_EQ(0, Deserialize<int64_t>(dest.c_str(), offset));
  56
  57   offset = dest.size();
  58   Serialize<int64_t>(1, &dest);
  59   EXPECT_EQ(1, Deserialize<int64_t>(dest.c_str(), offset));
  60
  61   offset = dest.size();
  62   Serialize<int64_t>(-1, &dest);
  63   EXPECT_EQ(-1, Deserialize<int64_t>(dest.c_str(), offset));
  64
  65   offset = dest.size();
  66   Serialize<int64_t>(-9223372036854775807, &dest);
  67   EXPECT_EQ(-9223372036854775807, Deserialize<int64_t>(dest.c_str(), offset));
  68
  69   offset = dest.size();
  70   Serialize<int64_t>(9223372036854775807, &dest);
  71   EXPECT_EQ(9223372036854775807, Deserialize<int64_t>(dest.c_str(), offset));
  72 }
  73
  74 TEST(SerializeTest, SerializeI32) {
  75   std::string dest;
  76   Serialize<int32_t>(0, &dest);
  77   EXPECT_EQ(
  78       std::string(
  79           {'\x00', '\x00', '\x00', '\x00'}),
  80       dest);
  81
  82   dest.clear();
  83   Serialize<int32_t>(1, &dest);
  84   EXPECT_EQ(
  85       std::string(
  86           {'\x00', '\x00', '\x00', '\x01'}),
  87       dest);
  88
  89
  90   dest.clear();
  91   Serialize<int32_t>(-1, &dest);
  92   EXPECT_EQ(
  93       std::string(
  94           {'\xff', '\xff', '\xff', '\xff'}),
  95       dest);
  96
  97   dest.clear();
  98   Serialize<int32_t>(2147483647, &dest);
  99   EXPECT_EQ(
 100       std::string(
 101           {'\x7f', '\xff', '\xff', '\xff'}),
 102       dest);
 103
 104   dest.clear();
 105   Serialize<int32_t>(-2147483648LL, &dest);
 106   EXPECT_EQ(
 107       std::string(
 108           {'\x80', '\x00', '\x00', '\x00'}),
 109       dest);
 110 }
 111
 112 TEST(SerializeTest, DeserializeI32) {
 113   std::string dest;
 114   std::size_t offset = dest.size();
 115   Serialize<int32_t>(0, &dest);
 116   EXPECT_EQ(0, Deserialize<int32_t>(dest.c_str(), offset));
 117
 118   offset = dest.size();
 119   Serialize<int32_t>(1, &dest);
 120   EXPECT_EQ(1, Deserialize<int32_t>(dest.c_str(), offset));
 121
 122   offset = dest.size();
 123   Serialize<int32_t>(-1, &dest);
 124   EXPECT_EQ(-1, Deserialize<int32_t>(dest.c_str(), offset));
 125
 126   offset = dest.size();
 127   Serialize<int32_t>(2147483647, &dest);
 128   EXPECT_EQ(2147483647, Deserialize<int32_t>(dest.c_str(), offset));
 129
 130   offset = dest.size();
 131   Serialize<int32_t>(-2147483648LL, &dest);
 132   EXPECT_EQ(-2147483648LL, Deserialize<int32_t>(dest.c_str(), offset));
 133 }
 134
 135 TEST(SerializeTest, SerializeI8) {
 136   std::string dest;
 137   Serialize<int8_t>(0, &dest);
 138   EXPECT_EQ(std::string({'\x00'}), dest);
 139
 140   dest.clear();
 141   Serialize<int8_t>(1, &dest);
 142   EXPECT_EQ(std::string({'\x01'}), dest);
 143
 144
 145   dest.clear();
 146   Serialize<int8_t>(-1, &dest);
 147   EXPECT_EQ(std::string({'\xff'}), dest);
 148
 149   dest.clear();
 150   Serialize<int8_t>(127, &dest);
 151   EXPECT_EQ(std::string({'\x7f'}), dest);
 152
 153   dest.clear();
 154   Serialize<int8_t>(-128, &dest);
 155   EXPECT_EQ(std::string({'\x80'}), dest);
 156 }
 157
 158 TEST(SerializeTest, DeserializeI8) {
 159   std::string dest;
 160   std::size_t offset = dest.size();
 161   Serialize<int8_t>(0, &dest);
 162   EXPECT_EQ(0, Deserialize<int8_t>(dest.c_str(), offset));
 163
 164   offset = dest.size();
 165   Serialize<int8_t>(1, &dest);
 166   EXPECT_EQ(1, Deserialize<int8_t>(dest.c_str(), offset));
 167
 168   offset = dest.size();
 169   Serialize<int8_t>(-1, &dest);
 170   EXPECT_EQ(-1, Deserialize<int8_t>(dest.c_str(), offset));
 171
 172   offset = dest.size();
 173   Serialize<int8_t>(127, &dest);
 174   EXPECT_EQ(127, Deserialize<int8_t>(dest.c_str(), offset));
 175
 176   offset = dest.size();
 177   Serialize<int8_t>(-128, &dest);
 178   EXPECT_EQ(-128, Deserialize<int8_t>(dest.c_str(), offset));
 179 }
 180
 181 } // namespace cassandra
 182 }  // namespace ROCKSDB_NAMESPACE
 183
 184 int main(int argc, char** argv) {
 185   ::testing::InitGoogleTest(&argc, argv);
 186   return RUN_ALL_TESTS();
 187 }