| 1 |
//===- unittest/Support/ProgramTest.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 "llvm/Support/Program.h" |
| 10 |
#include "llvm/Config/llvm-config.h" |
| 11 |
#include "llvm/Support/CommandLine.h" |
| 12 |
#include "llvm/Support/ConvertUTF.h" |
| 13 |
#include "llvm/Support/FileSystem.h" |
| 14 |
#include "llvm/Support/Path.h" |
| 15 |
#include "llvm/Support/Signals.h" |
| 16 |
#include "gtest/gtest.h" |
| 17 |
#include <stdlib.h> |
| 18 |
#include <thread> |
| 19 |
#if defined(__APPLE__) |
| 20 |
# include <crt_externs.h> |
| 21 |
#elif !defined(_MSC_VER) |
| 22 |
// Forward declare environ in case it's not provided by stdlib.h. |
| 23 |
extern char **environ; |
| 24 |
#endif |
| 25 |
|
| 26 |
#if defined(LLVM_ON_UNIX) |
| 27 |
#include <unistd.h> |
| 28 |
void sleep_for(unsigned int seconds) { |
| 29 |
sleep(seconds); |
| 30 |
} |
| 31 |
#elif defined(_WIN32) |
| 32 |
#include <windows.h> |
| 33 |
void sleep_for(unsigned int seconds) { |
| 34 |
Sleep(seconds * 1000); |
| 35 |
} |
| 36 |
#else |
| 37 |
#error sleep_for is not implemented on your platform. |
| 38 |
#endif |
| 39 |
|
| 40 |
#define ASSERT_NO_ERROR(x) \ |
| 41 |
if (std::error_code ASSERT_NO_ERROR_ec = x) { \ |
| 42 |
SmallString<128> MessageStorage; \ |
| 43 |
raw_svector_ostream Message(MessageStorage); \ |
| 44 |
Message << #x ": did not return errc::success.\n" \ |
| 45 |
<< "error number: " << ASSERT_NO_ERROR_ec.value() << "\n" \ |
| 46 |
<< "error message: " << ASSERT_NO_ERROR_ec.message() << "\n"; \ |
| 47 |
GTEST_FATAL_FAILURE_(MessageStorage.c_str()); \ |
| 48 |
} else { \ |
| 49 |
} |
| 50 |
// From TestMain.cpp. |
| 51 |
extern const char *TestMainArgv0; |
| 52 |
|
| 53 |
namespace { |
| 54 |
|
| 55 |
using namespace llvm; |
| 56 |
using namespace sys; |
| 57 |
|
| 58 |
static cl::opt<std::string> |
| 59 |
ProgramTestStringArg1("program-test-string-arg1"); |
| 60 |
static cl::opt<std::string> |
| 61 |
ProgramTestStringArg2("program-test-string-arg2"); |
| 62 |
|
| 63 |
class ProgramEnvTest : public testing::Test { |
| 64 |
std::vector<StringRef> EnvTable; |
| 65 |
std::vector<std::string> EnvStorage; |
| 66 |
|
| 67 |
protected: |
| 68 |
void SetUp() override { |
| 69 |
auto EnvP = [] { |
| 70 |
#if defined(_WIN32) |
| 71 |
_wgetenv(L"TMP"); // Populate _wenviron, initially is null |
| 72 |
return _wenviron; |
| 73 |
#elif defined(__APPLE__) |
| 74 |
return *_NSGetEnviron(); |
| 75 |
#else |
| 76 |
return environ; |
| 77 |
#endif |
| 78 |
}(); |
| 79 |
ASSERT_TRUE(EnvP); |
| 80 |
|
| 81 |
auto prepareEnvVar = [this](decltype(*EnvP) Var) -> StringRef { |
| 82 |
#if defined(_WIN32) |
| 83 |
// On Windows convert UTF16 encoded variable to UTF8 |
| 84 |
auto Len = wcslen(Var); |
| 85 |
ArrayRef<char> Ref{reinterpret_cast<char const *>(Var), |
| 86 |
Len * sizeof(*Var)}; |
| 87 |
EnvStorage.emplace_back(); |
| 88 |
auto convStatus = convertUTF16ToUTF8String(Ref, EnvStorage.back()); |
| 89 |
EXPECT_TRUE(convStatus); |
| 90 |
return EnvStorage.back(); |
| 91 |
#else |
| 92 |
(void)this; |
| 93 |
return StringRef(Var); |
| 94 |
#endif |
| 95 |
}; |
| 96 |
|
| 97 |
while (*EnvP != nullptr) { |
| 98 |
auto S = prepareEnvVar(*EnvP); |
| 99 |
if (!StringRef(S).startswith("GTEST_")) |
| 100 |
EnvTable.emplace_back(S); |
| 101 |
++EnvP; |
| 102 |
} |
| 103 |
} |
| 104 |
|
| 105 |
void TearDown() override { |
| 106 |
EnvTable.clear(); |
| 107 |
EnvStorage.clear(); |
| 108 |
} |
| 109 |
|
| 110 |
void addEnvVar(StringRef Var) { EnvTable.emplace_back(Var); } |
| 111 |
|
| 112 |
ArrayRef<StringRef> getEnviron() const { return EnvTable; } |
| 113 |
}; |
| 114 |
|
| 115 |
#ifdef _WIN32 |
| 116 |
void checkSeparators(StringRef Path) { |
| 117 |
char UndesiredSeparator = sys::path::get_separator()[0] == '/' ? '\\' : '/'; |
| 118 |
ASSERT_EQ(Path.find(UndesiredSeparator), StringRef::npos); |
| 119 |
} |
| 120 |
|
| 121 |
TEST_F(ProgramEnvTest, CreateProcessLongPath) { |
| 122 |
if (getenv("LLVM_PROGRAM_TEST_LONG_PATH")) |
| 123 |
exit(0); |
| 124 |
|
| 125 |
// getMainExecutable returns an absolute path; prepend the long-path prefix. |
| 126 |
SmallString<128> MyAbsExe( |
| 127 |
sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1)); |
| 128 |
checkSeparators(MyAbsExe); |
| 129 |
// Force a path with backslashes, when we are going to prepend the \\?\ |
| 130 |
// prefix. |
| 131 |
sys::path::native(MyAbsExe, sys::path::Style::windows_backslash); |
| 132 |
std::string MyExe; |
| 133 |
if (!StringRef(MyAbsExe).startswith("\\\\?\\")) |
| 134 |
MyExe.append("\\\\?\\"); |
| 135 |
MyExe.append(std::string(MyAbsExe.begin(), MyAbsExe.end())); |
| 136 |
|
| 137 |
StringRef ArgV[] = {MyExe, |
| 138 |
"--gtest_filter=ProgramEnvTest.CreateProcessLongPath"}; |
| 139 |
|
| 140 |
// Add LLVM_PROGRAM_TEST_LONG_PATH to the environment of the child. |
| 141 |
addEnvVar("LLVM_PROGRAM_TEST_LONG_PATH=1"); |
| 142 |
|
| 143 |
// Redirect stdout to a long path. |
| 144 |
SmallString<128> TestDirectory; |
| 145 |
ASSERT_NO_ERROR( |
| 146 |
fs::createUniqueDirectory("program-redirect-test", TestDirectory)); |
| 147 |
SmallString<256> LongPath(TestDirectory); |
| 148 |
LongPath.push_back('\\'); |
| 149 |
// MAX_PATH = 260 |
| 150 |
LongPath.append(260 - TestDirectory.size(), 'a'); |
| 151 |
|
| 152 |
std::string Error; |
| 153 |
bool ExecutionFailed; |
| 154 |
std::optional<StringRef> Redirects[] = {std::nullopt, LongPath.str(), |
| 155 |
std::nullopt}; |
| 156 |
int RC = ExecuteAndWait(MyExe, ArgV, getEnviron(), Redirects, |
| 157 |
/*secondsToWait=*/ 10, /*memoryLimit=*/ 0, &Error, |
| 158 |
&ExecutionFailed); |
| 159 |
EXPECT_FALSE(ExecutionFailed) << Error; |
| 160 |
EXPECT_EQ(0, RC); |
| 161 |
|
| 162 |
// Remove the long stdout. |
| 163 |
ASSERT_NO_ERROR(fs::remove(Twine(LongPath))); |
| 164 |
ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory))); |
| 165 |
} |
| 166 |
#endif |
| 167 |
|
| 168 |
TEST_F(ProgramEnvTest, CreateProcessTrailingSlash) { |
| 169 |
if (getenv("LLVM_PROGRAM_TEST_CHILD")) { |
| 170 |
if (ProgramTestStringArg1 == "has\\\\ trailing\\" && |
| 171 |
ProgramTestStringArg2 == "has\\\\ trailing\\") { |
| 172 |
exit(0); // Success! The arguments were passed and parsed. |
| 173 |
} |
| 174 |
exit(1); |
| 175 |
} |
| 176 |
|
| 177 |
std::string my_exe = |
| 178 |
sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1); |
| 179 |
StringRef argv[] = { |
| 180 |
my_exe, |
| 181 |
"--gtest_filter=ProgramEnvTest.CreateProcessTrailingSlash", |
| 182 |
"-program-test-string-arg1", |
| 183 |
"has\\\\ trailing\\", |
| 184 |
"-program-test-string-arg2", |
| 185 |
"has\\\\ trailing\\"}; |
| 186 |
|
| 187 |
// Add LLVM_PROGRAM_TEST_CHILD to the environment of the child. |
| 188 |
addEnvVar("LLVM_PROGRAM_TEST_CHILD=1"); |
| 189 |
|
| 190 |
std::string error; |
| 191 |
bool ExecutionFailed; |
| 192 |
// Redirect stdout and stdin to NUL, but let stderr through. |
| 193 |
#ifdef _WIN32 |
| 194 |
StringRef nul("NUL"); |
| 195 |
#else |
| 196 |
StringRef nul("/dev/null"); |
| 197 |
#endif |
| 198 |
std::optional<StringRef> redirects[] = {nul, nul, std::nullopt}; |
| 199 |
int rc = ExecuteAndWait(my_exe, argv, getEnviron(), redirects, |
| 200 |
/*secondsToWait=*/ 10, /*memoryLimit=*/ 0, &error, |
| 201 |
&ExecutionFailed); |
| 202 |
EXPECT_FALSE(ExecutionFailed) << error; |
| 203 |
EXPECT_EQ(0, rc); |
| 204 |
} |
| 205 |
|
| 206 |
TEST_F(ProgramEnvTest, TestExecuteNoWait) { |
| 207 |
using namespace llvm::sys; |
| 208 |
|
| 209 |
if (getenv("LLVM_PROGRAM_TEST_EXECUTE_NO_WAIT")) { |
| 210 |
sleep_for(/*seconds*/ 1); |
| 211 |
exit(0); |
| 212 |
} |
| 213 |
|
| 214 |
std::string Executable = |
| 215 |
sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1); |
| 216 |
StringRef argv[] = {Executable, |
| 217 |
"--gtest_filter=ProgramEnvTest.TestExecuteNoWait"}; |
| 218 |
|
| 219 |
// Add LLVM_PROGRAM_TEST_EXECUTE_NO_WAIT to the environment of the child. |
| 220 |
addEnvVar("LLVM_PROGRAM_TEST_EXECUTE_NO_WAIT=1"); |
| 221 |
|
| 222 |
std::string Error; |
| 223 |
bool ExecutionFailed; |
| 224 |
ProcessInfo PI1 = ExecuteNoWait(Executable, argv, getEnviron(), {}, 0, &Error, |
| 225 |
&ExecutionFailed); |
| 226 |
ASSERT_FALSE(ExecutionFailed) << Error; |
| 227 |
ASSERT_NE(PI1.Pid, ProcessInfo::InvalidPid) << "Invalid process id"; |
| 228 |
|
| 229 |
unsigned LoopCount = 0; |
| 230 |
|
| 231 |
// Test that Wait() with SecondsToWait=std::nullopt works. In this case, |
| 232 |
// LoopCount should only be incremented once. |
| 233 |
while (true) { |
| 234 |
++LoopCount; |
| 235 |
ProcessInfo WaitResult = |
| 236 |
llvm::sys::Wait(PI1, /*SecondsToWait=*/std::nullopt, &Error); |
| 237 |
ASSERT_TRUE(Error.empty()); |
| 238 |
if (WaitResult.Pid == PI1.Pid) |
| 239 |
break; |
| 240 |
} |
| 241 |
|
| 242 |
EXPECT_EQ(LoopCount, 1u) << "LoopCount should be 1"; |
| 243 |
|
| 244 |
ProcessInfo PI2 = ExecuteNoWait(Executable, argv, getEnviron(), |
| 245 |
/*Redirects*/ {}, /*MemoryLimit*/ 0, &Error, |
| 246 |
&ExecutionFailed); |
| 247 |
ASSERT_FALSE(ExecutionFailed) << Error; |
| 248 |
ASSERT_NE(PI2.Pid, ProcessInfo::InvalidPid) << "Invalid process id"; |
| 249 |
|
| 250 |
// Test that Wait() with SecondsToWait=0 performs a non-blocking wait. In this |
| 251 |
// case, LoopCount should be greater than 1 (more than one increment occurs). |
| 252 |
while (true) { |
| 253 |
++LoopCount; |
| 254 |
ProcessInfo WaitResult = llvm::sys::Wait(PI2, /*SecondsToWait=*/0, &Error); |
| 255 |
ASSERT_TRUE(Error.empty()); |
| 256 |
if (WaitResult.Pid == PI2.Pid) |
| 257 |
break; |
| 258 |
} |
| 259 |
|
| 260 |
ASSERT_GT(LoopCount, 1u) << "LoopCount should be >1"; |
| 261 |
} |
| 262 |
|
| 263 |
TEST_F(ProgramEnvTest, TestExecuteAndWaitTimeout) { |
| 264 |
using namespace llvm::sys; |
| 265 |
|
| 266 |
if (getenv("LLVM_PROGRAM_TEST_TIMEOUT")) { |
| 267 |
sleep_for(/*seconds*/ 10); |
| 268 |
exit(0); |
| 269 |
} |
| 270 |
|
| 271 |
std::string Executable = |
| 272 |
sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1); |
| 273 |
StringRef argv[] = { |
| 274 |
Executable, "--gtest_filter=ProgramEnvTest.TestExecuteAndWaitTimeout"}; |
| 275 |
|
| 276 |
// Add LLVM_PROGRAM_TEST_TIMEOUT to the environment of the child. |
| 277 |
addEnvVar("LLVM_PROGRAM_TEST_TIMEOUT=1"); |
| 278 |
|
| 279 |
std::string Error; |
| 280 |
bool ExecutionFailed; |
| 281 |
int RetCode = |
| 282 |
ExecuteAndWait(Executable, argv, getEnviron(), {}, /*SecondsToWait=*/1, |
| 283 |
/*MemoryLimit*/ 0, &Error, &ExecutionFailed); |
| 284 |
ASSERT_EQ(-2, RetCode); |
| 285 |
} |
| 286 |
|
| 287 |
TEST_F(ProgramEnvTest, TestExecuteNoWaitTimeoutPolling) { |
| 288 |
using namespace llvm::sys; |
| 289 |
|
| 290 |
if (getenv("LLVM_PROGRAM_TEST_TIMEOUT")) { |
| 291 |
sleep_for(/*seconds*/ 5); |
| 292 |
exit(0); |
| 293 |
} |
| 294 |
|
| 295 |
std::string Executable = |
| 296 |
sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1); |
| 297 |
StringRef argv[] = { |
| 298 |
Executable, |
| 299 |
"--gtest_filter=ProgramEnvTest.TestExecuteNoWaitTimeoutPolling"}; |
| 300 |
|
| 301 |
// Add LLVM_PROGRAM_TEST_TIMEOUT to the environment of the child. |
| 302 |
addEnvVar("LLVM_PROGRAM_TEST_TIMEOUT=1"); |
| 303 |
|
| 304 |
std::string Error; |
| 305 |
bool ExecutionFailed; |
| 306 |
ProcessInfo PI0 = ExecuteNoWait(Executable, argv, getEnviron(), |
| 307 |
/*Redirects=*/{}, /*MemoryLimit=*/0, &Error, |
| 308 |
&ExecutionFailed); |
| 309 |
ASSERT_FALSE(ExecutionFailed) << Error; |
| 310 |
ASSERT_NE(PI0.Pid, ProcessInfo::InvalidPid) << "Invalid process id"; |
| 311 |
|
| 312 |
// Check that we don't kill the process with a non-0 SecondsToWait if Polling. |
| 313 |
unsigned LoopCount = 0; |
| 314 |
ProcessInfo WaitResult; |
| 315 |
do { |
| 316 |
++LoopCount; |
| 317 |
WaitResult = llvm::sys::Wait(PI0, /*SecondsToWait=*/1, &Error, |
| 318 |
/*ProcStats=*/nullptr, |
| 319 |
/*Polling=*/true); |
| 320 |
ASSERT_TRUE(Error.empty()) << Error; |
| 321 |
} while (WaitResult.Pid != PI0.Pid); |
| 322 |
|
| 323 |
ASSERT_GT(LoopCount, 1u) << "LoopCount should be >1"; |
| 324 |
} |
| 325 |
|
| 326 |
TEST(ProgramTest, TestExecuteNegative) { |
| 327 |
std::string Executable = "i_dont_exist"; |
| 328 |
StringRef argv[] = {Executable}; |
| 329 |
|
| 330 |
{ |
| 331 |
std::string Error; |
| 332 |
bool ExecutionFailed; |
| 333 |
int RetCode = ExecuteAndWait(Executable, argv, std::nullopt, {}, 0, 0, |
| 334 |
&Error, &ExecutionFailed); |
| 335 |
ASSERT_LT(RetCode, 0) << "On error ExecuteAndWait should return 0 or " |
| 336 |
"positive value indicating the result code"; |
| 337 |
ASSERT_TRUE(ExecutionFailed); |
| 338 |
ASSERT_FALSE(Error.empty()); |
| 339 |
} |
| 340 |
|
| 341 |
{ |
| 342 |
std::string Error; |
| 343 |
bool ExecutionFailed; |
| 344 |
ProcessInfo PI = ExecuteNoWait(Executable, argv, std::nullopt, {}, 0, |
| 345 |
&Error, &ExecutionFailed); |
| 346 |
ASSERT_EQ(PI.Pid, ProcessInfo::InvalidPid) |
| 347 |
<< "On error ExecuteNoWait should return an invalid ProcessInfo"; |
| 348 |
ASSERT_TRUE(ExecutionFailed); |
| 349 |
ASSERT_FALSE(Error.empty()); |
| 350 |
} |
| 351 |
|
| 352 |
} |
| 353 |
|
| 354 |
#ifdef _WIN32 |
| 355 |
const char utf16le_text[] = |
| 356 |
"\x6c\x00\x69\x00\x6e\x00\x67\x00\xfc\x00\x69\x00\xe7\x00\x61\x00"; |
| 357 |
const char utf16be_text[] = |
| 358 |
"\x00\x6c\x00\x69\x00\x6e\x00\x67\x00\xfc\x00\x69\x00\xe7\x00\x61"; |
| 359 |
#endif |
| 360 |
const char utf8_text[] = "\x6c\x69\x6e\x67\xc3\xbc\x69\xc3\xa7\x61"; |
| 361 |
|
| 362 |
TEST(ProgramTest, TestWriteWithSystemEncoding) { |
| 363 |
SmallString<128> TestDirectory; |
| 364 |
ASSERT_NO_ERROR(fs::createUniqueDirectory("program-test", TestDirectory)); |
| 365 |
errs() << "Test Directory: " << TestDirectory << '\n'; |
| 366 |
errs().flush(); |
| 367 |
SmallString<128> file_pathname(TestDirectory); |
| 368 |
path::append(file_pathname, "international-file.txt"); |
| 369 |
// Only on Windows we should encode in UTF16. For other systems, use UTF8 |
| 370 |
ASSERT_NO_ERROR(sys::writeFileWithEncoding(file_pathname.c_str(), utf8_text, |
| 371 |
sys::WEM_UTF16)); |
| 372 |
int fd = 0; |
| 373 |
ASSERT_NO_ERROR(fs::openFileForRead(file_pathname.c_str(), fd)); |
| 374 |
#if defined(_WIN32) |
| 375 |
char buf[18]; |
| 376 |
ASSERT_EQ(::read(fd, buf, 18), 18); |
| 377 |
const char *utf16_text; |
| 378 |
if (strncmp(buf, "\xfe\xff", 2) == 0) { // UTF16-BE |
| 379 |
utf16_text = utf16be_text; |
| 380 |
} else if (strncmp(buf, "\xff\xfe", 2) == 0) { // UTF16-LE |
| 381 |
utf16_text = utf16le_text; |
| 382 |
} else { |
| 383 |
FAIL() << "Invalid BOM in UTF-16 file"; |
| 384 |
} |
| 385 |
ASSERT_EQ(strncmp(&buf[2], utf16_text, 16), 0); |
| 386 |
#else |
| 387 |
char buf[10]; |
| 388 |
ASSERT_EQ(::read(fd, buf, 10), 10); |
| 389 |
ASSERT_EQ(strncmp(buf, utf8_text, 10), 0); |
| 390 |
#endif |
| 391 |
::close(fd); |
| 392 |
ASSERT_NO_ERROR(fs::remove(file_pathname.str())); |
| 393 |
ASSERT_NO_ERROR(fs::remove(TestDirectory.str())); |
| 394 |
} |
| 395 |
|
| 396 |
TEST_F(ProgramEnvTest, TestExecuteAndWaitStatistics) { |
| 397 |
using namespace llvm::sys; |
| 398 |
|
| 399 |
if (getenv("LLVM_PROGRAM_TEST_STATISTICS")) |
| 400 |
exit(0); |
| 401 |
|
| 402 |
std::string Executable = |
| 403 |
sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1); |
| 404 |
StringRef argv[] = { |
| 405 |
Executable, "--gtest_filter=ProgramEnvTest.TestExecuteAndWaitStatistics"}; |
| 406 |
|
| 407 |
// Add LLVM_PROGRAM_TEST_STATISTICS to the environment of the child. |
| 408 |
addEnvVar("LLVM_PROGRAM_TEST_STATISTICS=1"); |
| 409 |
|
| 410 |
std::string Error; |
| 411 |
bool ExecutionFailed; |
| 412 |
std::optional<ProcessStatistics> ProcStat; |
| 413 |
int RetCode = ExecuteAndWait(Executable, argv, getEnviron(), {}, 0, 0, &Error, |
| 414 |
&ExecutionFailed, &ProcStat); |
| 415 |
ASSERT_EQ(0, RetCode); |
| 416 |
ASSERT_TRUE(ProcStat); |
| 417 |
ASSERT_GE(ProcStat->UserTime, std::chrono::microseconds(0)); |
| 418 |
ASSERT_GE(ProcStat->TotalTime, ProcStat->UserTime); |
| 419 |
} |
| 420 |
|
| 421 |
TEST_F(ProgramEnvTest, TestLockFile) { |
| 422 |
using namespace llvm::sys; |
| 423 |
|
| 424 |
if (const char *LockedFile = getenv("LLVM_PROGRAM_TEST_LOCKED_FILE")) { |
| 425 |
// Child process. |
| 426 |
int FD2; |
| 427 |
ASSERT_NO_ERROR(fs::openFileForReadWrite(LockedFile, FD2, |
| 428 |
fs::CD_OpenExisting, fs::OF_None)); |
| 429 |
|
| 430 |
std::error_code ErrC = fs::tryLockFile(FD2, std::chrono::seconds(5)); |
| 431 |
ASSERT_NO_ERROR(ErrC); |
| 432 |
ASSERT_NO_ERROR(fs::unlockFile(FD2)); |
| 433 |
close(FD2); |
| 434 |
exit(0); |
| 435 |
} |
| 436 |
|
| 437 |
// Create file that will be locked. |
| 438 |
SmallString<64> LockedFile; |
| 439 |
int FD1; |
| 440 |
ASSERT_NO_ERROR( |
| 441 |
fs::createTemporaryFile("TestLockFile", "temp", FD1, LockedFile)); |
| 442 |
|
| 443 |
std::string Executable = |
| 444 |
sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1); |
| 445 |
StringRef argv[] = {Executable, "--gtest_filter=ProgramEnvTest.TestLockFile"}; |
| 446 |
|
| 447 |
// Add LLVM_PROGRAM_TEST_LOCKED_FILE to the environment of the child. |
| 448 |
std::string EnvVar = "LLVM_PROGRAM_TEST_LOCKED_FILE="; |
| 449 |
EnvVar += LockedFile.str(); |
| 450 |
addEnvVar(EnvVar); |
| 451 |
|
| 452 |
// Lock the file. |
| 453 |
ASSERT_NO_ERROR(fs::tryLockFile(FD1)); |
| 454 |
|
| 455 |
std::string Error; |
| 456 |
bool ExecutionFailed; |
| 457 |
ProcessInfo PI2 = ExecuteNoWait(Executable, argv, getEnviron(), {}, 0, &Error, |
| 458 |
&ExecutionFailed); |
| 459 |
ASSERT_FALSE(ExecutionFailed) << Error; |
| 460 |
ASSERT_TRUE(Error.empty()); |
| 461 |
ASSERT_NE(PI2.Pid, ProcessInfo::InvalidPid) << "Invalid process id"; |
| 462 |
|
| 463 |
// Wait some time to give the child process a chance to start. |
| 464 |
std::this_thread::sleep_for(std::chrono::milliseconds(100)); |
| 465 |
|
| 466 |
ASSERT_NO_ERROR(fs::unlockFile(FD1)); |
| 467 |
ProcessInfo WaitResult = llvm::sys::Wait(PI2, /*SecondsToWait=*/5, &Error); |
| 468 |
ASSERT_TRUE(Error.empty()); |
| 469 |
ASSERT_EQ(0, WaitResult.ReturnCode); |
| 470 |
ASSERT_EQ(WaitResult.Pid, PI2.Pid); |
| 471 |
sys::fs::remove(LockedFile); |
| 472 |
} |
| 473 |
|
| 474 |
TEST_F(ProgramEnvTest, TestExecuteWithNoStacktraceHandler) { |
| 475 |
using namespace llvm::sys; |
| 476 |
|
| 477 |
if (getenv("LLVM_PROGRAM_TEST_NO_STACKTRACE_HANDLER")) { |
| 478 |
sys::PrintStackTrace(errs()); |
| 479 |
exit(0); |
| 480 |
} |
| 481 |
|
| 482 |
std::string Executable = |
| 483 |
sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1); |
| 484 |
StringRef argv[] = { |
| 485 |
Executable, |
| 486 |
"--gtest_filter=ProgramEnvTest.TestExecuteWithNoStacktraceHandler"}; |
| 487 |
|
| 488 |
addEnvVar("LLVM_PROGRAM_TEST_NO_STACKTRACE_HANDLER=1"); |
| 489 |
|
| 490 |
std::string Error; |
| 491 |
bool ExecutionFailed; |
| 492 |
int RetCode = ExecuteAndWait(Executable, argv, getEnviron(), {}, 0, 0, &Error, |
| 493 |
&ExecutionFailed); |
| 494 |
EXPECT_FALSE(ExecutionFailed) << Error; |
| 495 |
ASSERT_EQ(0, RetCode); |
| 496 |
} |
| 497 |
|
| 498 |
} // end anonymous namespace |