unittests/Support/ProgramTest.cpp

   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 } // end anonymous namespace