1 // Copyright 2024 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/containers/span_reader.h"
6
7 #include "testing/gmock/include/gmock/gmock.h"
8 #include "testing/gtest/include/gtest/gtest.h"
9
10 using testing::Optional;
11
12 namespace base {
13 namespace {
14
TEST(SpanReaderTest,Construct)15 TEST(SpanReaderTest, Construct) {
16 std::array<const int, 5u> kArray = {1, 2, 3, 4, 5};
17
18 auto r = SpanReader(base::span(kArray));
19 EXPECT_EQ(r.remaining(), 5u);
20 EXPECT_EQ(r.remaining_span().data(), &kArray[0u]);
21 EXPECT_EQ(r.remaining_span().size(), 5u);
22 }
23
TEST(SpanReaderTest,Skip)24 TEST(SpanReaderTest, Skip) {
25 std::array<const int, 5u> kArray = {1, 2, 3, 4, 5};
26
27 auto r = SpanReader(base::span(kArray));
28 EXPECT_EQ(r.num_read(), 0u);
29 EXPECT_FALSE(r.Skip(6u));
30 EXPECT_THAT(r.Skip(2u), Optional(base::span(kArray).first(2u)));
31 EXPECT_EQ(r.num_read(), 2u);
32 }
33
TEST(SpanReaderTest,Read)34 TEST(SpanReaderTest, Read) {
35 std::array<const int, 5u> kArray = {1, 2, 3, 4, 5};
36
37 auto r = SpanReader(base::span(kArray));
38 EXPECT_EQ(r.num_read(), 0u);
39 {
40 auto o = r.Read(2u);
41 static_assert(std::same_as<decltype(*o), span<const int>&>);
42 ASSERT_TRUE(o.has_value());
43 EXPECT_TRUE(*o == base::span(kArray).subspan(0u, 2u));
44 EXPECT_EQ(r.remaining(), 3u);
45 EXPECT_EQ(r.num_read(), 2u);
46 }
47 {
48 auto o = r.Read(5u);
49 static_assert(std::same_as<decltype(*o), span<const int>&>);
50 EXPECT_FALSE(o.has_value());
51 EXPECT_EQ(r.remaining(), 3u);
52 EXPECT_EQ(r.num_read(), 2u);
53 }
54 {
55 auto o = r.Read(1u);
56 static_assert(std::same_as<decltype(*o), span<const int>&>);
57 ASSERT_TRUE(o.has_value());
58 EXPECT_TRUE(*o == base::span(kArray).subspan(2u, 1u));
59 EXPECT_EQ(r.remaining(), 2u);
60 EXPECT_EQ(r.num_read(), 3u);
61 }
62 {
63 auto o = r.Read(2u);
64 static_assert(std::same_as<decltype(*o), span<const int>&>);
65 ASSERT_TRUE(o.has_value());
66 EXPECT_TRUE(*o == base::span(kArray).subspan(3u, 2u));
67 EXPECT_EQ(r.remaining(), 0u);
68 EXPECT_EQ(r.num_read(), 5u);
69 }
70 }
71
TEST(SpanReaderTest,ReadFixed)72 TEST(SpanReaderTest, ReadFixed) {
73 std::array<const int, 5u> kArray = {1, 2, 3, 4, 5};
74
75 auto r = SpanReader(base::span(kArray));
76 {
77 auto o = r.Read<2u>();
78 static_assert(std::same_as<decltype(*o), span<const int, 2u>&>);
79 ASSERT_TRUE(o.has_value());
80 EXPECT_TRUE(*o == base::span(kArray).subspan(0u, 2u));
81 EXPECT_EQ(r.remaining(), 3u);
82 }
83 {
84 auto o = r.Read<5u>();
85 static_assert(std::same_as<decltype(*o), span<const int, 5u>&>);
86 EXPECT_FALSE(o.has_value());
87 EXPECT_EQ(r.remaining(), 3u);
88 }
89 {
90 auto o = r.Read<1u>();
91 static_assert(std::same_as<decltype(*o), span<const int, 1u>&>);
92 ASSERT_TRUE(o.has_value());
93 EXPECT_TRUE(*o == base::span(kArray).subspan(2u, 1u));
94 EXPECT_EQ(r.remaining(), 2u);
95 }
96 {
97 auto o = r.Read<2u>();
98 static_assert(std::same_as<decltype(*o), span<const int, 2u>&>);
99 ASSERT_TRUE(o.has_value());
100 EXPECT_TRUE(*o == base::span(kArray).subspan(3u, 2u));
101 EXPECT_EQ(r.remaining(), 0u);
102 }
103 }
104
TEST(SpanReaderTest,ReadInto)105 TEST(SpanReaderTest, ReadInto) {
106 std::array<const int, 5u> kArray = {1, 2, 3, 4, 5};
107
108 auto r = SpanReader(base::span(kArray));
109 {
110 base::span<const int> s;
111 EXPECT_TRUE(r.ReadInto(2u, s));
112 EXPECT_TRUE(s == base::span(kArray).subspan(0u, 2u));
113 EXPECT_EQ(r.remaining(), 3u);
114 }
115 {
116 base::span<const int> s;
117 EXPECT_FALSE(r.ReadInto(5u, s));
118 EXPECT_EQ(r.remaining(), 3u);
119 }
120 {
121 base::span<const int> s;
122 EXPECT_TRUE(r.ReadInto(1u, s));
123 EXPECT_TRUE(s == base::span(kArray).subspan(2u, 1u));
124 EXPECT_EQ(r.remaining(), 2u);
125 }
126 {
127 base::span<const int> s;
128 EXPECT_TRUE(r.ReadInto(2u, s));
129 EXPECT_TRUE(s == base::span(kArray).subspan(3u, 2u));
130 EXPECT_EQ(r.remaining(), 0u);
131 }
132 }
133
TEST(SpanReaderTest,ReadCopy)134 TEST(SpanReaderTest, ReadCopy) {
135 std::array<const int, 5u> kArray = {1, 2, 3, 4, 5};
136
137 auto r = SpanReader(base::span(kArray));
138 {
139 std::array<int, 2u> s;
140 EXPECT_TRUE(r.ReadCopy(s));
141 EXPECT_TRUE(s == base::span(kArray).subspan(0u, 2u));
142 EXPECT_EQ(r.remaining(), 3u);
143 }
144 {
145 std::array<int, 5u> s;
146 EXPECT_FALSE(r.ReadCopy(s));
147 EXPECT_EQ(r.remaining(), 3u);
148 }
149 {
150 std::array<int, 1u> s;
151 EXPECT_TRUE(r.ReadCopy(s));
152 EXPECT_TRUE(s == base::span(kArray).subspan(2u, 1u));
153 EXPECT_EQ(r.remaining(), 2u);
154 }
155 {
156 std::array<int, 2u> s;
157 EXPECT_TRUE(r.ReadCopy(s));
158 EXPECT_TRUE(s == base::span(kArray).subspan(3u, 2u));
159 EXPECT_EQ(r.remaining(), 0u);
160 }
161 }
162
TEST(SpanReaderTest,ReadBigEndian)163 TEST(SpanReaderTest, ReadBigEndian) {
164 const std::array<uint8_t, 5u> kArray = {uint8_t{1}, uint8_t{2}, uint8_t{3},
165 uint8_t{4}, uint8_t{5}};
166
167 {
168 uint8_t val;
169
170 auto r = SpanReader(base::span(kArray));
171 EXPECT_TRUE(r.Skip(1u));
172 EXPECT_TRUE(r.ReadU8BigEndian(val));
173 EXPECT_EQ(r.remaining(), 3u);
174 EXPECT_EQ(val, 0x02u);
175 }
176
177 {
178 uint16_t val;
179
180 auto r = SpanReader(base::span(kArray));
181 EXPECT_TRUE(r.Skip(1u));
182 EXPECT_TRUE(r.ReadU16BigEndian(val));
183 EXPECT_EQ(r.remaining(), 2u);
184 EXPECT_EQ(val, 0x0203u);
185 }
186
187 {
188 uint32_t val;
189
190 auto r = SpanReader(base::span(kArray));
191 EXPECT_TRUE(r.Skip(1u));
192 EXPECT_TRUE(r.ReadU32BigEndian(val));
193 EXPECT_EQ(r.remaining(), 0u);
194 EXPECT_EQ(val, 0x02030405u);
195 }
196
197 std::array<uint8_t, 9u> kBigArray = {uint8_t{1}, uint8_t{2}, uint8_t{3},
198 uint8_t{4}, uint8_t{5}, uint8_t{6},
199 uint8_t{7}, uint8_t{8}, uint8_t{9}};
200
201 {
202 uint64_t val;
203
204 auto r = SpanReader(base::span(kBigArray));
205 EXPECT_TRUE(r.Skip(1u));
206 EXPECT_TRUE(r.ReadU64BigEndian(val));
207 EXPECT_EQ(r.remaining(), 0u);
208 EXPECT_EQ(val, 0x0203040506070809llu);
209 }
210 }
211
TEST(SpanReaderTest,ReadLittleEndian)212 TEST(SpanReaderTest, ReadLittleEndian) {
213 const std::array<uint8_t, 5u> kArray = {uint8_t{1}, uint8_t{2}, uint8_t{3},
214 uint8_t{4}, uint8_t{5}};
215
216 {
217 uint8_t val;
218
219 auto r = SpanReader(base::span(kArray));
220 EXPECT_TRUE(r.Skip(1u));
221 EXPECT_TRUE(r.ReadU8LittleEndian(val));
222 EXPECT_EQ(r.remaining(), 3u);
223 EXPECT_EQ(val, 0x02u);
224 }
225
226 {
227 uint16_t val;
228
229 auto r = SpanReader(base::span(kArray));
230 EXPECT_TRUE(r.Skip(1u));
231 EXPECT_TRUE(r.ReadU16LittleEndian(val));
232 EXPECT_EQ(r.remaining(), 2u);
233 EXPECT_EQ(val, 0x0302u);
234 }
235
236 {
237 uint32_t val;
238
239 auto r = SpanReader(base::span(kArray));
240 EXPECT_TRUE(r.Skip(1u));
241 EXPECT_TRUE(r.ReadU32LittleEndian(val));
242 EXPECT_EQ(r.remaining(), 0u);
243 EXPECT_EQ(val, 0x05040302u);
244 }
245
246 std::array<uint8_t, 9u> kBigArray = {uint8_t{1}, uint8_t{2}, uint8_t{3},
247 uint8_t{4}, uint8_t{5}, uint8_t{6},
248 uint8_t{7}, uint8_t{8}, uint8_t{9}};
249
250 {
251 uint64_t val;
252
253 auto r = SpanReader(base::span(kBigArray));
254 EXPECT_TRUE(r.Skip(1u));
255 EXPECT_TRUE(r.ReadU64LittleEndian(val));
256 EXPECT_EQ(r.remaining(), 0u);
257 EXPECT_EQ(val, 0x0908070605040302llu);
258 }
259 }
260
TEST(SpanReaderTest,ReadNativeEndian)261 TEST(SpanReaderTest, ReadNativeEndian) {
262 const std::array<uint8_t, 5u> kArray = {uint8_t{1}, uint8_t{2}, uint8_t{3},
263 uint8_t{4}, uint8_t{5}};
264
265 {
266 uint8_t val;
267
268 auto r = SpanReader(base::span(kArray));
269 EXPECT_TRUE(r.Skip(1u));
270 EXPECT_TRUE(r.ReadU8NativeEndian(val));
271 EXPECT_EQ(r.remaining(), 3u);
272 EXPECT_EQ(val, 0x02u);
273 }
274
275 {
276 uint16_t val;
277
278 auto r = SpanReader(base::span(kArray));
279 EXPECT_TRUE(r.Skip(1u));
280 EXPECT_TRUE(r.ReadU16NativeEndian(val));
281 EXPECT_EQ(r.remaining(), 2u);
282 EXPECT_EQ(val, 0x0302u);
283 }
284
285 {
286 uint32_t val;
287
288 auto r = SpanReader(base::span(kArray));
289 EXPECT_TRUE(r.Skip(1u));
290 EXPECT_TRUE(r.ReadU32NativeEndian(val));
291 EXPECT_EQ(r.remaining(), 0u);
292 EXPECT_EQ(val, 0x05040302u);
293 }
294
295 std::array<uint8_t, 9u> kBigArray = {uint8_t{1}, uint8_t{2}, uint8_t{3},
296 uint8_t{4}, uint8_t{5}, uint8_t{6},
297 uint8_t{7}, uint8_t{8}, uint8_t{9}};
298
299 {
300 uint64_t val;
301
302 auto r = SpanReader(base::span(kBigArray));
303 EXPECT_TRUE(r.Skip(1u));
304 EXPECT_TRUE(r.ReadU64NativeEndian(val));
305 EXPECT_EQ(r.remaining(), 0u);
306 EXPECT_EQ(val, 0x0908070605040302llu);
307 }
308 }
309
TEST(SpanReaderTest,ReadChar)310 TEST(SpanReaderTest, ReadChar) {
311 std::array<const uint8_t, 5u> kArray = {uint8_t{1}, uint8_t{2}, uint8_t{3},
312 uint8_t{4}, uint8_t{5}};
313
314 auto r = SpanReader(base::span(kArray));
315 EXPECT_EQ(r.num_read(), 0u);
316
317 char c;
318 EXPECT_TRUE(r.ReadChar(c));
319 EXPECT_EQ(c, char{1});
320 EXPECT_TRUE(r.Skip(3u));
321 EXPECT_TRUE(r.ReadChar(c));
322 EXPECT_EQ(c, char{5});
323 EXPECT_FALSE(r.ReadChar(c));
324 EXPECT_EQ(c, char{5});
325 }
326
327 } // namespace
328 } // namespace base
329