1 // Copyright 2019 The Pigweed Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14
15 #include "pw_varint/varint.h"
16
17 #include <cinttypes>
18 #include <cstdint>
19 #include <cstring>
20 #include <limits>
21
22 #include "gtest/gtest.h"
23
24 namespace pw::varint {
25 namespace {
26
27 extern "C" {
28
29 // Functions defined in varint_test.c which call the varint API from C.
30 size_t pw_varint_CallEncode(uint64_t integer, void* output, size_t output_size);
31 size_t pw_varint_CallZigZagEncode(int64_t integer,
32 void* output,
33 size_t output_size);
34 size_t pw_varint_CallDecode(void* input, size_t input_size, uint64_t* output);
35 size_t pw_varint_CallZigZagDecode(void* input,
36 size_t input_size,
37 int64_t* output);
38
39 } // extern "C"
40
41 class Varint : public ::testing::Test {
42 protected:
Varint()43 Varint() : buffer_ {
44 std::byte{'a'}, std::byte{'b'}, std::byte{'c'}, std::byte{'d'},
45 std::byte{'e'}, std::byte{'f'}, std::byte{'g'}, std::byte{'h'},
46 std::byte{'i'}, std::byte {
47 'j'
48 }
49 }
50 {}
51 std::byte buffer_[10];
52 };
53
TEST_F(Varint,EncodeSizeUnsigned32_SmallSingleByte)54 TEST_F(Varint, EncodeSizeUnsigned32_SmallSingleByte) {
55 ASSERT_EQ(1u, Encode(UINT32_C(0), buffer_));
56 EXPECT_EQ(std::byte{0}, buffer_[0]);
57 ASSERT_EQ(1u, Encode(UINT32_C(1), buffer_));
58 EXPECT_EQ(std::byte{1}, buffer_[0]);
59 ASSERT_EQ(1u, Encode(UINT32_C(2), buffer_));
60 EXPECT_EQ(std::byte{2}, buffer_[0]);
61 }
62
TEST_F(Varint,EncodeSizeUnsigned32_SmallSingleByte_C)63 TEST_F(Varint, EncodeSizeUnsigned32_SmallSingleByte_C) {
64 ASSERT_EQ(1u, pw_varint_CallEncode(UINT32_C(0), buffer_, sizeof(buffer_)));
65 EXPECT_EQ(std::byte{0}, buffer_[0]);
66 ASSERT_EQ(1u, pw_varint_CallEncode(UINT32_C(1), buffer_, sizeof(buffer_)));
67 EXPECT_EQ(std::byte{1}, buffer_[0]);
68 ASSERT_EQ(1u, pw_varint_CallEncode(UINT32_C(2), buffer_, sizeof(buffer_)));
69 EXPECT_EQ(std::byte{2}, buffer_[0]);
70 }
71
TEST_F(Varint,EncodeSizeUnsigned32_LargeSingleByte)72 TEST_F(Varint, EncodeSizeUnsigned32_LargeSingleByte) {
73 ASSERT_EQ(1u, Encode(UINT32_C(63), buffer_));
74 EXPECT_EQ(std::byte{63}, buffer_[0]);
75 ASSERT_EQ(1u, Encode(UINT32_C(64), buffer_));
76 EXPECT_EQ(std::byte{64}, buffer_[0]);
77 ASSERT_EQ(1u, Encode(UINT32_C(126), buffer_));
78 EXPECT_EQ(std::byte{126}, buffer_[0]);
79 ASSERT_EQ(1u, Encode(UINT32_C(127), buffer_));
80 EXPECT_EQ(std::byte{127}, buffer_[0]);
81 }
82
TEST_F(Varint,EncodeSizeUnsigned32_LargeSingleByte_C)83 TEST_F(Varint, EncodeSizeUnsigned32_LargeSingleByte_C) {
84 ASSERT_EQ(1u, pw_varint_CallEncode(UINT32_C(63), buffer_, sizeof(buffer_)));
85 EXPECT_EQ(std::byte{63}, buffer_[0]);
86 ASSERT_EQ(1u, pw_varint_CallEncode(UINT32_C(64), buffer_, sizeof(buffer_)));
87 EXPECT_EQ(std::byte{64}, buffer_[0]);
88 ASSERT_EQ(1u, pw_varint_CallEncode(UINT32_C(126), buffer_, sizeof(buffer_)));
89 EXPECT_EQ(std::byte{126}, buffer_[0]);
90 ASSERT_EQ(1u, pw_varint_CallEncode(UINT32_C(127), buffer_, sizeof(buffer_)));
91 EXPECT_EQ(std::byte{127}, buffer_[0]);
92 }
93
TEST_F(Varint,EncodeSizeUnsigned32_MultiByte)94 TEST_F(Varint, EncodeSizeUnsigned32_MultiByte) {
95 ASSERT_EQ(2u, Encode(UINT32_C(128), buffer_));
96 EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
97 ASSERT_EQ(2u, Encode(UINT32_C(129), buffer_));
98 EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
99
100 ASSERT_EQ(5u, Encode(std::numeric_limits<uint32_t>::max() - 1, buffer_));
101 EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer_, 5), 0);
102
103 ASSERT_EQ(5u, Encode(std::numeric_limits<uint32_t>::max(), buffer_));
104 EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer_, 5), 0);
105 }
106
TEST_F(Varint,EncodeSizeUnsigned32_MultiByte_C)107 TEST_F(Varint, EncodeSizeUnsigned32_MultiByte_C) {
108 ASSERT_EQ(2u, pw_varint_CallEncode(UINT32_C(128), buffer_, sizeof(buffer_)));
109 EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
110 ASSERT_EQ(2u, pw_varint_CallEncode(UINT32_C(129), buffer_, sizeof(buffer_)));
111 EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
112
113 ASSERT_EQ(
114 5u,
115 pw_varint_CallEncode(
116 std::numeric_limits<uint32_t>::max() - 1, buffer_, sizeof(buffer_)));
117 EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer_, 5), 0);
118
119 ASSERT_EQ(
120 5u,
121 pw_varint_CallEncode(
122 std::numeric_limits<uint32_t>::max(), buffer_, sizeof(buffer_)));
123 EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer_, 5), 0);
124 }
125
TEST_F(Varint,EncodeSizeSigned32_SmallSingleByte)126 TEST_F(Varint, EncodeSizeSigned32_SmallSingleByte) {
127 ASSERT_EQ(1u, Encode(INT32_C(0), buffer_));
128 EXPECT_EQ(std::byte{0}, buffer_[0]);
129 ASSERT_EQ(1u, Encode(INT32_C(-1), buffer_));
130 EXPECT_EQ(std::byte{1}, buffer_[0]);
131 ASSERT_EQ(1u, Encode(INT32_C(1), buffer_));
132 EXPECT_EQ(std::byte{2}, buffer_[0]);
133 ASSERT_EQ(1u, Encode(INT32_C(-2), buffer_));
134 EXPECT_EQ(std::byte{3}, buffer_[0]);
135 ASSERT_EQ(1u, Encode(INT32_C(2), buffer_));
136 EXPECT_EQ(std::byte{4}, buffer_[0]);
137 }
138
TEST_F(Varint,EncodeSizeSigned32_SmallSingleByte_C)139 TEST_F(Varint, EncodeSizeSigned32_SmallSingleByte_C) {
140 ASSERT_EQ(1u,
141 pw_varint_CallZigZagEncode(INT32_C(0), buffer_, sizeof(buffer_)));
142 EXPECT_EQ(std::byte{0}, buffer_[0]);
143 ASSERT_EQ(1u,
144 pw_varint_CallZigZagEncode(INT32_C(-1), buffer_, sizeof(buffer_)));
145 EXPECT_EQ(std::byte{1}, buffer_[0]);
146 ASSERT_EQ(1u,
147 pw_varint_CallZigZagEncode(INT32_C(1), buffer_, sizeof(buffer_)));
148 EXPECT_EQ(std::byte{2}, buffer_[0]);
149 ASSERT_EQ(1u,
150 pw_varint_CallZigZagEncode(INT32_C(-2), buffer_, sizeof(buffer_)));
151 EXPECT_EQ(std::byte{3}, buffer_[0]);
152 ASSERT_EQ(1u,
153 pw_varint_CallZigZagEncode(INT32_C(2), buffer_, sizeof(buffer_)));
154 EXPECT_EQ(std::byte{4}, buffer_[0]);
155 }
156
TEST_F(Varint,EncodeSizeSigned32_LargeSingleByte)157 TEST_F(Varint, EncodeSizeSigned32_LargeSingleByte) {
158 ASSERT_EQ(1u, Encode(INT32_C(-63), buffer_));
159 EXPECT_EQ(std::byte{125}, buffer_[0]);
160 ASSERT_EQ(1u, Encode(INT32_C(63), buffer_));
161 EXPECT_EQ(std::byte{126}, buffer_[0]);
162 ASSERT_EQ(1u, Encode(INT32_C(-64), buffer_));
163 EXPECT_EQ(std::byte{127}, buffer_[0]);
164 }
165
TEST_F(Varint,EncodeSizeSigned32_LargeSingleByte_C)166 TEST_F(Varint, EncodeSizeSigned32_LargeSingleByte_C) {
167 ASSERT_EQ(1u,
168 pw_varint_CallZigZagEncode(INT32_C(-63), buffer_, sizeof(buffer_)));
169 EXPECT_EQ(std::byte{125}, buffer_[0]);
170 ASSERT_EQ(1u,
171 pw_varint_CallZigZagEncode(INT32_C(63), buffer_, sizeof(buffer_)));
172 EXPECT_EQ(std::byte{126}, buffer_[0]);
173 ASSERT_EQ(1u,
174 pw_varint_CallZigZagEncode(INT32_C(-64), buffer_, sizeof(buffer_)));
175 EXPECT_EQ(std::byte{127}, buffer_[0]);
176 }
177
TEST_F(Varint,EncodeSizeSigned32_MultiByte)178 TEST_F(Varint, EncodeSizeSigned32_MultiByte) {
179 ASSERT_EQ(2u, Encode(INT32_C(64), buffer_));
180 EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
181 ASSERT_EQ(2u, Encode(INT32_C(-65), buffer_));
182 EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
183 ASSERT_EQ(2u, Encode(INT32_C(65), buffer_));
184 EXPECT_EQ(std::memcmp("\x82\x01", buffer_, 2), 0);
185
186 ASSERT_EQ(5u, Encode(std::numeric_limits<int32_t>::min(), buffer_));
187 EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer_, 5), 0);
188
189 ASSERT_EQ(5u, Encode(std::numeric_limits<int32_t>::max(), buffer_));
190 EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer_, 5), 0);
191 }
192
TEST_F(Varint,EncodeSizeSigned32_MultiByte_C)193 TEST_F(Varint, EncodeSizeSigned32_MultiByte_C) {
194 ASSERT_EQ(2u,
195 pw_varint_CallZigZagEncode(INT32_C(64), buffer_, sizeof(buffer_)));
196 EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
197 ASSERT_EQ(2u,
198 pw_varint_CallZigZagEncode(INT32_C(-65), buffer_, sizeof(buffer_)));
199 EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
200 ASSERT_EQ(2u,
201 pw_varint_CallZigZagEncode(INT32_C(65), buffer_, sizeof(buffer_)));
202 EXPECT_EQ(std::memcmp("\x82\x01", buffer_, 2), 0);
203
204 ASSERT_EQ(5u,
205 pw_varint_CallZigZagEncode(
206 std::numeric_limits<int32_t>::min(), buffer_, sizeof(buffer_)));
207 EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer_, 5), 0);
208
209 ASSERT_EQ(5u,
210 pw_varint_CallZigZagEncode(
211 std::numeric_limits<int32_t>::max(), buffer_, sizeof(buffer_)));
212 EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer_, 5), 0);
213 }
214
TEST_F(Varint,EncodeSizeUnsigned64_SmallSingleByte)215 TEST_F(Varint, EncodeSizeUnsigned64_SmallSingleByte) {
216 ASSERT_EQ(1u, Encode(UINT64_C(0), buffer_));
217 EXPECT_EQ(std::byte{0}, buffer_[0]);
218 ASSERT_EQ(1u, Encode(UINT64_C(1), buffer_));
219 EXPECT_EQ(std::byte{1}, buffer_[0]);
220 ASSERT_EQ(1u, Encode(UINT64_C(2), buffer_));
221 EXPECT_EQ(std::byte{2}, buffer_[0]);
222 }
223
TEST_F(Varint,EncodeSizeUnsigned64_SmallSingleByte_C)224 TEST_F(Varint, EncodeSizeUnsigned64_SmallSingleByte_C) {
225 ASSERT_EQ(1u, pw_varint_CallEncode(UINT64_C(0), buffer_, sizeof(buffer_)));
226 EXPECT_EQ(std::byte{0}, buffer_[0]);
227 ASSERT_EQ(1u, pw_varint_CallEncode(UINT64_C(1), buffer_, sizeof(buffer_)));
228 EXPECT_EQ(std::byte{1}, buffer_[0]);
229 ASSERT_EQ(1u, pw_varint_CallEncode(UINT64_C(2), buffer_, sizeof(buffer_)));
230 EXPECT_EQ(std::byte{2}, buffer_[0]);
231 }
232
TEST_F(Varint,EncodeSizeUnsigned64_LargeSingleByte)233 TEST_F(Varint, EncodeSizeUnsigned64_LargeSingleByte) {
234 ASSERT_EQ(1u, Encode(UINT64_C(63), buffer_));
235 EXPECT_EQ(std::byte{63}, buffer_[0]);
236 ASSERT_EQ(1u, Encode(UINT64_C(64), buffer_));
237 EXPECT_EQ(std::byte{64}, buffer_[0]);
238 ASSERT_EQ(1u, Encode(UINT64_C(126), buffer_));
239 EXPECT_EQ(std::byte{126}, buffer_[0]);
240 ASSERT_EQ(1u, Encode(UINT64_C(127), buffer_));
241 EXPECT_EQ(std::byte{127}, buffer_[0]);
242 }
243
TEST_F(Varint,EncodeSizeUnsigned64_LargeSingleByte_C)244 TEST_F(Varint, EncodeSizeUnsigned64_LargeSingleByte_C) {
245 ASSERT_EQ(1u, pw_varint_CallEncode(UINT64_C(63), buffer_, sizeof(buffer_)));
246 EXPECT_EQ(std::byte{63}, buffer_[0]);
247 ASSERT_EQ(1u, pw_varint_CallEncode(UINT64_C(64), buffer_, sizeof(buffer_)));
248 EXPECT_EQ(std::byte{64}, buffer_[0]);
249 ASSERT_EQ(1u, pw_varint_CallEncode(UINT64_C(126), buffer_, sizeof(buffer_)));
250 EXPECT_EQ(std::byte{126}, buffer_[0]);
251 ASSERT_EQ(1u, pw_varint_CallEncode(UINT64_C(127), buffer_, sizeof(buffer_)));
252 EXPECT_EQ(std::byte{127}, buffer_[0]);
253 }
254
TEST_F(Varint,EncodeSizeUnsigned64_MultiByte)255 TEST_F(Varint, EncodeSizeUnsigned64_MultiByte) {
256 ASSERT_EQ(2u, Encode(UINT64_C(128), buffer_));
257 EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
258 ASSERT_EQ(2u, Encode(UINT64_C(129), buffer_));
259 EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
260
261 ASSERT_EQ(5u, Encode(std::numeric_limits<uint32_t>::max() - 1, buffer_));
262 EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer_, 5), 0);
263
264 ASSERT_EQ(5u, Encode(std::numeric_limits<uint32_t>::max(), buffer_));
265 EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer_, 5), 0);
266
267 ASSERT_EQ(10u, Encode(std::numeric_limits<uint64_t>::max() - 1, buffer_));
268 EXPECT_EQ(
269 std::memcmp("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer_, 10), 0);
270
271 ASSERT_EQ(10u, Encode(std::numeric_limits<uint64_t>::max(), buffer_));
272 EXPECT_EQ(
273 std::memcmp("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer_, 10), 0);
274 }
275
TEST_F(Varint,EncodeSizeUnsigned64_MultiByte_C)276 TEST_F(Varint, EncodeSizeUnsigned64_MultiByte_C) {
277 ASSERT_EQ(2u, pw_varint_CallEncode(UINT64_C(128), buffer_, sizeof(buffer_)));
278 EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
279 ASSERT_EQ(2u, pw_varint_CallEncode(UINT64_C(129), buffer_, sizeof(buffer_)));
280 EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
281
282 ASSERT_EQ(
283 5u,
284 pw_varint_CallEncode(
285 std::numeric_limits<uint32_t>::max() - 1, buffer_, sizeof(buffer_)));
286 EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer_, 5), 0);
287
288 ASSERT_EQ(
289 5u,
290 pw_varint_CallEncode(
291 std::numeric_limits<uint32_t>::max(), buffer_, sizeof(buffer_)));
292 EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer_, 5), 0);
293
294 ASSERT_EQ(
295 10u,
296 pw_varint_CallEncode(
297 std::numeric_limits<uint64_t>::max() - 1, buffer_, sizeof(buffer_)));
298 EXPECT_EQ(
299 std::memcmp("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer_, 10), 0);
300
301 ASSERT_EQ(
302 10u,
303 pw_varint_CallEncode(
304 std::numeric_limits<uint64_t>::max(), buffer_, sizeof(buffer_)));
305 EXPECT_EQ(
306 std::memcmp("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer_, 10), 0);
307 }
308
TEST_F(Varint,EncodeSizeSigned64_SmallSingleByte)309 TEST_F(Varint, EncodeSizeSigned64_SmallSingleByte) {
310 ASSERT_EQ(1u, Encode(INT64_C(0), buffer_));
311 EXPECT_EQ(std::byte{0}, buffer_[0]);
312 ASSERT_EQ(1u, Encode(INT64_C(-1), buffer_));
313 EXPECT_EQ(std::byte{1}, buffer_[0]);
314 ASSERT_EQ(1u, Encode(INT64_C(1), buffer_));
315 EXPECT_EQ(std::byte{2}, buffer_[0]);
316 ASSERT_EQ(1u, Encode(INT64_C(-2), buffer_));
317 EXPECT_EQ(std::byte{3}, buffer_[0]);
318 ASSERT_EQ(1u, Encode(INT64_C(2), buffer_));
319 EXPECT_EQ(std::byte{4}, buffer_[0]);
320 }
321
TEST_F(Varint,EncodeSizeSigned64_SmallSingleByte_C)322 TEST_F(Varint, EncodeSizeSigned64_SmallSingleByte_C) {
323 ASSERT_EQ(1u,
324 pw_varint_CallZigZagEncode(INT64_C(0), buffer_, sizeof(buffer_)));
325 EXPECT_EQ(std::byte{0}, buffer_[0]);
326 ASSERT_EQ(1u,
327 pw_varint_CallZigZagEncode(INT64_C(-1), buffer_, sizeof(buffer_)));
328 EXPECT_EQ(std::byte{1}, buffer_[0]);
329 ASSERT_EQ(1u,
330 pw_varint_CallZigZagEncode(INT64_C(1), buffer_, sizeof(buffer_)));
331 EXPECT_EQ(std::byte{2}, buffer_[0]);
332 ASSERT_EQ(1u,
333 pw_varint_CallZigZagEncode(INT64_C(-2), buffer_, sizeof(buffer_)));
334 EXPECT_EQ(std::byte{3}, buffer_[0]);
335 ASSERT_EQ(1u,
336 pw_varint_CallZigZagEncode(INT64_C(2), buffer_, sizeof(buffer_)));
337 EXPECT_EQ(std::byte{4}, buffer_[0]);
338 }
339
TEST_F(Varint,EncodeSizeSigned64_LargeSingleByte)340 TEST_F(Varint, EncodeSizeSigned64_LargeSingleByte) {
341 ASSERT_EQ(1u, Encode(INT64_C(-63), buffer_));
342 EXPECT_EQ(std::byte{125}, buffer_[0]);
343 ASSERT_EQ(1u, Encode(INT64_C(63), buffer_));
344 EXPECT_EQ(std::byte{126}, buffer_[0]);
345 ASSERT_EQ(1u, Encode(INT64_C(-64), buffer_));
346 EXPECT_EQ(std::byte{127}, buffer_[0]);
347 }
348
TEST_F(Varint,EncodeSizeSigned64_LargeSingleByte_C)349 TEST_F(Varint, EncodeSizeSigned64_LargeSingleByte_C) {
350 ASSERT_EQ(1u,
351 pw_varint_CallZigZagEncode(INT64_C(-63), buffer_, sizeof(buffer_)));
352 EXPECT_EQ(std::byte{125}, buffer_[0]);
353 ASSERT_EQ(1u,
354 pw_varint_CallZigZagEncode(INT64_C(63), buffer_, sizeof(buffer_)));
355 EXPECT_EQ(std::byte{126}, buffer_[0]);
356 ASSERT_EQ(1u,
357 pw_varint_CallZigZagEncode(INT64_C(-64), buffer_, sizeof(buffer_)));
358 EXPECT_EQ(std::byte{127}, buffer_[0]);
359 }
360
TEST_F(Varint,EncodeSizeSigned64_MultiByte)361 TEST_F(Varint, EncodeSizeSigned64_MultiByte) {
362 ASSERT_EQ(2u, Encode(INT64_C(64), buffer_));
363 EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
364 ASSERT_EQ(2u, Encode(INT64_C(-65), buffer_));
365 EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
366 ASSERT_EQ(2u, Encode(INT64_C(65), buffer_));
367 EXPECT_EQ(std::memcmp("\x82\x01", buffer_, 2), 0);
368
369 ASSERT_EQ(5u,
370 Encode(static_cast<int64_t>(std::numeric_limits<int32_t>::min()),
371 buffer_));
372 EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer_, 5), 0);
373
374 ASSERT_EQ(5u,
375 Encode(static_cast<int64_t>(std::numeric_limits<int32_t>::max()),
376 buffer_));
377 EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer_, 5), 0);
378
379 ASSERT_EQ(10u, Encode(std::numeric_limits<int64_t>::min(), buffer_));
380 EXPECT_EQ(
381 std::memcmp("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer_, 10), 0);
382
383 ASSERT_EQ(10u, Encode(std::numeric_limits<int64_t>::max(), buffer_));
384 EXPECT_EQ(
385 std::memcmp("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer_, 10), 0);
386 }
387
TEST_F(Varint,EncodeSizeSigned64_MultiByte_C)388 TEST_F(Varint, EncodeSizeSigned64_MultiByte_C) {
389 ASSERT_EQ(2u,
390 pw_varint_CallZigZagEncode(INT64_C(64), buffer_, sizeof(buffer_)));
391 EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
392 ASSERT_EQ(2u,
393 pw_varint_CallZigZagEncode(INT64_C(-65), buffer_, sizeof(buffer_)));
394 EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
395 ASSERT_EQ(2u,
396 pw_varint_CallZigZagEncode(INT64_C(65), buffer_, sizeof(buffer_)));
397 EXPECT_EQ(std::memcmp("\x82\x01", buffer_, 2), 0);
398
399 ASSERT_EQ(5u,
400 pw_varint_CallZigZagEncode(
401 static_cast<int64_t>(std::numeric_limits<int32_t>::min()),
402 buffer_,
403 sizeof(buffer_)));
404 EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer_, 5), 0);
405
406 ASSERT_EQ(5u,
407 pw_varint_CallZigZagEncode(
408 static_cast<int64_t>(std::numeric_limits<int32_t>::max()),
409 buffer_,
410 sizeof(buffer_)));
411 EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer_, 5), 0);
412
413 ASSERT_EQ(10u,
414 pw_varint_CallZigZagEncode(
415 std::numeric_limits<int64_t>::min(), buffer_, sizeof(buffer_)));
416 EXPECT_EQ(
417 std::memcmp("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer_, 10), 0);
418
419 ASSERT_EQ(10u,
420 pw_varint_CallZigZagEncode(
421 std::numeric_limits<int64_t>::max(), buffer_, sizeof(buffer_)));
422 EXPECT_EQ(
423 std::memcmp("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer_, 10), 0);
424 }
425
426 // How much to increment by for each iteration of the exhaustive encode/decode
427 // tests. Set the increment to 1 to test every number (this is slow).
428 constexpr int kIncrement = 100'000'009;
429
TEST_F(Varint,EncodeDecodeSigned32)430 TEST_F(Varint, EncodeDecodeSigned32) {
431 int32_t i = std::numeric_limits<int32_t>::min();
432 while (true) {
433 size_t encoded = Encode(i, buffer_);
434
435 int64_t result;
436 size_t decoded = Decode(buffer_, &result);
437
438 EXPECT_EQ(encoded, decoded);
439 ASSERT_EQ(i, result);
440
441 if (i > std::numeric_limits<int32_t>::max() - kIncrement) {
442 break;
443 }
444
445 i += kIncrement;
446 }
447 }
448
TEST_F(Varint,EncodeDecodeSigned32_C)449 TEST_F(Varint, EncodeDecodeSigned32_C) {
450 int32_t i = std::numeric_limits<int32_t>::min();
451 while (true) {
452 size_t encoded = pw_varint_CallZigZagEncode(i, buffer_, sizeof(buffer_));
453
454 int64_t result;
455 size_t decoded =
456 pw_varint_CallZigZagDecode(buffer_, sizeof(buffer_), &result);
457
458 EXPECT_EQ(encoded, decoded);
459 ASSERT_EQ(i, result);
460
461 if (i > std::numeric_limits<int32_t>::max() - kIncrement) {
462 break;
463 }
464
465 i += kIncrement;
466 }
467 }
468
TEST_F(Varint,EncodeDecodeUnsigned32)469 TEST_F(Varint, EncodeDecodeUnsigned32) {
470 uint32_t i = 0;
471 while (true) {
472 size_t encoded = Encode(i, buffer_);
473
474 uint64_t result;
475 size_t decoded = Decode(buffer_, &result);
476
477 EXPECT_EQ(encoded, decoded);
478 ASSERT_EQ(i, result);
479
480 if (i > std::numeric_limits<uint32_t>::max() - kIncrement) {
481 break;
482 }
483
484 i += kIncrement;
485 }
486 }
487
TEST_F(Varint,EncodeDecodeUnsigned32_C)488 TEST_F(Varint, EncodeDecodeUnsigned32_C) {
489 uint32_t i = 0;
490 while (true) {
491 size_t encoded = pw_varint_CallEncode(i, buffer_, sizeof(buffer_));
492
493 uint64_t result;
494 size_t decoded = pw_varint_CallDecode(buffer_, sizeof(buffer_), &result);
495
496 EXPECT_EQ(encoded, decoded);
497 ASSERT_EQ(i, result);
498
499 if (i > std::numeric_limits<uint32_t>::max() - kIncrement) {
500 break;
501 }
502
503 i += kIncrement;
504 }
505 }
506
507 template <size_t kStringSize>
MakeBuffer(const char (& data)[kStringSize])508 auto MakeBuffer(const char (&data)[kStringSize]) {
509 constexpr size_t kSizeBytes = kStringSize - 1;
510 static_assert(kSizeBytes <= 10, "Varint arrays never need be larger than 10");
511
512 std::array<std::byte, kSizeBytes> array;
513 std::memcpy(array.data(), data, kSizeBytes);
514 return array;
515 }
516
TEST(VarintDecode,DecodeSigned64_SingleByte)517 TEST(VarintDecode, DecodeSigned64_SingleByte) {
518 int64_t value = -1234;
519
520 EXPECT_EQ(Decode(MakeBuffer("\x00"), &value), 1u);
521 EXPECT_EQ(value, 0);
522
523 EXPECT_EQ(Decode(MakeBuffer("\x01"), &value), 1u);
524 EXPECT_EQ(value, -1);
525
526 EXPECT_EQ(Decode(MakeBuffer("\x02"), &value), 1u);
527 EXPECT_EQ(value, 1);
528
529 EXPECT_EQ(Decode(MakeBuffer("\x03"), &value), 1u);
530 EXPECT_EQ(value, -2);
531
532 EXPECT_EQ(Decode(MakeBuffer("\x04"), &value), 1u);
533 EXPECT_EQ(value, 2);
534
535 EXPECT_EQ(Decode(MakeBuffer("\x04"), &value), 1u);
536 EXPECT_EQ(value, 2);
537 }
538
TEST(VarintDecode,DecodeSigned64_SingleByte_C)539 TEST(VarintDecode, DecodeSigned64_SingleByte_C) {
540 int64_t value = -1234;
541
542 auto buffer = MakeBuffer("\x00");
543 EXPECT_EQ(pw_varint_CallZigZagDecode(buffer.data(), buffer.size(), &value),
544 1u);
545 EXPECT_EQ(value, 0);
546
547 buffer = MakeBuffer("\x01");
548 EXPECT_EQ(pw_varint_CallZigZagDecode(buffer.data(), buffer.size(), &value),
549 1u);
550 EXPECT_EQ(value, -1);
551
552 buffer = MakeBuffer("\x02");
553 EXPECT_EQ(pw_varint_CallZigZagDecode(buffer.data(), buffer.size(), &value),
554 1u);
555 EXPECT_EQ(value, 1);
556
557 buffer = MakeBuffer("\x03");
558 EXPECT_EQ(pw_varint_CallZigZagDecode(buffer.data(), buffer.size(), &value),
559 1u);
560 EXPECT_EQ(value, -2);
561
562 buffer = MakeBuffer("\x04");
563 EXPECT_EQ(pw_varint_CallZigZagDecode(buffer.data(), buffer.size(), &value),
564 1u);
565 EXPECT_EQ(value, 2);
566
567 buffer = MakeBuffer("\x04");
568 EXPECT_EQ(pw_varint_CallZigZagDecode(buffer.data(), buffer.size(), &value),
569 1u);
570 EXPECT_EQ(value, 2);
571 }
572
TEST(VarintDecode,DecodeSigned64_MultiByte)573 TEST(VarintDecode, DecodeSigned64_MultiByte) {
574 int64_t value = -1234;
575
576 EXPECT_EQ(Decode(MakeBuffer("\x80\x01"), &value), 2u);
577 EXPECT_EQ(value, 64);
578
579 EXPECT_EQ(Decode(MakeBuffer("\x81\x01"), &value), 2u);
580 EXPECT_EQ(value, -65);
581
582 EXPECT_EQ(Decode(MakeBuffer("\x82\x01"), &value), 2u);
583 EXPECT_EQ(value, 65);
584
585 EXPECT_EQ(Decode(MakeBuffer("\xff\xff\xff\xff\x0f"), &value), 5u);
586 EXPECT_EQ(value, std::numeric_limits<int32_t>::min());
587
588 EXPECT_EQ(Decode(MakeBuffer("\xfe\xff\xff\xff\x0f"), &value), 5u);
589 EXPECT_EQ(value, std::numeric_limits<int32_t>::max());
590
591 EXPECT_EQ(
592 Decode(MakeBuffer("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01"), &value),
593 10u);
594 EXPECT_EQ(value, std::numeric_limits<int64_t>::min());
595
596 EXPECT_EQ(
597 Decode(MakeBuffer("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01"), &value),
598 10u);
599 EXPECT_EQ(value, std::numeric_limits<int64_t>::max());
600 }
601
TEST(VarintDecode,DecodeSigned64_MultiByte_C)602 TEST(VarintDecode, DecodeSigned64_MultiByte_C) {
603 int64_t value = -1234;
604
605 auto buffer2 = MakeBuffer("\x80\x01");
606 EXPECT_EQ(pw_varint_CallZigZagDecode(buffer2.data(), buffer2.size(), &value),
607 2u);
608 EXPECT_EQ(value, 64);
609
610 buffer2 = MakeBuffer("\x81\x01");
611 EXPECT_EQ(pw_varint_CallZigZagDecode(buffer2.data(), buffer2.size(), &value),
612 2u);
613 EXPECT_EQ(value, -65);
614
615 buffer2 = MakeBuffer("\x82\x01");
616 EXPECT_EQ(pw_varint_CallZigZagDecode(buffer2.data(), buffer2.size(), &value),
617 2u);
618 EXPECT_EQ(value, 65);
619
620 auto buffer4 = MakeBuffer("\xff\xff\xff\xff\x0f");
621 EXPECT_EQ(pw_varint_CallZigZagDecode(buffer4.data(), buffer4.size(), &value),
622 5u);
623 EXPECT_EQ(value, std::numeric_limits<int32_t>::min());
624
625 buffer4 = MakeBuffer("\xfe\xff\xff\xff\x0f");
626 EXPECT_EQ(pw_varint_CallZigZagDecode(buffer4.data(), buffer4.size(), &value),
627 5u);
628 EXPECT_EQ(value, std::numeric_limits<int32_t>::max());
629
630 auto buffer8 = MakeBuffer("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01");
631 EXPECT_EQ(pw_varint_CallZigZagDecode(buffer8.data(), buffer8.size(), &value),
632 10u);
633 EXPECT_EQ(value, std::numeric_limits<int64_t>::min());
634
635 buffer8 = MakeBuffer("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01");
636 EXPECT_EQ(pw_varint_CallZigZagDecode(buffer8.data(), buffer8.size(), &value),
637 10u);
638 EXPECT_EQ(value, std::numeric_limits<int64_t>::max());
639 }
640
TEST(Varint,ZigZagEncode_Int8)641 TEST(Varint, ZigZagEncode_Int8) {
642 EXPECT_EQ(ZigZagEncode(int8_t(0)), uint8_t(0));
643 EXPECT_EQ(ZigZagEncode(int8_t(-1)), uint8_t(1));
644 EXPECT_EQ(ZigZagEncode(int8_t(1)), uint8_t(2));
645 EXPECT_EQ(ZigZagEncode(int8_t(-2)), uint8_t(3));
646 EXPECT_EQ(ZigZagEncode(int8_t(2)), uint8_t(4));
647 EXPECT_EQ(ZigZagEncode(int8_t(-33)), uint8_t(65));
648 EXPECT_EQ(ZigZagEncode(int8_t(33)), uint8_t(66));
649 EXPECT_EQ(ZigZagEncode(std::numeric_limits<int8_t>::min()),
650 std::numeric_limits<uint8_t>::max());
651 EXPECT_EQ(ZigZagEncode(std::numeric_limits<int8_t>::max()),
652 std::numeric_limits<uint8_t>::max() - 1u);
653 }
654
TEST(Varint,ZigZagEncode_Int16)655 TEST(Varint, ZigZagEncode_Int16) {
656 EXPECT_EQ(ZigZagEncode(int16_t(0)), uint16_t(0));
657 EXPECT_EQ(ZigZagEncode(int16_t(-1)), uint16_t(1));
658 EXPECT_EQ(ZigZagEncode(int16_t(1)), uint16_t(2));
659 EXPECT_EQ(ZigZagEncode(int16_t(-2)), uint16_t(3));
660 EXPECT_EQ(ZigZagEncode(int16_t(2)), uint16_t(4));
661 EXPECT_EQ(ZigZagEncode(int16_t(-3333)), uint16_t(6665));
662 EXPECT_EQ(ZigZagEncode(int16_t(3333)), uint16_t(6666));
663 EXPECT_EQ(ZigZagEncode(std::numeric_limits<int16_t>::min()),
664 std::numeric_limits<uint16_t>::max());
665 EXPECT_EQ(ZigZagEncode(std::numeric_limits<int16_t>::max()),
666 std::numeric_limits<uint16_t>::max() - 1u);
667 }
668
TEST(Varint,ZigZagEncode_Int32)669 TEST(Varint, ZigZagEncode_Int32) {
670 EXPECT_EQ(ZigZagEncode(int32_t(0)), uint32_t(0));
671 EXPECT_EQ(ZigZagEncode(int32_t(-1)), uint32_t(1));
672 EXPECT_EQ(ZigZagEncode(int32_t(1)), uint32_t(2));
673 EXPECT_EQ(ZigZagEncode(int32_t(-2)), uint32_t(3));
674 EXPECT_EQ(ZigZagEncode(int32_t(2)), uint32_t(4));
675 EXPECT_EQ(ZigZagEncode(int32_t(-128)), uint32_t(255));
676 EXPECT_EQ(ZigZagEncode(int32_t(128)), uint32_t(256));
677 EXPECT_EQ(ZigZagEncode(int32_t(-333333)), uint32_t(666665));
678 EXPECT_EQ(ZigZagEncode(int32_t(333333)), uint32_t(666666));
679 EXPECT_EQ(ZigZagEncode(std::numeric_limits<int32_t>::min()),
680 std::numeric_limits<uint32_t>::max());
681 EXPECT_EQ(ZigZagEncode(std::numeric_limits<int32_t>::max()),
682 std::numeric_limits<uint32_t>::max() - 1u);
683 }
684
TEST(Varint,ZigZagEncode_Int64)685 TEST(Varint, ZigZagEncode_Int64) {
686 EXPECT_EQ(ZigZagEncode(int64_t(0)), uint64_t(0));
687 EXPECT_EQ(ZigZagEncode(int64_t(-1)), uint64_t(1));
688 EXPECT_EQ(ZigZagEncode(int64_t(1)), uint64_t(2));
689 EXPECT_EQ(ZigZagEncode(int64_t(-2)), uint64_t(3));
690 EXPECT_EQ(ZigZagEncode(int64_t(2)), uint64_t(4));
691 EXPECT_EQ(ZigZagEncode(int64_t(-3333333333)), uint64_t(6666666665));
692 EXPECT_EQ(ZigZagEncode(int64_t(3333333333)), uint64_t(6666666666));
693 EXPECT_EQ(ZigZagEncode(std::numeric_limits<int64_t>::min()),
694 std::numeric_limits<uint64_t>::max());
695 EXPECT_EQ(ZigZagEncode(std::numeric_limits<int64_t>::max()),
696 std::numeric_limits<uint64_t>::max() - 1u);
697 }
698
TEST(Varint,ZigZagDecode_Int8)699 TEST(Varint, ZigZagDecode_Int8) {
700 EXPECT_EQ(ZigZagDecode(uint8_t(0)), int8_t(0));
701 EXPECT_EQ(ZigZagDecode(uint8_t(1)), int8_t(-1));
702 EXPECT_EQ(ZigZagDecode(uint8_t(2)), int8_t(1));
703 EXPECT_EQ(ZigZagDecode(uint8_t(3)), int8_t(-2));
704 EXPECT_EQ(ZigZagDecode(uint8_t(4)), int8_t(2));
705 EXPECT_EQ(ZigZagDecode(uint8_t(65)), int8_t(-33));
706 EXPECT_EQ(ZigZagDecode(uint8_t(66)), int8_t(33));
707 EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint8_t>::max()),
708 std::numeric_limits<int8_t>::min());
709 EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint8_t>::max() - 1u),
710 std::numeric_limits<int8_t>::max());
711 }
712
TEST(Varint,ZigZagDecode_Int16)713 TEST(Varint, ZigZagDecode_Int16) {
714 EXPECT_EQ(ZigZagDecode(uint16_t(0)), int16_t(0));
715 EXPECT_EQ(ZigZagDecode(uint16_t(1)), int16_t(-1));
716 EXPECT_EQ(ZigZagDecode(uint16_t(2)), int16_t(1));
717 EXPECT_EQ(ZigZagDecode(uint16_t(3)), int16_t(-2));
718 EXPECT_EQ(ZigZagDecode(uint16_t(4)), int16_t(2));
719 EXPECT_EQ(ZigZagDecode(uint16_t(6665)), int16_t(-3333));
720 EXPECT_EQ(ZigZagDecode(uint16_t(6666)), int16_t(3333));
721 EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint16_t>::max()),
722 std::numeric_limits<int16_t>::min());
723 EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint16_t>::max() - 1u),
724 std::numeric_limits<int16_t>::max());
725 }
726
TEST(Varint,ZigZagDecode_Int32)727 TEST(Varint, ZigZagDecode_Int32) {
728 EXPECT_EQ(ZigZagDecode(uint32_t(0)), int32_t(0));
729 EXPECT_EQ(ZigZagDecode(uint32_t(1)), int32_t(-1));
730 EXPECT_EQ(ZigZagDecode(uint32_t(2)), int32_t(1));
731 EXPECT_EQ(ZigZagDecode(uint32_t(3)), int32_t(-2));
732 EXPECT_EQ(ZigZagDecode(uint32_t(4)), int32_t(2));
733 EXPECT_EQ(ZigZagDecode(uint32_t(255)), int32_t(-128));
734 EXPECT_EQ(ZigZagDecode(uint32_t(256)), int32_t(128));
735 EXPECT_EQ(ZigZagDecode(uint32_t(666665)), int32_t(-333333));
736 EXPECT_EQ(ZigZagDecode(uint32_t(666666)), int32_t(333333));
737 EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint32_t>::max()),
738 std::numeric_limits<int32_t>::min());
739 EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint32_t>::max() - 1u),
740 std::numeric_limits<int32_t>::max());
741 }
742
TEST(Varint,ZigZagDecode_Int64)743 TEST(Varint, ZigZagDecode_Int64) {
744 EXPECT_EQ(ZigZagDecode(uint64_t(0)), int64_t(0));
745 EXPECT_EQ(ZigZagDecode(uint64_t(1)), int64_t(-1));
746 EXPECT_EQ(ZigZagDecode(uint64_t(2)), int64_t(1));
747 EXPECT_EQ(ZigZagDecode(uint64_t(3)), int64_t(-2));
748 EXPECT_EQ(ZigZagDecode(uint64_t(4)), int64_t(2));
749 EXPECT_EQ(ZigZagDecode(uint64_t(6666666665)), int64_t(-3333333333));
750 EXPECT_EQ(ZigZagDecode(uint64_t(6666666666)), int64_t(3333333333));
751 EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint64_t>::max()),
752 std::numeric_limits<int64_t>::min());
753 EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint64_t>::max() - 1llu),
754 std::numeric_limits<int64_t>::max());
755 }
756
TEST(Varint,ZigZagEncodeDecode)757 TEST(Varint, ZigZagEncodeDecode) {
758 EXPECT_EQ(ZigZagDecode(ZigZagEncode(0)), 0);
759 EXPECT_EQ(ZigZagDecode(ZigZagEncode(1)), 1);
760 EXPECT_EQ(ZigZagDecode(ZigZagEncode(-1)), -1);
761 EXPECT_EQ(ZigZagDecode(ZigZagEncode(8675309)), 8675309);
762 EXPECT_EQ(ZigZagDecode(ZigZagEncode(std::numeric_limits<int8_t>::min())),
763 std::numeric_limits<int8_t>::min());
764 EXPECT_EQ(ZigZagDecode(ZigZagEncode(std::numeric_limits<int8_t>::max())),
765 std::numeric_limits<int8_t>::max());
766 EXPECT_EQ(ZigZagDecode(ZigZagEncode(std::numeric_limits<int16_t>::min())),
767 std::numeric_limits<int16_t>::min());
768 EXPECT_EQ(ZigZagDecode(ZigZagEncode(std::numeric_limits<int16_t>::max())),
769 std::numeric_limits<int16_t>::max());
770 EXPECT_EQ(ZigZagDecode(ZigZagEncode(std::numeric_limits<int32_t>::min())),
771 std::numeric_limits<int32_t>::min());
772 EXPECT_EQ(ZigZagDecode(ZigZagEncode(std::numeric_limits<int32_t>::max())),
773 std::numeric_limits<int32_t>::max());
774 EXPECT_EQ(ZigZagDecode(ZigZagEncode(std::numeric_limits<int64_t>::min())),
775 std::numeric_limits<int64_t>::min());
776 EXPECT_EQ(ZigZagDecode(ZigZagEncode(std::numeric_limits<int64_t>::max())),
777 std::numeric_limits<int64_t>::max());
778 }
779
TEST_F(Varint,EncodeWithOptions_SingleByte)780 TEST_F(Varint, EncodeWithOptions_SingleByte) {
781 ASSERT_EQ(Encode(0u, buffer_, Format::kZeroTerminatedLeastSignificant), 1u);
782 EXPECT_EQ(buffer_[0], std::byte{0x00});
783
784 ASSERT_EQ(Encode(1u, buffer_, Format::kZeroTerminatedLeastSignificant), 1u);
785 EXPECT_EQ(buffer_[0], std::byte{0x02});
786
787 ASSERT_EQ(Encode(0x7f, buffer_, Format::kZeroTerminatedLeastSignificant), 1u);
788 EXPECT_EQ(buffer_[0], std::byte{0xfe});
789
790 ASSERT_EQ(Encode(0u, buffer_, Format::kOneTerminatedLeastSignificant), 1u);
791 EXPECT_EQ(buffer_[0], std::byte{0x01});
792
793 ASSERT_EQ(Encode(2u, buffer_, Format::kOneTerminatedLeastSignificant), 1u);
794 EXPECT_EQ(buffer_[0], std::byte{0x05});
795
796 ASSERT_EQ(Encode(0x7f, buffer_, Format::kOneTerminatedLeastSignificant), 1u);
797 EXPECT_EQ(buffer_[0], std::byte{0xff});
798
799 ASSERT_EQ(Encode(0u, buffer_, Format::kZeroTerminatedMostSignificant), 1u);
800 EXPECT_EQ(buffer_[0], std::byte{0x00});
801
802 ASSERT_EQ(Encode(7u, buffer_, Format::kZeroTerminatedMostSignificant), 1u);
803 EXPECT_EQ(buffer_[0], std::byte{0x07});
804
805 ASSERT_EQ(Encode(0x7f, buffer_, Format::kZeroTerminatedMostSignificant), 1u);
806 EXPECT_EQ(buffer_[0], std::byte{0x7f});
807
808 ASSERT_EQ(Encode(0u, buffer_, Format::kOneTerminatedMostSignificant), 1u);
809 EXPECT_EQ(buffer_[0], std::byte{0x80});
810
811 ASSERT_EQ(Encode(15u, buffer_, Format::kOneTerminatedMostSignificant), 1u);
812 EXPECT_EQ(buffer_[0], std::byte{0x8f});
813
814 ASSERT_EQ(Encode(0x7f, buffer_, Format::kOneTerminatedMostSignificant), 1u);
815 EXPECT_EQ(buffer_[0], std::byte{0xff});
816 }
817
TEST_F(Varint,EncodeWithOptions_MultiByte)818 TEST_F(Varint, EncodeWithOptions_MultiByte) {
819 ASSERT_EQ(Encode(128u, buffer_, Format::kZeroTerminatedLeastSignificant), 2u);
820 EXPECT_EQ(std::memcmp("\x01\x02", buffer_, 2), 0);
821
822 ASSERT_EQ(
823 Encode(0xffffffff, buffer_, Format::kZeroTerminatedLeastSignificant), 5u);
824 EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x1e", buffer_, 5), 0);
825
826 ASSERT_EQ(Encode(128u, buffer_, Format::kOneTerminatedLeastSignificant), 2u);
827 EXPECT_EQ(std::memcmp("\x00\x03", buffer_, 2), 0);
828
829 ASSERT_EQ(Encode(0xffffffff, buffer_, Format::kOneTerminatedLeastSignificant),
830 5u);
831 EXPECT_EQ(std::memcmp("\xfe\xfe\xfe\xfe\x1f", buffer_, 5), 0);
832
833 ASSERT_EQ(Encode(128u, buffer_, Format::kZeroTerminatedMostSignificant), 2u);
834 EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
835
836 ASSERT_EQ(Encode(0xffffffff, buffer_, Format::kZeroTerminatedMostSignificant),
837 5u);
838 EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer_, 5), 0);
839
840 ASSERT_EQ(Encode(128u, buffer_, Format::kOneTerminatedMostSignificant), 2u);
841 EXPECT_EQ(std::memcmp("\x00\x81", buffer_, 2), 0);
842
843 ASSERT_EQ(Encode(0xffffffff, buffer_, Format::kOneTerminatedMostSignificant),
844 5u);
845 EXPECT_EQ(std::memcmp("\x7f\x7f\x7f\x7f\x8f", buffer_, 5), 0);
846 }
847
TEST(Varint,DecodeWithOptions_SingleByte)848 TEST(Varint, DecodeWithOptions_SingleByte) {
849 uint64_t value = -1234;
850
851 EXPECT_EQ(
852 Decode(
853 MakeBuffer("\x00"), &value, Format::kZeroTerminatedLeastSignificant),
854 1u);
855 EXPECT_EQ(value, 0u);
856
857 EXPECT_EQ(
858 Decode(
859 MakeBuffer("\x04"), &value, Format::kZeroTerminatedLeastSignificant),
860 1u);
861 EXPECT_EQ(value, 2u);
862
863 EXPECT_EQ(
864 Decode(
865 MakeBuffer("\xaa"), &value, Format::kZeroTerminatedLeastSignificant),
866 1u);
867 EXPECT_EQ(value, 85u);
868
869 EXPECT_EQ(
870 Decode(
871 MakeBuffer("\x01"), &value, Format::kZeroTerminatedLeastSignificant),
872 0u);
873
874 EXPECT_EQ(
875 Decode(
876 MakeBuffer("\x01"), &value, Format::kOneTerminatedLeastSignificant),
877 1u);
878 EXPECT_EQ(value, 0u);
879
880 EXPECT_EQ(
881 Decode(
882 MakeBuffer("\x13"), &value, Format::kOneTerminatedLeastSignificant),
883 1u);
884 EXPECT_EQ(value, 9u);
885
886 EXPECT_EQ(
887 Decode(
888 MakeBuffer("\x00"), &value, Format::kOneTerminatedLeastSignificant),
889 0u);
890
891 EXPECT_EQ(
892 Decode(
893 MakeBuffer("\x00"), &value, Format::kZeroTerminatedMostSignificant),
894 1u);
895 EXPECT_EQ(value, 0u);
896
897 EXPECT_EQ(
898 Decode(
899 MakeBuffer("\x04"), &value, Format::kZeroTerminatedMostSignificant),
900 1u);
901 EXPECT_EQ(value, 4u);
902
903 EXPECT_EQ(
904 Decode(
905 MakeBuffer("\xff"), &value, Format::kZeroTerminatedMostSignificant),
906 0u);
907
908 EXPECT_EQ(
909 Decode(MakeBuffer("\x80"), &value, Format::kOneTerminatedMostSignificant),
910 1u);
911 EXPECT_EQ(value, 0u);
912
913 EXPECT_EQ(
914 Decode(MakeBuffer("\x83"), &value, Format::kOneTerminatedMostSignificant),
915 1u);
916 EXPECT_EQ(value, 3u);
917
918 EXPECT_EQ(
919 Decode(MakeBuffer("\xaa"), &value, Format::kOneTerminatedMostSignificant),
920 1u);
921 EXPECT_EQ(value, 42u);
922
923 EXPECT_EQ(
924 Decode(MakeBuffer("\xff"), &value, Format::kOneTerminatedMostSignificant),
925 1u);
926 EXPECT_EQ(value, 127u);
927
928 EXPECT_EQ(
929 Decode(MakeBuffer("\x00"), &value, Format::kOneTerminatedMostSignificant),
930 0u);
931 }
932
TEST(Varint,DecodeWithOptions_MultiByte)933 TEST(Varint, DecodeWithOptions_MultiByte) {
934 uint64_t value = -1234;
935
936 EXPECT_EQ(Decode(MakeBuffer("\x01\x10"),
937 &value,
938 Format::kZeroTerminatedLeastSignificant),
939 2u);
940 EXPECT_EQ(value, 1024u);
941
942 EXPECT_EQ(Decode(MakeBuffer("\xff\xff\xff\xfe"),
943 &value,
944 Format::kZeroTerminatedLeastSignificant),
945 4u);
946 EXPECT_EQ(value, 0x0fffffffu);
947
948 EXPECT_EQ(Decode(MakeBuffer("\x01\x01\x01\x01\x00"),
949 &value,
950 Format::kZeroTerminatedLeastSignificant),
951 5u);
952 EXPECT_EQ(value, 0u);
953
954 EXPECT_EQ(Decode(MakeBuffer("\x82\x2d"),
955 &value,
956 Format::kOneTerminatedLeastSignificant),
957 2u);
958 EXPECT_EQ(value, 2881u);
959
960 EXPECT_EQ(Decode(MakeBuffer("\xfe\xfe\xfe\xff"),
961 &value,
962 Format::kOneTerminatedLeastSignificant),
963 4u);
964 EXPECT_EQ(value, 0x0fffffffu);
965
966 EXPECT_EQ(Decode(MakeBuffer("\x00\x00\x00\x00\x01"),
967 &value,
968 Format::kOneTerminatedLeastSignificant),
969 5u);
970 EXPECT_EQ(value, 0u);
971
972 EXPECT_EQ(Decode(MakeBuffer("\x83\x6a"),
973 &value,
974 Format::kZeroTerminatedMostSignificant),
975 2u);
976 EXPECT_EQ(value, 0b1101010'0000011u);
977
978 EXPECT_EQ(Decode(MakeBuffer("\xff\xff\xff\x7f"),
979 &value,
980 Format::kZeroTerminatedMostSignificant),
981 4u);
982 EXPECT_EQ(value, 0x0fffffffu);
983
984 EXPECT_EQ(Decode(MakeBuffer("\x80\x80\x80\x80\x00"),
985 &value,
986 Format::kZeroTerminatedMostSignificant),
987 5u);
988 EXPECT_EQ(value, 0u);
989
990 EXPECT_EQ(Decode(MakeBuffer("\x6a\x83"),
991 &value,
992 Format::kOneTerminatedMostSignificant),
993 2u);
994 EXPECT_EQ(value, 0b0000011'1101010u);
995
996 EXPECT_EQ(Decode(MakeBuffer("\x7f\x7f\x7f\xff"),
997 &value,
998 Format::kOneTerminatedMostSignificant),
999 4u);
1000 EXPECT_EQ(value, 0x0fffffffu);
1001
1002 EXPECT_EQ(Decode(MakeBuffer("\x00\x00\x00\x00\x80"),
1003 &value,
1004 Format::kOneTerminatedMostSignificant),
1005 5u);
1006 EXPECT_EQ(value, 0u);
1007 }
1008
TEST(Varint,EncodedSize)1009 TEST(Varint, EncodedSize) {
1010 EXPECT_EQ(EncodedSize(uint64_t(0u)), 1u);
1011 EXPECT_EQ(EncodedSize(uint64_t(1u)), 1u);
1012 EXPECT_EQ(EncodedSize(uint64_t(127u)), 1u);
1013 EXPECT_EQ(EncodedSize(uint64_t(128u)), 2u);
1014 EXPECT_EQ(EncodedSize(uint64_t(16383u)), 2u);
1015 EXPECT_EQ(EncodedSize(uint64_t(16384u)), 3u);
1016 EXPECT_EQ(EncodedSize(uint64_t(2097151u)), 3u);
1017 EXPECT_EQ(EncodedSize(uint64_t(2097152u)), 4u);
1018 EXPECT_EQ(EncodedSize(uint64_t(268435455u)), 4u);
1019 EXPECT_EQ(EncodedSize(uint64_t(268435456u)), 5u);
1020 EXPECT_EQ(EncodedSize(uint64_t(34359738367u)), 5u);
1021 EXPECT_EQ(EncodedSize(uint64_t(34359738368u)), 6u);
1022 EXPECT_EQ(EncodedSize(uint64_t(4398046511103u)), 6u);
1023 EXPECT_EQ(EncodedSize(uint64_t(4398046511104u)), 7u);
1024 EXPECT_EQ(EncodedSize(uint64_t(562949953421311u)), 7u);
1025 EXPECT_EQ(EncodedSize(uint64_t(562949953421312u)), 8u);
1026 EXPECT_EQ(EncodedSize(uint64_t(72057594037927935u)), 8u);
1027 EXPECT_EQ(EncodedSize(uint64_t(72057594037927936u)), 9u);
1028 EXPECT_EQ(EncodedSize(uint64_t(9223372036854775807u)), 9u);
1029 EXPECT_EQ(EncodedSize(uint64_t(9223372036854775808u)), 10u);
1030 EXPECT_EQ(EncodedSize(std::numeric_limits<uint64_t>::max()), 10u);
1031 EXPECT_EQ(EncodedSize(std::numeric_limits<int64_t>::max()), 9u);
1032 EXPECT_EQ(EncodedSize(int64_t(-1)), 10u);
1033 EXPECT_EQ(EncodedSize(std::numeric_limits<int64_t>::min()), 10u);
1034 }
1035
TEST(Varint,ZigZagEncodedSize)1036 TEST(Varint, ZigZagEncodedSize) {
1037 EXPECT_EQ(ZigZagEncodedSize(int64_t(0)), 1u);
1038 EXPECT_EQ(ZigZagEncodedSize(int64_t(-1)), 1u);
1039 EXPECT_EQ(ZigZagEncodedSize(int64_t(1)), 1u);
1040 EXPECT_EQ(ZigZagEncodedSize(int64_t(-64)), 1u);
1041 EXPECT_EQ(ZigZagEncodedSize(int64_t(-65)), 2u);
1042 EXPECT_EQ(ZigZagEncodedSize(int64_t(63)), 1u);
1043 EXPECT_EQ(ZigZagEncodedSize(int64_t(64)), 2u);
1044 EXPECT_EQ(ZigZagEncodedSize(std::numeric_limits<int8_t>::min()), 2u);
1045 EXPECT_EQ(ZigZagEncodedSize(std::numeric_limits<int8_t>::max()), 2u);
1046 EXPECT_EQ(ZigZagEncodedSize(std::numeric_limits<int16_t>::min()), 3u);
1047 EXPECT_EQ(ZigZagEncodedSize(std::numeric_limits<int16_t>::max()), 3u);
1048 EXPECT_EQ(ZigZagEncodedSize(std::numeric_limits<int32_t>::min()), 5u);
1049 EXPECT_EQ(ZigZagEncodedSize(std::numeric_limits<int32_t>::max()), 5u);
1050 EXPECT_EQ(ZigZagEncodedSize(std::numeric_limits<int64_t>::min()), 10u);
1051 EXPECT_EQ(ZigZagEncodedSize(std::numeric_limits<int64_t>::max()), 10u);
1052 }
1053
CalculateMaxValueInBytes(size_t bytes)1054 constexpr uint64_t CalculateMaxValueInBytes(size_t bytes) {
1055 uint64_t value = 0;
1056 for (size_t i = 0; i < bytes; ++i) {
1057 value |= uint64_t(0x7f) << (7 * i);
1058 }
1059 return value;
1060 }
1061
TEST(Varint,MaxValueInBytes)1062 TEST(Varint, MaxValueInBytes) {
1063 static_assert(MaxValueInBytes(0) == 0);
1064 static_assert(MaxValueInBytes(1) == 0x7f);
1065 static_assert(MaxValueInBytes(2) == 0x3fff);
1066 static_assert(MaxValueInBytes(3) == 0x1fffff);
1067 static_assert(MaxValueInBytes(4) == 0x0fffffff);
1068 static_assert(MaxValueInBytes(5) == CalculateMaxValueInBytes(5));
1069 static_assert(MaxValueInBytes(6) == CalculateMaxValueInBytes(6));
1070 static_assert(MaxValueInBytes(7) == CalculateMaxValueInBytes(7));
1071 static_assert(MaxValueInBytes(8) == CalculateMaxValueInBytes(8));
1072 static_assert(MaxValueInBytes(9) == CalculateMaxValueInBytes(9));
1073 static_assert(MaxValueInBytes(10) == std::numeric_limits<uint64_t>::max());
1074 static_assert(MaxValueInBytes(11) == std::numeric_limits<uint64_t>::max());
1075 static_assert(MaxValueInBytes(100) == std::numeric_limits<uint64_t>::max());
1076 }
1077
1078 } // namespace
1079 } // namespace pw::varint
1080