1 //===-- DataExtractorTest.cpp ---------------------------------------------===// 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 "gtest/gtest.h" 10 11 #include "lldb/Utility/DataExtractor.h" 12 13 using namespace lldb_private; 14 15 TEST(DataExtractorTest, GetBitfield) { 16 uint8_t buffer[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}; 17 DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle, 18 sizeof(void *)); 19 DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *)); 20 21 lldb::offset_t offset; 22 23 offset = 0; 24 ASSERT_EQ(buffer[1], LE.GetMaxU64Bitfield(&offset, sizeof(buffer), 8, 8)); 25 offset = 0; 26 ASSERT_EQ(buffer[1], BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 8, 8)); 27 offset = 0; 28 ASSERT_EQ(static_cast<uint64_t>(0x0123456789ABCDEF), 29 BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 64, 0)); 30 offset = 0; 31 ASSERT_EQ(static_cast<uint64_t>(0x01234567), 32 BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 32, 0)); 33 offset = 0; 34 ASSERT_EQ(static_cast<uint64_t>(0x012345678), 35 BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 36, 0)); 36 37 offset = 0; 38 ASSERT_EQ(int8_t(buffer[1]), 39 LE.GetMaxS64Bitfield(&offset, sizeof(buffer), 8, 8)); 40 offset = 0; 41 ASSERT_EQ(int8_t(buffer[1]), 42 BE.GetMaxS64Bitfield(&offset, sizeof(buffer), 8, 8)); 43 } 44 45 TEST(DataExtractorTest, PeekData) { 46 uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04}; 47 DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4); 48 49 EXPECT_EQ(buffer + 0, E.PeekData(0, 0)); 50 EXPECT_EQ(buffer + 0, E.PeekData(0, 4)); 51 EXPECT_EQ(nullptr, E.PeekData(0, 5)); 52 53 EXPECT_EQ(buffer + 2, E.PeekData(2, 0)); 54 EXPECT_EQ(buffer + 2, E.PeekData(2, 2)); 55 EXPECT_EQ(nullptr, E.PeekData(2, 3)); 56 57 EXPECT_EQ(buffer + 4, E.PeekData(4, 0)); 58 EXPECT_EQ(nullptr, E.PeekData(4, 1)); 59 } 60 61 TEST(DataExtractorTest, GetCStr) { 62 uint8_t buffer[] = {'X', 'f', 'o', 'o', '\0'}; 63 DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4); 64 65 lldb::offset_t offset = 1; 66 EXPECT_STREQ("foo", E.GetCStr(&offset)); 67 EXPECT_EQ(5U, offset); 68 } 69 70 TEST(DataExtractorTest, GetCStrEmpty) { 71 uint8_t buffer[] = {'X', '\0'}; 72 DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4); 73 74 lldb::offset_t offset = 1; 75 EXPECT_STREQ("", E.GetCStr(&offset)); 76 EXPECT_EQ(2U, offset); 77 } 78 79 TEST(DataExtractorTest, GetCStrUnterminated) { 80 uint8_t buffer[] = {'X', 'f', 'o', 'o'}; 81 DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4); 82 83 lldb::offset_t offset = 1; 84 EXPECT_EQ(nullptr, E.GetCStr(&offset)); 85 EXPECT_EQ(1U, offset); 86 } 87 88 TEST(DataExtractorTest, GetCStrAtEnd) { 89 uint8_t buffer[] = {'X'}; 90 DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4); 91 92 lldb::offset_t offset = 1; 93 EXPECT_EQ(nullptr, E.GetCStr(&offset)); 94 EXPECT_EQ(1U, offset); 95 } 96 97 TEST(DataExtractorTest, GetCStrAtNullOffset) { 98 uint8_t buffer[] = {'f', 'o', 'o', '\0'}; 99 DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4); 100 101 lldb::offset_t offset = 0; 102 EXPECT_STREQ("foo", E.GetCStr(&offset)); 103 EXPECT_EQ(4U, offset); 104 } 105 106 TEST(DataExtractorTest, GetMaxU64) { 107 uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}; 108 DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle, 109 sizeof(void *)); 110 DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *)); 111 112 lldb::offset_t offset; 113 114 // Check with the minimum allowed byte size. 115 offset = 0; 116 EXPECT_EQ(0x01U, LE.GetMaxU64(&offset, 1)); 117 EXPECT_EQ(1U, offset); 118 offset = 0; 119 EXPECT_EQ(0x01U, BE.GetMaxU64(&offset, 1)); 120 EXPECT_EQ(1U, offset); 121 122 // Check with a non-zero offset. 123 offset = 1; 124 EXPECT_EQ(0x0302U, LE.GetMaxU64(&offset, 2)); 125 EXPECT_EQ(3U, offset); 126 offset = 1; 127 EXPECT_EQ(0x0203U, BE.GetMaxU64(&offset, 2)); 128 EXPECT_EQ(3U, offset); 129 130 // Check with the byte size not being a multiple of 2. 131 offset = 0; 132 EXPECT_EQ(0x07060504030201U, LE.GetMaxU64(&offset, 7)); 133 EXPECT_EQ(7U, offset); 134 offset = 0; 135 EXPECT_EQ(0x01020304050607U, BE.GetMaxU64(&offset, 7)); 136 EXPECT_EQ(7U, offset); 137 138 // Check with the maximum allowed byte size. 139 offset = 0; 140 EXPECT_EQ(0x0807060504030201U, LE.GetMaxU64(&offset, 8)); 141 EXPECT_EQ(8U, offset); 142 offset = 0; 143 EXPECT_EQ(0x0102030405060708U, BE.GetMaxU64(&offset, 8)); 144 EXPECT_EQ(8U, offset); 145 } 146 147 TEST(DataExtractorTest, GetMaxS64) { 148 uint8_t buffer[] = {0x01, 0x02, 0x83, 0x04, 0x05, 0x06, 0x07, 0x08}; 149 DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle, 150 sizeof(void *)); 151 DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *)); 152 153 lldb::offset_t offset; 154 155 // Check with the minimum allowed byte size. 156 offset = 0; 157 EXPECT_EQ(0x01, LE.GetMaxS64(&offset, 1)); 158 EXPECT_EQ(1U, offset); 159 offset = 0; 160 EXPECT_EQ(0x01, BE.GetMaxS64(&offset, 1)); 161 EXPECT_EQ(1U, offset); 162 163 // Check that sign extension works correctly. 164 offset = 0; 165 int64_t value = LE.GetMaxS64(&offset, 3); 166 EXPECT_EQ(0xffffffffff830201U, *reinterpret_cast<uint64_t *>(&value)); 167 EXPECT_EQ(3U, offset); 168 offset = 2; 169 value = BE.GetMaxS64(&offset, 3); 170 EXPECT_EQ(0xffffffffff830405U, *reinterpret_cast<uint64_t *>(&value)); 171 EXPECT_EQ(5U, offset); 172 173 // Check with the maximum allowed byte size. 174 offset = 0; 175 EXPECT_EQ(0x0807060504830201, LE.GetMaxS64(&offset, 8)); 176 EXPECT_EQ(8U, offset); 177 offset = 0; 178 EXPECT_EQ(0x0102830405060708, BE.GetMaxS64(&offset, 8)); 179 EXPECT_EQ(8U, offset); 180 } 181 182 TEST(DataExtractorTest, GetMaxU64_unchecked) { 183 uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}; 184 DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle, 185 sizeof(void *)); 186 DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *)); 187 188 lldb::offset_t offset; 189 190 // Check with the minimum allowed byte size. 191 offset = 0; 192 EXPECT_EQ(0x01U, LE.GetMaxU64_unchecked(&offset, 1)); 193 EXPECT_EQ(1U, offset); 194 offset = 0; 195 EXPECT_EQ(0x01U, BE.GetMaxU64_unchecked(&offset, 1)); 196 EXPECT_EQ(1U, offset); 197 198 // Check with a non-zero offset. 199 offset = 1; 200 EXPECT_EQ(0x0302U, LE.GetMaxU64_unchecked(&offset, 2)); 201 EXPECT_EQ(3U, offset); 202 offset = 1; 203 EXPECT_EQ(0x0203U, BE.GetMaxU64_unchecked(&offset, 2)); 204 EXPECT_EQ(3U, offset); 205 206 // Check with the byte size not being a multiple of 2. 207 offset = 0; 208 EXPECT_EQ(0x07060504030201U, LE.GetMaxU64_unchecked(&offset, 7)); 209 EXPECT_EQ(7U, offset); 210 offset = 0; 211 EXPECT_EQ(0x01020304050607U, BE.GetMaxU64_unchecked(&offset, 7)); 212 EXPECT_EQ(7U, offset); 213 214 // Check with the maximum allowed byte size. 215 offset = 0; 216 EXPECT_EQ(0x0807060504030201U, LE.GetMaxU64_unchecked(&offset, 8)); 217 EXPECT_EQ(8U, offset); 218 offset = 0; 219 EXPECT_EQ(0x0102030405060708U, BE.GetMaxU64_unchecked(&offset, 8)); 220 EXPECT_EQ(8U, offset); 221 } 222