unittests/Support/ProgramTest.cpp

   1 //===- unittest/Support/ProgramTest.cpp -----------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/Support/CommandLine.h"
  11 #include "llvm/Support/FileSystem.h"
  12 #include "llvm/Support/Path.h"
  13 #include "llvm/Support/Program.h"
  14 #include "gtest/gtest.h"
  15 #include <stdlib.h>
  16 #if defined(__APPLE__)
  17 # include <crt_externs.h>
  18 #elif !defined(_MSC_VER)
  19 // Forward declare environ in case it's not provided by stdlib.h.
  20 extern char **environ;
  21 #endif
  22
  23 #if defined(LLVM_ON_UNIX)
  24 #include <unistd.h>
  25 void sleep_for(unsigned int seconds) {
  26   sleep(seconds);
  27 }
  28 #elif defined(LLVM_ON_WIN32)
  29 #include <windows.h>
  30 void sleep_for(unsigned int seconds) {
  31   Sleep(seconds * 1000);
  32 }
  33 #else
  34 #error sleep_for is not implemented on your platform.
  35 #endif
  36
  37 #define ASSERT_NO_ERROR(x)                                                     \
  38   if (std::error_code ASSERT_NO_ERROR_ec = x) {                                \
  39     SmallString<128> MessageStorage;                                           \
  40     raw_svector_ostream Message(MessageStorage);                               \
  41     Message << #x ": did not return errc::success.\n"                          \
  42             << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n"          \
  43             << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n";      \
  44     GTEST_FATAL_FAILURE_(MessageStorage.c_str());                              \
  45   } else {                                                                     \
  46   }
  47 // From TestMain.cpp.
  48 extern const char *TestMainArgv0;
  49
  50 namespace {
  51
  52 using namespace llvm;
  53 using namespace sys;
  54
  55 static cl::opt<std::string>
  56 ProgramTestStringArg1("program-test-string-arg1");
  57 static cl::opt<std::string>
  58 ProgramTestStringArg2("program-test-string-arg2");
  59
  60 static void CopyEnvironment(std::vector<const char *> &out) {
  61 #ifdef __APPLE__
  62   char **envp = *_NSGetEnviron();
  63 #else
  64   // environ seems to work for Windows and most other Unices.
  65   char **envp = environ;
  66 #endif
  67   while (*envp != nullptr) {
  68     out.push_back(*envp);
  69     ++envp;
  70   }
  71 }
  72
  73 TEST(ProgramTest, CreateProcessTrailingSlash) {
  74   if (getenv("LLVM_PROGRAM_TEST_CHILD")) {
  75     if (ProgramTestStringArg1 == "has\\\\ trailing\\" &&
  76         ProgramTestStringArg2 == "has\\\\ trailing\\") {
  77       exit(0);  // Success!  The arguments were passed and parsed.
  78     }
  79     exit(1);
  80   }
  81
  82   std::string my_exe =
  83       sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1);
  84   const char *argv[] = {
  85     my_exe.c_str(),
  86     "--gtest_filter=ProgramTest.CreateProcessTrailingSlash",
  87     "-program-test-string-arg1", "has\\\\ trailing\\",
  88     "-program-test-string-arg2", "has\\\\ trailing\\",
  89     nullptr
  90   };
  91
  92   // Add LLVM_PROGRAM_TEST_CHILD to the environment of the child.
  93   std::vector<const char *> envp;
  94   CopyEnvironment(envp);
  95   envp.push_back("LLVM_PROGRAM_TEST_CHILD=1");
  96   envp.push_back(nullptr);
  97
  98   std::string error;
  99   bool ExecutionFailed;
 100   // Redirect stdout and stdin to NUL, but let stderr through.
 101 #ifdef LLVM_ON_WIN32
 102   StringRef nul("NUL");
 103 #else
 104   StringRef nul("/dev/null");
 105 #endif
 106   const StringRef *redirects[] = { &nul, &nul, nullptr };
 107   int rc = ExecuteAndWait(my_exe, argv, &envp[0], redirects,
 108                           /*secondsToWait=*/ 10, /*memoryLimit=*/ 0, &error,
 109                           &ExecutionFailed);
 110   EXPECT_FALSE(ExecutionFailed) << error;
 111   EXPECT_EQ(0, rc);
 112 }
 113
 114 TEST(ProgramTest, TestExecuteNoWait) {
 115   using namespace llvm::sys;
 116
 117   if (getenv("LLVM_PROGRAM_TEST_EXECUTE_NO_WAIT")) {
 118     sleep_for(/*seconds*/ 1);
 119     exit(0);
 120   }
 121
 122   std::string Executable =
 123       sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1);
 124   const char *argv[] = {
 125     Executable.c_str(),
 126     "--gtest_filter=ProgramTest.TestExecuteNoWait",
 127     nullptr
 128   };
 129
 130   // Add LLVM_PROGRAM_TEST_EXECUTE_NO_WAIT to the environment of the child.
 131   std::vector<const char *> envp;
 132   CopyEnvironment(envp);
 133   envp.push_back("LLVM_PROGRAM_TEST_EXECUTE_NO_WAIT=1");
 134   envp.push_back(nullptr);
 135
 136   std::string Error;
 137   bool ExecutionFailed;
 138   ProcessInfo PI1 = ExecuteNoWait(Executable, argv, &envp[0], nullptr, 0,
 139                                   &Error, &ExecutionFailed);
 140   ASSERT_FALSE(ExecutionFailed) << Error;
 141   ASSERT_NE(PI1.Pid, 0) << "Invalid process id";
 142
 143   unsigned LoopCount = 0;
 144
 145   // Test that Wait() with WaitUntilTerminates=true works. In this case,
 146   // LoopCount should only be incremented once.
 147   while (true) {
 148     ++LoopCount;
 149     ProcessInfo WaitResult = Wait(PI1, 0, true, &Error);
 150     ASSERT_TRUE(Error.empty());
 151     if (WaitResult.Pid == PI1.Pid)
 152       break;
 153   }
 154
 155   EXPECT_EQ(LoopCount, 1u) << "LoopCount should be 1";
 156
 157   ProcessInfo PI2 = ExecuteNoWait(Executable, argv, &envp[0], nullptr, 0,
 158                                   &Error, &ExecutionFailed);
 159   ASSERT_FALSE(ExecutionFailed) << Error;
 160   ASSERT_NE(PI2.Pid, 0) << "Invalid process id";
 161
 162   // Test that Wait() with SecondsToWait=0 performs a non-blocking wait. In this
 163   // cse, LoopCount should be greater than 1 (more than one increment occurs).
 164   while (true) {
 165     ++LoopCount;
 166     ProcessInfo WaitResult = Wait(PI2, 0, false, &Error);
 167     ASSERT_TRUE(Error.empty());
 168     if (WaitResult.Pid == PI2.Pid)
 169       break;
 170   }
 171
 172   ASSERT_GT(LoopCount, 1u) << "LoopCount should be >1";
 173 }
 174
 175 TEST(ProgramTest, TestExecuteAndWaitTimeout) {
 176   using namespace llvm::sys;
 177
 178   if (getenv("LLVM_PROGRAM_TEST_TIMEOUT")) {
 179     sleep_for(/*seconds*/ 10);
 180     exit(0);
 181   }
 182
 183   std::string Executable =
 184       sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1);
 185   const char *argv[] = {
 186     Executable.c_str(),
 187     "--gtest_filter=ProgramTest.TestExecuteAndWaitTimeout",
 188     nullptr
 189   };
 190
 191   // Add LLVM_PROGRAM_TEST_TIMEOUT to the environment of the child.
 192   std::vector<const char *> envp;
 193   CopyEnvironment(envp);
 194   envp.push_back("LLVM_PROGRAM_TEST_TIMEOUT=1");
 195   envp.push_back(nullptr);
 196
 197   std::string Error;
 198   bool ExecutionFailed;
 199   int RetCode =
 200       ExecuteAndWait(Executable, argv, &envp[0], nullptr, /*secondsToWait=*/1, 0,
 201                      &Error, &ExecutionFailed);
 202   ASSERT_EQ(-2, RetCode);
 203 }
 204
 205 TEST(ProgramTest, TestExecuteNegative) {
 206   std::string Executable = "i_dont_exist";
 207   const char *argv[] = { Executable.c_str(), nullptr };
 208
 209   {
 210     std::string Error;
 211     bool ExecutionFailed;
 212     int RetCode = ExecuteAndWait(Executable, argv, nullptr, nullptr, 0, 0,
 213                                  &Error, &ExecutionFailed);
 214     ASSERT_TRUE(RetCode < 0) << "On error ExecuteAndWait should return 0 or "
 215                                 "positive value indicating the result code";
 216     ASSERT_TRUE(ExecutionFailed);
 217     ASSERT_FALSE(Error.empty());
 218   }
 219
 220   {
 221     std::string Error;
 222     bool ExecutionFailed;
 223     ProcessInfo PI = ExecuteNoWait(Executable, argv, nullptr, nullptr, 0,
 224                                    &Error, &ExecutionFailed);
 225     ASSERT_EQ(PI.Pid, 0)
 226         << "On error ExecuteNoWait should return an invalid ProcessInfo";
 227     ASSERT_TRUE(ExecutionFailed);
 228     ASSERT_FALSE(Error.empty());
 229   }
 230
 231 }
 232
 233 #ifdef LLVM_ON_WIN32
 234 const char utf16le_text[] =
 235     "\x6c\x00\x69\x00\x6e\x00\x67\x00\xfc\x00\x69\x00\xe7\x00\x61\x00";
 236 const char utf16be_text[] =
 237     "\x00\x6c\x00\x69\x00\x6e\x00\x67\x00\xfc\x00\x69\x00\xe7\x00\x61";
 238 #endif
 239 const char utf8_text[] = "\x6c\x69\x6e\x67\xc3\xbc\x69\xc3\xa7\x61";
 240
 241 TEST(ProgramTest, TestWriteWithSystemEncoding) {
 242   SmallString<128> TestDirectory;
 243   ASSERT_NO_ERROR(fs::createUniqueDirectory("program-test", TestDirectory));
 244   errs() << "Test Directory: " << TestDirectory << '\n';
 245   errs().flush();
 246   SmallString<128> file_pathname(TestDirectory);
 247   path::append(file_pathname, "international-file.txt");
 248   // Only on Windows we should encode in UTF16. For other systems, use UTF8
 249   ASSERT_NO_ERROR(sys::writeFileWithEncoding(file_pathname.c_str(), utf8_text,
 250                                              sys::WEM_UTF16));
 251   int fd = 0;
 252   ASSERT_NO_ERROR(fs::openFileForRead(file_pathname.c_str(), fd));
 253 #if defined(LLVM_ON_WIN32)
 254   char buf[18];
 255   ASSERT_EQ(::read(fd, buf, 18), 18);
 256   if (strncmp(buf, "\xfe\xff", 2) == 0) { // UTF16-BE
 257     ASSERT_EQ(strncmp(&buf[2], utf16be_text, 16), 0);
 258   } else if (strncmp(buf, "\xff\xfe", 2) == 0) { // UTF16-LE
 259     ASSERT_EQ(strncmp(&buf[2], utf16le_text, 16), 0);
 260   } else {
 261     FAIL() << "Invalid BOM in UTF-16 file";
 262   }
 263 #else
 264   char buf[10];
 265   ASSERT_EQ(::read(fd, buf, 10), 10);
 266   ASSERT_EQ(strncmp(buf, utf8_text, 10), 0);
 267 #endif
 268   ::close(fd);
 269   ASSERT_NO_ERROR(fs::remove(file_pathname.str()));
 270   ASSERT_NO_ERROR(fs::remove(TestDirectory.str()));
 271 }
 272
 273 } // end anonymous namespace