1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #define _CRT_SECURE_NO_WARNINGS
9 #include "base/command_line.h"
10 #include "base/debug/alias.h"
11 #include "base/debug/stack_trace.h"
12 #include "base/files/file_path.h"
13 #include "base/logging.h"
14 #include "base/memory/scoped_ptr.h"
15 #include "base/path_service.h"
16 #include "base/posix/eintr_wrapper.h"
17 #include "base/process/kill.h"
18 #include "base/process/launch.h"
19 #include "base/process/memory.h"
20 #include "base/process/process.h"
21 #include "base/process/process_metrics.h"
22 #include "base/strings/string_number_conversions.h"
23 #include "base/strings/utf_string_conversions.h"
24 #include "base/synchronization/waitable_event.h"
25 #include "base/test/multiprocess_test.h"
26 #include "base/test/test_timeouts.h"
27 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
28 #include "base/threading/platform_thread.h"
29 #include "base/threading/thread.h"
30 #include "testing/gtest/include/gtest/gtest.h"
31 #include "testing/multiprocess_func_list.h"
42 #include <sys/resource.h>
43 #include <sys/socket.h>
48 #include "base/win/windows_version.h"
50 #if defined(OS_MACOSX)
51 #include <mach/vm_param.h>
52 #include <malloc/malloc.h>
59 #if defined(OS_ANDROID)
60 const char kShellPath[] = "/system/bin/sh";
61 const char kPosixShell[] = "sh";
63 const char kShellPath[] = "/bin/sh";
64 const char kPosixShell[] = "bash";
67 const char kSignalFileSlow[] = "SlowChildProcess.die";
68 const char kSignalFileKill[] = "KilledChildProcess.die";
71 const int kExpectedStillRunningExitCode = 0x102;
72 const int kExpectedKilledExitCode = 1;
74 const int kExpectedStillRunningExitCode = 0;
77 // Sleeps until file filename is created.
78 void WaitToDie(const char* filename) {
81 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
82 fp = fopen(filename, "r");
87 // Signals children they should die now.
88 void SignalChildren(const char* filename) {
89 FILE* fp = fopen(filename, "w");
93 // Using a pipe to the child to wait for an event was considered, but
94 // there were cases in the past where pipes caused problems (other
95 // libraries closing the fds, child deadlocking). This is a simple
96 // case, so it's not worth the risk. Using wait loops is discouraged
98 base::TerminationStatus WaitForChildTermination(base::ProcessHandle handle,
100 // Now we wait until the result is something other than STILL_RUNNING.
101 base::TerminationStatus status = base::TERMINATION_STATUS_STILL_RUNNING;
102 const base::TimeDelta kInterval = base::TimeDelta::FromMilliseconds(20);
103 base::TimeDelta waited;
105 status = base::GetTerminationStatus(handle, exit_code);
106 base::PlatformThread::Sleep(kInterval);
108 } while (status == base::TERMINATION_STATUS_STILL_RUNNING &&
109 // Waiting for more time for process termination on android devices.
110 #if defined(OS_ANDROID)
111 waited < TestTimeouts::large_test_timeout());
113 waited < TestTimeouts::action_max_timeout());
121 class ProcessUtilTest : public base::MultiProcessTest {
123 #if defined(OS_POSIX)
124 // Spawn a child process that counts how many file descriptors are open.
125 int CountOpenFDsInChild();
127 // Converts the filename to a platform specific filepath.
128 // On Android files can not be created in arbitrary directories.
129 static std::string GetSignalFilePath(const char* filename);
132 std::string ProcessUtilTest::GetSignalFilePath(const char* filename) {
133 #if !defined(OS_ANDROID)
137 PathService::Get(base::DIR_CACHE, &tmp_dir);
138 tmp_dir = tmp_dir.Append(filename);
139 return tmp_dir.value();
143 MULTIPROCESS_TEST_MAIN(SimpleChildProcess) {
147 // TODO(viettrungluu): This should be in a "MultiProcessTestTest".
148 TEST_F(ProcessUtilTest, SpawnChild) {
149 base::ProcessHandle handle = SpawnChild("SimpleChildProcess");
150 ASSERT_NE(base::kNullProcessHandle, handle);
151 EXPECT_TRUE(base::WaitForSingleProcess(
152 handle, TestTimeouts::action_max_timeout()));
153 base::CloseProcessHandle(handle);
156 MULTIPROCESS_TEST_MAIN(SlowChildProcess) {
157 WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileSlow).c_str());
161 TEST_F(ProcessUtilTest, KillSlowChild) {
162 const std::string signal_file =
163 ProcessUtilTest::GetSignalFilePath(kSignalFileSlow);
164 remove(signal_file.c_str());
165 base::ProcessHandle handle = SpawnChild("SlowChildProcess");
166 ASSERT_NE(base::kNullProcessHandle, handle);
167 SignalChildren(signal_file.c_str());
168 EXPECT_TRUE(base::WaitForSingleProcess(
169 handle, TestTimeouts::action_max_timeout()));
170 base::CloseProcessHandle(handle);
171 remove(signal_file.c_str());
174 // Times out on Linux and Win, flakes on other platforms, http://crbug.com/95058
175 TEST_F(ProcessUtilTest, DISABLED_GetTerminationStatusExit) {
176 const std::string signal_file =
177 ProcessUtilTest::GetSignalFilePath(kSignalFileSlow);
178 remove(signal_file.c_str());
179 base::ProcessHandle handle = SpawnChild("SlowChildProcess");
180 ASSERT_NE(base::kNullProcessHandle, handle);
183 EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
184 base::GetTerminationStatus(handle, &exit_code));
185 EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
187 SignalChildren(signal_file.c_str());
189 base::TerminationStatus status =
190 WaitForChildTermination(handle, &exit_code);
191 EXPECT_EQ(base::TERMINATION_STATUS_NORMAL_TERMINATION, status);
192 EXPECT_EQ(0, exit_code);
193 base::CloseProcessHandle(handle);
194 remove(signal_file.c_str());
198 // TODO(cpu): figure out how to test this in other platforms.
199 TEST_F(ProcessUtilTest, GetProcId) {
200 base::ProcessId id1 = base::GetProcId(GetCurrentProcess());
202 base::ProcessHandle handle = SpawnChild("SimpleChildProcess");
203 ASSERT_NE(base::kNullProcessHandle, handle);
204 base::ProcessId id2 = base::GetProcId(handle);
207 base::CloseProcessHandle(handle);
211 #if !defined(OS_MACOSX)
212 // This test is disabled on Mac, since it's flaky due to ReportCrash
213 // taking a variable amount of time to parse and load the debug and
214 // symbol data for this unit test's executable before firing the
217 // TODO(gspencer): turn this test process into a very small program
218 // with no symbols (instead of using the multiprocess testing
219 // framework) to reduce the ReportCrash overhead.
220 const char kSignalFileCrash[] = "CrashingChildProcess.die";
222 MULTIPROCESS_TEST_MAIN(CrashingChildProcess) {
223 WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileCrash).c_str());
224 #if defined(OS_POSIX)
225 // Have to disable to signal handler for segv so we can get a crash
226 // instead of an abnormal termination through the crash dump handler.
227 ::signal(SIGSEGV, SIG_DFL);
229 // Make this process have a segmentation fault.
230 volatile int* oops = NULL;
235 // This test intentionally crashes, so we don't need to run it under
237 #if defined(ADDRESS_SANITIZER) || defined(SYZYASAN)
238 #define MAYBE_GetTerminationStatusCrash DISABLED_GetTerminationStatusCrash
240 #define MAYBE_GetTerminationStatusCrash GetTerminationStatusCrash
242 TEST_F(ProcessUtilTest, MAYBE_GetTerminationStatusCrash) {
243 const std::string signal_file =
244 ProcessUtilTest::GetSignalFilePath(kSignalFileCrash);
245 remove(signal_file.c_str());
246 base::ProcessHandle handle = SpawnChild("CrashingChildProcess");
247 ASSERT_NE(base::kNullProcessHandle, handle);
250 EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
251 base::GetTerminationStatus(handle, &exit_code));
252 EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
254 SignalChildren(signal_file.c_str());
256 base::TerminationStatus status =
257 WaitForChildTermination(handle, &exit_code);
258 EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_CRASHED, status);
261 EXPECT_EQ(0xc0000005, exit_code);
262 #elif defined(OS_POSIX)
263 int signaled = WIFSIGNALED(exit_code);
264 EXPECT_NE(0, signaled);
265 int signal = WTERMSIG(exit_code);
266 EXPECT_EQ(SIGSEGV, signal);
268 base::CloseProcessHandle(handle);
270 // Reset signal handlers back to "normal".
271 base::debug::EnableInProcessStackDumping();
272 remove(signal_file.c_str());
274 #endif // !defined(OS_MACOSX)
276 MULTIPROCESS_TEST_MAIN(KilledChildProcess) {
277 WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileKill).c_str());
280 HANDLE handle = ::OpenProcess(PROCESS_ALL_ACCESS, 0, ::GetCurrentProcessId());
281 ::TerminateProcess(handle, kExpectedKilledExitCode);
282 #elif defined(OS_POSIX)
283 // Send a SIGKILL to this process, just like the OOM killer would.
284 ::kill(getpid(), SIGKILL);
289 TEST_F(ProcessUtilTest, GetTerminationStatusKill) {
290 const std::string signal_file =
291 ProcessUtilTest::GetSignalFilePath(kSignalFileKill);
292 remove(signal_file.c_str());
293 base::ProcessHandle handle = SpawnChild("KilledChildProcess");
294 ASSERT_NE(base::kNullProcessHandle, handle);
297 EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
298 base::GetTerminationStatus(handle, &exit_code));
299 EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
301 SignalChildren(signal_file.c_str());
303 base::TerminationStatus status =
304 WaitForChildTermination(handle, &exit_code);
305 EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_WAS_KILLED, status);
307 EXPECT_EQ(kExpectedKilledExitCode, exit_code);
308 #elif defined(OS_POSIX)
309 int signaled = WIFSIGNALED(exit_code);
310 EXPECT_NE(0, signaled);
311 int signal = WTERMSIG(exit_code);
312 EXPECT_EQ(SIGKILL, signal);
314 base::CloseProcessHandle(handle);
315 remove(signal_file.c_str());
318 // Ensure that the priority of a process is restored correctly after
319 // backgrounding and restoring.
320 // Note: a platform may not be willing or able to lower the priority of
321 // a process. The calls to SetProcessBackground should be noops then.
322 TEST_F(ProcessUtilTest, SetProcessBackgrounded) {
323 base::ProcessHandle handle = SpawnChild("SimpleChildProcess");
324 base::Process process(handle);
325 int old_priority = process.GetPriority();
327 EXPECT_TRUE(process.SetProcessBackgrounded(true));
328 EXPECT_TRUE(process.IsProcessBackgrounded());
329 EXPECT_TRUE(process.SetProcessBackgrounded(false));
330 EXPECT_FALSE(process.IsProcessBackgrounded());
332 process.SetProcessBackgrounded(true);
333 process.SetProcessBackgrounded(false);
335 int new_priority = process.GetPriority();
336 EXPECT_EQ(old_priority, new_priority);
339 // Same as SetProcessBackgrounded but to this very process. It uses
340 // a different code path at least for Windows.
341 TEST_F(ProcessUtilTest, SetProcessBackgroundedSelf) {
342 base::Process process(base::Process::Current().handle());
343 int old_priority = process.GetPriority();
345 EXPECT_TRUE(process.SetProcessBackgrounded(true));
346 EXPECT_TRUE(process.IsProcessBackgrounded());
347 EXPECT_TRUE(process.SetProcessBackgrounded(false));
348 EXPECT_FALSE(process.IsProcessBackgrounded());
350 process.SetProcessBackgrounded(true);
351 process.SetProcessBackgrounded(false);
353 int new_priority = process.GetPriority();
354 EXPECT_EQ(old_priority, new_priority);
358 // TODO(estade): if possible, port this test.
359 TEST_F(ProcessUtilTest, GetAppOutput) {
360 // Let's create a decently long message.
362 for (int i = 0; i < 1025; i++) { // 1025 so it does not end on a kilo-byte
366 // cmd.exe's echo always adds a \r\n to its output.
367 std::string expected(message);
370 FilePath cmd(L"cmd.exe");
371 CommandLine cmd_line(cmd);
372 cmd_line.AppendArg("/c");
373 cmd_line.AppendArg("echo " + message + "");
375 ASSERT_TRUE(base::GetAppOutput(cmd_line, &output));
376 EXPECT_EQ(expected, output);
378 // Let's make sure stderr is ignored.
379 CommandLine other_cmd_line(cmd);
380 other_cmd_line.AppendArg("/c");
381 // http://msdn.microsoft.com/library/cc772622.aspx
382 cmd_line.AppendArg("echo " + message + " >&2");
384 ASSERT_TRUE(base::GetAppOutput(other_cmd_line, &output));
385 EXPECT_EQ("", output);
388 // TODO(estade): if possible, port this test.
389 TEST_F(ProcessUtilTest, LaunchAsUser) {
390 base::UserTokenHandle token;
391 ASSERT_TRUE(OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &token));
392 base::LaunchOptions options;
393 options.as_user = token;
394 EXPECT_TRUE(base::LaunchProcess(MakeCmdLine("SimpleChildProcess"), options,
398 static const char kEventToTriggerHandleSwitch[] = "event-to-trigger-handle";
400 MULTIPROCESS_TEST_MAIN(TriggerEventChildProcess) {
401 std::string handle_value_string =
402 CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
403 kEventToTriggerHandleSwitch);
404 CHECK(!handle_value_string.empty());
406 uint64 handle_value_uint64;
407 CHECK(base::StringToUint64(handle_value_string, &handle_value_uint64));
408 // Give ownership of the handle to |event|.
409 base::WaitableEvent event(reinterpret_cast<HANDLE>(handle_value_uint64));
416 TEST_F(ProcessUtilTest, InheritSpecifiedHandles) {
417 // Manually create the event, so that it can be inheritable.
418 SECURITY_ATTRIBUTES security_attributes = {};
419 security_attributes.nLength = static_cast<DWORD>(sizeof(security_attributes));
420 security_attributes.lpSecurityDescriptor = NULL;
421 security_attributes.bInheritHandle = true;
423 // Takes ownership of the event handle.
424 base::WaitableEvent event(
425 CreateEvent(&security_attributes, true, false, NULL));
426 base::HandlesToInheritVector handles_to_inherit;
427 handles_to_inherit.push_back(event.handle());
428 base::LaunchOptions options;
429 options.handles_to_inherit = &handles_to_inherit;
431 CommandLine cmd_line = MakeCmdLine("TriggerEventChildProcess");
432 cmd_line.AppendSwitchASCII(kEventToTriggerHandleSwitch,
433 base::Uint64ToString(reinterpret_cast<uint64>(event.handle())));
435 // This functionality actually requires Vista or later. Make sure that it
436 // fails properly on XP.
437 if (base::win::GetVersion() < base::win::VERSION_VISTA) {
438 EXPECT_FALSE(base::LaunchProcess(cmd_line, options, NULL));
442 // Launch the process and wait for it to trigger the event.
443 ASSERT_TRUE(base::LaunchProcess(cmd_line, options, NULL));
444 EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
446 #endif // defined(OS_WIN)
448 #if defined(OS_POSIX)
452 // Returns the maximum number of files that a process can have open.
453 // Returns 0 on error.
454 int GetMaxFilesOpenInProcess() {
456 if (getrlimit(RLIMIT_NOFILE, &rlim) != 0) {
460 // rlim_t is a uint64 - clip to maxint. We do this since FD #s are ints
461 // which are all 32 bits on the supported platforms.
462 rlim_t max_int = static_cast<rlim_t>(std::numeric_limits<int32>::max());
463 if (rlim.rlim_cur > max_int) {
467 return rlim.rlim_cur;
470 const int kChildPipe = 20; // FD # for write end of pipe in child process.
474 MULTIPROCESS_TEST_MAIN(ProcessUtilsLeakFDChildProcess) {
475 // This child process counts the number of open FDs, it then writes that
476 // number out to a pipe connected to the parent.
477 int num_open_files = 0;
478 int write_pipe = kChildPipe;
479 int max_files = GetMaxFilesOpenInProcess();
480 for (int i = STDERR_FILENO + 1; i < max_files; i++) {
481 if (i != kChildPipe) {
483 if ((fd = HANDLE_EINTR(dup(i))) != -1) {
490 int written = HANDLE_EINTR(write(write_pipe, &num_open_files,
491 sizeof(num_open_files)));
492 DCHECK_EQ(static_cast<size_t>(written), sizeof(num_open_files));
493 int ret = IGNORE_EINTR(close(write_pipe));
499 int ProcessUtilTest::CountOpenFDsInChild() {
504 base::FileHandleMappingVector fd_mapping_vec;
505 fd_mapping_vec.push_back(std::pair<int, int>(fds[1], kChildPipe));
506 base::LaunchOptions options;
507 options.fds_to_remap = &fd_mapping_vec;
508 base::ProcessHandle handle =
509 SpawnChildWithOptions("ProcessUtilsLeakFDChildProcess", options);
511 int ret = IGNORE_EINTR(close(fds[1]));
514 // Read number of open files in client process from pipe;
515 int num_open_files = -1;
517 HANDLE_EINTR(read(fds[0], &num_open_files, sizeof(num_open_files)));
518 CHECK_EQ(bytes_read, static_cast<ssize_t>(sizeof(num_open_files)));
520 #if defined(THREAD_SANITIZER)
521 // Compiler-based ThreadSanitizer makes this test slow.
522 CHECK(base::WaitForSingleProcess(handle, base::TimeDelta::FromSeconds(3)));
524 CHECK(base::WaitForSingleProcess(handle, base::TimeDelta::FromSeconds(1)));
526 base::CloseProcessHandle(handle);
527 ret = IGNORE_EINTR(close(fds[0]));
530 return num_open_files;
533 #if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER)
534 // ProcessUtilTest.FDRemapping is flaky when ran under xvfb-run on Precise.
535 // The problem is 100% reproducible with both ASan and TSan.
536 // See http://crbug.com/136720.
537 #define MAYBE_FDRemapping DISABLED_FDRemapping
539 #define MAYBE_FDRemapping FDRemapping
541 TEST_F(ProcessUtilTest, MAYBE_FDRemapping) {
542 int fds_before = CountOpenFDsInChild();
544 // open some dummy fds to make sure they don't propagate over to the
546 int dev_null = open("/dev/null", O_RDONLY);
548 socketpair(AF_UNIX, SOCK_STREAM, 0, sockets);
550 int fds_after = CountOpenFDsInChild();
552 ASSERT_EQ(fds_after, fds_before);
555 ret = IGNORE_EINTR(close(sockets[0]));
557 ret = IGNORE_EINTR(close(sockets[1]));
559 ret = IGNORE_EINTR(close(dev_null));
565 std::string TestLaunchProcess(const base::EnvironmentMap& env_changes,
566 const int clone_flags) {
567 std::vector<std::string> args;
568 base::FileHandleMappingVector fds_to_remap;
570 args.push_back(kPosixShell);
571 args.push_back("-c");
572 args.push_back("echo $BASE_TEST");
575 PCHECK(pipe(fds) == 0);
577 fds_to_remap.push_back(std::make_pair(fds[1], 1));
578 base::LaunchOptions options;
580 options.environ = env_changes;
581 options.fds_to_remap = &fds_to_remap;
582 #if defined(OS_LINUX)
583 options.clone_flags = clone_flags;
585 CHECK_EQ(0, clone_flags);
587 EXPECT_TRUE(base::LaunchProcess(args, options, NULL));
588 PCHECK(IGNORE_EINTR(close(fds[1])) == 0);
591 const ssize_t n = HANDLE_EINTR(read(fds[0], buf, sizeof(buf)));
594 PCHECK(IGNORE_EINTR(close(fds[0])) == 0);
596 return std::string(buf, n);
599 const char kLargeString[] =
600 "0123456789012345678901234567890123456789012345678901234567890123456789"
601 "0123456789012345678901234567890123456789012345678901234567890123456789"
602 "0123456789012345678901234567890123456789012345678901234567890123456789"
603 "0123456789012345678901234567890123456789012345678901234567890123456789"
604 "0123456789012345678901234567890123456789012345678901234567890123456789"
605 "0123456789012345678901234567890123456789012345678901234567890123456789"
606 "0123456789012345678901234567890123456789012345678901234567890123456789";
610 TEST_F(ProcessUtilTest, LaunchProcess) {
611 base::EnvironmentMap env_changes;
612 const int no_clone_flags = 0;
614 const char kBaseTest[] = "BASE_TEST";
616 env_changes[kBaseTest] = "bar";
617 EXPECT_EQ("bar\n", TestLaunchProcess(env_changes, no_clone_flags));
620 EXPECT_EQ(0, setenv(kBaseTest, "testing", 1 /* override */));
621 EXPECT_EQ("testing\n", TestLaunchProcess(env_changes, no_clone_flags));
623 env_changes[kBaseTest] = std::string();
624 EXPECT_EQ("\n", TestLaunchProcess(env_changes, no_clone_flags));
626 env_changes[kBaseTest] = "foo";
627 EXPECT_EQ("foo\n", TestLaunchProcess(env_changes, no_clone_flags));
630 EXPECT_EQ(0, setenv(kBaseTest, kLargeString, 1 /* override */));
631 EXPECT_EQ(std::string(kLargeString) + "\n",
632 TestLaunchProcess(env_changes, no_clone_flags));
634 env_changes[kBaseTest] = "wibble";
635 EXPECT_EQ("wibble\n", TestLaunchProcess(env_changes, no_clone_flags));
637 #if defined(OS_LINUX)
638 // Test a non-trival value for clone_flags.
639 // Don't test on Valgrind as it has limited support for clone().
640 if (!RunningOnValgrind()) {
641 EXPECT_EQ("wibble\n", TestLaunchProcess(env_changes, CLONE_FS | SIGCHLD));
646 TEST_F(ProcessUtilTest, GetAppOutput) {
649 #if defined(OS_ANDROID)
650 std::vector<std::string> argv;
651 argv.push_back("sh"); // Instead of /bin/sh, force path search to find it.
652 argv.push_back("-c");
654 argv.push_back("exit 0");
655 EXPECT_TRUE(base::GetAppOutput(CommandLine(argv), &output));
656 EXPECT_STREQ("", output.c_str());
659 EXPECT_FALSE(base::GetAppOutput(CommandLine(argv), &output));
660 EXPECT_STREQ("", output.c_str());
662 argv[2] = "echo foobar42";
663 EXPECT_TRUE(base::GetAppOutput(CommandLine(argv), &output));
664 EXPECT_STREQ("foobar42\n", output.c_str());
666 EXPECT_TRUE(base::GetAppOutput(CommandLine(FilePath("true")), &output));
667 EXPECT_STREQ("", output.c_str());
669 EXPECT_FALSE(base::GetAppOutput(CommandLine(FilePath("false")), &output));
671 std::vector<std::string> argv;
672 argv.push_back("/bin/echo");
673 argv.push_back("-n");
674 argv.push_back("foobar42");
675 EXPECT_TRUE(base::GetAppOutput(CommandLine(argv), &output));
676 EXPECT_STREQ("foobar42", output.c_str());
677 #endif // defined(OS_ANDROID)
680 TEST_F(ProcessUtilTest, GetAppOutputRestricted) {
681 // Unfortunately, since we can't rely on the path, we need to know where
682 // everything is. So let's use /bin/sh, which is on every POSIX system, and
684 std::vector<std::string> argv;
685 argv.push_back(std::string(kShellPath)); // argv[0]
686 argv.push_back("-c"); // argv[1]
688 // On success, should set |output|. We use |/bin/sh -c 'exit 0'| instead of
689 // |true| since the location of the latter may be |/bin| or |/usr/bin| (and we
690 // need absolute paths).
691 argv.push_back("exit 0"); // argv[2]; equivalent to "true"
692 std::string output = "abc";
693 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 100));
694 EXPECT_STREQ("", output.c_str());
696 argv[2] = "exit 1"; // equivalent to "false"
698 EXPECT_FALSE(base::GetAppOutputRestricted(CommandLine(argv),
700 EXPECT_STREQ("", output.c_str());
702 // Amount of output exactly equal to space allowed.
703 argv[2] = "echo 123456789"; // (the sh built-in doesn't take "-n")
705 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 10));
706 EXPECT_STREQ("123456789\n", output.c_str());
708 // Amount of output greater than space allowed.
710 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 5));
711 EXPECT_STREQ("12345", output.c_str());
713 // Amount of output less than space allowed.
715 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 15));
716 EXPECT_STREQ("123456789\n", output.c_str());
718 // Zero space allowed.
720 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 0));
721 EXPECT_STREQ("", output.c_str());
724 #if !defined(OS_MACOSX) && !defined(OS_OPENBSD)
725 // TODO(benwells): GetAppOutputRestricted should terminate applications
726 // with SIGPIPE when we have enough output. http://crbug.com/88502
727 TEST_F(ProcessUtilTest, GetAppOutputRestrictedSIGPIPE) {
728 std::vector<std::string> argv;
731 argv.push_back(std::string(kShellPath)); // argv[0]
732 argv.push_back("-c");
733 #if defined(OS_ANDROID)
734 argv.push_back("while echo 12345678901234567890; do :; done");
735 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 10));
736 EXPECT_STREQ("1234567890", output.c_str());
738 argv.push_back("yes");
739 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 10));
740 EXPECT_STREQ("y\ny\ny\ny\ny\n", output.c_str());
745 #if defined(ADDRESS_SANITIZER) && defined(OS_MACOSX) && \
746 defined(ARCH_CPU_64_BITS)
747 // Times out under AddressSanitizer on 64-bit OS X, see
748 // http://crbug.com/298197.
749 #define MAYBE_GetAppOutputRestrictedNoZombies \
750 DISABLED_GetAppOutputRestrictedNoZombies
752 #define MAYBE_GetAppOutputRestrictedNoZombies GetAppOutputRestrictedNoZombies
754 TEST_F(ProcessUtilTest, MAYBE_GetAppOutputRestrictedNoZombies) {
755 std::vector<std::string> argv;
757 argv.push_back(std::string(kShellPath)); // argv[0]
758 argv.push_back("-c"); // argv[1]
759 argv.push_back("echo 123456789012345678901234567890"); // argv[2]
761 // Run |GetAppOutputRestricted()| 300 (> default per-user processes on Mac OS
762 // 10.5) times with an output buffer big enough to capture all output.
763 for (int i = 0; i < 300; i++) {
765 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 100));
766 EXPECT_STREQ("123456789012345678901234567890\n", output.c_str());
769 // Ditto, but with an output buffer too small to capture all output.
770 for (int i = 0; i < 300; i++) {
772 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 10));
773 EXPECT_STREQ("1234567890", output.c_str());
777 TEST_F(ProcessUtilTest, GetAppOutputWithExitCode) {
778 // Test getting output from a successful application.
779 std::vector<std::string> argv;
782 argv.push_back(std::string(kShellPath)); // argv[0]
783 argv.push_back("-c"); // argv[1]
784 argv.push_back("echo foo"); // argv[2];
785 EXPECT_TRUE(base::GetAppOutputWithExitCode(CommandLine(argv), &output,
787 EXPECT_STREQ("foo\n", output.c_str());
788 EXPECT_EQ(exit_code, 0);
790 // Test getting output from an application which fails with a specific exit
793 argv[2] = "echo foo; exit 2";
794 EXPECT_TRUE(base::GetAppOutputWithExitCode(CommandLine(argv), &output,
796 EXPECT_STREQ("foo\n", output.c_str());
797 EXPECT_EQ(exit_code, 2);
800 TEST_F(ProcessUtilTest, GetParentProcessId) {
801 base::ProcessId ppid = base::GetParentProcessId(base::GetCurrentProcId());
802 EXPECT_EQ(ppid, getppid());
805 // TODO(port): port those unit tests.
806 bool IsProcessDead(base::ProcessHandle child) {
807 // waitpid() will actually reap the process which is exactly NOT what we
808 // want to test for. The good thing is that if it can't find the process
809 // we'll get a nice value for errno which we can test for.
810 const pid_t result = HANDLE_EINTR(waitpid(child, NULL, WNOHANG));
811 return result == -1 && errno == ECHILD;
814 TEST_F(ProcessUtilTest, DelayedTermination) {
815 base::ProcessHandle child_process = SpawnChild("process_util_test_never_die");
816 ASSERT_TRUE(child_process);
817 base::EnsureProcessTerminated(child_process);
818 base::WaitForSingleProcess(child_process, base::TimeDelta::FromSeconds(5));
820 // Check that process was really killed.
821 EXPECT_TRUE(IsProcessDead(child_process));
822 base::CloseProcessHandle(child_process);
825 MULTIPROCESS_TEST_MAIN(process_util_test_never_die) {
832 TEST_F(ProcessUtilTest, ImmediateTermination) {
833 base::ProcessHandle child_process =
834 SpawnChild("process_util_test_die_immediately");
835 ASSERT_TRUE(child_process);
836 // Give it time to die.
838 base::EnsureProcessTerminated(child_process);
840 // Check that process was really killed.
841 EXPECT_TRUE(IsProcessDead(child_process));
842 base::CloseProcessHandle(child_process);
845 MULTIPROCESS_TEST_MAIN(process_util_test_die_immediately) {
849 #endif // defined(OS_POSIX)