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