| 1 |
//===-- CompileCommandsTests.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 "CompileCommands.h" |
| 10 |
#include "Config.h" |
| 11 |
#include "TestFS.h" |
| 12 |
#include "support/Context.h" |
| 13 |
|
| 14 |
#include "clang/Tooling/ArgumentsAdjusters.h" |
| 15 |
#include "llvm/ADT/ArrayRef.h" |
| 16 |
#include "llvm/ADT/STLExtras.h" |
| 17 |
#include "llvm/ADT/ScopeExit.h" |
| 18 |
#include "llvm/ADT/StringExtras.h" |
| 19 |
#include "llvm/ADT/StringRef.h" |
| 20 |
#include "llvm/Support/FileSystem.h" |
| 21 |
#include "llvm/Support/Path.h" |
| 22 |
#include "llvm/Support/Process.h" |
| 23 |
|
| 24 |
#include "gmock/gmock.h" |
| 25 |
#include "gtest/gtest.h" |
| 26 |
|
| 27 |
namespace clang { |
| 28 |
namespace clangd { |
| 29 |
namespace { |
| 30 |
|
| 31 |
using ::testing::_; |
| 32 |
using ::testing::Contains; |
| 33 |
using ::testing::ElementsAre; |
| 34 |
using ::testing::HasSubstr; |
| 35 |
using ::testing::Not; |
| 36 |
|
| 37 |
// Sadly, CommandMangler::detect(), which contains much of the logic, is |
| 38 |
// a bunch of untested integration glue. We test the string manipulation here |
| 39 |
// assuming its results are correct. |
| 40 |
|
| 41 |
// Make use of all features and assert the exact command we get out. |
| 42 |
// Other tests just verify presence/absence of certain args. |
| 43 |
TEST(CommandMangler, Everything) { |
| 44 |
auto Mangler = CommandMangler::forTests(); |
| 45 |
Mangler.ClangPath = testPath("fake/clang"); |
| 46 |
Mangler.ResourceDir = testPath("fake/resources"); |
| 47 |
Mangler.Sysroot = testPath("fake/sysroot"); |
| 48 |
tooling::CompileCommand Cmd; |
| 49 |
Cmd.CommandLine = {"clang++", "--", "foo.cc", "bar.cc"}; |
| 50 |
Mangler(Cmd, "foo.cc"); |
| 51 |
EXPECT_THAT(Cmd.CommandLine, |
| 52 |
ElementsAre(testPath("fake/clang++"), |
| 53 |
"-resource-dir=" + testPath("fake/resources"), |
| 54 |
"-isysroot", testPath("fake/sysroot"), "--", |
| 55 |
"foo.cc")); |
| 56 |
} |
| 57 |
|
| 58 |
TEST(CommandMangler, FilenameMismatch) { |
| 59 |
auto Mangler = CommandMangler::forTests(); |
| 60 |
Mangler.ClangPath = testPath("clang"); |
| 61 |
// Our compile flags refer to foo.cc... |
| 62 |
tooling::CompileCommand Cmd; |
| 63 |
Cmd.CommandLine = {"clang", "foo.cc"}; |
| 64 |
// but we're applying it to foo.h... |
| 65 |
Mangler(Cmd, "foo.h"); |
| 66 |
// so transferCompileCommand should add -x c++-header to preserve semantics. |
| 67 |
EXPECT_THAT(Cmd.CommandLine, ElementsAre(testPath("clang"), "-x", |
| 68 |
"c++-header", "--", "foo.h")); |
| 69 |
} |
| 70 |
|
| 71 |
TEST(CommandMangler, ResourceDir) { |
| 72 |
auto Mangler = CommandMangler::forTests(); |
| 73 |
Mangler.ResourceDir = testPath("fake/resources"); |
| 74 |
tooling::CompileCommand Cmd; |
| 75 |
Cmd.CommandLine = {"clang++", "foo.cc"}; |
| 76 |
Mangler(Cmd, "foo.cc"); |
| 77 |
EXPECT_THAT(Cmd.CommandLine, |
| 78 |
Contains("-resource-dir=" + testPath("fake/resources"))); |
| 79 |
} |
| 80 |
|
| 81 |
TEST(CommandMangler, Sysroot) { |
| 82 |
auto Mangler = CommandMangler::forTests(); |
| 83 |
Mangler.Sysroot = testPath("fake/sysroot"); |
| 84 |
|
| 85 |
tooling::CompileCommand Cmd; |
| 86 |
Cmd.CommandLine = {"clang++", "foo.cc"}; |
| 87 |
Mangler(Cmd, "foo.cc"); |
| 88 |
EXPECT_THAT(llvm::join(Cmd.CommandLine, " "), |
| 89 |
HasSubstr("-isysroot " + testPath("fake/sysroot"))); |
| 90 |
} |
| 91 |
|
| 92 |
TEST(CommandMangler, ClangPath) { |
| 93 |
auto Mangler = CommandMangler::forTests(); |
| 94 |
Mangler.ClangPath = testPath("fake/clang"); |
| 95 |
|
| 96 |
tooling::CompileCommand Cmd; |
| 97 |
Cmd.CommandLine = {"clang++", "foo.cc"}; |
| 98 |
Mangler(Cmd, "foo.cc"); |
| 99 |
EXPECT_EQ(testPath("fake/clang++"), Cmd.CommandLine.front()); |
| 100 |
|
| 101 |
Cmd.CommandLine = {"unknown-binary", "foo.cc"}; |
| 102 |
Mangler(Cmd, "foo.cc"); |
| 103 |
EXPECT_EQ(testPath("fake/unknown-binary"), Cmd.CommandLine.front()); |
| 104 |
|
| 105 |
Cmd.CommandLine = {testPath("path/clang++"), "foo.cc"}; |
| 106 |
Mangler(Cmd, "foo.cc"); |
| 107 |
EXPECT_EQ(testPath("path/clang++"), Cmd.CommandLine.front()); |
| 108 |
|
| 109 |
Cmd.CommandLine = {"foo/unknown-binary", "foo.cc"}; |
| 110 |
Mangler(Cmd, "foo.cc"); |
| 111 |
EXPECT_EQ("foo/unknown-binary", Cmd.CommandLine.front()); |
| 112 |
} |
| 113 |
|
| 114 |
// Only run the PATH/symlink resolving test on unix, we need to fiddle |
| 115 |
// with permissions and environment variables... |
| 116 |
#ifdef LLVM_ON_UNIX |
| 117 |
MATCHER(ok, "") { |
| 118 |
if (arg) { |
| 119 |
*result_listener << arg.message(); |
| 120 |
return false; |
| 121 |
} |
| 122 |
return true; |
| 123 |
} |
| 124 |
|
| 125 |
TEST(CommandMangler, ClangPathResolve) { |
| 126 |
// Set up filesystem: |
| 127 |
// /temp/ |
| 128 |
// bin/ |
| 129 |
// foo -> temp/lib/bar |
| 130 |
// lib/ |
| 131 |
// bar |
| 132 |
llvm::SmallString<256> TempDir; |
| 133 |
ASSERT_THAT(llvm::sys::fs::createUniqueDirectory("ClangPathResolve", TempDir), |
| 134 |
ok()); |
| 135 |
// /var/tmp is a symlink on Mac. Resolve it so we're asserting the right path. |
| 136 |
ASSERT_THAT(llvm::sys::fs::real_path(TempDir.str(), TempDir), ok()); |
| 137 |
auto CleanDir = llvm::make_scope_exit( |
| 138 |
[&] { llvm::sys::fs::remove_directories(TempDir); }); |
| 139 |
ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/bin"), ok()); |
| 140 |
ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/lib"), ok()); |
| 141 |
int FD; |
| 142 |
ASSERT_THAT(llvm::sys::fs::openFileForWrite(TempDir + "/lib/bar", FD), ok()); |
| 143 |
ASSERT_THAT(llvm::sys::Process::SafelyCloseFileDescriptor(FD), ok()); |
| 144 |
::chmod((TempDir + "/lib/bar").str().c_str(), 0755); // executable |
| 145 |
ASSERT_THAT( |
| 146 |
llvm::sys::fs::create_link(TempDir + "/lib/bar", TempDir + "/bin/foo"), |
| 147 |
ok()); |
| 148 |
|
| 149 |
// Test the case where the driver is an absolute path to a symlink. |
| 150 |
auto Mangler = CommandMangler::forTests(); |
| 151 |
Mangler.ClangPath = testPath("fake/clang"); |
| 152 |
tooling::CompileCommand Cmd; |
| 153 |
Cmd.CommandLine = {(TempDir + "/bin/foo").str(), "foo.cc"}; |
| 154 |
Mangler(Cmd, "foo.cc"); |
| 155 |
// Directory based on resolved symlink, basename preserved. |
| 156 |
EXPECT_EQ((TempDir + "/lib/foo").str(), Cmd.CommandLine.front()); |
| 157 |
|
| 158 |
// Set PATH to point to temp/bin so we can find 'foo' on it. |
| 159 |
ASSERT_TRUE(::getenv("PATH")); |
| 160 |
auto RestorePath = |
| 161 |
llvm::make_scope_exit([OldPath = std::string(::getenv("PATH"))] { |
| 162 |
::setenv("PATH", OldPath.c_str(), 1); |
| 163 |
}); |
| 164 |
::setenv("PATH", (TempDir + "/bin").str().c_str(), /*overwrite=*/1); |
| 165 |
|
| 166 |
// Test the case where the driver is a $PATH-relative path to a symlink. |
| 167 |
Mangler = CommandMangler::forTests(); |
| 168 |
Mangler.ClangPath = testPath("fake/clang"); |
| 169 |
// Driver found on PATH. |
| 170 |
Cmd.CommandLine = {"foo", "foo.cc"}; |
| 171 |
Mangler(Cmd, "foo.cc"); |
| 172 |
// Found the symlink and resolved the path as above. |
| 173 |
EXPECT_EQ((TempDir + "/lib/foo").str(), Cmd.CommandLine.front()); |
| 174 |
|
| 175 |
// Symlink not resolved with -no-canonical-prefixes. |
| 176 |
Cmd.CommandLine = {"foo", "-no-canonical-prefixes", "foo.cc"}; |
| 177 |
Mangler(Cmd, "foo.cc"); |
| 178 |
EXPECT_EQ((TempDir + "/bin/foo").str(), Cmd.CommandLine.front()); |
| 179 |
} |
| 180 |
#endif |
| 181 |
|
| 182 |
TEST(CommandMangler, ConfigEdits) { |
| 183 |
auto Mangler = CommandMangler::forTests(); |
| 184 |
tooling::CompileCommand Cmd; |
| 185 |
Cmd.CommandLine = {"clang++", "foo.cc"}; |
| 186 |
{ |
| 187 |
Config Cfg; |
| 188 |
Cfg.CompileFlags.Edits.push_back([](std::vector<std::string> &Argv) { |
| 189 |
for (auto &Arg : Argv) |
| 190 |
for (char &C : Arg) |
| 191 |
C = llvm::toUpper(C); |
| 192 |
}); |
| 193 |
Cfg.CompileFlags.Edits.push_back([](std::vector<std::string> &Argv) { |
| 194 |
Argv = tooling::getInsertArgumentAdjuster("--hello")(Argv, ""); |
| 195 |
}); |
| 196 |
WithContextValue WithConfig(Config::Key, std::move(Cfg)); |
| 197 |
Mangler(Cmd, "foo.cc"); |
| 198 |
} |
| 199 |
// Edits are applied in given order and before other mangling and they always |
| 200 |
// go before filename. |
| 201 |
EXPECT_THAT(Cmd.CommandLine, ElementsAre(_, "--hello", "--", "FOO.CC")); |
| 202 |
} |
| 203 |
|
| 204 |
static std::string strip(llvm::StringRef Arg, llvm::StringRef Argv) { |
| 205 |
llvm::SmallVector<llvm::StringRef> Parts; |
| 206 |
llvm::SplitString(Argv, Parts); |
| 207 |
std::vector<std::string> Args = {Parts.begin(), Parts.end()}; |
| 208 |
ArgStripper S; |
| 209 |
S.strip(Arg); |
| 210 |
S.process(Args); |
| 211 |
return printArgv(Args); |
| 212 |
} |
| 213 |
|
| 214 |
TEST(ArgStripperTest, Spellings) { |
| 215 |
// May use alternate prefixes. |
| 216 |
EXPECT_EQ(strip("-pedantic", "clang -pedantic foo.cc"), "clang foo.cc"); |
| 217 |
EXPECT_EQ(strip("-pedantic", "clang --pedantic foo.cc"), "clang foo.cc"); |
| 218 |
EXPECT_EQ(strip("--pedantic", "clang -pedantic foo.cc"), "clang foo.cc"); |
| 219 |
EXPECT_EQ(strip("--pedantic", "clang --pedantic foo.cc"), "clang foo.cc"); |
| 220 |
// May use alternate names. |
| 221 |
EXPECT_EQ(strip("-x", "clang -x c++ foo.cc"), "clang foo.cc"); |
| 222 |
EXPECT_EQ(strip("-x", "clang --language=c++ foo.cc"), "clang foo.cc"); |
| 223 |
EXPECT_EQ(strip("--language=", "clang -x c++ foo.cc"), "clang foo.cc"); |
| 224 |
EXPECT_EQ(strip("--language=", "clang --language=c++ foo.cc"), |
| 225 |
"clang foo.cc"); |
| 226 |
} |
| 227 |
|
| 228 |
TEST(ArgStripperTest, UnknownFlag) { |
| 229 |
EXPECT_EQ(strip("-xyzzy", "clang -xyzzy foo.cc"), "clang foo.cc"); |
| 230 |
EXPECT_EQ(strip("-xyz*", "clang -xyzzy foo.cc"), "clang foo.cc"); |
| 231 |
EXPECT_EQ(strip("-xyzzy", "clang -Xclang -xyzzy foo.cc"), "clang foo.cc"); |
| 232 |
} |
| 233 |
|
| 234 |
TEST(ArgStripperTest, Xclang) { |
| 235 |
// Flags may be -Xclang escaped. |
| 236 |
EXPECT_EQ(strip("-ast-dump", "clang -Xclang -ast-dump foo.cc"), |
| 237 |
"clang foo.cc"); |
| 238 |
// Args may be -Xclang escaped. |
| 239 |
EXPECT_EQ(strip("-add-plugin", "clang -Xclang -add-plugin -Xclang z foo.cc"), |
| 240 |
"clang foo.cc"); |
| 241 |
} |
| 242 |
|
| 243 |
TEST(ArgStripperTest, ClangCL) { |
| 244 |
// /I is a synonym for -I in clang-cl mode only. |
| 245 |
// Not stripped by default. |
| 246 |
EXPECT_EQ(strip("-I", "clang -I /usr/inc /Interesting/file.cc"), |
| 247 |
"clang /Interesting/file.cc"); |
| 248 |
// Stripped when invoked as clang-cl. |
| 249 |
EXPECT_EQ(strip("-I", "clang-cl -I /usr/inc /Interesting/file.cc"), |
| 250 |
"clang-cl"); |
| 251 |
// Stripped when invoked as CL.EXE |
| 252 |
EXPECT_EQ(strip("-I", "CL.EXE -I /usr/inc /Interesting/file.cc"), "CL.EXE"); |
| 253 |
// Stripped when passed --driver-mode=cl. |
| 254 |
EXPECT_EQ(strip("-I", "cc -I /usr/inc /Interesting/file.cc --driver-mode=cl"), |
| 255 |
"cc --driver-mode=cl"); |
| 256 |
} |
| 257 |
|
| 258 |
TEST(ArgStripperTest, ArgStyles) { |
| 259 |
// Flag |
| 260 |
EXPECT_EQ(strip("-Qn", "clang -Qn foo.cc"), "clang foo.cc"); |
| 261 |
EXPECT_EQ(strip("-Qn", "clang -QnZ foo.cc"), "clang -QnZ foo.cc"); |
| 262 |
// Joined |
| 263 |
EXPECT_EQ(strip("-std=", "clang -std= foo.cc"), "clang foo.cc"); |
| 264 |
EXPECT_EQ(strip("-std=", "clang -std=c++11 foo.cc"), "clang foo.cc"); |
| 265 |
// Separate |
| 266 |
EXPECT_EQ(strip("-mllvm", "clang -mllvm X foo.cc"), "clang foo.cc"); |
| 267 |
EXPECT_EQ(strip("-mllvm", "clang -mllvmX foo.cc"), "clang -mllvmX foo.cc"); |
| 268 |
// RemainingArgsJoined |
| 269 |
EXPECT_EQ(strip("/link", "clang-cl /link b c d foo.cc"), "clang-cl"); |
| 270 |
EXPECT_EQ(strip("/link", "clang-cl /linka b c d foo.cc"), "clang-cl"); |
| 271 |
// CommaJoined |
| 272 |
EXPECT_EQ(strip("-Wl,", "clang -Wl,x,y foo.cc"), "clang foo.cc"); |
| 273 |
EXPECT_EQ(strip("-Wl,", "clang -Wl, foo.cc"), "clang foo.cc"); |
| 274 |
// MultiArg |
| 275 |
EXPECT_EQ(strip("-segaddr", "clang -segaddr a b foo.cc"), "clang foo.cc"); |
| 276 |
EXPECT_EQ(strip("-segaddr", "clang -segaddra b foo.cc"), |
| 277 |
"clang -segaddra b foo.cc"); |
| 278 |
// JoinedOrSeparate |
| 279 |
EXPECT_EQ(strip("-G", "clang -GX foo.cc"), "clang foo.cc"); |
| 280 |
EXPECT_EQ(strip("-G", "clang -G X foo.cc"), "clang foo.cc"); |
| 281 |
// JoinedAndSeparate |
| 282 |
EXPECT_EQ(strip("-plugin-arg-", "clang -cc1 -plugin-arg-X Y foo.cc"), |
| 283 |
"clang -cc1 foo.cc"); |
| 284 |
EXPECT_EQ(strip("-plugin-arg-", "clang -cc1 -plugin-arg- Y foo.cc"), |
| 285 |
"clang -cc1 foo.cc"); |
| 286 |
} |
| 287 |
|
| 288 |
TEST(ArgStripperTest, EndOfList) { |
| 289 |
// When we hit the end-of-args prematurely, we don't crash. |
| 290 |
// We consume the incomplete args if we've matched the target option. |
| 291 |
EXPECT_EQ(strip("-I", "clang -Xclang"), "clang -Xclang"); |
| 292 |
EXPECT_EQ(strip("-I", "clang -Xclang -I"), "clang"); |
| 293 |
EXPECT_EQ(strip("-I", "clang -I -Xclang"), "clang"); |
| 294 |
EXPECT_EQ(strip("-I", "clang -I"), "clang"); |
| 295 |
} |
| 296 |
|
| 297 |
TEST(ArgStripperTest, Multiple) { |
| 298 |
ArgStripper S; |
| 299 |
S.strip("-o"); |
| 300 |
S.strip("-c"); |
| 301 |
std::vector<std::string> Args = {"clang", "-o", "foo.o", "foo.cc", "-c"}; |
| 302 |
S.process(Args); |
| 303 |
EXPECT_THAT(Args, ElementsAre("clang", "foo.cc")); |
| 304 |
} |
| 305 |
|
| 306 |
TEST(ArgStripperTest, Warning) { |
| 307 |
{ |
| 308 |
// -W is a flag name |
| 309 |
ArgStripper S; |
| 310 |
S.strip("-W"); |
| 311 |
std::vector<std::string> Args = {"clang", "-Wfoo", "-Wno-bar", "-Werror", |
| 312 |
"foo.cc"}; |
| 313 |
S.process(Args); |
| 314 |
EXPECT_THAT(Args, ElementsAre("clang", "foo.cc")); |
| 315 |
} |
| 316 |
{ |
| 317 |
// -Wfoo is not a flag name, matched literally. |
| 318 |
ArgStripper S; |
| 319 |
S.strip("-Wunused"); |
| 320 |
std::vector<std::string> Args = {"clang", "-Wunused", "-Wno-unused", |
| 321 |
"foo.cc"}; |
| 322 |
S.process(Args); |
| 323 |
EXPECT_THAT(Args, ElementsAre("clang", "-Wno-unused", "foo.cc")); |
| 324 |
} |
| 325 |
} |
| 326 |
|
| 327 |
TEST(ArgStripperTest, Define) { |
| 328 |
{ |
| 329 |
// -D is a flag name |
| 330 |
ArgStripper S; |
| 331 |
S.strip("-D"); |
| 332 |
std::vector<std::string> Args = {"clang", "-Dfoo", "-Dbar=baz", "foo.cc"}; |
| 333 |
S.process(Args); |
| 334 |
EXPECT_THAT(Args, ElementsAre("clang", "foo.cc")); |
| 335 |
} |
| 336 |
{ |
| 337 |
// -Dbar is not: matched literally |
| 338 |
ArgStripper S; |
| 339 |
S.strip("-Dbar"); |
| 340 |
std::vector<std::string> Args = {"clang", "-Dfoo", "-Dbar=baz", "foo.cc"}; |
| 341 |
S.process(Args); |
| 342 |
EXPECT_THAT(Args, ElementsAre("clang", "-Dfoo", "-Dbar=baz", "foo.cc")); |
| 343 |
S.strip("-Dfoo"); |
| 344 |
S.process(Args); |
| 345 |
EXPECT_THAT(Args, ElementsAre("clang", "-Dbar=baz", "foo.cc")); |
| 346 |
S.strip("-Dbar=*"); |
| 347 |
S.process(Args); |
| 348 |
EXPECT_THAT(Args, ElementsAre("clang", "foo.cc")); |
| 349 |
} |
| 350 |
} |
| 351 |
|
| 352 |
TEST(ArgStripperTest, OrderDependent) { |
| 353 |
ArgStripper S; |
| 354 |
// If -include is stripped first, we see -pch as its arg and foo.pch remains. |
| 355 |
// To get this case right, we must process -include-pch first. |
| 356 |
S.strip("-include"); |
| 357 |
S.strip("-include-pch"); |
| 358 |
std::vector<std::string> Args = {"clang", "-include-pch", "foo.pch", |
| 359 |
"foo.cc"}; |
| 360 |
S.process(Args); |
| 361 |
EXPECT_THAT(Args, ElementsAre("clang", "foo.cc")); |
| 362 |
} |
| 363 |
|
| 364 |
TEST(PrintArgvTest, All) { |
| 365 |
std::vector<llvm::StringRef> Args = { |
| 366 |
"one", "two", "thr ee", "f\"o\"ur", "fi\\ve", "$" |
| 367 |
}; |
| 368 |
const char *Expected = R"(one two "thr ee" "f\"o\"ur" "fi\\ve" $)"; |
| 369 |
EXPECT_EQ(Expected, printArgv(Args)); |
| 370 |
} |
| 371 |
|
| 372 |
TEST(CommandMangler, InputsAfterDashDash) { |
| 373 |
const auto Mangler = CommandMangler::forTests(); |
| 374 |
{ |
| 375 |
tooling::CompileCommand Cmd; |
| 376 |
Cmd.CommandLine = {"clang", "/Users/foo.cc"}; |
| 377 |
Mangler(Cmd, "/Users/foo.cc"); |
| 378 |
EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).take_back(2), |
| 379 |
ElementsAre("--", "/Users/foo.cc")); |
| 380 |
EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).drop_back(2), |
| 381 |
Not(Contains("/Users/foo.cc"))); |
| 382 |
} |
| 383 |
// In CL mode /U triggers an undef operation, hence `/Users/foo.cc` shouldn't |
| 384 |
// be interpreted as a file. |
| 385 |
{ |
| 386 |
tooling::CompileCommand Cmd; |
| 387 |
Cmd.CommandLine = {"clang", "--driver-mode=cl", "bar.cc", "/Users/foo.cc"}; |
| 388 |
Mangler(Cmd, "bar.cc"); |
| 389 |
EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).take_back(2), |
| 390 |
ElementsAre("--", "bar.cc")); |
| 391 |
EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).drop_back(2), |
| 392 |
Not(Contains("bar.cc"))); |
| 393 |
} |
| 394 |
// All inputs but the main file is dropped. |
| 395 |
{ |
| 396 |
tooling::CompileCommand Cmd; |
| 397 |
Cmd.CommandLine = {"clang", "foo.cc", "bar.cc"}; |
| 398 |
Mangler(Cmd, "baz.cc"); |
| 399 |
EXPECT_THAT(llvm::ArrayRef(Cmd.CommandLine).take_back(2), |
| 400 |
ElementsAre("--", "baz.cc")); |
| 401 |
EXPECT_THAT( |
| 402 |
llvm::ArrayRef(Cmd.CommandLine).drop_back(2), |
| 403 |
testing::AllOf(Not(Contains("foo.cc")), Not(Contains("bar.cc")))); |
| 404 |
} |
| 405 |
} |
| 406 |
|
| 407 |
TEST(CommandMangler, StripsMultipleArch) { |
| 408 |
const auto Mangler = CommandMangler::forTests(); |
| 409 |
tooling::CompileCommand Cmd; |
| 410 |
Cmd.CommandLine = {"clang", "-arch", "foo", "-arch", "bar", "/Users/foo.cc"}; |
| 411 |
Mangler(Cmd, "/Users/foo.cc"); |
| 412 |
EXPECT_EQ(llvm::count_if(Cmd.CommandLine, |
| 413 |
[](llvm::StringRef Arg) { return Arg == "-arch"; }), |
| 414 |
0); |
| 415 |
|
| 416 |
// Single arch option is preserved. |
| 417 |
Cmd.CommandLine = {"clang", "-arch", "foo", "/Users/foo.cc"}; |
| 418 |
Mangler(Cmd, "/Users/foo.cc"); |
| 419 |
EXPECT_EQ(llvm::count_if(Cmd.CommandLine, |
| 420 |
[](llvm::StringRef Arg) { return Arg == "-arch"; }), |
| 421 |
1); |
| 422 |
} |
| 423 |
|
| 424 |
TEST(CommandMangler, EmptyArgs) { |
| 425 |
const auto Mangler = CommandMangler::forTests(); |
| 426 |
tooling::CompileCommand Cmd; |
| 427 |
Cmd.CommandLine = {}; |
| 428 |
// Make sure we don't crash. |
| 429 |
Mangler(Cmd, "foo.cc"); |
| 430 |
} |
| 431 |
|
| 432 |
TEST(CommandMangler, PathsAsPositional) { |
| 433 |
const auto Mangler = CommandMangler::forTests(); |
| 434 |
tooling::CompileCommand Cmd; |
| 435 |
Cmd.CommandLine = { |
| 436 |
"clang", |
| 437 |
"--driver-mode=cl", |
| 438 |
"-I", |
| 439 |
"foo", |
| 440 |
}; |
| 441 |
// Make sure we don't crash. |
| 442 |
Mangler(Cmd, "a.cc"); |
| 443 |
EXPECT_THAT(Cmd.CommandLine, Contains("foo")); |
| 444 |
} |
| 445 |
} // namespace |
| 446 |
} // namespace clangd |
| 447 |
} // namespace clang |