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