]>
git.proxmox.com Git - ceph.git/blob - ceph/src/rocksdb/util/coding_test.cc
1 // Copyright (c) 2011-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).
6 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
7 // Use of this source code is governed by a BSD-style license that can be
8 // found in the LICENSE file. See the AUTHORS file for names of contributors.
10 #include "util/coding.h"
12 #include "test_util/testharness.h"
14 namespace ROCKSDB_NAMESPACE
{
17 TEST(Coding
, Fixed16
) {
19 for (uint16_t v
= 0; v
< 0xFFFF; v
++) {
23 const char* p
= s
.data();
24 for (uint16_t v
= 0; v
< 0xFFFF; v
++) {
25 uint16_t actual
= DecodeFixed16(p
);
27 p
+= sizeof(uint16_t);
31 TEST(Coding
, Fixed32
) {
33 for (uint32_t v
= 0; v
< 100000; v
++) {
37 const char* p
= s
.data();
38 for (uint32_t v
= 0; v
< 100000; v
++) {
39 uint32_t actual
= DecodeFixed32(p
);
41 p
+= sizeof(uint32_t);
45 TEST(Coding
, Fixed64
) {
47 for (int power
= 0; power
<= 63; power
++) {
48 uint64_t v
= static_cast<uint64_t>(1) << power
;
49 PutFixed64(&s
, v
- 1);
50 PutFixed64(&s
, v
+ 0);
51 PutFixed64(&s
, v
+ 1);
54 const char* p
= s
.data();
55 for (int power
= 0; power
<= 63; power
++) {
56 uint64_t v
= static_cast<uint64_t>(1) << power
;
58 actual
= DecodeFixed64(p
);
59 ASSERT_EQ(v
- 1, actual
);
60 p
+= sizeof(uint64_t);
62 actual
= DecodeFixed64(p
);
63 ASSERT_EQ(v
+ 0, actual
);
64 p
+= sizeof(uint64_t);
66 actual
= DecodeFixed64(p
);
67 ASSERT_EQ(v
+ 1, actual
);
68 p
+= sizeof(uint64_t);
72 // Test that encoding routines generate little-endian encodings
73 TEST(Coding
, EncodingOutput
) {
75 PutFixed32(&dst
, 0x04030201);
76 ASSERT_EQ(4U, dst
.size());
77 ASSERT_EQ(0x01, static_cast<int>(dst
[0]));
78 ASSERT_EQ(0x02, static_cast<int>(dst
[1]));
79 ASSERT_EQ(0x03, static_cast<int>(dst
[2]));
80 ASSERT_EQ(0x04, static_cast<int>(dst
[3]));
83 PutFixed64(&dst
, 0x0807060504030201ull
);
84 ASSERT_EQ(8U, dst
.size());
85 ASSERT_EQ(0x01, static_cast<int>(dst
[0]));
86 ASSERT_EQ(0x02, static_cast<int>(dst
[1]));
87 ASSERT_EQ(0x03, static_cast<int>(dst
[2]));
88 ASSERT_EQ(0x04, static_cast<int>(dst
[3]));
89 ASSERT_EQ(0x05, static_cast<int>(dst
[4]));
90 ASSERT_EQ(0x06, static_cast<int>(dst
[5]));
91 ASSERT_EQ(0x07, static_cast<int>(dst
[6]));
92 ASSERT_EQ(0x08, static_cast<int>(dst
[7]));
95 TEST(Coding
, Varint32
) {
97 for (uint32_t i
= 0; i
< (32 * 32); i
++) {
98 uint32_t v
= (i
/ 32) << (i
% 32);
102 const char* p
= s
.data();
103 const char* limit
= p
+ s
.size();
104 for (uint32_t i
= 0; i
< (32 * 32); i
++) {
105 uint32_t expected
= (i
/ 32) << (i
% 32);
107 const char* start
= p
;
108 p
= GetVarint32Ptr(p
, limit
, &actual
);
109 ASSERT_TRUE(p
!= nullptr);
110 ASSERT_EQ(expected
, actual
);
111 ASSERT_EQ(VarintLength(actual
), p
- start
);
113 ASSERT_EQ(p
, s
.data() + s
.size());
116 TEST(Coding
, Varint64
) {
117 // Construct the list of values to check
118 std::vector
<uint64_t> values
;
119 // Some special values
121 values
.push_back(100);
122 values
.push_back(~static_cast<uint64_t>(0));
123 values
.push_back(~static_cast<uint64_t>(0) - 1);
124 for (uint32_t k
= 0; k
< 64; k
++) {
125 // Test values near powers of two
126 const uint64_t power
= 1ull << k
;
127 values
.push_back(power
);
128 values
.push_back(power
- 1);
129 values
.push_back(power
+ 1);
133 for (unsigned int i
= 0; i
< values
.size(); i
++) {
134 PutVarint64(&s
, values
[i
]);
137 const char* p
= s
.data();
138 const char* limit
= p
+ s
.size();
139 for (unsigned int i
= 0; i
< values
.size(); i
++) {
140 ASSERT_TRUE(p
< limit
);
142 const char* start
= p
;
143 p
= GetVarint64Ptr(p
, limit
, &actual
);
144 ASSERT_TRUE(p
!= nullptr);
145 ASSERT_EQ(values
[i
], actual
);
146 ASSERT_EQ(VarintLength(actual
), p
- start
);
151 TEST(Coding
, Varint32Overflow
) {
153 std::string
input("\x81\x82\x83\x84\x85\x11");
154 ASSERT_TRUE(GetVarint32Ptr(input
.data(), input
.data() + input
.size(),
155 &result
) == nullptr);
158 TEST(Coding
, Varint32Truncation
) {
159 uint32_t large_value
= (1u << 31) + 100;
161 PutVarint32(&s
, large_value
);
163 for (unsigned int len
= 0; len
+ 1 < s
.size(); len
++) {
164 ASSERT_TRUE(GetVarint32Ptr(s
.data(), s
.data() + len
, &result
) == nullptr);
166 ASSERT_TRUE(GetVarint32Ptr(s
.data(), s
.data() + s
.size(), &result
) !=
168 ASSERT_EQ(large_value
, result
);
171 TEST(Coding
, Varint64Overflow
) {
173 std::string
input("\x81\x82\x83\x84\x85\x81\x82\x83\x84\x85\x11");
174 ASSERT_TRUE(GetVarint64Ptr(input
.data(), input
.data() + input
.size(),
175 &result
) == nullptr);
178 TEST(Coding
, Varint64Truncation
) {
179 uint64_t large_value
= (1ull << 63) + 100ull;
181 PutVarint64(&s
, large_value
);
183 for (unsigned int len
= 0; len
+ 1 < s
.size(); len
++) {
184 ASSERT_TRUE(GetVarint64Ptr(s
.data(), s
.data() + len
, &result
) == nullptr);
186 ASSERT_TRUE(GetVarint64Ptr(s
.data(), s
.data() + s
.size(), &result
) !=
188 ASSERT_EQ(large_value
, result
);
191 TEST(Coding
, Strings
) {
193 PutLengthPrefixedSlice(&s
, Slice(""));
194 PutLengthPrefixedSlice(&s
, Slice("foo"));
195 PutLengthPrefixedSlice(&s
, Slice("bar"));
196 PutLengthPrefixedSlice(&s
, Slice(std::string(200, 'x')));
200 ASSERT_TRUE(GetLengthPrefixedSlice(&input
, &v
));
201 ASSERT_EQ("", v
.ToString());
202 ASSERT_TRUE(GetLengthPrefixedSlice(&input
, &v
));
203 ASSERT_EQ("foo", v
.ToString());
204 ASSERT_TRUE(GetLengthPrefixedSlice(&input
, &v
));
205 ASSERT_EQ("bar", v
.ToString());
206 ASSERT_TRUE(GetLengthPrefixedSlice(&input
, &v
));
207 ASSERT_EQ(std::string(200, 'x'), v
.ToString());
208 ASSERT_EQ("", input
.ToString());
211 } // namespace ROCKSDB_NAMESPACE
213 int main(int argc
, char** argv
) {
214 ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
215 ::testing::InitGoogleTest(&argc
, argv
);
216 return RUN_ALL_TESTS();