| // Copyright 2019 The Pigweed Authors |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| // use this file except in compliance with the License. You may obtain a copy of |
| // the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| // License for the specific language governing permissions and limitations under |
| // the License. |
| |
| #include "pw_varint/varint.h" |
| |
| #include <cinttypes> |
| #include <cstdint> |
| #include <cstring> |
| #include <limits> |
| |
| #include "pw_fuzzer/fuzztest.h" |
| #include "pw_unit_test/constexpr.h" |
| #include "pw_unit_test/framework.h" |
| |
| namespace pw::varint { |
| namespace { |
| |
| // Test fixtures. |
| |
| extern "C" { |
| |
| // Functions defined in varint_test.c which call the varint API from C. |
| size_t pw_varint_CallEncode32(uint32_t value, |
| void* out_encoded, |
| size_t out_encoded_size); |
| size_t pw_varint_CallEncode64(uint64_t value, |
| void* out_encoded, |
| size_t out_encoded_size); |
| size_t pw_varint_CallZigZagAndVarintEncode64(int64_t value, |
| void* out_encoded, |
| size_t out_encoded_size); |
| size_t pw_varint_CallDecode32(const void* encoded, |
| size_t encoded_size, |
| uint32_t* out_value); |
| size_t pw_varint_CallDecode64(const void* encoded, |
| size_t encoded_size, |
| uint64_t* out_value); |
| size_t pw_varint_CallZigZagAndVarintDecode64(const void* encoded, |
| size_t encoded_size, |
| int64_t* out_value); |
| |
| } // extern "C" |
| |
| // Constant expression that writes `data` from a string to a span of `bytes`. |
| template <size_t kStringSize> |
| constexpr ConstByteSpan Write(const char (&data)[kStringSize], ByteSpan bytes) { |
| constexpr size_t kSizeBytes = kStringSize - 1; |
| static_assert(kSizeBytes <= kMaxVarint64SizeBytes); |
| PW_ASSERT(kSizeBytes <= bytes.size()); |
| for (size_t i = 0; i < kSizeBytes; ++i) { |
| bytes[i] = static_cast<std::byte>(data[i]); |
| } |
| return bytes.subspan(0, kSizeBytes); |
| } |
| |
| // Constant expression that returns whether the `data` in a string matches a |
| // span of `bytes`. |
| template <size_t kStringSize> |
| [[nodiscard]] constexpr bool Compare(const char (&data)[kStringSize], |
| ConstByteSpan bytes) { |
| constexpr size_t kSizeBytes = kStringSize - 1; |
| if (bytes.size() < kSizeBytes) { |
| return false; |
| } |
| for (size_t i = 0; i < kSizeBytes; ++i) { |
| if (data[i] != static_cast<char>(bytes[i])) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| // Unit tests. |
| |
| PW_CONSTEXPR_TEST(Varint, EncodeSizeUnsigned32_SmallSingleByte, { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| PW_TEST_ASSERT_EQ(1u, Encode(UINT32_C(0), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{0}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(UINT32_C(1), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{1}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(UINT32_C(2), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{2}, buffer[0]); |
| }); |
| |
| TEST(Varint, EncodeSizeUnsigned32_SmallSingleByte_C) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| ASSERT_EQ(1u, pw_varint_CallEncode64(UINT32_C(0), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{0}, buffer[0]); |
| ASSERT_EQ(1u, pw_varint_CallEncode64(UINT32_C(1), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{1}, buffer[0]); |
| ASSERT_EQ(1u, pw_varint_CallEncode64(UINT32_C(2), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{2}, buffer[0]); |
| } |
| |
| PW_CONSTEXPR_TEST(Varint, EncodeSizeUnsigned32_LargeSingleByte, { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| PW_TEST_ASSERT_EQ(1u, Encode(UINT32_C(63), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{63}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(UINT32_C(64), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{64}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(UINT32_C(126), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{126}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(UINT32_C(127), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{127}, buffer[0]); |
| }); |
| |
| TEST(Varint, EncodeSizeUnsigned32_LargeSingleByte_C) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| ASSERT_EQ(1u, pw_varint_CallEncode64(UINT32_C(63), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{63}, buffer[0]); |
| ASSERT_EQ(1u, pw_varint_CallEncode64(UINT32_C(64), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{64}, buffer[0]); |
| ASSERT_EQ(1u, pw_varint_CallEncode64(UINT32_C(126), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{126}, buffer[0]); |
| ASSERT_EQ(1u, pw_varint_CallEncode64(UINT32_C(127), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{127}, buffer[0]); |
| } |
| |
| PW_CONSTEXPR_TEST(Varint, EncodeSizeUnsigned32_MultiByte, { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| PW_TEST_ASSERT_EQ(2u, Encode(UINT32_C(128), buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\x80\x01", buffer)); |
| PW_TEST_ASSERT_EQ(2u, Encode(UINT32_C(129), buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\x81\x01", buffer)); |
| |
| PW_TEST_ASSERT_EQ(5u, |
| Encode(std::numeric_limits<uint32_t>::max() - 1, buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\xfe\xff\xff\xff\x0f", buffer)); |
| |
| PW_TEST_ASSERT_EQ(5u, Encode(std::numeric_limits<uint32_t>::max(), buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\xff\xff\xff\xff\x0f", buffer)); |
| }); |
| |
| TEST(Varint, EncodeSizeUnsigned32_MultiByte_C) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| ASSERT_EQ(2u, pw_varint_CallEncode64(UINT32_C(128), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\x80\x01", buffer, 2), 0); |
| ASSERT_EQ(2u, pw_varint_CallEncode64(UINT32_C(129), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\x81\x01", buffer, 2), 0); |
| |
| ASSERT_EQ( |
| 5u, |
| pw_varint_CallEncode32( |
| std::numeric_limits<uint32_t>::max() - 1, buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer, 5), 0); |
| |
| ASSERT_EQ(5u, |
| pw_varint_CallEncode32( |
| std::numeric_limits<uint32_t>::max(), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer, 5), 0); |
| |
| // Call with 64-bit function as well |
| ASSERT_EQ(2u, pw_varint_CallEncode64(UINT32_C(128), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\x80\x01", buffer, 2), 0); |
| ASSERT_EQ(2u, pw_varint_CallEncode64(UINT32_C(129), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\x81\x01", buffer, 2), 0); |
| |
| ASSERT_EQ( |
| 5u, |
| pw_varint_CallEncode64( |
| std::numeric_limits<uint32_t>::max() - 1, buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer, 5), 0); |
| |
| ASSERT_EQ(5u, |
| pw_varint_CallEncode64( |
| std::numeric_limits<uint32_t>::max(), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer, 5), 0); |
| } |
| |
| PW_CONSTEXPR_TEST(Varint, EncodeSizeSigned32_SmallSingleByte, { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| PW_TEST_ASSERT_EQ(1u, Encode(INT32_C(0), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{0}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(INT32_C(-1), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{1}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(INT32_C(1), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{2}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(INT32_C(-2), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{3}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(INT32_C(2), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{4}, buffer[0]); |
| }); |
| |
| TEST(Varint, EncodeSizeSigned32_SmallSingleByte_C) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT32_C(0), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{0}, buffer[0]); |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT32_C(-1), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{1}, buffer[0]); |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT32_C(1), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{2}, buffer[0]); |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT32_C(-2), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{3}, buffer[0]); |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT32_C(2), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{4}, buffer[0]); |
| } |
| |
| PW_CONSTEXPR_TEST(Varint, EncodeSizeSigned32_LargeSingleByte, { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| PW_TEST_ASSERT_EQ(1u, Encode(INT32_C(-63), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{125}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(INT32_C(63), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{126}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(INT32_C(-64), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{127}, buffer[0]); |
| }); |
| |
| TEST(Varint, EncodeSizeSigned32_LargeSingleByte_C) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT32_C(-63), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{125}, buffer[0]); |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT32_C(63), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{126}, buffer[0]); |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT32_C(-64), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{127}, buffer[0]); |
| } |
| |
| PW_CONSTEXPR_TEST(Varint, EncodeSizeSigned32_MultiByte, { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| PW_TEST_ASSERT_EQ(2u, Encode(INT32_C(64), buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\x80\x01", buffer)); |
| PW_TEST_ASSERT_EQ(2u, Encode(INT32_C(-65), buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\x81\x01", buffer)); |
| PW_TEST_ASSERT_EQ(2u, Encode(INT32_C(65), buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\x82\x01", buffer)); |
| |
| PW_TEST_ASSERT_EQ(5u, Encode(std::numeric_limits<int32_t>::min(), buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\xff\xff\xff\xff\x0f", buffer)); |
| |
| PW_TEST_ASSERT_EQ(5u, Encode(std::numeric_limits<int32_t>::max(), buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\xfe\xff\xff\xff\x0f", buffer)); |
| }); |
| |
| TEST(Varint, EncodeSizeSigned32_MultiByte_C) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| ASSERT_EQ(2u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT32_C(64), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\x80\x01", buffer, 2), 0); |
| ASSERT_EQ(2u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT32_C(-65), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\x81\x01", buffer, 2), 0); |
| ASSERT_EQ(2u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT32_C(65), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\x82\x01", buffer, 2), 0); |
| |
| ASSERT_EQ(5u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| std::numeric_limits<int32_t>::min(), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer, 5), 0); |
| |
| ASSERT_EQ(5u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| std::numeric_limits<int32_t>::max(), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer, 5), 0); |
| } |
| |
| PW_CONSTEXPR_TEST(Varint, EncodeSizeUnsigned64_SmallSingleByte, { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| PW_TEST_ASSERT_EQ(1u, Encode(UINT64_C(0), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{0}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(UINT64_C(1), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{1}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(UINT64_C(2), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{2}, buffer[0]); |
| }); |
| |
| TEST(Varint, EncodeSizeUnsigned64_SmallSingleByte_C) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| ASSERT_EQ(1u, pw_varint_CallEncode64(UINT64_C(0), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{0}, buffer[0]); |
| ASSERT_EQ(1u, pw_varint_CallEncode64(UINT64_C(1), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{1}, buffer[0]); |
| ASSERT_EQ(1u, pw_varint_CallEncode64(UINT64_C(2), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{2}, buffer[0]); |
| } |
| |
| PW_CONSTEXPR_TEST(Varint, EncodeSizeUnsigned64_LargeSingleByte, { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| PW_TEST_ASSERT_EQ(1u, Encode(UINT64_C(63), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{63}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(UINT64_C(64), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{64}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(UINT64_C(126), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{126}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(UINT64_C(127), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{127}, buffer[0]); |
| }); |
| |
| TEST(Varint, EncodeSizeUnsigned64_LargeSingleByte_C) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| ASSERT_EQ(1u, pw_varint_CallEncode64(UINT64_C(63), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{63}, buffer[0]); |
| ASSERT_EQ(1u, pw_varint_CallEncode64(UINT64_C(64), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{64}, buffer[0]); |
| ASSERT_EQ(1u, pw_varint_CallEncode64(UINT64_C(126), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{126}, buffer[0]); |
| ASSERT_EQ(1u, pw_varint_CallEncode64(UINT64_C(127), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{127}, buffer[0]); |
| } |
| |
| PW_CONSTEXPR_TEST(Varint, EncodeSizeUnsigned64_MultiByte, { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| PW_TEST_ASSERT_EQ(2u, Encode(UINT64_C(128), buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\x80\x01", buffer)); |
| PW_TEST_ASSERT_EQ(2u, Encode(UINT64_C(129), buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\x81\x01", buffer)); |
| |
| PW_TEST_ASSERT_EQ(5u, |
| Encode(std::numeric_limits<uint32_t>::max() - 1, buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\xfe\xff\xff\xff\x0f", buffer)); |
| |
| PW_TEST_ASSERT_EQ(5u, Encode(std::numeric_limits<uint32_t>::max(), buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\xff\xff\xff\xff\x0f", buffer)); |
| |
| PW_TEST_ASSERT_EQ(10u, |
| Encode(std::numeric_limits<uint64_t>::max() - 1, buffer)); |
| PW_TEST_EXPECT_TRUE( |
| Compare("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer)); |
| |
| PW_TEST_ASSERT_EQ(10u, Encode(std::numeric_limits<uint64_t>::max(), buffer)); |
| PW_TEST_EXPECT_TRUE( |
| Compare("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer)); |
| }); |
| |
| TEST(Varint, EncodeSizeUnsigned64_MultiByte_C) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| ASSERT_EQ(2u, pw_varint_CallEncode64(UINT64_C(128), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\x80\x01", buffer, 2), 0); |
| ASSERT_EQ(2u, pw_varint_CallEncode64(UINT64_C(129), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\x81\x01", buffer, 2), 0); |
| |
| ASSERT_EQ( |
| 5u, |
| pw_varint_CallEncode64( |
| std::numeric_limits<uint32_t>::max() - 1, buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer, 5), 0); |
| |
| ASSERT_EQ(5u, |
| pw_varint_CallEncode64( |
| std::numeric_limits<uint32_t>::max(), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer, 5), 0); |
| |
| ASSERT_EQ( |
| 10u, |
| pw_varint_CallEncode64( |
| std::numeric_limits<uint64_t>::max() - 1, buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer, 10), |
| 0); |
| |
| ASSERT_EQ(10u, |
| pw_varint_CallEncode64( |
| std::numeric_limits<uint64_t>::max(), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer, 10), |
| 0); |
| } |
| |
| PW_CONSTEXPR_TEST(Varint, EncodeSizeSigned64_SmallSingleByte, { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| PW_TEST_ASSERT_EQ(1u, Encode(INT64_C(0), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{0}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(INT64_C(-1), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{1}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(INT64_C(1), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{2}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(INT64_C(-2), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{3}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(INT64_C(2), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{4}, buffer[0]); |
| }); |
| |
| TEST(Varint, EncodeSizeSigned64_SmallSingleByte_C) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT64_C(0), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{0}, buffer[0]); |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT64_C(-1), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{1}, buffer[0]); |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT64_C(1), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{2}, buffer[0]); |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT64_C(-2), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{3}, buffer[0]); |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT64_C(2), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{4}, buffer[0]); |
| } |
| |
| PW_CONSTEXPR_TEST(Varint, EncodeSizeSigned64_LargeSingleByte, { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| PW_TEST_ASSERT_EQ(1u, Encode(INT64_C(-63), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{125}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(INT64_C(63), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{126}, buffer[0]); |
| PW_TEST_ASSERT_EQ(1u, Encode(INT64_C(-64), buffer)); |
| PW_TEST_EXPECT_EQ(std::byte{127}, buffer[0]); |
| }); |
| |
| TEST(Varint, EncodeSizeSigned64_LargeSingleByte_C) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT64_C(-63), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{125}, buffer[0]); |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT64_C(63), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{126}, buffer[0]); |
| ASSERT_EQ(1u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT64_C(-64), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::byte{127}, buffer[0]); |
| } |
| |
| PW_CONSTEXPR_TEST(Varint, EncodeSizeSigned64_MultiByte, { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| PW_TEST_ASSERT_EQ(2u, Encode(INT64_C(64), buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\x80\x01", buffer)); |
| PW_TEST_ASSERT_EQ(2u, Encode(INT64_C(-65), buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\x81\x01", buffer)); |
| PW_TEST_ASSERT_EQ(2u, Encode(INT64_C(65), buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\x82\x01", buffer)); |
| |
| PW_TEST_ASSERT_EQ( |
| 5u, |
| Encode(static_cast<int64_t>(std::numeric_limits<int32_t>::min()), |
| buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\xff\xff\xff\xff\x0f", buffer)); |
| |
| PW_TEST_ASSERT_EQ( |
| 5u, |
| Encode(static_cast<int64_t>(std::numeric_limits<int32_t>::max()), |
| buffer)); |
| PW_TEST_EXPECT_TRUE(Compare("\xfe\xff\xff\xff\x0f", buffer)); |
| |
| PW_TEST_ASSERT_EQ(10u, Encode(std::numeric_limits<int64_t>::min(), buffer)); |
| PW_TEST_EXPECT_TRUE( |
| Compare("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer)); |
| |
| PW_TEST_ASSERT_EQ(10u, Encode(std::numeric_limits<int64_t>::max(), buffer)); |
| PW_TEST_EXPECT_TRUE( |
| Compare("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer)); |
| }); |
| |
| TEST(Varint, EncodeSizeSigned64_MultiByte_C) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| ASSERT_EQ(2u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT64_C(64), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\x80\x01", buffer, 2), 0); |
| ASSERT_EQ(2u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT64_C(-65), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\x81\x01", buffer, 2), 0); |
| ASSERT_EQ(2u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| INT64_C(65), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\x82\x01", buffer, 2), 0); |
| |
| ASSERT_EQ(5u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| static_cast<int64_t>(std::numeric_limits<int32_t>::min()), |
| buffer, |
| sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer, 5), 0); |
| |
| ASSERT_EQ(5u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| static_cast<int64_t>(std::numeric_limits<int32_t>::max()), |
| buffer, |
| sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer, 5), 0); |
| |
| ASSERT_EQ(10u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| std::numeric_limits<int64_t>::min(), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer, 10), |
| 0); |
| |
| ASSERT_EQ(10u, |
| pw_varint_CallZigZagAndVarintEncode64( |
| std::numeric_limits<int64_t>::max(), buffer, sizeof(buffer))); |
| EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer, 10), |
| 0); |
| } |
| |
| // How much to increment by for each iteration of the exhaustive encode/decode |
| // tests. Set the increment to 1 to test every number (this is slow). |
| constexpr int kIncrement = 100'000'009; |
| |
| template <typename T, typename U = T> |
| void EncodeDecode(T value) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| size_t encoded = Encode(value, buffer); |
| |
| U result; |
| size_t decoded = Decode(buffer, &result); |
| |
| EXPECT_EQ(encoded, decoded); |
| ASSERT_EQ(value, result); |
| } |
| |
| void EncodeDecodeSigned32(int32_t value) { |
| EncodeDecode<int32_t, int64_t>(value); |
| } |
| |
| void EncodeDecodeUnsigned32(uint32_t value) { |
| EncodeDecode<uint32_t, uint64_t>(value); |
| } |
| |
| TEST(Varint, EncodeDecodeSigned32Incremental) { |
| int32_t i = std::numeric_limits<int32_t>::min(); |
| while (true) { |
| EncodeDecodeSigned32(i); |
| |
| if (i > std::numeric_limits<int32_t>::max() - kIncrement) { |
| break; |
| } |
| |
| i += kIncrement; |
| } |
| } |
| |
| FUZZ_TEST(Varint, EncodeDecodeSigned32); |
| |
| TEST(Varint, EncodeDecodeUnsigned32Incremental) { |
| uint32_t i = 0; |
| while (true) { |
| EncodeDecodeUnsigned32(i); |
| |
| if (i > std::numeric_limits<uint32_t>::max() - kIncrement) { |
| break; |
| } |
| |
| i += kIncrement; |
| } |
| } |
| |
| FUZZ_TEST(Varint, EncodeDecodeUnsigned32); |
| |
| template <typename T, typename U = T> |
| void EncodeDecode_C(T value) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| size_t encoded = 0; |
| U result(0); |
| size_t decoded = 0; |
| if constexpr (sizeof(T) <= sizeof(uint32_t)) { |
| encoded = pw_varint_CallEncode32( |
| static_cast<uint32_t>(value), buffer, sizeof(buffer)); |
| decoded = pw_varint_CallDecode32(buffer, sizeof(buffer), &result); |
| } else { |
| encoded = pw_varint_CallEncode64( |
| static_cast<uint64_t>(value), buffer, sizeof(buffer)); |
| decoded = pw_varint_CallDecode64(buffer, sizeof(buffer), &result); |
| } |
| EXPECT_EQ(encoded, decoded); |
| ASSERT_EQ(value, static_cast<T>(result)); |
| } |
| |
| void EncodeDecodeSigned32_C(int32_t value) { |
| EncodeDecode_C<int32_t, uint32_t>(value); |
| } |
| |
| void EncodeDecodeUnsigned32_C(uint32_t value) { |
| EncodeDecode_C<uint32_t, uint32_t>(value); |
| } |
| |
| TEST(Varint, EncodeDecodeSigned32Incremental_C) { |
| int32_t i = std::numeric_limits<int32_t>::min(); |
| while (true) { |
| EncodeDecodeSigned32_C(i); |
| |
| if (i > std::numeric_limits<int32_t>::max() - kIncrement) { |
| break; |
| } |
| |
| i += kIncrement; |
| } |
| } |
| |
| FUZZ_TEST(Varint, EncodeDecodeSigned32_C); |
| |
| TEST(Varint, EncodeDecodeUnsigned32Incremental_C) { |
| uint32_t i = 0; |
| while (true) { |
| EncodeDecodeUnsigned32_C(i); |
| |
| if (i > std::numeric_limits<uint32_t>::max() - kIncrement) { |
| break; |
| } |
| |
| i += kIncrement; |
| } |
| } |
| |
| FUZZ_TEST(Varint, EncodeDecodeUnsigned32_C); |
| |
| PW_CONSTEXPR_TEST(Varint, DecodeSigned64_SingleByte, { |
| std::byte buffer[kMaxVarint64SizeBytes] = {}; |
| int64_t value = -1234; |
| |
| PW_TEST_EXPECT_EQ(Decode(Write("\x00", buffer), &value), 1u); |
| PW_TEST_EXPECT_EQ(value, 0); |
| |
| PW_TEST_EXPECT_EQ(Decode(Write("\x01", buffer), &value), 1u); |
| PW_TEST_EXPECT_EQ(value, -1); |
| |
| PW_TEST_EXPECT_EQ(Decode(Write("\x02", buffer), &value), 1u); |
| PW_TEST_EXPECT_EQ(value, 1); |
| |
| PW_TEST_EXPECT_EQ(Decode(Write("\x03", buffer), &value), 1u); |
| PW_TEST_EXPECT_EQ(value, -2); |
| |
| PW_TEST_EXPECT_EQ(Decode(Write("\x04", buffer), &value), 1u); |
| PW_TEST_EXPECT_EQ(value, 2); |
| |
| PW_TEST_EXPECT_EQ(Decode(Write("\x04", buffer), &value), 1u); |
| PW_TEST_EXPECT_EQ(value, 2); |
| }); |
| |
| TEST(Varint, DecodeSigned64_SingleByte_C) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {}; |
| int64_t value = -1234; |
| |
| auto bytes = Write("\x00", buffer); |
| EXPECT_EQ( |
| pw_varint_CallZigZagAndVarintDecode64(bytes.data(), bytes.size(), &value), |
| 1u); |
| EXPECT_EQ(value, 0); |
| |
| bytes = Write("\x01", buffer); |
| EXPECT_EQ( |
| pw_varint_CallZigZagAndVarintDecode64(bytes.data(), bytes.size(), &value), |
| 1u); |
| EXPECT_EQ(value, -1); |
| |
| bytes = Write("\x02", buffer); |
| EXPECT_EQ( |
| pw_varint_CallZigZagAndVarintDecode64(bytes.data(), bytes.size(), &value), |
| 1u); |
| EXPECT_EQ(value, 1); |
| |
| bytes = Write("\x03", buffer); |
| EXPECT_EQ( |
| pw_varint_CallZigZagAndVarintDecode64(bytes.data(), bytes.size(), &value), |
| 1u); |
| EXPECT_EQ(value, -2); |
| |
| bytes = Write("\x04", buffer); |
| EXPECT_EQ( |
| pw_varint_CallZigZagAndVarintDecode64(bytes.data(), bytes.size(), &value), |
| 1u); |
| EXPECT_EQ(value, 2); |
| |
| bytes = Write("\x04", buffer); |
| EXPECT_EQ( |
| pw_varint_CallZigZagAndVarintDecode64(bytes.data(), bytes.size(), &value), |
| 1u); |
| EXPECT_EQ(value, 2); |
| } |
| |
| PW_CONSTEXPR_TEST(Varint, DecodeSigned64_MultiByte, { |
| std::byte buffer[kMaxVarint64SizeBytes] = {}; |
| int64_t value = -1234; |
| |
| PW_TEST_EXPECT_EQ(Decode(Write("\x80\x01", buffer), &value), 2u); |
| PW_TEST_EXPECT_EQ(value, 64); |
| |
| PW_TEST_EXPECT_EQ(Decode(Write("\x81\x01", buffer), &value), 2u); |
| PW_TEST_EXPECT_EQ(value, -65); |
| |
| PW_TEST_EXPECT_EQ(Decode(Write("\x82\x01", buffer), &value), 2u); |
| PW_TEST_EXPECT_EQ(value, 65); |
| |
| PW_TEST_EXPECT_EQ(Decode(Write("\xff\xff\xff\xff\x0f", buffer), &value), 5u); |
| PW_TEST_EXPECT_EQ(value, std::numeric_limits<int32_t>::min()); |
| |
| PW_TEST_EXPECT_EQ(Decode(Write("\xfe\xff\xff\xff\x0f", buffer), &value), 5u); |
| PW_TEST_EXPECT_EQ(value, std::numeric_limits<int32_t>::max()); |
| |
| PW_TEST_EXPECT_EQ( |
| Decode(Write("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer), &value), |
| 10u); |
| PW_TEST_EXPECT_EQ(value, std::numeric_limits<int64_t>::min()); |
| |
| PW_TEST_EXPECT_EQ( |
| Decode(Write("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer), &value), |
| 10u); |
| PW_TEST_EXPECT_EQ(value, std::numeric_limits<int64_t>::max()); |
| }); |
| |
| TEST(Varint, DecodeSigned64_MultiByte_C) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {}; |
| int64_t value = -1234; |
| |
| auto bytes2 = Write("\x80\x01", buffer); |
| EXPECT_EQ(pw_varint_CallZigZagAndVarintDecode64( |
| bytes2.data(), bytes2.size(), &value), |
| 2u); |
| EXPECT_EQ(value, 64); |
| |
| bytes2 = Write("\x81\x01", buffer); |
| EXPECT_EQ(pw_varint_CallZigZagAndVarintDecode64( |
| bytes2.data(), bytes2.size(), &value), |
| 2u); |
| EXPECT_EQ(value, -65); |
| |
| bytes2 = Write("\x82\x01", buffer); |
| EXPECT_EQ(pw_varint_CallZigZagAndVarintDecode64( |
| bytes2.data(), bytes2.size(), &value), |
| 2u); |
| EXPECT_EQ(value, 65); |
| |
| auto bytes4 = Write("\xff\xff\xff\xff\x0f", buffer); |
| EXPECT_EQ(pw_varint_CallZigZagAndVarintDecode64( |
| bytes4.data(), bytes4.size(), &value), |
| 5u); |
| EXPECT_EQ(value, std::numeric_limits<int32_t>::min()); |
| |
| bytes4 = Write("\xfe\xff\xff\xff\x0f", buffer); |
| EXPECT_EQ(pw_varint_CallZigZagAndVarintDecode64( |
| bytes4.data(), bytes4.size(), &value), |
| 5u); |
| EXPECT_EQ(value, std::numeric_limits<int32_t>::max()); |
| |
| auto bytes8 = Write("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer); |
| EXPECT_EQ(pw_varint_CallZigZagAndVarintDecode64( |
| bytes8.data(), bytes8.size(), &value), |
| 10u); |
| EXPECT_EQ(value, std::numeric_limits<int64_t>::min()); |
| |
| bytes8 = Write("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer); |
| EXPECT_EQ(pw_varint_CallZigZagAndVarintDecode64( |
| bytes8.data(), bytes8.size(), &value), |
| 10u); |
| EXPECT_EQ(value, std::numeric_limits<int64_t>::max()); |
| } |
| |
| PW_CONSTEXPR_TEST(Varint, ZigZagEncode_Int8, { |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int8_t(0)), uint8_t(0)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int8_t(-1)), uint8_t(1)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int8_t(1)), uint8_t(2)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int8_t(-2)), uint8_t(3)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int8_t(2)), uint8_t(4)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int8_t(-33)), uint8_t(65)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int8_t(33)), uint8_t(66)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(std::numeric_limits<int8_t>::min()), |
| std::numeric_limits<uint8_t>::max()); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(std::numeric_limits<int8_t>::max()), |
| std::numeric_limits<uint8_t>::max() - 1u); |
| }); |
| |
| PW_CONSTEXPR_TEST(Varint, ZigZagEncode_Int16, { |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int16_t(0)), uint16_t(0)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int16_t(-1)), uint16_t(1)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int16_t(1)), uint16_t(2)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int16_t(-2)), uint16_t(3)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int16_t(2)), uint16_t(4)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int16_t(-3333)), uint16_t(6665)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int16_t(3333)), uint16_t(6666)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(std::numeric_limits<int16_t>::min()), |
| std::numeric_limits<uint16_t>::max()); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(std::numeric_limits<int16_t>::max()), |
| std::numeric_limits<uint16_t>::max() - 1u); |
| }); |
| |
| PW_CONSTEXPR_TEST(Varint, ZigZagEncode_Int32, { |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int32_t(0)), uint32_t(0)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int32_t(-1)), uint32_t(1)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int32_t(1)), uint32_t(2)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int32_t(-2)), uint32_t(3)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int32_t(2)), uint32_t(4)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int32_t(-128)), uint32_t(255)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int32_t(128)), uint32_t(256)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int32_t(-333333)), uint32_t(666665)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int32_t(333333)), uint32_t(666666)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(std::numeric_limits<int32_t>::min()), |
| std::numeric_limits<uint32_t>::max()); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(std::numeric_limits<int32_t>::max()), |
| std::numeric_limits<uint32_t>::max() - 1u); |
| }); |
| |
| PW_CONSTEXPR_TEST(Varint, ZigZagEncode_Int64, { |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int64_t(0)), uint64_t(0)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int64_t(-1)), uint64_t(1)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int64_t(1)), uint64_t(2)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int64_t(-2)), uint64_t(3)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int64_t(2)), uint64_t(4)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int64_t(-3333333333)), uint64_t(6666666665)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(int64_t(3333333333)), uint64_t(6666666666)); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(std::numeric_limits<int64_t>::min()), |
| std::numeric_limits<uint64_t>::max()); |
| PW_TEST_EXPECT_EQ(ZigZagEncode(std::numeric_limits<int64_t>::max()), |
| std::numeric_limits<uint64_t>::max() - 1u); |
| }); |
| |
| PW_CONSTEXPR_TEST(Varint, ZigZagDecode_Int8, { |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint8_t(0)), int8_t(0)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint8_t(1)), int8_t(-1)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint8_t(2)), int8_t(1)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint8_t(3)), int8_t(-2)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint8_t(4)), int8_t(2)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint8_t(65)), int8_t(-33)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint8_t(66)), int8_t(33)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint8_t>::max()), |
| std::numeric_limits<int8_t>::min()); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint8_t>::max() - 1u), |
| std::numeric_limits<int8_t>::max()); |
| }); |
| |
| PW_CONSTEXPR_TEST(Varint, ZigZagDecode_Int16, { |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint16_t(0)), int16_t(0)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint16_t(1)), int16_t(-1)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint16_t(2)), int16_t(1)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint16_t(3)), int16_t(-2)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint16_t(4)), int16_t(2)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint16_t(6665)), int16_t(-3333)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint16_t(6666)), int16_t(3333)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint16_t>::max()), |
| std::numeric_limits<int16_t>::min()); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint16_t>::max() - 1u), |
| std::numeric_limits<int16_t>::max()); |
| }); |
| |
| PW_CONSTEXPR_TEST(Varint, ZigZagDecode_Int32, { |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint32_t(0)), int32_t(0)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint32_t(1)), int32_t(-1)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint32_t(2)), int32_t(1)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint32_t(3)), int32_t(-2)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint32_t(4)), int32_t(2)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint32_t(255)), int32_t(-128)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint32_t(256)), int32_t(128)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint32_t(666665)), int32_t(-333333)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint32_t(666666)), int32_t(333333)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint32_t>::max()), |
| std::numeric_limits<int32_t>::min()); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint32_t>::max() - 1u), |
| std::numeric_limits<int32_t>::max()); |
| }); |
| |
| PW_CONSTEXPR_TEST(Varint, ZigZagDecode_Int64, { |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint64_t(0)), int64_t(0)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint64_t(1)), int64_t(-1)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint64_t(2)), int64_t(1)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint64_t(3)), int64_t(-2)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint64_t(4)), int64_t(2)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint64_t(6666666665)), int64_t(-3333333333)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(uint64_t(6666666666)), int64_t(3333333333)); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint64_t>::max()), |
| std::numeric_limits<int64_t>::min()); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(std::numeric_limits<uint64_t>::max() - 1llu), |
| std::numeric_limits<int64_t>::max()); |
| }); |
| |
| PW_CONSTEXPR_TEST(Varint, ZigZagEncodeDecode, { |
| PW_TEST_EXPECT_EQ(ZigZagDecode(ZigZagEncode(0)), 0); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(ZigZagEncode(1)), 1); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(ZigZagEncode(-1)), -1); |
| PW_TEST_EXPECT_EQ(ZigZagDecode(ZigZagEncode(8675309)), 8675309); |
| PW_TEST_EXPECT_EQ( |
| ZigZagDecode(ZigZagEncode(std::numeric_limits<int8_t>::min())), |
| std::numeric_limits<int8_t>::min()); |
| PW_TEST_EXPECT_EQ( |
| ZigZagDecode(ZigZagEncode(std::numeric_limits<int8_t>::max())), |
| std::numeric_limits<int8_t>::max()); |
| PW_TEST_EXPECT_EQ( |
| ZigZagDecode(ZigZagEncode(std::numeric_limits<int16_t>::min())), |
| std::numeric_limits<int16_t>::min()); |
| PW_TEST_EXPECT_EQ( |
| ZigZagDecode(ZigZagEncode(std::numeric_limits<int16_t>::max())), |
| std::numeric_limits<int16_t>::max()); |
| PW_TEST_EXPECT_EQ( |
| ZigZagDecode(ZigZagEncode(std::numeric_limits<int32_t>::min())), |
| std::numeric_limits<int32_t>::min()); |
| PW_TEST_EXPECT_EQ( |
| ZigZagDecode(ZigZagEncode(std::numeric_limits<int32_t>::max())), |
| std::numeric_limits<int32_t>::max()); |
| PW_TEST_EXPECT_EQ( |
| ZigZagDecode(ZigZagEncode(std::numeric_limits<int64_t>::min())), |
| std::numeric_limits<int64_t>::min()); |
| PW_TEST_EXPECT_EQ( |
| ZigZagDecode(ZigZagEncode(std::numeric_limits<int64_t>::max())), |
| std::numeric_limits<int64_t>::max()); |
| }); |
| |
| TEST(Varint, EncodeWithOptions_SingleByte) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| ASSERT_EQ(Encode(0u, buffer, Format::kZeroTerminatedLeastSignificant), 1u); |
| EXPECT_EQ(buffer[0], std::byte{0x00}); |
| |
| ASSERT_EQ(Encode(1u, buffer, Format::kZeroTerminatedLeastSignificant), 1u); |
| EXPECT_EQ(buffer[0], std::byte{0x02}); |
| |
| ASSERT_EQ(Encode(0x7f, buffer, Format::kZeroTerminatedLeastSignificant), 1u); |
| EXPECT_EQ(buffer[0], std::byte{0xfe}); |
| |
| ASSERT_EQ(Encode(0u, buffer, Format::kOneTerminatedLeastSignificant), 1u); |
| EXPECT_EQ(buffer[0], std::byte{0x01}); |
| |
| ASSERT_EQ(Encode(2u, buffer, Format::kOneTerminatedLeastSignificant), 1u); |
| EXPECT_EQ(buffer[0], std::byte{0x05}); |
| |
| ASSERT_EQ(Encode(0x7f, buffer, Format::kOneTerminatedLeastSignificant), 1u); |
| EXPECT_EQ(buffer[0], std::byte{0xff}); |
| |
| ASSERT_EQ(Encode(0u, buffer, Format::kZeroTerminatedMostSignificant), 1u); |
| EXPECT_EQ(buffer[0], std::byte{0x00}); |
| |
| ASSERT_EQ(Encode(7u, buffer, Format::kZeroTerminatedMostSignificant), 1u); |
| EXPECT_EQ(buffer[0], std::byte{0x07}); |
| |
| ASSERT_EQ(Encode(0x7f, buffer, Format::kZeroTerminatedMostSignificant), 1u); |
| EXPECT_EQ(buffer[0], std::byte{0x7f}); |
| |
| ASSERT_EQ(Encode(0u, buffer, Format::kOneTerminatedMostSignificant), 1u); |
| EXPECT_EQ(buffer[0], std::byte{0x80}); |
| |
| ASSERT_EQ(Encode(15u, buffer, Format::kOneTerminatedMostSignificant), 1u); |
| EXPECT_EQ(buffer[0], std::byte{0x8f}); |
| |
| ASSERT_EQ(Encode(0x7f, buffer, Format::kOneTerminatedMostSignificant), 1u); |
| EXPECT_EQ(buffer[0], std::byte{0xff}); |
| } |
| |
| TEST(Varint, EncodeWithOptions_MultiByte) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {std::byte('\xff')}; |
| ASSERT_EQ(Encode(128u, buffer, Format::kZeroTerminatedLeastSignificant), 2u); |
| EXPECT_TRUE(Compare("\x01\x02", buffer)); |
| |
| ASSERT_EQ(Encode(0xffffffff, buffer, Format::kZeroTerminatedLeastSignificant), |
| 5u); |
| EXPECT_TRUE(Compare("\xff\xff\xff\xff\x1e", buffer)); |
| |
| ASSERT_EQ(Encode(128u, buffer, Format::kOneTerminatedLeastSignificant), 2u); |
| EXPECT_TRUE(Compare("\x00\x03", buffer)); |
| |
| ASSERT_EQ(Encode(0xffffffff, buffer, Format::kOneTerminatedLeastSignificant), |
| 5u); |
| EXPECT_TRUE(Compare("\xfe\xfe\xfe\xfe\x1f", buffer)); |
| |
| ASSERT_EQ(Encode(128u, buffer, Format::kZeroTerminatedMostSignificant), 2u); |
| EXPECT_TRUE(Compare("\x80\x01", buffer)); |
| |
| ASSERT_EQ(Encode(0xffffffff, buffer, Format::kZeroTerminatedMostSignificant), |
| 5u); |
| EXPECT_TRUE(Compare("\xff\xff\xff\xff\x0f", buffer)); |
| |
| ASSERT_EQ(Encode(128u, buffer, Format::kOneTerminatedMostSignificant), 2u); |
| EXPECT_TRUE(Compare("\x00\x81", buffer)); |
| |
| ASSERT_EQ(Encode(0xffffffff, buffer, Format::kOneTerminatedMostSignificant), |
| 5u); |
| EXPECT_TRUE(Compare("\x7f\x7f\x7f\x7f\x8f", buffer)); |
| } |
| |
| TEST(Varint, DecodeWithOptions_SingleByte) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {}; |
| uint64_t value; |
| |
| EXPECT_EQ(Decode(Write("\x00", buffer), |
| &value, |
| Format::kZeroTerminatedLeastSignificant), |
| 1u); |
| EXPECT_EQ(value, 0u); |
| |
| EXPECT_EQ(Decode(Write("\x04", buffer), |
| &value, |
| Format::kZeroTerminatedLeastSignificant), |
| 1u); |
| EXPECT_EQ(value, 2u); |
| |
| EXPECT_EQ(Decode(Write("\xaa", buffer), |
| &value, |
| Format::kZeroTerminatedLeastSignificant), |
| 1u); |
| EXPECT_EQ(value, 85u); |
| |
| EXPECT_EQ(Decode(Write("\x01", buffer), |
| &value, |
| Format::kZeroTerminatedLeastSignificant), |
| 0u); |
| |
| EXPECT_EQ(Decode(Write("\x01", buffer), |
| &value, |
| Format::kOneTerminatedLeastSignificant), |
| 1u); |
| EXPECT_EQ(value, 0u); |
| |
| EXPECT_EQ(Decode(Write("\x13", buffer), |
| &value, |
| Format::kOneTerminatedLeastSignificant), |
| 1u); |
| EXPECT_EQ(value, 9u); |
| |
| EXPECT_EQ(Decode(Write("\x00", buffer), |
| &value, |
| Format::kOneTerminatedLeastSignificant), |
| 0u); |
| |
| EXPECT_EQ(Decode(Write("\x00", buffer), |
| &value, |
| Format::kZeroTerminatedMostSignificant), |
| 1u); |
| EXPECT_EQ(value, 0u); |
| |
| EXPECT_EQ(Decode(Write("\x04", buffer), |
| &value, |
| Format::kZeroTerminatedMostSignificant), |
| 1u); |
| EXPECT_EQ(value, 4u); |
| |
| EXPECT_EQ(Decode(Write("\xff", buffer), |
| &value, |
| Format::kZeroTerminatedMostSignificant), |
| 0u); |
| |
| EXPECT_EQ( |
| Decode( |
| Write("\x80", buffer), &value, Format::kOneTerminatedMostSignificant), |
| 1u); |
| EXPECT_EQ(value, 0u); |
| |
| EXPECT_EQ( |
| Decode( |
| Write("\x83", buffer), &value, Format::kOneTerminatedMostSignificant), |
| 1u); |
| EXPECT_EQ(value, 3u); |
| |
| EXPECT_EQ( |
| Decode( |
| Write("\xaa", buffer), &value, Format::kOneTerminatedMostSignificant), |
| 1u); |
| EXPECT_EQ(value, 42u); |
| |
| EXPECT_EQ( |
| Decode( |
| Write("\xff", buffer), &value, Format::kOneTerminatedMostSignificant), |
| 1u); |
| EXPECT_EQ(value, 127u); |
| |
| EXPECT_EQ( |
| Decode( |
| Write("\x00", buffer), &value, Format::kOneTerminatedMostSignificant), |
| 0u); |
| } |
| |
| TEST(Varint, DecodeWithOptions_MultiByte) { |
| std::byte buffer[kMaxVarint64SizeBytes] = {}; |
| uint64_t value; |
| |
| EXPECT_EQ(Decode(Write("\x01\x10", buffer), |
| &value, |
| Format::kZeroTerminatedLeastSignificant), |
| 2u); |
| EXPECT_EQ(value, 1024u); |
| |
| EXPECT_EQ(Decode(Write("\xff\xff\xff\xfe", buffer), |
| &value, |
| Format::kZeroTerminatedLeastSignificant), |
| 4u); |
| EXPECT_EQ(value, 0x0fffffffu); |
| |
| EXPECT_EQ(Decode(Write("\x01\x01\x01\x01\x00", buffer), |
| &value, |
| Format::kZeroTerminatedLeastSignificant), |
| 5u); |
| EXPECT_EQ(value, 0u); |
| |
| EXPECT_EQ(Decode(Write("\x82\x2d", buffer), |
| &value, |
| Format::kOneTerminatedLeastSignificant), |
| 2u); |
| EXPECT_EQ(value, 2881u); |
| |
| EXPECT_EQ(Decode(Write("\xfe\xfe\xfe\xff", buffer), |
| &value, |
| Format::kOneTerminatedLeastSignificant), |
| 4u); |
| EXPECT_EQ(value, 0x0fffffffu); |
| |
| EXPECT_EQ(Decode(Write("\x00\x00\x00\x00\x01", buffer), |
| &value, |
| Format::kOneTerminatedLeastSignificant), |
| 5u); |
| EXPECT_EQ(value, 0u); |
| |
| EXPECT_EQ(Decode(Write("\x83\x6a", buffer), |
| &value, |
| Format::kZeroTerminatedMostSignificant), |
| 2u); |
| EXPECT_EQ(value, 0b1101010'0000011u); |
| |
| EXPECT_EQ(Decode(Write("\xff\xff\xff\x7f", buffer), |
| &value, |
| Format::kZeroTerminatedMostSignificant), |
| 4u); |
| EXPECT_EQ(value, 0x0fffffffu); |
| |
| EXPECT_EQ(Decode(Write("\x80\x80\x80\x80\x00", buffer), |
| &value, |
| Format::kZeroTerminatedMostSignificant), |
| 5u); |
| EXPECT_EQ(value, 0u); |
| |
| EXPECT_EQ(Decode(Write("\x6a\x83", buffer), |
| &value, |
| Format::kOneTerminatedMostSignificant), |
| 2u); |
| EXPECT_EQ(value, 0b0000011'1101010u); |
| |
| EXPECT_EQ(Decode(Write("\x7f\x7f\x7f\xff", buffer), |
| &value, |
| Format::kOneTerminatedMostSignificant), |
| 4u); |
| EXPECT_EQ(value, 0x0fffffffu); |
| |
| EXPECT_EQ(Decode(Write("\x00\x00\x00\x00\x80", buffer), |
| &value, |
| Format::kOneTerminatedMostSignificant), |
| 5u); |
| EXPECT_EQ(value, 0u); |
| } |
| |
| #define ENCODED_SIZE_TEST(function) \ |
| TEST(Varint, function) { \ |
| EXPECT_EQ(function(uint64_t(0u)), 1u); \ |
| EXPECT_EQ(function(uint64_t(1u)), 1u); \ |
| EXPECT_EQ(function(uint64_t(127u)), 1u); \ |
| EXPECT_EQ(function(uint64_t(128u)), 2u); \ |
| EXPECT_EQ(function(uint64_t(16383u)), 2u); \ |
| EXPECT_EQ(function(uint64_t(16384u)), 3u); \ |
| EXPECT_EQ(function(uint64_t(2097151u)), 3u); \ |
| EXPECT_EQ(function(uint64_t(2097152u)), 4u); \ |
| EXPECT_EQ(function(uint64_t(268435455u)), 4u); \ |
| EXPECT_EQ(function(uint64_t(268435456u)), 5u); \ |
| EXPECT_EQ(function(uint64_t(34359738367u)), 5u); \ |
| EXPECT_EQ(function(uint64_t(34359738368u)), 6u); \ |
| EXPECT_EQ(function(uint64_t(4398046511103u)), 6u); \ |
| EXPECT_EQ(function(uint64_t(4398046511104u)), 7u); \ |
| EXPECT_EQ(function(uint64_t(562949953421311u)), 7u); \ |
| EXPECT_EQ(function(uint64_t(562949953421312u)), 8u); \ |
| EXPECT_EQ(function(uint64_t(72057594037927935u)), 8u); \ |
| EXPECT_EQ(function(uint64_t(72057594037927936u)), 9u); \ |
| EXPECT_EQ(function(uint64_t(9223372036854775807u)), 9u); \ |
| EXPECT_EQ(function(uint64_t(9223372036854775808u)), 10u); \ |
| EXPECT_EQ(function(std::numeric_limits<uint64_t>::max()), 10u); \ |
| EXPECT_EQ( \ |
| static_cast<uint64_t>(function(std::numeric_limits<int64_t>::max())), \ |
| 9u); \ |
| EXPECT_EQ(function(uint64_t(-1)), 10u); \ |
| EXPECT_EQ( \ |
| function(static_cast<uint64_t>(std::numeric_limits<int64_t>::min())), \ |
| 10u); \ |
| } \ |
| static_assert(true) |
| |
| ENCODED_SIZE_TEST(EncodedSize); |
| ENCODED_SIZE_TEST(pw_varint_EncodedSizeBytes); |
| ENCODED_SIZE_TEST(PW_VARINT_ENCODED_SIZE_BYTES); |
| |
| constexpr uint64_t CalculateMaxValueInBytes(size_t bytes) { |
| uint64_t value = 0; |
| for (size_t i = 0; i < bytes; ++i) { |
| value |= uint64_t(0x7f) << (7 * i); |
| } |
| return value; |
| } |
| |
| PW_CONSTEXPR_TEST(Varint, MaxValueInBytes, { |
| static_assert(MaxValueInBytes(0) == 0); |
| static_assert(MaxValueInBytes(1) == 0x7f); |
| static_assert(MaxValueInBytes(2) == 0x3fff); |
| static_assert(MaxValueInBytes(3) == 0x1fffff); |
| static_assert(MaxValueInBytes(4) == 0x0fffffff); |
| static_assert(MaxValueInBytes(5) == CalculateMaxValueInBytes(5)); |
| static_assert(MaxValueInBytes(6) == CalculateMaxValueInBytes(6)); |
| static_assert(MaxValueInBytes(7) == CalculateMaxValueInBytes(7)); |
| static_assert(MaxValueInBytes(8) == CalculateMaxValueInBytes(8)); |
| static_assert(MaxValueInBytes(9) == CalculateMaxValueInBytes(9)); |
| static_assert(MaxValueInBytes(10) == std::numeric_limits<uint64_t>::max()); |
| static_assert(MaxValueInBytes(11) == std::numeric_limits<uint64_t>::max()); |
| static_assert(MaxValueInBytes(100) == std::numeric_limits<uint64_t>::max()); |
| }); |
| |
| } // namespace |
| } // namespace pw::varint |
