1 // Copyright 2021 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/stream.h"
16
17 #include <array>
18 #include <cstddef>
19 #include <cstdint>
20 #include <cstring>
21 #include <limits>
22
23 #include "gtest/gtest.h"
24 #include "pw_stream/memory_stream.h"
25
26 namespace pw::varint {
27 namespace {
28 template <size_t kStringSize>
MakeBuffer(const char (& data)[kStringSize])29 auto MakeBuffer(const char (&data)[kStringSize]) {
30 constexpr size_t kSizeBytes = kStringSize - 1;
31 static_assert(kSizeBytes <= 10, "Varint arrays never need be larger than 10");
32
33 std::array<std::byte, kSizeBytes> array;
34 std::memcpy(array.data(), data, kSizeBytes);
35 return array;
36 }
37 } // namespace
38
TEST(VarintRead,Signed64_SingleByte)39 TEST(VarintRead, Signed64_SingleByte) {
40 int64_t value = -1234;
41
42 {
43 const auto buffer = MakeBuffer("\x00");
44 stream::MemoryReader reader(buffer);
45 const auto sws = Read(reader, &value);
46 EXPECT_TRUE(sws.ok());
47 EXPECT_EQ(sws.size(), 1u);
48 EXPECT_EQ(value, 0);
49 }
50
51 {
52 const auto buffer = MakeBuffer("\x01");
53 stream::MemoryReader reader(buffer);
54 const auto sws = Read(reader, &value);
55 EXPECT_TRUE(sws.ok());
56 EXPECT_EQ(sws.size(), 1u);
57 EXPECT_EQ(value, -1);
58 }
59
60 {
61 const auto buffer = MakeBuffer("\x02");
62 stream::MemoryReader reader(buffer);
63 const auto sws = Read(reader, &value);
64 EXPECT_TRUE(sws.ok());
65 EXPECT_EQ(sws.size(), 1u);
66 EXPECT_EQ(value, 1);
67 }
68
69 {
70 const auto buffer = MakeBuffer("\x03");
71 stream::MemoryReader reader(buffer);
72 const auto sws = Read(reader, &value);
73 EXPECT_TRUE(sws.ok());
74 EXPECT_EQ(sws.size(), 1u);
75 EXPECT_EQ(value, -2);
76 }
77
78 {
79 const auto buffer = MakeBuffer("\x04");
80 stream::MemoryReader reader(buffer);
81 const auto sws = Read(reader, &value);
82 EXPECT_TRUE(sws.ok());
83 EXPECT_EQ(sws.size(), 1u);
84 EXPECT_EQ(value, 2);
85 }
86 }
87
TEST(VarintRead,Signed64_MultiByte)88 TEST(VarintRead, Signed64_MultiByte) {
89 int64_t value = -1234;
90
91 {
92 const auto buffer = MakeBuffer("\x80\x01");
93 stream::MemoryReader reader(buffer);
94 const auto sws = Read(reader, &value);
95 EXPECT_TRUE(sws.ok());
96 EXPECT_EQ(sws.size(), 2u);
97 EXPECT_EQ(value, 64);
98 }
99
100 {
101 const auto buffer = MakeBuffer("\x81\x01");
102 stream::MemoryReader reader(buffer);
103 const auto sws = Read(reader, &value);
104 EXPECT_TRUE(sws.ok());
105 EXPECT_EQ(sws.size(), 2u);
106 EXPECT_EQ(value, -65);
107 }
108
109 {
110 const auto buffer = MakeBuffer("\x82\x01");
111 stream::MemoryReader reader(buffer);
112 const auto sws = Read(reader, &value);
113 EXPECT_TRUE(sws.ok());
114 EXPECT_EQ(sws.size(), 2u);
115 EXPECT_EQ(value, 65);
116 }
117
118 {
119 const auto buffer = MakeBuffer("\xff\xff\xff\xff\x0f");
120 stream::MemoryReader reader(buffer);
121 const auto sws = Read(reader, &value);
122 EXPECT_TRUE(sws.ok());
123 EXPECT_EQ(sws.size(), 5u);
124 EXPECT_EQ(value, std::numeric_limits<int32_t>::min());
125 }
126
127 {
128 const auto buffer = MakeBuffer("\xfe\xff\xff\xff\x0f");
129 stream::MemoryReader reader(buffer);
130 const auto sws = Read(reader, &value);
131 EXPECT_TRUE(sws.ok());
132 EXPECT_EQ(sws.size(), 5u);
133 EXPECT_EQ(value, std::numeric_limits<int32_t>::max());
134 }
135
136 {
137 const auto buffer = MakeBuffer("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01");
138 stream::MemoryReader reader(buffer);
139 const auto sws = Read(reader, &value);
140 EXPECT_TRUE(sws.ok());
141 EXPECT_EQ(sws.size(), 10u);
142 EXPECT_EQ(value, std::numeric_limits<int64_t>::min());
143 }
144
145 {
146 const auto buffer = MakeBuffer("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01");
147 stream::MemoryReader reader(buffer);
148 const auto sws = Read(reader, &value);
149 EXPECT_TRUE(sws.ok());
150 EXPECT_EQ(sws.size(), 10u);
151 EXPECT_EQ(value, std::numeric_limits<int64_t>::max());
152 }
153 }
154
TEST(VarintRead,Unsigned64_SingleByte)155 TEST(VarintRead, Unsigned64_SingleByte) {
156 uint64_t value = 1234;
157
158 {
159 const auto buffer = MakeBuffer("\x00");
160 stream::MemoryReader reader(buffer);
161 const auto sws = Read(reader, &value);
162 EXPECT_TRUE(sws.ok());
163 EXPECT_EQ(sws.size(), 1u);
164 EXPECT_EQ(value, 0u);
165 }
166
167 {
168 const auto buffer = MakeBuffer("\x04");
169 stream::MemoryReader reader(buffer);
170 const auto sws = Read(reader, &value);
171 EXPECT_TRUE(sws.ok());
172 EXPECT_EQ(sws.size(), 1u);
173 EXPECT_EQ(value, 4u);
174 }
175
176 {
177 const auto buffer = MakeBuffer("\x41");
178 stream::MemoryReader reader(buffer);
179 const auto sws = Read(reader, &value);
180 EXPECT_TRUE(sws.ok());
181 EXPECT_EQ(sws.size(), 1u);
182 EXPECT_EQ(value, 65u);
183 }
184 }
185
TEST(VarintRead,Unsigned64_MultiByte)186 TEST(VarintRead, Unsigned64_MultiByte) {
187 uint64_t value = -1234;
188
189 {
190 const auto buffer = MakeBuffer("\x80\x01");
191 stream::MemoryReader reader(buffer);
192 const auto sws = Read(reader, &value);
193 EXPECT_TRUE(sws.ok());
194 EXPECT_EQ(sws.size(), 2u);
195 EXPECT_EQ(value, 128u);
196 }
197
198 {
199 const auto buffer = MakeBuffer("\x81\x01");
200 stream::MemoryReader reader(buffer);
201 const auto sws = Read(reader, &value);
202 EXPECT_TRUE(sws.ok());
203 EXPECT_EQ(sws.size(), 2u);
204 EXPECT_EQ(value, 129u);
205 }
206
207 {
208 const auto buffer = MakeBuffer("\xfe\xff\xff\xff\x0f");
209 stream::MemoryReader reader(buffer);
210 const auto sws = Read(reader, &value);
211 EXPECT_TRUE(sws.ok());
212 EXPECT_EQ(sws.size(), 5u);
213 EXPECT_EQ(value, std::numeric_limits<uint32_t>::max() - 1);
214 }
215
216 {
217 const auto buffer = MakeBuffer("\xff\xff\xff\xff\x0f");
218 stream::MemoryReader reader(buffer);
219 const auto sws = Read(reader, &value);
220 EXPECT_TRUE(sws.ok());
221 EXPECT_EQ(sws.size(), 5u);
222 EXPECT_EQ(value, std::numeric_limits<uint32_t>::max());
223 }
224
225 {
226 const auto buffer = MakeBuffer("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01");
227 stream::MemoryReader reader(buffer);
228 const auto sws = Read(reader, &value);
229 EXPECT_TRUE(sws.ok());
230 EXPECT_EQ(sws.size(), 10u);
231 EXPECT_EQ(value, std::numeric_limits<uint64_t>::max() - 1);
232 }
233
234 {
235 const auto buffer = MakeBuffer("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01");
236 stream::MemoryReader reader(buffer);
237 const auto sws = Read(reader, &value);
238 EXPECT_TRUE(sws.ok());
239 EXPECT_EQ(sws.size(), 10u);
240 EXPECT_EQ(value, std::numeric_limits<uint64_t>::max());
241 }
242 }
243
244 } // namespace pw::varint
245