1 //===-- CppModuleConfigurationTest.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/ExpressionParser/Clang/CppModuleConfiguration.h"
10 #include "Plugins/ExpressionParser/Clang/ClangHost.h"
11 #include "TestingSupport/SubsystemRAII.h"
12 #include "lldb/Host/FileSystem.h"
13 #include "lldb/Host/HostInfo.h"
14
15 #include "gmock/gmock.h"
16 #include "gtest/gtest.h"
17
18 using namespace lldb_private;
19
20 namespace {
21 struct CppModuleConfigurationTest : public testing::Test {
22 llvm::MemoryBufferRef m_empty_buffer;
23 llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> m_fs;
24
CppModuleConfigurationTest__anon79d508220111::CppModuleConfigurationTest25 CppModuleConfigurationTest()
26 : m_empty_buffer("", "<empty buffer>"),
27 m_fs(new llvm::vfs::InMemoryFileSystem()) {}
28
SetUp__anon79d508220111::CppModuleConfigurationTest29 void SetUp() override {
30 FileSystem::Initialize(m_fs);
31 HostInfo::Initialize();
32 }
33
TearDown__anon79d508220111::CppModuleConfigurationTest34 void TearDown() override {
35 HostInfo::Terminate();
36 FileSystem::Terminate();
37 }
38
39 /// Utility function turning a list of paths into a FileSpecList.
makeFiles__anon79d508220111::CppModuleConfigurationTest40 FileSpecList makeFiles(llvm::ArrayRef<std::string> paths) {
41 FileSpecList result;
42 for (const std::string &path : paths) {
43 result.Append(FileSpec(path, FileSpec::Style::posix));
44 if (!m_fs->addFileNoOwn(path, static_cast<time_t>(0), m_empty_buffer))
45 llvm_unreachable("Invalid test configuration?");
46 }
47 return result;
48 }
49 };
50 } // namespace
51
52 /// Returns the Clang resource include directory.
ResourceInc()53 static std::string ResourceInc() {
54 llvm::SmallString<256> resource_dir;
55 llvm::sys::path::append(resource_dir, GetClangResourceDir().GetPath(),
56 "include");
57 return std::string(resource_dir);
58 }
59
TEST_F(CppModuleConfigurationTest,Linux)60 TEST_F(CppModuleConfigurationTest, Linux) {
61 // Test the average Linux configuration.
62
63 std::string usr = "/usr/include";
64 std::string libcpp = "/usr/include/c++/v1";
65 std::vector<std::string> files = {// C library
66 usr + "/stdio.h",
67 // C++ library
68 libcpp + "/vector",
69 libcpp + "/module.modulemap"};
70 CppModuleConfiguration config(makeFiles(files), llvm::Triple());
71 EXPECT_THAT(config.GetImportedModules(), testing::ElementsAre("std"));
72 EXPECT_THAT(config.GetIncludeDirs(),
73 testing::ElementsAre(libcpp, ResourceInc(), usr));
74 }
75
TEST_F(CppModuleConfigurationTest,LinuxTargetSpecificInclude)76 TEST_F(CppModuleConfigurationTest, LinuxTargetSpecificInclude) {
77 // Test the average Linux configuration.
78
79 std::string usr = "/usr/include";
80 std::string usr_target = "/usr/include/x86_64-linux-gnu";
81 std::string libcpp = "/usr/include/c++/v1";
82 std::string libcpp_target = "/usr/include/x86_64-unknown-linux-gnu/c++/v1";
83 std::vector<std::string> files = {
84 // C library
85 usr + "/stdio.h", usr_target + "/sys/cdefs.h",
86 // C++ library
87 libcpp + "/vector", libcpp + "/module.modulemap"};
88 CppModuleConfiguration config(makeFiles(files),
89 llvm::Triple("x86_64-unknown-linux-gnu"));
90 EXPECT_THAT(config.GetImportedModules(), testing::ElementsAre("std"));
91 EXPECT_THAT(config.GetIncludeDirs(),
92 testing::ElementsAre(libcpp, ResourceInc(), usr, usr_target,
93 libcpp_target));
94 }
95
TEST_F(CppModuleConfigurationTest,Sysroot)96 TEST_F(CppModuleConfigurationTest, Sysroot) {
97 // Test that having a sysroot for the whole system works fine.
98
99 std::string libcpp = "/home/user/sysroot/usr/include/c++/v1";
100 std::string usr = "/home/user/sysroot/usr/include";
101 std::vector<std::string> files = {// C library
102 usr + "/stdio.h",
103 // C++ library
104 libcpp + "/vector",
105 libcpp + "/module.modulemap"};
106 CppModuleConfiguration config(makeFiles(files), llvm::Triple());
107 EXPECT_THAT(config.GetImportedModules(), testing::ElementsAre("std"));
108 EXPECT_THAT(config.GetIncludeDirs(),
109 testing::ElementsAre(libcpp, ResourceInc(), usr));
110 }
111
TEST_F(CppModuleConfigurationTest,LinuxLocalLibCpp)112 TEST_F(CppModuleConfigurationTest, LinuxLocalLibCpp) {
113 // Test that a locally build libc++ is detected.
114
115 std::string usr = "/usr/include";
116 std::string libcpp = "/home/user/llvm-build/include/c++/v1";
117 std::vector<std::string> files = {// C library
118 usr + "/stdio.h",
119 // C++ library
120 libcpp + "/vector",
121 libcpp + "/module.modulemap"};
122 CppModuleConfiguration config(makeFiles(files), llvm::Triple());
123 EXPECT_THAT(config.GetImportedModules(), testing::ElementsAre("std"));
124 EXPECT_THAT(config.GetIncludeDirs(),
125 testing::ElementsAre(libcpp, ResourceInc(), usr));
126 }
127
TEST_F(CppModuleConfigurationTest,UnrelatedLibrary)128 TEST_F(CppModuleConfigurationTest, UnrelatedLibrary) {
129 // Test that having an unrelated library in /usr/include doesn't break.
130
131 std::string usr = "/usr/include";
132 std::string libcpp = "/home/user/llvm-build/include/c++/v1";
133 std::vector<std::string> files = {// C library
134 usr + "/stdio.h",
135 // unrelated library
136 usr + "/boost/vector",
137 // C++ library
138 libcpp + "/vector",
139 libcpp + "/module.modulemap"};
140 CppModuleConfiguration config(makeFiles(files), llvm::Triple());
141 EXPECT_THAT(config.GetImportedModules(), testing::ElementsAre("std"));
142 EXPECT_THAT(config.GetIncludeDirs(),
143 testing::ElementsAre(libcpp, ResourceInc(), usr));
144 }
145
TEST_F(CppModuleConfigurationTest,UnrelatedLibraryWithTargetSpecificInclude)146 TEST_F(CppModuleConfigurationTest, UnrelatedLibraryWithTargetSpecificInclude) {
147 // Test that having an unrelated library in /usr/include doesn't break.
148
149 std::string usr = "/usr/include";
150 std::string libcpp = "/home/user/llvm-build/include/c++/v1";
151 std::string libcpp_target =
152 "/home/user/llvm-build/include/x86_64-unknown-linux-gnu/c++/v1";
153 std::vector<std::string> files = {// C library
154 usr + "/stdio.h",
155 // unrelated library
156 usr + "/boost/vector",
157 // C++ library
158 libcpp + "/vector",
159 libcpp + "/module.modulemap"};
160 CppModuleConfiguration config(makeFiles(files),
161 llvm::Triple("x86_64-unknown-linux-gnu"));
162 EXPECT_THAT(config.GetImportedModules(), testing::ElementsAre("std"));
163 EXPECT_THAT(config.GetIncludeDirs(),
164 testing::ElementsAre(libcpp, ResourceInc(), usr, libcpp_target));
165 }
166
TEST_F(CppModuleConfigurationTest,Xcode)167 TEST_F(CppModuleConfigurationTest, Xcode) {
168 // Test detection of libc++ coming from Xcode with generic platform names.
169
170 std::string p = "/Applications/Xcode.app/Contents/Developer/";
171 std::string libcpp = p + "Toolchains/B.xctoolchain/usr/include/c++/v1";
172 std::string usr =
173 p + "Platforms/A.platform/Developer/SDKs/OSVers.sdk/usr/include";
174 std::vector<std::string> files = {
175 // C library
176 usr + "/stdio.h",
177 // C++ library
178 libcpp + "/vector",
179 libcpp + "/module.modulemap",
180 };
181 CppModuleConfiguration config(makeFiles(files), llvm::Triple());
182 EXPECT_THAT(config.GetImportedModules(), testing::ElementsAre("std"));
183 EXPECT_THAT(config.GetIncludeDirs(),
184 testing::ElementsAre(libcpp, ResourceInc(), usr));
185 }
186
TEST_F(CppModuleConfigurationTest,LibCppV2)187 TEST_F(CppModuleConfigurationTest, LibCppV2) {
188 // Test that a "v2" of libc++ is still correctly detected.
189
190 std::string libcpp = "/usr/include/c++/v2";
191 std::vector<std::string> files = {// C library
192 "/usr/include/stdio.h",
193 // C++ library
194 libcpp + "/vector",
195 libcpp + "/module.modulemap"};
196 CppModuleConfiguration config(makeFiles(files), llvm::Triple());
197 EXPECT_THAT(config.GetImportedModules(), testing::ElementsAre("std"));
198 EXPECT_THAT(config.GetIncludeDirs(),
199 testing::ElementsAre("/usr/include/c++/v2", ResourceInc(),
200 "/usr/include"));
201 }
202
TEST_F(CppModuleConfigurationTest,UnknownLibCppFile)203 TEST_F(CppModuleConfigurationTest, UnknownLibCppFile) {
204 // Test that having some unknown file in the libc++ path doesn't break
205 // anything.
206
207 std::string libcpp = "/usr/include/c++/v1";
208 std::vector<std::string> files = {// C library
209 "/usr/include/stdio.h",
210 // C++ library
211 libcpp + "/non_existing_file",
212 libcpp + "/module.modulemap",
213 libcpp + "/vector"};
214 CppModuleConfiguration config(makeFiles(files), llvm::Triple());
215 EXPECT_THAT(config.GetImportedModules(), testing::ElementsAre("std"));
216 EXPECT_THAT(config.GetIncludeDirs(),
217 testing::ElementsAre("/usr/include/c++/v1", ResourceInc(),
218 "/usr/include"));
219 }
220
TEST_F(CppModuleConfigurationTest,MissingUsrInclude)221 TEST_F(CppModuleConfigurationTest, MissingUsrInclude) {
222 // Test that we don't load 'std' if we can't find the C standard library.
223
224 std::string libcpp = "/usr/include/c++/v1";
225 std::vector<std::string> files = {// C++ library
226 libcpp + "/vector",
227 libcpp + "/module.modulemap"};
228 CppModuleConfiguration config(makeFiles(files), llvm::Triple());
229 EXPECT_THAT(config.GetImportedModules(), testing::ElementsAre());
230 EXPECT_THAT(config.GetIncludeDirs(), testing::ElementsAre());
231 }
232
TEST_F(CppModuleConfigurationTest,MissingLibCpp)233 TEST_F(CppModuleConfigurationTest, MissingLibCpp) {
234 // Test that we don't load 'std' if we don't have a libc++.
235
236 std::string usr = "/usr/include";
237 std::vector<std::string> files = {
238 // C library
239 usr + "/stdio.h",
240 };
241 CppModuleConfiguration config(makeFiles(files), llvm::Triple());
242 EXPECT_THAT(config.GetImportedModules(), testing::ElementsAre());
243 EXPECT_THAT(config.GetIncludeDirs(), testing::ElementsAre());
244 }
245
TEST_F(CppModuleConfigurationTest,IgnoreLibStdCpp)246 TEST_F(CppModuleConfigurationTest, IgnoreLibStdCpp) {
247 // Test that we don't do anything bad when we encounter libstdc++ paths.
248
249 std::string usr = "/usr/include";
250 std::vector<std::string> files = {
251 // C library
252 usr + "/stdio.h",
253 // C++ library
254 usr + "/c++/8.0.1/vector",
255 };
256 CppModuleConfiguration config(makeFiles(files), llvm::Triple());
257 EXPECT_THAT(config.GetImportedModules(), testing::ElementsAre());
258 EXPECT_THAT(config.GetIncludeDirs(), testing::ElementsAre());
259 }
260
TEST_F(CppModuleConfigurationTest,AmbiguousCLib)261 TEST_F(CppModuleConfigurationTest, AmbiguousCLib) {
262 // Test that we don't do anything when we are not sure where the
263 // right C standard library is.
264
265 std::string usr1 = "/usr/include";
266 std::string usr2 = "/usr/include/other/path";
267 std::string libcpp = usr1 + "c++/v1";
268 std::vector<std::string> files = {
269 // First C library
270 usr1 + "/stdio.h",
271 // Second C library
272 usr2 + "/stdio.h",
273 // C++ library
274 libcpp + "/vector",
275 libcpp + "/module.modulemap",
276 };
277 CppModuleConfiguration config(makeFiles(files), llvm::Triple());
278 EXPECT_THAT(config.GetImportedModules(), testing::ElementsAre());
279 EXPECT_THAT(config.GetIncludeDirs(), testing::ElementsAre());
280 }
281
TEST_F(CppModuleConfigurationTest,AmbiguousLibCpp)282 TEST_F(CppModuleConfigurationTest, AmbiguousLibCpp) {
283 // Test that we don't do anything when we are not sure where the
284 // right libc++ is.
285
286 std::string usr = "/usr/include";
287 std::string libcpp1 = usr + "c++/v1";
288 std::string libcpp2 = usr + "c++/v2";
289 std::vector<std::string> files = {
290 // C library
291 usr + "/stdio.h",
292 // First C++ library
293 libcpp1 + "/vector",
294 libcpp1 + "/module.modulemap",
295 // Second C++ library
296 libcpp2 + "/vector",
297 libcpp2 + "/module.modulemap",
298 };
299 CppModuleConfiguration config(makeFiles(files), llvm::Triple());
300 EXPECT_THAT(config.GetImportedModules(), testing::ElementsAre());
301 EXPECT_THAT(config.GetIncludeDirs(), testing::ElementsAre());
302 }
303