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