Debian Codegraph @

llvm-project/lldb/unittests/SymbolFile/NativePDB/UdtRecordCompleterTests.cpp

raw
1 //===-- UdtRecordCompleterTests.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 "Plugins/SymbolFile/NativePDB/UdtRecordCompleter.h"
10 #include "gmock/gmock.h"
11 #include "gtest/gtest.h"
12
13 using namespace lldb_private::npdb;
14 using namespace llvm;
15
16 namespace {
17 using Member = UdtRecordCompleter::Member;
18 using MemberUP = std::unique_ptr<Member>;
19 using Record = UdtRecordCompleter::Record;
20
21 class WrappedMember {
22 public:
23 WrappedMember(const Member &obj) : m_obj(obj) {}
24
25 private:
26 const Member &m_obj;
27
28 friend bool operator==(const WrappedMember &lhs, const WrappedMember &rhs) {
29 return lhs.m_obj.kind == rhs.m_obj.kind &&
30 lhs.m_obj.name == rhs.m_obj.name &&
31 lhs.m_obj.bit_offset == rhs.m_obj.bit_offset &&
32 lhs.m_obj.bit_size == rhs.m_obj.bit_size &&
33 lhs.m_obj.base_offset == rhs.m_obj.base_offset &&
34 std::equal(lhs.m_obj.fields.begin(), lhs.m_obj.fields.end(),
35 rhs.m_obj.fields.begin(), rhs.m_obj.fields.end(),
36 [](const MemberUP &lhs, const MemberUP &rhs) {
37 return WrappedMember(*lhs) == WrappedMember(*rhs);
38 });
39 }
40
41 friend llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
42 const WrappedMember &w) {
43 os << llvm::formatv("Member{.kind={0}, .name=\"{1}\", .bit_offset={2}, "
44 ".bit_size={3}, .base_offset={4}, .fields=[",
45 w.m_obj.kind, w.m_obj.name, w.m_obj.bit_offset,
46 w.m_obj.bit_size, w.m_obj.base_offset);
47 llvm::ListSeparator sep;
48 for (auto &f : w.m_obj.fields)
49 os << sep << WrappedMember(*f);
50 return os << "]}";
51 }
52 };
53
54 class WrappedRecord {
55 public:
56 WrappedRecord(const Record &obj) : m_obj(obj) {}
57
58 private:
59 const Record &m_obj;
60
61 friend bool operator==(const WrappedRecord &lhs, const WrappedRecord &rhs) {
62 return lhs.m_obj.start_offset == rhs.m_obj.start_offset &&
63 std::equal(
64 lhs.m_obj.record.fields.begin(), lhs.m_obj.record.fields.end(),
65 rhs.m_obj.record.fields.begin(), rhs.m_obj.record.fields.end(),
66 [](const MemberUP &lhs, const MemberUP &rhs) {
67 return WrappedMember(*lhs) == WrappedMember(*rhs);
68 });
69 }
70
71 friend llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
72 const WrappedRecord &w) {
73 os << llvm::formatv("Record{.start_offset={0}, .record.fields=[",
74 w.m_obj.start_offset);
75 llvm::ListSeparator sep;
76 for (const MemberUP &f : w.m_obj.record.fields)
77 os << sep << WrappedMember(*f);
78 return os << "]}";
79 }
80 };
81
82 class UdtRecordCompleterRecordTests : public testing::Test {
83 protected:
84 Record record;
85
86 public:
87 void SetKind(Member::Kind kind) { record.record.kind = kind; }
88 void CollectMember(StringRef name, uint64_t byte_offset, uint64_t byte_size) {
89 record.CollectMember(name, byte_offset * 8, byte_size * 8,
90 clang::QualType(), lldb::eAccessPublic, 0);
91 }
92 void ConstructRecord() { record.ConstructRecord(); }
93 };
94 Member *AddField(Member *member, StringRef name, uint64_t byte_offset,
95 uint64_t byte_size, Member::Kind kind,
96 uint64_t base_offset = 0) {
97 auto field =
98 std::make_unique<Member>(name, byte_offset * 8, byte_size * 8,
99 clang::QualType(), lldb::eAccessPublic, 0);
100 field->kind = kind;
101 field->base_offset = base_offset;
102 member->fields.push_back(std::move(field));
103 return member->fields.back().get();
104 }
105 } // namespace
106
107 TEST_F(UdtRecordCompleterRecordTests, TestAnonymousUnionInStruct) {
108 SetKind(Member::Kind::Struct);
109 CollectMember("m1", 0, 4);
110 CollectMember("m2", 0, 4);
111 CollectMember("m3", 0, 1);
112 CollectMember("m4", 0, 8);
113 ConstructRecord();
114
115 // struct {
116 // union {
117 // m1;
118 // m2;
119 // m3;
120 // m4;
121 // };
122 // };
123 Record record;
124 record.start_offset = 0;
125 Member *u = AddField(&record.record, "", 0, 0, Member::Union);
126 AddField(u, "m1", 0, 4, Member::Field);
127 AddField(u, "m2", 0, 4, Member::Field);
128 AddField(u, "m3", 0, 1, Member::Field);
129 AddField(u, "m4", 0, 8, Member::Field);
130 EXPECT_EQ(WrappedRecord(this->record), WrappedRecord(record));
131 }
132
133 TEST_F(UdtRecordCompleterRecordTests, TestAnonymousUnionInUnion) {
134 SetKind(Member::Kind::Union);
135 CollectMember("m1", 0, 4);
136 CollectMember("m2", 0, 4);
137 CollectMember("m3", 0, 1);
138 CollectMember("m4", 0, 8);
139 ConstructRecord();
140
141 // union {
142 // m1;
143 // m2;
144 // m3;
145 // m4;
146 // };
147 Record record;
148 record.start_offset = 0;
149 AddField(&record.record, "m1", 0, 4, Member::Field);
150 AddField(&record.record, "m2", 0, 4, Member::Field);
151 AddField(&record.record, "m3", 0, 1, Member::Field);
152 AddField(&record.record, "m4", 0, 8, Member::Field);
153 EXPECT_EQ(WrappedRecord(this->record), WrappedRecord(record));
154 }
155
156 TEST_F(UdtRecordCompleterRecordTests, TestAnonymousStructInUnion) {
157 SetKind(Member::Kind::Union);
158 CollectMember("m1", 0, 4);
159 CollectMember("m2", 4, 4);
160 CollectMember("m3", 8, 1);
161 ConstructRecord();
162
163 // union {
164 // struct {
165 // m1;
166 // m2;
167 // m3;
168 // };
169 // };
170 Record record;
171 record.start_offset = 0;
172 Member *s = AddField(&record.record, "", 0, 0, Member::Kind::Struct);
173 AddField(s, "m1", 0, 4, Member::Field);
174 AddField(s, "m2", 4, 4, Member::Field);
175 AddField(s, "m3", 8, 1, Member::Field);
176 EXPECT_EQ(WrappedRecord(this->record), WrappedRecord(record));
177 }
178
179 TEST_F(UdtRecordCompleterRecordTests, TestNestedUnionStructInStruct) {
180 SetKind(Member::Kind::Struct);
181 CollectMember("m1", 0, 4);
182 CollectMember("m2", 0, 2);
183 CollectMember("m3", 0, 2);
184 CollectMember("m4", 2, 4);
185 CollectMember("m5", 3, 2);
186 ConstructRecord();
187
188 // struct {
189 // union {
190 // m1;
191 // struct {
192 // m2;
193 // m5;
194 // };
195 // struct {
196 // m3;
197 // m4;
198 // };
199 // };
200 // };
201 Record record;
202 record.start_offset = 0;
203 Member *u = AddField(&record.record, "", 0, 0, Member::Union);
204 AddField(u, "m1", 0, 4, Member::Field);
205 Member *s1 = AddField(u, "", 0, 0, Member::Struct);
206 Member *s2 = AddField(u, "", 0, 0, Member::Struct);
207 AddField(s1, "m2", 0, 2, Member::Field);
208 AddField(s1, "m5", 3, 2, Member::Field);
209 AddField(s2, "m3", 0, 2, Member::Field);
210 AddField(s2, "m4", 2, 4, Member::Field);
211 EXPECT_EQ(WrappedRecord(this->record), WrappedRecord(record));
212 }
213
214 TEST_F(UdtRecordCompleterRecordTests, TestNestedUnionStructInUnion) {
215 SetKind(Member::Kind::Union);
216 CollectMember("m1", 0, 4);
217 CollectMember("m2", 0, 2);
218 CollectMember("m3", 0, 2);
219 CollectMember("m4", 2, 4);
220 CollectMember("m5", 3, 2);
221 ConstructRecord();
222
223 // union {
224 // m1;
225 // struct {
226 // m2;
227 // m5;
228 // };
229 // struct {
230 // m3;
231 // m4;
232 // };
233 // };
234 Record record;
235 record.start_offset = 0;
236 AddField(&record.record, "m1", 0, 4, Member::Field);
237 Member *s1 = AddField(&record.record, "", 0, 0, Member::Struct);
238 Member *s2 = AddField(&record.record, "", 0, 0, Member::Struct);
239 AddField(s1, "m2", 0, 2, Member::Field);
240 AddField(s1, "m5", 3, 2, Member::Field);
241 AddField(s2, "m3", 0, 2, Member::Field);
242 AddField(s2, "m4", 2, 4, Member::Field);
243 EXPECT_EQ(WrappedRecord(this->record), WrappedRecord(record));
244 }