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 
TEST(SerializeTest,SerializeI64)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 
TEST(SerializeTest,DeserializeI64)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 
TEST(SerializeTest,SerializeI32)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 
TEST(SerializeTest,DeserializeI32)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 
TEST(SerializeTest,SerializeI8)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 
TEST(SerializeTest,DeserializeI8)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 
main(int argc,char ** argv)184 int main(int argc, char** argv) {
185   ::testing::InitGoogleTest(&argc, argv);
186   return RUN_ALL_TESTS();
187 }
188