1 //===- llvm/unittest/Support/DataExtractorTest.cpp - DataExtractor tests --===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "llvm/Support/DataExtractor.h"
10 #include "llvm/Testing/Support/Error.h"
11 #include "gtest/gtest.h"
12 using namespace llvm;
13
14 namespace {
15
16 const char numberData[] = "\x80\x90\xFF\xFF\x80\x00\x00\x00";
17 const char leb128data[] = "\xA6\x49";
18 const char bigleb128data[] = "\xAA\xA9\xFF\xAA\xFF\xAA\xFF\x4A";
19
TEST(DataExtractorTest,OffsetOverflow)20 TEST(DataExtractorTest, OffsetOverflow) {
21 DataExtractor DE(StringRef(numberData, sizeof(numberData)-1), false, 8);
22 EXPECT_FALSE(DE.isValidOffsetForDataOfSize(-2U, 5));
23 }
24
TEST(DataExtractorTest,UnsignedNumbers)25 TEST(DataExtractorTest, UnsignedNumbers) {
26 DataExtractor DE(StringRef(numberData, sizeof(numberData)-1), false, 8);
27 uint64_t offset = 0;
28
29 EXPECT_EQ(0x80U, DE.getU8(&offset));
30 EXPECT_EQ(1U, offset);
31 offset = 0;
32 EXPECT_EQ(0x8090U, DE.getU16(&offset));
33 EXPECT_EQ(2U, offset);
34 offset = 0;
35 EXPECT_EQ(0x8090FFFFU, DE.getU32(&offset));
36 EXPECT_EQ(4U, offset);
37 offset = 0;
38 EXPECT_EQ(0x8090FFFF80000000ULL, DE.getU64(&offset));
39 EXPECT_EQ(8U, offset);
40 offset = 0;
41 EXPECT_EQ(0x8090FFFF80000000ULL, DE.getAddress(&offset));
42 EXPECT_EQ(8U, offset);
43 offset = 0;
44
45 uint32_t data[2];
46 EXPECT_EQ(data, DE.getU32(&offset, data, 2));
47 EXPECT_EQ(0x8090FFFFU, data[0]);
48 EXPECT_EQ(0x80000000U, data[1]);
49 EXPECT_EQ(8U, offset);
50 offset = 0;
51
52 // Now for little endian.
53 DE = DataExtractor(StringRef(numberData, sizeof(numberData)-1), true, 4);
54 EXPECT_EQ(0x9080U, DE.getU16(&offset));
55 EXPECT_EQ(2U, offset);
56 offset = 0;
57 EXPECT_EQ(0xFFFF9080U, DE.getU32(&offset));
58 EXPECT_EQ(4U, offset);
59 offset = 0;
60 EXPECT_EQ(0x80FFFF9080ULL, DE.getU64(&offset));
61 EXPECT_EQ(8U, offset);
62 offset = 0;
63 EXPECT_EQ(0xFFFF9080U, DE.getAddress(&offset));
64 EXPECT_EQ(4U, offset);
65 offset = 0;
66
67 EXPECT_EQ(data, DE.getU32(&offset, data, 2));
68 EXPECT_EQ(0xFFFF9080U, data[0]);
69 EXPECT_EQ(0x80U, data[1]);
70 EXPECT_EQ(8U, offset);
71 }
72
TEST(DataExtractorTest,SignedNumbers)73 TEST(DataExtractorTest, SignedNumbers) {
74 DataExtractor DE(StringRef(numberData, sizeof(numberData)-1), false, 8);
75 uint64_t offset = 0;
76
77 EXPECT_EQ(-128, DE.getSigned(&offset, 1));
78 EXPECT_EQ(1U, offset);
79 offset = 0;
80 EXPECT_EQ(-32624, DE.getSigned(&offset, 2));
81 EXPECT_EQ(2U, offset);
82 offset = 0;
83 EXPECT_EQ(-2137980929, DE.getSigned(&offset, 4));
84 EXPECT_EQ(4U, offset);
85 offset = 0;
86 EXPECT_EQ(-9182558167379214336LL, DE.getSigned(&offset, 8));
87 EXPECT_EQ(8U, offset);
88 }
89
TEST(DataExtractorTest,Strings)90 TEST(DataExtractorTest, Strings) {
91 const char stringData[] = "hellohello\0hello";
92 DataExtractor DE(StringRef(stringData, sizeof(stringData)-1), false, 8);
93 uint64_t offset = 0;
94
95 EXPECT_EQ(stringData, DE.getCStr(&offset));
96 EXPECT_EQ(11U, offset);
97 EXPECT_EQ(nullptr, DE.getCStr(&offset));
98 EXPECT_EQ(11U, offset);
99
100 DataExtractor::Cursor C(0);
101 EXPECT_EQ(stringData, DE.getCStr(C));
102 EXPECT_EQ(11U, C.tell());
103 EXPECT_EQ(nullptr, DE.getCStr(C));
104 EXPECT_EQ(11U, C.tell());
105 EXPECT_THAT_ERROR(
106 C.takeError(),
107 FailedWithMessage("no null terminated string at offset 0xb"));
108 }
109
TEST(DataExtractorTest,LEB128)110 TEST(DataExtractorTest, LEB128) {
111 DataExtractor DE(StringRef(leb128data, sizeof(leb128data)-1), false, 8);
112 uint64_t offset = 0;
113
114 EXPECT_EQ(9382ULL, DE.getULEB128(&offset));
115 EXPECT_EQ(2U, offset);
116 offset = 0;
117 EXPECT_EQ(-7002LL, DE.getSLEB128(&offset));
118 EXPECT_EQ(2U, offset);
119
120 DataExtractor BDE(StringRef(bigleb128data, sizeof(bigleb128data)-1), false,8);
121 offset = 0;
122 EXPECT_EQ(42218325750568106ULL, BDE.getULEB128(&offset));
123 EXPECT_EQ(8U, offset);
124 offset = 0;
125 EXPECT_EQ(-29839268287359830LL, BDE.getSLEB128(&offset));
126 EXPECT_EQ(8U, offset);
127 }
128
TEST(DataExtractorTest,LEB128_error)129 TEST(DataExtractorTest, LEB128_error) {
130 DataExtractor DE(StringRef("\x81"), false, 8);
131 uint64_t Offset = 0;
132 EXPECT_EQ(0U, DE.getULEB128(&Offset));
133 EXPECT_EQ(0U, Offset);
134
135 Offset = 0;
136 EXPECT_EQ(0U, DE.getSLEB128(&Offset));
137 EXPECT_EQ(0U, Offset);
138
139 DataExtractor::Cursor C(0);
140 EXPECT_EQ(0U, DE.getULEB128(C));
141 EXPECT_THAT_ERROR(
142 C.takeError(),
143 FailedWithMessage("unable to decode LEB128 at offset 0x00000000: "
144 "malformed uleb128, extends past end"));
145
146 C = DataExtractor::Cursor(0);
147 EXPECT_EQ(0U, DE.getSLEB128(C));
148 EXPECT_THAT_ERROR(
149 C.takeError(),
150 FailedWithMessage("unable to decode LEB128 at offset 0x00000000: "
151 "malformed sleb128, extends past end"));
152
153 // Show non-zero offsets are reported appropriately.
154 C = DataExtractor::Cursor(1);
155 EXPECT_EQ(0U, DE.getULEB128(C));
156 EXPECT_THAT_ERROR(
157 C.takeError(),
158 FailedWithMessage("unable to decode LEB128 at offset 0x00000001: "
159 "malformed uleb128, extends past end"));
160 }
161
TEST(DataExtractorTest,Cursor_tell)162 TEST(DataExtractorTest, Cursor_tell) {
163 DataExtractor DE(StringRef("AB"), false, 8);
164 DataExtractor::Cursor C(0);
165 // A successful read operation advances the cursor
166 EXPECT_EQ('A', DE.getU8(C));
167 EXPECT_EQ(1u, C.tell());
168
169 // An unsuccessful one doesn't.
170 EXPECT_EQ(0u, DE.getU16(C));
171 EXPECT_EQ(1u, C.tell());
172
173 // And neither do any subsequent operations.
174 EXPECT_EQ(0, DE.getU8(C));
175 EXPECT_EQ(1u, C.tell());
176
177 consumeError(C.takeError());
178 }
179
TEST(DataExtractorTest,Cursor_takeError)180 TEST(DataExtractorTest, Cursor_takeError) {
181 DataExtractor DE(StringRef("AB"), false, 8);
182 DataExtractor::Cursor C(0);
183 // Initially, the cursor is in the "success" state.
184 EXPECT_THAT_ERROR(C.takeError(), Succeeded());
185
186 // It remains "success" after a successful read.
187 EXPECT_EQ('A', DE.getU8(C));
188 EXPECT_THAT_ERROR(C.takeError(), Succeeded());
189
190 // An unsuccessful read sets the error state.
191 EXPECT_EQ(0u, DE.getU32(C));
192 EXPECT_THAT_ERROR(C.takeError(), Failed());
193
194 // Once set the error sticks until explicitly cleared.
195 EXPECT_EQ(0u, DE.getU32(C));
196 EXPECT_EQ(0, DE.getU8(C));
197 EXPECT_THAT_ERROR(C.takeError(), Failed());
198
199 // At which point reads can be succeed again.
200 EXPECT_EQ('B', DE.getU8(C));
201 EXPECT_THAT_ERROR(C.takeError(), Succeeded());
202 }
203
TEST(DataExtractorTest,Cursor_chaining)204 TEST(DataExtractorTest, Cursor_chaining) {
205 DataExtractor DE(StringRef("ABCD"), false, 8);
206 DataExtractor::Cursor C(0);
207
208 // Multiple reads can be chained without trigerring any assertions.
209 EXPECT_EQ('A', DE.getU8(C));
210 EXPECT_EQ('B', DE.getU8(C));
211 EXPECT_EQ('C', DE.getU8(C));
212 EXPECT_EQ('D', DE.getU8(C));
213 // And the error checked at the end.
214 EXPECT_THAT_ERROR(C.takeError(), Succeeded());
215 }
216
217 #if defined(GTEST_HAS_DEATH_TEST) && defined(_DEBUG)
TEST(DataExtractorDeathTest,Cursor)218 TEST(DataExtractorDeathTest, Cursor) {
219 DataExtractor DE(StringRef("AB"), false, 8);
220
221 // Even an unused cursor must be checked for errors:
222 EXPECT_DEATH(DataExtractor::Cursor(0),
223 "Success values must still be checked prior to being destroyed");
224
225 {
226 auto C = std::make_unique<DataExtractor::Cursor>(0);
227 EXPECT_EQ(0u, DE.getU32(*C));
228 // It must also be checked after an unsuccessful operation.
229 // destruction.
230 EXPECT_DEATH(C.reset(), "unexpected end of data");
231 EXPECT_THAT_ERROR(C->takeError(), Failed());
232 }
233 {
234 auto C = std::make_unique<DataExtractor::Cursor>(0);
235 EXPECT_EQ('A', DE.getU8(*C));
236 // Same goes for a successful one.
237 EXPECT_DEATH(
238 C.reset(),
239 "Success values must still be checked prior to being destroyed");
240 EXPECT_THAT_ERROR(C->takeError(), Succeeded());
241 }
242 {
243 auto C = std::make_unique<DataExtractor::Cursor>(0);
244 EXPECT_EQ('A', DE.getU8(*C));
245 EXPECT_EQ(0u, DE.getU32(*C));
246 // Even if a successful operation is followed by an unsuccessful one.
247 EXPECT_DEATH(C.reset(), "unexpected end of data");
248 EXPECT_THAT_ERROR(C->takeError(), Failed());
249 }
250 {
251 auto C = std::make_unique<DataExtractor::Cursor>(0);
252 EXPECT_EQ(0u, DE.getU32(*C));
253 EXPECT_EQ(0, DE.getU8(*C));
254 // Even if an unsuccessful operation is followed by one that would normally
255 // succeed.
256 EXPECT_DEATH(C.reset(), "unexpected end of data");
257 EXPECT_THAT_ERROR(C->takeError(), Failed());
258 }
259 }
260 #endif
261
TEST(DataExtractorTest,getU8_vector)262 TEST(DataExtractorTest, getU8_vector) {
263 DataExtractor DE(StringRef("AB"), false, 8);
264 DataExtractor::Cursor C(0);
265 SmallVector<uint8_t, 2> S;
266
267 DE.getU8(C, S, 4);
268 EXPECT_THAT_ERROR(C.takeError(), Failed());
269 EXPECT_EQ("", toStringRef(S));
270
271 DE.getU8(C, S, 2);
272 EXPECT_THAT_ERROR(C.takeError(), Succeeded());
273 EXPECT_EQ("AB", toStringRef(S));
274
275 C = DataExtractor::Cursor(0x47);
276 DE.getU8(C, S, 2);
277 EXPECT_THAT_ERROR(
278 C.takeError(),
279 FailedWithMessage("offset 0x47 is beyond the end of data at 0x2"));
280 }
281
TEST(DataExtractorTest,getU24)282 TEST(DataExtractorTest, getU24) {
283 DataExtractor DE(StringRef("ABCD"), false, 8);
284 DataExtractor::Cursor C(0);
285
286 EXPECT_EQ(0x414243u, DE.getU24(C));
287 EXPECT_EQ(0u, DE.getU24(C));
288 EXPECT_EQ(3u, C.tell());
289 EXPECT_THAT_ERROR(C.takeError(), Failed());
290 }
291
TEST(DataExtractorTest,skip)292 TEST(DataExtractorTest, skip) {
293 DataExtractor DE(StringRef("AB"), false, 8);
294 DataExtractor::Cursor C(0);
295
296 DE.skip(C, 4);
297 EXPECT_THAT_ERROR(C.takeError(), Failed());
298 EXPECT_EQ(0u, C.tell());
299
300 DE.skip(C, 2);
301 EXPECT_THAT_ERROR(C.takeError(), Succeeded());
302 EXPECT_EQ(2u, C.tell());
303 }
304
TEST(DataExtractorTest,eof)305 TEST(DataExtractorTest, eof) {
306 DataExtractor DE(StringRef("A"), false, 8);
307 DataExtractor::Cursor C(0);
308
309 EXPECT_FALSE(DE.eof(C));
310
311 EXPECT_EQ(0, DE.getU16(C));
312 EXPECT_FALSE(DE.eof(C));
313 EXPECT_THAT_ERROR(C.takeError(), Failed());
314
315 EXPECT_EQ('A', DE.getU8(C));
316 EXPECT_TRUE(DE.eof(C));
317 EXPECT_THAT_ERROR(C.takeError(), Succeeded());
318 }
319
TEST(DataExtractorTest,size)320 TEST(DataExtractorTest, size) {
321 uint8_t Data[] = {'A', 'B', 'C', 'D'};
322 DataExtractor DE1(StringRef(reinterpret_cast<char *>(Data), sizeof(Data)),
323 false, 8);
324 EXPECT_EQ(DE1.size(), sizeof(Data));
325 DataExtractor DE2(ArrayRef<uint8_t>(Data), false, 8);
326 EXPECT_EQ(DE2.size(), sizeof(Data));
327 }
328
TEST(DataExtractorTest,FixedLengthString)329 TEST(DataExtractorTest, FixedLengthString) {
330 const char Data[] = "hello\x00\x00\x00world \thola\x00";
331 DataExtractor DE(StringRef(Data, sizeof(Data)-1), false, 8);
332 uint64_t Offset = 0;
333 StringRef Str;
334 // Test extracting too many bytes doesn't modify Offset and returns None.
335 Str = DE.getFixedLengthString(&Offset, sizeof(Data));
336 EXPECT_TRUE(Str.empty());
337 EXPECT_EQ(Offset, 0u);
338
339 // Test extracting a fixed width C string with trailing NULL characters.
340 Str = DE.getFixedLengthString(&Offset, 8);
341 EXPECT_EQ(Offset, 8u);
342 EXPECT_EQ(Str.size(), 5u);
343 EXPECT_EQ(Str, "hello");
344 // Test extracting a fixed width C string with trailing space and tab
345 // characters.
346 Str = DE.getFixedLengthString(&Offset, 8, " \t");
347 EXPECT_EQ(Offset, 16u);
348 EXPECT_EQ(Str.size(), 5u);
349 EXPECT_EQ(Str, "world");
350 // Now extract a normal C string.
351 Str = DE.getCStrRef(&Offset);
352 EXPECT_EQ(Str.size(), 4u);
353 EXPECT_EQ(Str, "hola");
354 }
355
356
TEST(DataExtractorTest,GetBytes)357 TEST(DataExtractorTest, GetBytes) {
358 // Use data with an embedded NULL character for good measure.
359 const char Data[] = "\x01\x02\x00\x04";
360 StringRef Bytes(Data, sizeof(Data)-1);
361 DataExtractor DE(Bytes, false, 8);
362 uint64_t Offset = 0;
363 StringRef Str;
364 // Test extracting too many bytes doesn't modify Offset and returns None.
365 Str = DE.getBytes(&Offset, sizeof(Data));
366 EXPECT_TRUE(Str.empty());
367 EXPECT_EQ(Offset, 0u);
368 // Test extracting 4 bytes from the stream.
369 Str = DE.getBytes(&Offset, 4);
370 EXPECT_EQ(Offset, 4u);
371 EXPECT_EQ(Str.size(), 4u);
372 EXPECT_EQ(Str, Bytes);
373
374 DataExtractor::Cursor C(0);
375 EXPECT_EQ(StringRef("\x01\x02"), DE.getBytes(C, 2));
376 EXPECT_EQ(StringRef("\x00\x04", 2), DE.getBytes(C, 2));
377 EXPECT_EQ(StringRef(), DE.getBytes(C, 2));
378 EXPECT_EQ(StringRef(), DE.getBytes(C, 2));
379 EXPECT_EQ(4u, C.tell());
380 EXPECT_THAT_ERROR(C.takeError(), Failed());
381 }
382
383 }
384