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