X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=unittests%2FSupport%2FProgramTest.cpp;h=4e7316fb3ace5f3f37ac9642e1cf51f6ba325075;hb=d52e9a143f254be7ac1f2e648f3c3dbe278f4711;hp=479b6b57ec236416f97ad805f77ede8d7c4e1f0b;hpb=6641fa7c6c8873343d94f48a996209ebeb7b5b34;p=oota-llvm.git diff --git a/unittests/Support/ProgramTest.cpp b/unittests/Support/ProgramTest.cpp old mode 100755 new mode 100644 index 479b6b57ec2..4e7316fb3ac --- a/unittests/Support/ProgramTest.cpp +++ b/unittests/Support/ProgramTest.cpp @@ -8,11 +8,34 @@ //===----------------------------------------------------------------------===// #include "llvm/Support/CommandLine.h" +#include "llvm/Support/FileSystem.h" #include "llvm/Support/Path.h" #include "llvm/Support/Program.h" #include "gtest/gtest.h" - #include +#if defined(__APPLE__) +# include +#elif !defined(_MSC_VER) +// Forward declare environ in case it's not provided by stdlib.h. +extern char **environ; +#endif + +#if defined(LLVM_ON_UNIX) +#include +void sleep_for(unsigned int seconds) { + sleep(seconds); +} +#elif defined(LLVM_ON_WIN32) +#include +void sleep_for(unsigned int seconds) { + Sleep(seconds * 1000); +} +#else +#error sleep_for is not implemented on your platform. +#endif + +// From TestMain.cpp. +extern const char *TestMainArgv0; namespace { @@ -24,10 +47,14 @@ ProgramTestStringArg1("program-test-string-arg1"); static cl::opt ProgramTestStringArg2("program-test-string-arg2"); -static void CopyEnvironment(std::vector out) { - // environ appears to be pretty portable. +static void CopyEnvironment(std::vector &out) { +#ifdef __APPLE__ + char **envp = *_NSGetEnviron(); +#else + // environ seems to work for Windows and most other Unices. char **envp = environ; - while (*envp != 0) { +#endif + while (*envp != nullptr) { out.push_back(*envp); ++envp; } @@ -42,37 +69,155 @@ TEST(ProgramTest, CreateProcessTrailingSlash) { exit(1); } - // FIXME: Hardcoding argv0 here since I don't know a good cross-platform way - // to get it. Maybe ParseCommandLineOptions() should save it? - Path my_exe = Path::GetMainExecutable("SupportTests", &ProgramTestStringArg1); + std::string my_exe = + sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1); const char *argv[] = { my_exe.c_str(), - "--gtest_filter=ProgramTest.CreateProcessTrailingSlashChild", + "--gtest_filter=ProgramTest.CreateProcessTrailingSlash", "-program-test-string-arg1", "has\\\\ trailing\\", "-program-test-string-arg2", "has\\\\ trailing\\", - 0 + nullptr }; // Add LLVM_PROGRAM_TEST_CHILD to the environment of the child. std::vector envp; CopyEnvironment(envp); envp.push_back("LLVM_PROGRAM_TEST_CHILD=1"); - envp.push_back(0); + envp.push_back(nullptr); std::string error; bool ExecutionFailed; // Redirect stdout and stdin to NUL, but let stderr through. #ifdef LLVM_ON_WIN32 - Path nul("NUL"); + StringRef nul("NUL"); #else - Path nul("/dev/null"); + StringRef nul("/dev/null"); #endif - const Path *redirects[] = { &nul, &nul, 0 }; - int rc = Program::ExecuteAndWait(my_exe, argv, &envp[0], redirects, - /*secondsToWait=*/10, /*memoryLimit=*/0, - &error, &ExecutionFailed); + const StringRef *redirects[] = { &nul, &nul, nullptr }; + int rc = ExecuteAndWait(my_exe, argv, &envp[0], redirects, + /*secondsToWait=*/ 10, /*memoryLimit=*/ 0, &error, + &ExecutionFailed); EXPECT_FALSE(ExecutionFailed) << error; EXPECT_EQ(0, rc); } +TEST(ProgramTest, TestExecuteNoWait) { + using namespace llvm::sys; + + if (getenv("LLVM_PROGRAM_TEST_EXECUTE_NO_WAIT")) { + sleep_for(/*seconds*/ 1); + exit(0); + } + + std::string Executable = + sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1); + const char *argv[] = { + Executable.c_str(), + "--gtest_filter=ProgramTest.TestExecuteNoWait", + nullptr + }; + + // Add LLVM_PROGRAM_TEST_EXECUTE_NO_WAIT to the environment of the child. + std::vector envp; + CopyEnvironment(envp); + envp.push_back("LLVM_PROGRAM_TEST_EXECUTE_NO_WAIT=1"); + envp.push_back(nullptr); + + std::string Error; + bool ExecutionFailed; + ProcessInfo PI1 = ExecuteNoWait(Executable, argv, &envp[0], nullptr, 0, + &Error, &ExecutionFailed); + ASSERT_FALSE(ExecutionFailed) << Error; + ASSERT_NE(PI1.Pid, 0) << "Invalid process id"; + + unsigned LoopCount = 0; + + // Test that Wait() with WaitUntilTerminates=true works. In this case, + // LoopCount should only be incremented once. + while (true) { + ++LoopCount; + ProcessInfo WaitResult = Wait(PI1, 0, true, &Error); + ASSERT_TRUE(Error.empty()); + if (WaitResult.Pid == PI1.Pid) + break; + } + + EXPECT_EQ(LoopCount, 1u) << "LoopCount should be 1"; + + ProcessInfo PI2 = ExecuteNoWait(Executable, argv, &envp[0], nullptr, 0, + &Error, &ExecutionFailed); + ASSERT_FALSE(ExecutionFailed) << Error; + ASSERT_NE(PI2.Pid, 0) << "Invalid process id"; + + // Test that Wait() with SecondsToWait=0 performs a non-blocking wait. In this + // cse, LoopCount should be greater than 1 (more than one increment occurs). + while (true) { + ++LoopCount; + ProcessInfo WaitResult = Wait(PI2, 0, false, &Error); + ASSERT_TRUE(Error.empty()); + if (WaitResult.Pid == PI2.Pid) + break; + } + + ASSERT_GT(LoopCount, 1u) << "LoopCount should be >1"; +} + +TEST(ProgramTest, TestExecuteAndWaitTimeout) { + using namespace llvm::sys; + + if (getenv("LLVM_PROGRAM_TEST_TIMEOUT")) { + sleep_for(/*seconds*/ 10); + exit(0); + } + + std::string Executable = + sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1); + const char *argv[] = { + Executable.c_str(), + "--gtest_filter=ProgramTest.TestExecuteAndWaitTimeout", + nullptr + }; + + // Add LLVM_PROGRAM_TEST_TIMEOUT to the environment of the child. + std::vector envp; + CopyEnvironment(envp); + envp.push_back("LLVM_PROGRAM_TEST_TIMEOUT=1"); + envp.push_back(nullptr); + + std::string Error; + bool ExecutionFailed; + int RetCode = + ExecuteAndWait(Executable, argv, &envp[0], nullptr, /*secondsToWait=*/1, 0, + &Error, &ExecutionFailed); + ASSERT_EQ(-2, RetCode); +} + +TEST(ProgramTest, TestExecuteNegative) { + std::string Executable = "i_dont_exist"; + const char *argv[] = { Executable.c_str(), nullptr }; + + { + std::string Error; + bool ExecutionFailed; + int RetCode = ExecuteAndWait(Executable, argv, nullptr, nullptr, 0, 0, + &Error, &ExecutionFailed); + ASSERT_TRUE(RetCode < 0) << "On error ExecuteAndWait should return 0 or " + "positive value indicating the result code"; + ASSERT_TRUE(ExecutionFailed); + ASSERT_FALSE(Error.empty()); + } + + { + std::string Error; + bool ExecutionFailed; + ProcessInfo PI = ExecuteNoWait(Executable, argv, nullptr, nullptr, 0, + &Error, &ExecutionFailed); + ASSERT_EQ(PI.Pid, 0) + << "On error ExecuteNoWait should return an invalid ProcessInfo"; + ASSERT_TRUE(ExecutionFailed); + ASSERT_FALSE(Error.empty()); + } + +} + } // end anonymous namespace