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