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