pw_varint: Configurable encoding options
This adds an additional varint encoding and decoding API that allows
configuring which bit indicates the continuation or termination of the
number.
Change-Id: I34df4b330341129322b2296f4f07b8ea397964ab
Reviewed-on: https://pigweed-review.googlesource.com/c/pigweed/pigweed/+/37320
Commit-Queue: Alexei Frolov <frolv@google.com>
Reviewed-by: Wyatt Hepler <hepler@google.com>
diff --git a/pw_varint/public/pw_varint/varint.h b/pw_varint/public/pw_varint/varint.h
index a8db949..4432e19 100644
--- a/pw_varint/public/pw_varint/varint.h
+++ b/pw_varint/public/pw_varint/varint.h
@@ -24,17 +24,47 @@
// Expose a subset of the varint API for use in C code.
-size_t pw_VarintEncode(uint64_t integer, void* output, size_t output_size);
-size_t pw_VarintZigZagEncode(int64_t integer, void* output, size_t output_size);
+typedef enum {
+ PW_VARINT_ZERO_TERMINATED_LEAST_SIGNIFICANT = 0b00,
+ PW_VARINT_ZERO_TERMINATED_MOST_SIGNIFICANT = 0b01,
+ PW_VARINT_ONE_TERMINATED_LEAST_SIGNIFICANT = 0b10,
+ PW_VARINT_ONE_TERMINATED_MOST_SIGNIFICANT = 0b11,
+} pw_varint_Format;
-size_t pw_VarintDecode(const void* input, size_t input_size, uint64_t* output);
-size_t pw_VarintZigZagDecode(const void* input,
- size_t input_size,
- int64_t* output);
+size_t pw_varint_EncodeCustom(uint64_t integer,
+ void* output,
+ size_t output_size,
+ pw_varint_Format format);
+size_t pw_varint_DecodeCustom(const void* input,
+ size_t input_size,
+ uint64_t* output,
+ pw_varint_Format format);
+
+static inline size_t pw_varint_Encode(uint64_t integer,
+ void* output,
+ size_t output_size) {
+ return pw_varint_EncodeCustom(
+ integer, output, output_size, PW_VARINT_ZERO_TERMINATED_MOST_SIGNIFICANT);
+}
+
+size_t pw_varint_ZigZagEncode(int64_t integer,
+ void* output,
+ size_t output_size);
+
+static inline size_t pw_varint_Decode(const void* input,
+ size_t input_size,
+ uint64_t* output) {
+ return pw_varint_DecodeCustom(
+ input, input_size, output, PW_VARINT_ZERO_TERMINATED_MOST_SIGNIFICANT);
+}
+
+size_t pw_varint_ZigZagDecode(const void* input,
+ size_t input_size,
+ int64_t* output);
// Returns the size of an when encoded as a varint.
-size_t pw_VarintEncodedSize(uint64_t integer);
-size_t pw_VarintZigZagEncodedSize(int64_t integer);
+size_t pw_varint_EncodedSize(uint64_t integer);
+size_t pw_varint_ZigZagEncodedSize(int64_t integer);
#ifdef __cplusplus
@@ -83,7 +113,7 @@
// Encodes a uint64_t with Little-Endian Base 128 (LEB128) encoding.
inline size_t EncodeLittleEndianBase128(uint64_t integer,
const std::span<std::byte>& output) {
- return pw_VarintEncode(integer, output.data(), output.size());
+ return pw_varint_Encode(integer, output.data(), output.size());
}
// Encodes the provided integer using a variable-length encoding and returns the
@@ -99,9 +129,9 @@
template <typename T>
size_t Encode(T integer, const std::span<std::byte>& output) {
if (std::is_signed<T>()) {
- return pw_VarintZigZagEncode(integer, output.data(), output.size());
+ return pw_varint_ZigZagEncode(integer, output.data(), output.size());
} else {
- return pw_VarintEncode(integer, output.data(), output.size());
+ return pw_varint_Encode(integer, output.data(), output.size());
}
}
@@ -126,11 +156,36 @@
// }
//
inline size_t Decode(const std::span<const std::byte>& input, int64_t* value) {
- return pw_VarintZigZagDecode(input.data(), input.size(), value);
+ return pw_varint_ZigZagDecode(input.data(), input.size(), value);
}
inline size_t Decode(const std::span<const std::byte>& input, uint64_t* value) {
- return pw_VarintDecode(input.data(), input.size(), value);
+ return pw_varint_Decode(input.data(), input.size(), value);
+}
+
+enum class Format {
+ kZeroTerminatedLeastSignificant = PW_VARINT_ZERO_TERMINATED_LEAST_SIGNIFICANT,
+ kZeroTerminatedMostSignificant = PW_VARINT_ZERO_TERMINATED_MOST_SIGNIFICANT,
+ kOneTerminatedLeastSignificant = PW_VARINT_ONE_TERMINATED_LEAST_SIGNIFICANT,
+ kOneTerminatedMostSignificant = PW_VARINT_ONE_TERMINATED_MOST_SIGNIFICANT,
+};
+
+// Encodes a varint in a custom format.
+inline size_t Encode(uint64_t value,
+ std::span<std::byte> output,
+ Format format) {
+ return pw_varint_EncodeCustom(value,
+ output.data(),
+ output.size(),
+ static_cast<pw_varint_Format>(format));
+}
+
+// Decodes a varint from a custom format.
+inline size_t Decode(std::span<const std::byte> input,
+ uint64_t* value,
+ Format format) {
+ return pw_varint_DecodeCustom(
+ input.data(), input.size(), value, static_cast<pw_varint_Format>(format));
}
// Returns a size of an integer when encoded as a varint.
diff --git a/pw_varint/varint.cc b/pw_varint/varint.cc
index e2d1eb2..648c1db 100644
--- a/pw_varint/varint.cc
+++ b/pw_varint/varint.cc
@@ -18,36 +18,65 @@
namespace pw {
namespace varint {
+namespace {
-extern "C" size_t pw_VarintEncode(uint64_t integer,
- void* output,
- size_t output_size) {
+inline bool ZeroTerminated(pw_varint_Format format) {
+ return (static_cast<unsigned>(format) & 0b10) == 0;
+}
+
+inline bool LeastSignificant(pw_varint_Format format) {
+ return (static_cast<unsigned>(format) & 0b01) == 0;
+}
+
+} // namespace
+
+extern "C" size_t pw_varint_EncodeCustom(uint64_t input,
+ void* output,
+ size_t output_size,
+ pw_varint_Format format) {
size_t written = 0;
std::byte* buffer = static_cast<std::byte*>(output);
+ int value_shift = LeastSignificant(format) ? 1 : 0;
+ int term_shift = value_shift == 1 ? 0 : 7;
+
+ std::byte cont, term;
+ if (ZeroTerminated(format)) {
+ cont = std::byte(0x01) << term_shift;
+ term = std::byte(0x00) << term_shift;
+ } else {
+ cont = std::byte(0x00) << term_shift;
+ term = std::byte(0x01) << term_shift;
+ }
+
do {
if (written >= output_size) {
return 0;
}
- // Grab 7 bits; the eighth bit is set to 1 to indicate more data coming.
- buffer[written++] = static_cast<std::byte>(integer) | std::byte(0x80);
- integer >>= 7;
- } while (integer != 0u);
+ bool last_byte = (input >> 7) == 0u;
- buffer[written - 1] &= std::byte(0x7f); // clear the top bit of the last byte
+ // Grab 7 bits and set the eighth according to the continuation bit.
+ std::byte value = (static_cast<std::byte>(input) & std::byte(0x7f))
+ << value_shift;
+
+ if (last_byte) {
+ value |= term;
+ } else {
+ value |= cont;
+ }
+
+ buffer[written++] = value;
+ input >>= 7;
+ } while (input != 0u);
+
return written;
}
-extern "C" size_t pw_VarintZigZagEncode(int64_t integer,
- void* output,
- size_t output_size) {
- return pw_VarintEncode(ZigZagEncode(integer), output, output_size);
-}
-
-extern "C" size_t pw_VarintDecode(const void* input,
- size_t input_size,
- uint64_t* output) {
+extern "C" size_t pw_varint_DecodeCustom(const void* input,
+ size_t input_size,
+ uint64_t* output,
+ pw_varint_Format format) {
uint64_t decoded_value = 0;
uint_fast8_t count = 0;
const std::byte* buffer = static_cast<const std::byte*>(input);
@@ -55,17 +84,35 @@
// The largest 64-bit ints require 10 B.
const size_t max_count = std::min(kMaxVarint64SizeBytes, input_size);
+ std::byte mask;
+ uint32_t shift;
+ if (LeastSignificant(format)) {
+ mask = std::byte(0xfe);
+ shift = 1;
+ } else {
+ mask = std::byte(0x7f);
+ shift = 0;
+ }
+
+ // Determines whether a byte is the last byte of a varint.
+ auto is_last_byte = [&](std::byte byte) {
+ if (ZeroTerminated(format)) {
+ return (byte & ~mask) == std::byte(0);
+ }
+ return (byte & ~mask) != std::byte(0);
+ };
+
while (true) {
if (count >= max_count) {
return 0;
}
// Add the bottom seven bits of the next byte to the result.
- decoded_value |= static_cast<uint64_t>(buffer[count] & std::byte(0x7f))
+ decoded_value |= static_cast<uint64_t>((buffer[count] & mask) >> shift)
<< (7 * count);
- // Stop decoding if the top bit is not set.
- if ((buffer[count++] & std::byte(0x80)) == std::byte(0)) {
+ // Stop decoding if the end is reached.
+ if (is_last_byte(buffer[count++])) {
break;
}
}
@@ -74,20 +121,40 @@
return count;
}
-extern "C" size_t pw_VarintZigZagDecode(const void* input,
- size_t input_size,
- int64_t* output) {
+// TODO(frolv): Remove this deprecated function.
+extern "C" size_t pw_VarintEncode(uint64_t integer,
+ void* output,
+ size_t output_size) {
+ return pw_varint_Encode(integer, output, output_size);
+}
+
+extern "C" size_t pw_varint_ZigZagEncode(int64_t integer,
+ void* output,
+ size_t output_size) {
+ return pw_varint_Encode(ZigZagEncode(integer), output, output_size);
+}
+
+// TODO(frolv): Remove this deprecated function.
+extern "C" size_t pw_VarintDecode(const void* input,
+ size_t input_size,
+ uint64_t* output) {
+ return pw_varint_Decode(input, input_size, output);
+}
+
+extern "C" size_t pw_varint_ZigZagDecode(const void* input,
+ size_t input_size,
+ int64_t* output) {
uint64_t value = 0;
- size_t bytes = pw_VarintDecode(input, input_size, &value);
+ size_t bytes = pw_varint_Decode(input, input_size, &value);
*output = ZigZagDecode(value);
return bytes;
}
-extern "C" size_t pw_VarintEncodedSize(uint64_t integer) {
+extern "C" size_t pw_varint_EncodedSize(uint64_t integer) {
return EncodedSize(integer);
}
-extern "C" size_t pw_VarintZigZagEncodedSize(int64_t integer) {
+extern "C" size_t pw_varint_ZigZagEncodedSize(int64_t integer) {
return ZigZagEncodedSize(integer);
}
diff --git a/pw_varint/varint_test.cc b/pw_varint/varint_test.cc
index eceaeb7..2d373d2 100644
--- a/pw_varint/varint_test.cc
+++ b/pw_varint/varint_test.cc
@@ -27,14 +27,14 @@
extern "C" {
// Functions defined in varint_test.c which call the varint API from C.
-size_t pw_VarintCallEncode(uint64_t integer, void* output, size_t output_size);
-size_t pw_VarintCallZigZagEncode(int64_t integer,
- void* output,
- size_t output_size);
-size_t pw_VarintCallDecode(void* input, size_t input_size, uint64_t* output);
-size_t pw_VarintCallZigZagDecode(void* input,
- size_t input_size,
- int64_t* output);
+size_t pw_varint_CallEncode(uint64_t integer, void* output, size_t output_size);
+size_t pw_varint_CallZigZagEncode(int64_t integer,
+ void* output,
+ size_t output_size);
+size_t pw_varint_CallDecode(void* input, size_t input_size, uint64_t* output);
+size_t pw_varint_CallZigZagDecode(void* input,
+ size_t input_size,
+ int64_t* output);
} // extern "C"
@@ -64,11 +64,11 @@
}
TEST_F(Varint, EncodeSizeUnsigned32_SmallSingleByte_C) {
- ASSERT_EQ(1u, pw_VarintCallEncode(UINT32_C(0), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(1u, pw_varint_CallEncode(UINT32_C(0), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{0}, buffer_[0]);
- ASSERT_EQ(1u, pw_VarintCallEncode(UINT32_C(1), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(1u, pw_varint_CallEncode(UINT32_C(1), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{1}, buffer_[0]);
- ASSERT_EQ(1u, pw_VarintCallEncode(UINT32_C(2), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(1u, pw_varint_CallEncode(UINT32_C(2), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{2}, buffer_[0]);
}
@@ -84,13 +84,13 @@
}
TEST_F(Varint, EncodeSizeUnsigned32_LargeSingleByte_C) {
- ASSERT_EQ(1u, pw_VarintCallEncode(UINT32_C(63), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(1u, pw_varint_CallEncode(UINT32_C(63), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{63}, buffer_[0]);
- ASSERT_EQ(1u, pw_VarintCallEncode(UINT32_C(64), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(1u, pw_varint_CallEncode(UINT32_C(64), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{64}, buffer_[0]);
- ASSERT_EQ(1u, pw_VarintCallEncode(UINT32_C(126), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(1u, pw_varint_CallEncode(UINT32_C(126), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{126}, buffer_[0]);
- ASSERT_EQ(1u, pw_VarintCallEncode(UINT32_C(127), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(1u, pw_varint_CallEncode(UINT32_C(127), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{127}, buffer_[0]);
}
@@ -108,20 +108,20 @@
}
TEST_F(Varint, EncodeSizeUnsigned32_MultiByte_C) {
- ASSERT_EQ(2u, pw_VarintCallEncode(UINT32_C(128), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(2u, pw_varint_CallEncode(UINT32_C(128), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
- ASSERT_EQ(2u, pw_VarintCallEncode(UINT32_C(129), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(2u, pw_varint_CallEncode(UINT32_C(129), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
ASSERT_EQ(
5u,
- pw_VarintCallEncode(
+ pw_varint_CallEncode(
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_VarintCallEncode(
+ pw_varint_CallEncode(
std::numeric_limits<uint32_t>::max(), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer_, 5), 0);
}
@@ -141,19 +141,19 @@
TEST_F(Varint, EncodeSizeSigned32_SmallSingleByte_C) {
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT32_C(0), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT32_C(0), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{0}, buffer_[0]);
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT32_C(-1), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT32_C(-1), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{1}, buffer_[0]);
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT32_C(1), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT32_C(1), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{2}, buffer_[0]);
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT32_C(-2), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT32_C(-2), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{3}, buffer_[0]);
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT32_C(2), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT32_C(2), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{4}, buffer_[0]);
}
@@ -168,13 +168,13 @@
TEST_F(Varint, EncodeSizeSigned32_LargeSingleByte_C) {
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT32_C(-63), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT32_C(-63), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{125}, buffer_[0]);
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT32_C(63), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT32_C(63), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{126}, buffer_[0]);
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT32_C(-64), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT32_C(-64), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{127}, buffer_[0]);
}
@@ -195,22 +195,22 @@
TEST_F(Varint, EncodeSizeSigned32_MultiByte_C) {
ASSERT_EQ(2u,
- pw_VarintCallZigZagEncode(INT32_C(64), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT32_C(64), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
ASSERT_EQ(2u,
- pw_VarintCallZigZagEncode(INT32_C(-65), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT32_C(-65), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
ASSERT_EQ(2u,
- pw_VarintCallZigZagEncode(INT32_C(65), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT32_C(65), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::memcmp("\x82\x01", buffer_, 2), 0);
ASSERT_EQ(5u,
- pw_VarintCallZigZagEncode(
+ pw_varint_CallZigZagEncode(
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_VarintCallZigZagEncode(
+ pw_varint_CallZigZagEncode(
std::numeric_limits<int32_t>::max(), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer_, 5), 0);
}
@@ -225,11 +225,11 @@
}
TEST_F(Varint, EncodeSizeUnsigned64_SmallSingleByte_C) {
- ASSERT_EQ(1u, pw_VarintCallEncode(UINT64_C(0), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(1u, pw_varint_CallEncode(UINT64_C(0), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{0}, buffer_[0]);
- ASSERT_EQ(1u, pw_VarintCallEncode(UINT64_C(1), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(1u, pw_varint_CallEncode(UINT64_C(1), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{1}, buffer_[0]);
- ASSERT_EQ(1u, pw_VarintCallEncode(UINT64_C(2), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(1u, pw_varint_CallEncode(UINT64_C(2), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{2}, buffer_[0]);
}
@@ -245,13 +245,13 @@
}
TEST_F(Varint, EncodeSizeUnsigned64_LargeSingleByte_C) {
- ASSERT_EQ(1u, pw_VarintCallEncode(UINT64_C(63), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(1u, pw_varint_CallEncode(UINT64_C(63), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{63}, buffer_[0]);
- ASSERT_EQ(1u, pw_VarintCallEncode(UINT64_C(64), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(1u, pw_varint_CallEncode(UINT64_C(64), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{64}, buffer_[0]);
- ASSERT_EQ(1u, pw_VarintCallEncode(UINT64_C(126), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(1u, pw_varint_CallEncode(UINT64_C(126), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{126}, buffer_[0]);
- ASSERT_EQ(1u, pw_VarintCallEncode(UINT64_C(127), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(1u, pw_varint_CallEncode(UINT64_C(127), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{127}, buffer_[0]);
}
@@ -277,33 +277,33 @@
}
TEST_F(Varint, EncodeSizeUnsigned64_MultiByte_C) {
- ASSERT_EQ(2u, pw_VarintCallEncode(UINT64_C(128), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(2u, pw_varint_CallEncode(UINT64_C(128), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
- ASSERT_EQ(2u, pw_VarintCallEncode(UINT64_C(129), buffer_, sizeof(buffer_)));
+ ASSERT_EQ(2u, pw_varint_CallEncode(UINT64_C(129), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
ASSERT_EQ(
5u,
- pw_VarintCallEncode(
+ pw_varint_CallEncode(
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_VarintCallEncode(
+ pw_varint_CallEncode(
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_VarintCallEncode(
+ pw_varint_CallEncode(
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_VarintCallEncode(
+ pw_varint_CallEncode(
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);
@@ -324,19 +324,19 @@
TEST_F(Varint, EncodeSizeSigned64_SmallSingleByte_C) {
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT64_C(0), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT64_C(0), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{0}, buffer_[0]);
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT64_C(-1), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT64_C(-1), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{1}, buffer_[0]);
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT64_C(1), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT64_C(1), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{2}, buffer_[0]);
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT64_C(-2), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT64_C(-2), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{3}, buffer_[0]);
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT64_C(2), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT64_C(2), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{4}, buffer_[0]);
}
@@ -351,13 +351,13 @@
TEST_F(Varint, EncodeSizeSigned64_LargeSingleByte_C) {
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT64_C(-63), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT64_C(-63), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{125}, buffer_[0]);
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT64_C(63), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT64_C(63), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{126}, buffer_[0]);
ASSERT_EQ(1u,
- pw_VarintCallZigZagEncode(INT64_C(-64), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT64_C(-64), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::byte{127}, buffer_[0]);
}
@@ -390,37 +390,37 @@
TEST_F(Varint, EncodeSizeSigned64_MultiByte_C) {
ASSERT_EQ(2u,
- pw_VarintCallZigZagEncode(INT64_C(64), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT64_C(64), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
ASSERT_EQ(2u,
- pw_VarintCallZigZagEncode(INT64_C(-65), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT64_C(-65), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
ASSERT_EQ(2u,
- pw_VarintCallZigZagEncode(INT64_C(65), buffer_, sizeof(buffer_)));
+ pw_varint_CallZigZagEncode(INT64_C(65), buffer_, sizeof(buffer_)));
EXPECT_EQ(std::memcmp("\x82\x01", buffer_, 2), 0);
ASSERT_EQ(5u,
- pw_VarintCallZigZagEncode(
+ pw_varint_CallZigZagEncode(
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_VarintCallZigZagEncode(
+ pw_varint_CallZigZagEncode(
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_VarintCallZigZagEncode(
+ pw_varint_CallZigZagEncode(
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_VarintCallZigZagEncode(
+ pw_varint_CallZigZagEncode(
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);
@@ -452,11 +452,11 @@
TEST_F(Varint, EncodeDecodeSigned32_C) {
int32_t i = std::numeric_limits<int32_t>::min();
while (true) {
- size_t encoded = pw_VarintCallZigZagEncode(i, buffer_, sizeof(buffer_));
+ size_t encoded = pw_varint_CallZigZagEncode(i, buffer_, sizeof(buffer_));
int64_t result;
size_t decoded =
- pw_VarintCallZigZagDecode(buffer_, sizeof(buffer_), &result);
+ pw_varint_CallZigZagDecode(buffer_, sizeof(buffer_), &result);
EXPECT_EQ(encoded, decoded);
ASSERT_EQ(i, result);
@@ -491,10 +491,10 @@
TEST_F(Varint, EncodeDecodeUnsigned32_C) {
uint32_t i = 0;
while (true) {
- size_t encoded = pw_VarintCallEncode(i, buffer_, sizeof(buffer_));
+ size_t encoded = pw_varint_CallEncode(i, buffer_, sizeof(buffer_));
uint64_t result;
- size_t decoded = pw_VarintCallDecode(buffer_, sizeof(buffer_), &result);
+ size_t decoded = pw_varint_CallDecode(buffer_, sizeof(buffer_), &result);
EXPECT_EQ(encoded, decoded);
ASSERT_EQ(i, result);
@@ -543,32 +543,32 @@
int64_t value = -1234;
auto buffer = MakeBuffer("\x00");
- EXPECT_EQ(pw_VarintCallZigZagDecode(buffer.data(), buffer.size(), &value),
+ EXPECT_EQ(pw_varint_CallZigZagDecode(buffer.data(), buffer.size(), &value),
1u);
EXPECT_EQ(value, 0);
buffer = MakeBuffer("\x01");
- EXPECT_EQ(pw_VarintCallZigZagDecode(buffer.data(), buffer.size(), &value),
+ EXPECT_EQ(pw_varint_CallZigZagDecode(buffer.data(), buffer.size(), &value),
1u);
EXPECT_EQ(value, -1);
buffer = MakeBuffer("\x02");
- EXPECT_EQ(pw_VarintCallZigZagDecode(buffer.data(), buffer.size(), &value),
+ EXPECT_EQ(pw_varint_CallZigZagDecode(buffer.data(), buffer.size(), &value),
1u);
EXPECT_EQ(value, 1);
buffer = MakeBuffer("\x03");
- EXPECT_EQ(pw_VarintCallZigZagDecode(buffer.data(), buffer.size(), &value),
+ EXPECT_EQ(pw_varint_CallZigZagDecode(buffer.data(), buffer.size(), &value),
1u);
EXPECT_EQ(value, -2);
buffer = MakeBuffer("\x04");
- EXPECT_EQ(pw_VarintCallZigZagDecode(buffer.data(), buffer.size(), &value),
+ EXPECT_EQ(pw_varint_CallZigZagDecode(buffer.data(), buffer.size(), &value),
1u);
EXPECT_EQ(value, 2);
buffer = MakeBuffer("\x04");
- EXPECT_EQ(pw_VarintCallZigZagDecode(buffer.data(), buffer.size(), &value),
+ EXPECT_EQ(pw_varint_CallZigZagDecode(buffer.data(), buffer.size(), &value),
1u);
EXPECT_EQ(value, 2);
}
@@ -606,37 +606,37 @@
int64_t value = -1234;
auto buffer2 = MakeBuffer("\x80\x01");
- EXPECT_EQ(pw_VarintCallZigZagDecode(buffer2.data(), buffer2.size(), &value),
+ EXPECT_EQ(pw_varint_CallZigZagDecode(buffer2.data(), buffer2.size(), &value),
2u);
EXPECT_EQ(value, 64);
buffer2 = MakeBuffer("\x81\x01");
- EXPECT_EQ(pw_VarintCallZigZagDecode(buffer2.data(), buffer2.size(), &value),
+ EXPECT_EQ(pw_varint_CallZigZagDecode(buffer2.data(), buffer2.size(), &value),
2u);
EXPECT_EQ(value, -65);
buffer2 = MakeBuffer("\x82\x01");
- EXPECT_EQ(pw_VarintCallZigZagDecode(buffer2.data(), buffer2.size(), &value),
+ EXPECT_EQ(pw_varint_CallZigZagDecode(buffer2.data(), buffer2.size(), &value),
2u);
EXPECT_EQ(value, 65);
auto buffer4 = MakeBuffer("\xff\xff\xff\xff\x0f");
- EXPECT_EQ(pw_VarintCallZigZagDecode(buffer4.data(), buffer4.size(), &value),
+ EXPECT_EQ(pw_varint_CallZigZagDecode(buffer4.data(), buffer4.size(), &value),
5u);
EXPECT_EQ(value, std::numeric_limits<int32_t>::min());
buffer4 = MakeBuffer("\xfe\xff\xff\xff\x0f");
- EXPECT_EQ(pw_VarintCallZigZagDecode(buffer4.data(), buffer4.size(), &value),
+ EXPECT_EQ(pw_varint_CallZigZagDecode(buffer4.data(), buffer4.size(), &value),
5u);
EXPECT_EQ(value, std::numeric_limits<int32_t>::max());
auto buffer8 = MakeBuffer("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01");
- EXPECT_EQ(pw_VarintCallZigZagDecode(buffer8.data(), buffer8.size(), &value),
+ EXPECT_EQ(pw_varint_CallZigZagDecode(buffer8.data(), buffer8.size(), &value),
10u);
EXPECT_EQ(value, std::numeric_limits<int64_t>::min());
buffer8 = MakeBuffer("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01");
- EXPECT_EQ(pw_VarintCallZigZagDecode(buffer8.data(), buffer8.size(), &value),
+ EXPECT_EQ(pw_varint_CallZigZagDecode(buffer8.data(), buffer8.size(), &value),
10u);
EXPECT_EQ(value, std::numeric_limits<int64_t>::max());
}
@@ -780,6 +780,235 @@
std::numeric_limits<int64_t>::max());
}
+TEST_F(Varint, EncodeWithOptions_SingleByte) {
+ 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_F(Varint, EncodeWithOptions_MultiByte) {
+ ASSERT_EQ(Encode(128u, buffer_, Format::kZeroTerminatedLeastSignificant), 2u);
+ EXPECT_EQ(std::memcmp("\x01\x02", buffer_, 2), 0);
+
+ ASSERT_EQ(
+ Encode(0xffffffff, buffer_, Format::kZeroTerminatedLeastSignificant), 5u);
+ EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x1e", buffer_, 5), 0);
+
+ ASSERT_EQ(Encode(128u, buffer_, Format::kOneTerminatedLeastSignificant), 2u);
+ EXPECT_EQ(std::memcmp("\x00\x03", buffer_, 2), 0);
+
+ ASSERT_EQ(Encode(0xffffffff, buffer_, Format::kOneTerminatedLeastSignificant),
+ 5u);
+ EXPECT_EQ(std::memcmp("\xfe\xfe\xfe\xfe\x1f", buffer_, 5), 0);
+
+ ASSERT_EQ(Encode(128u, buffer_, Format::kZeroTerminatedMostSignificant), 2u);
+ EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
+
+ ASSERT_EQ(Encode(0xffffffff, buffer_, Format::kZeroTerminatedMostSignificant),
+ 5u);
+ EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer_, 5), 0);
+
+ ASSERT_EQ(Encode(128u, buffer_, Format::kOneTerminatedMostSignificant), 2u);
+ EXPECT_EQ(std::memcmp("\x00\x81", buffer_, 2), 0);
+
+ ASSERT_EQ(Encode(0xffffffff, buffer_, Format::kOneTerminatedMostSignificant),
+ 5u);
+ EXPECT_EQ(std::memcmp("\x7f\x7f\x7f\x7f\x8f", buffer_, 5), 0);
+}
+
+TEST(Varint, DecodeWithOptions_SingleByte) {
+ uint64_t value = -1234;
+
+ EXPECT_EQ(
+ Decode(
+ MakeBuffer("\x00"), &value, Format::kZeroTerminatedLeastSignificant),
+ 1u);
+ EXPECT_EQ(value, 0u);
+
+ EXPECT_EQ(
+ Decode(
+ MakeBuffer("\x04"), &value, Format::kZeroTerminatedLeastSignificant),
+ 1u);
+ EXPECT_EQ(value, 2u);
+
+ EXPECT_EQ(
+ Decode(
+ MakeBuffer("\xaa"), &value, Format::kZeroTerminatedLeastSignificant),
+ 1u);
+ EXPECT_EQ(value, 85u);
+
+ EXPECT_EQ(
+ Decode(
+ MakeBuffer("\x01"), &value, Format::kZeroTerminatedLeastSignificant),
+ 0u);
+
+ EXPECT_EQ(
+ Decode(
+ MakeBuffer("\x01"), &value, Format::kOneTerminatedLeastSignificant),
+ 1u);
+ EXPECT_EQ(value, 0u);
+
+ EXPECT_EQ(
+ Decode(
+ MakeBuffer("\x13"), &value, Format::kOneTerminatedLeastSignificant),
+ 1u);
+ EXPECT_EQ(value, 9u);
+
+ EXPECT_EQ(
+ Decode(
+ MakeBuffer("\x00"), &value, Format::kOneTerminatedLeastSignificant),
+ 0u);
+
+ EXPECT_EQ(
+ Decode(
+ MakeBuffer("\x00"), &value, Format::kZeroTerminatedMostSignificant),
+ 1u);
+ EXPECT_EQ(value, 0u);
+
+ EXPECT_EQ(
+ Decode(
+ MakeBuffer("\x04"), &value, Format::kZeroTerminatedMostSignificant),
+ 1u);
+ EXPECT_EQ(value, 4u);
+
+ EXPECT_EQ(
+ Decode(
+ MakeBuffer("\xff"), &value, Format::kZeroTerminatedMostSignificant),
+ 0u);
+
+ EXPECT_EQ(
+ Decode(MakeBuffer("\x80"), &value, Format::kOneTerminatedMostSignificant),
+ 1u);
+ EXPECT_EQ(value, 0u);
+
+ EXPECT_EQ(
+ Decode(MakeBuffer("\x83"), &value, Format::kOneTerminatedMostSignificant),
+ 1u);
+ EXPECT_EQ(value, 3u);
+
+ EXPECT_EQ(
+ Decode(MakeBuffer("\xaa"), &value, Format::kOneTerminatedMostSignificant),
+ 1u);
+ EXPECT_EQ(value, 42u);
+
+ EXPECT_EQ(
+ Decode(MakeBuffer("\xff"), &value, Format::kOneTerminatedMostSignificant),
+ 1u);
+ EXPECT_EQ(value, 127u);
+
+ EXPECT_EQ(
+ Decode(MakeBuffer("\x00"), &value, Format::kOneTerminatedMostSignificant),
+ 0u);
+}
+
+TEST(Varint, DecodeWithOptions_MultiByte) {
+ uint64_t value = -1234;
+
+ EXPECT_EQ(Decode(MakeBuffer("\x01\x10"),
+ &value,
+ Format::kZeroTerminatedLeastSignificant),
+ 2u);
+ EXPECT_EQ(value, 1024u);
+
+ EXPECT_EQ(Decode(MakeBuffer("\xff\xff\xff\xfe"),
+ &value,
+ Format::kZeroTerminatedLeastSignificant),
+ 4u);
+ EXPECT_EQ(value, 0x0fffffffu);
+
+ EXPECT_EQ(Decode(MakeBuffer("\x01\x01\x01\x01\x00"),
+ &value,
+ Format::kZeroTerminatedLeastSignificant),
+ 5u);
+ EXPECT_EQ(value, 0u);
+
+ EXPECT_EQ(Decode(MakeBuffer("\x82\x2d"),
+ &value,
+ Format::kOneTerminatedLeastSignificant),
+ 2u);
+ EXPECT_EQ(value, 2881u);
+
+ EXPECT_EQ(Decode(MakeBuffer("\xfe\xfe\xfe\xff"),
+ &value,
+ Format::kOneTerminatedLeastSignificant),
+ 4u);
+ EXPECT_EQ(value, 0x0fffffffu);
+
+ EXPECT_EQ(Decode(MakeBuffer("\x00\x00\x00\x00\x01"),
+ &value,
+ Format::kOneTerminatedLeastSignificant),
+ 5u);
+ EXPECT_EQ(value, 0u);
+
+ EXPECT_EQ(Decode(MakeBuffer("\x83\x6a"),
+ &value,
+ Format::kZeroTerminatedMostSignificant),
+ 2u);
+ EXPECT_EQ(value, 0b1101010'0000011u);
+
+ EXPECT_EQ(Decode(MakeBuffer("\xff\xff\xff\x7f"),
+ &value,
+ Format::kZeroTerminatedMostSignificant),
+ 4u);
+ EXPECT_EQ(value, 0x0fffffffu);
+
+ EXPECT_EQ(Decode(MakeBuffer("\x80\x80\x80\x80\x00"),
+ &value,
+ Format::kZeroTerminatedMostSignificant),
+ 5u);
+ EXPECT_EQ(value, 0u);
+
+ EXPECT_EQ(Decode(MakeBuffer("\x6a\x83"),
+ &value,
+ Format::kOneTerminatedMostSignificant),
+ 2u);
+ EXPECT_EQ(value, 0b0000011'1101010u);
+
+ EXPECT_EQ(Decode(MakeBuffer("\x7f\x7f\x7f\xff"),
+ &value,
+ Format::kOneTerminatedMostSignificant),
+ 4u);
+ EXPECT_EQ(value, 0x0fffffffu);
+
+ EXPECT_EQ(Decode(MakeBuffer("\x00\x00\x00\x00\x80"),
+ &value,
+ Format::kOneTerminatedMostSignificant),
+ 5u);
+ EXPECT_EQ(value, 0u);
+}
+
TEST(Varint, EncodedSize) {
EXPECT_EQ(EncodedSize(uint64_t(0u)), 1u);
EXPECT_EQ(EncodedSize(uint64_t(1u)), 1u);
diff --git a/pw_varint/varint_test_c.c b/pw_varint/varint_test_c.c
index 232dab3..0e66ac9 100644
--- a/pw_varint/varint_test_c.c
+++ b/pw_varint/varint_test_c.c
@@ -19,22 +19,24 @@
#include "pw_varint/varint.h"
-size_t pw_VarintCallEncode(uint64_t integer, void* output, size_t output_size) {
- return pw_VarintEncode(integer, output, output_size);
+size_t pw_varint_CallEncode(uint64_t integer,
+ void* output,
+ size_t output_size) {
+ return pw_varint_Encode(integer, output, output_size);
}
-size_t pw_VarintCallZigZagEncode(int64_t integer,
- void* output,
- size_t output_size) {
- return pw_VarintZigZagEncode(integer, output, output_size);
+size_t pw_varint_CallZigZagEncode(int64_t integer,
+ void* output,
+ size_t output_size) {
+ return pw_varint_ZigZagEncode(integer, output, output_size);
}
-size_t pw_VarintCallDecode(void* input, size_t input_size, uint64_t* output) {
- return pw_VarintDecode(input, input_size, output);
+size_t pw_varint_CallDecode(void* input, size_t input_size, uint64_t* output) {
+ return pw_varint_Decode(input, input_size, output);
}
-size_t pw_VarintCallZigZagDecode(void* input,
- size_t input_size,
- int64_t* output) {
- return pw_VarintZigZagDecode(input, input_size, output);
+size_t pw_varint_CallZigZagDecode(void* input,
+ size_t input_size,
+ int64_t* output) {
+ return pw_varint_ZigZagDecode(input, input_size, output);
}
