sandbox/linux/services/scoped_process_unittest.cc

   1 // Copyright 2014 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.
   4
   5 #include <errno.h>
   6 #include <fcntl.h>
   7 #include <sys/stat.h>
   8 #include <sys/types.h>
   9 #include <sys/wait.h>
  10 #include <unistd.h>
  11
  12 #include "base/basictypes.h"
  13 #include "base/bind.h"
  14 #include "base/callback.h"
  15 #include "base/file_util.h"
  16 #include "base/files/scoped_file.h"
  17 #include "base/logging.h"
  18 #include "base/posix/eintr_wrapper.h"
  19 #include "base/threading/platform_thread.h"
  20 #include "base/time/time.h"
  21 #include "sandbox/linux/services/scoped_process.h"
  22 #include "sandbox/linux/tests/unit_tests.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24
  25 namespace sandbox {
  26
  27 namespace {
  28
  29 void DoExit() { _exit(0); }
  30
  31 void ExitWithCode(int exit_code) { _exit(exit_code); }
  32
  33 void RaiseAndExit(int signal) {
  34   PCHECK(0 == raise(signal));
  35   _exit(0);
  36 }
  37
  38 void DoNothing() {}
  39
  40 TEST(ScopedProcess, ScopedProcessNormalExit) {
  41   const int kCustomExitCode = 12;
  42   ScopedProcess process(base::Bind(&ExitWithCode, kCustomExitCode));
  43   bool got_signaled = true;
  44   int exit_code = process.WaitForExit(&got_signaled);
  45   EXPECT_FALSE(got_signaled);
  46   EXPECT_EQ(kCustomExitCode, exit_code);
  47
  48   // Verify that WaitForExit() can be called multiple times on the same
  49   // process.
  50   bool got_signaled2 = true;
  51   int exit_code2 = process.WaitForExit(&got_signaled2);
  52   EXPECT_FALSE(got_signaled2);
  53   EXPECT_EQ(kCustomExitCode, exit_code2);
  54 }
  55
  56 // Disable this test on Android, SIGABRT is funky there.
  57 TEST(ScopedProcess, DISABLE_ON_ANDROID(ScopedProcessAbort)) {
  58   PCHECK(SIG_ERR != signal(SIGABRT, SIG_DFL));
  59   ScopedProcess process(base::Bind(&RaiseAndExit, SIGABRT));
  60   bool got_signaled = false;
  61   int exit_code = process.WaitForExit(&got_signaled);
  62   EXPECT_TRUE(got_signaled);
  63   EXPECT_EQ(SIGABRT, exit_code);
  64 }
  65
  66 TEST(ScopedProcess, ScopedProcessSignaled) {
  67   ScopedProcess process(base::Bind(&DoNothing));
  68   bool got_signaled = false;
  69   ASSERT_EQ(0, kill(process.GetPid(), SIGKILL));
  70   int exit_code = process.WaitForExit(&got_signaled);
  71   EXPECT_TRUE(got_signaled);
  72   EXPECT_EQ(SIGKILL, exit_code);
  73 }
  74
  75 TEST(ScopedProcess, DiesForReal) {
  76   int pipe_fds[2];
  77   ASSERT_EQ(0, pipe(pipe_fds));
  78   base::ScopedFD read_end_closer(pipe_fds[0]);
  79   base::ScopedFD write_end_closer(pipe_fds[1]);
  80
  81   { ScopedProcess process(base::Bind(&DoExit)); }
  82
  83   // Close writing end of the pipe.
  84   write_end_closer.reset();
  85   pipe_fds[1] = -1;
  86
  87   ASSERT_EQ(0, fcntl(pipe_fds[0], F_SETFL, O_NONBLOCK));
  88   char c;
  89   // If the child process is dead for real, there will be no writing end
  90   // for this pipe left and read will EOF instead of returning EWOULDBLOCK.
  91   ASSERT_EQ(0, read(pipe_fds[0], &c, 1));
  92 }
  93
  94 TEST(ScopedProcess, SynchronizationBasic) {
  95   ScopedProcess process1(base::Bind(&DoNothing));
  96   EXPECT_TRUE(process1.WaitForClosureToRun());
  97
  98   ScopedProcess process2(base::Bind(&DoExit));
  99   // The closure didn't finish running normally. This case is simple enough
 100   // that process.WaitForClosureToRun() should return false, even though the
 101   // API does not guarantees that it will return at all.
 102   EXPECT_FALSE(process2.WaitForClosureToRun());
 103 }
 104
 105 void SleepInMsAndWriteOneByte(int time_to_sleep, int fd) {
 106   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(time_to_sleep));
 107   CHECK(1 == write(fd, "1", 1));
 108 }
 109
 110 TEST(ScopedProcess, SynchronizationWorks) {
 111   int pipe_fds[2];
 112   ASSERT_EQ(0, pipe(pipe_fds));
 113   base::ScopedFD read_end_closer(pipe_fds[0]);
 114   base::ScopedFD write_end_closer(pipe_fds[1]);
 115
 116   // Start a process with a closure that takes a little bit to run.
 117   ScopedProcess process(
 118       base::Bind(&SleepInMsAndWriteOneByte, 100, pipe_fds[1]));
 119   EXPECT_TRUE(process.WaitForClosureToRun());
 120
 121   // Verify that the closure did, indeed, run.
 122   ASSERT_EQ(0, fcntl(pipe_fds[0], F_SETFL, O_NONBLOCK));
 123   char c = 0;
 124   EXPECT_EQ(1, read(pipe_fds[0], &c, 1));
 125   EXPECT_EQ('1', c);
 126 }
 127
 128 }  // namespace
 129
 130 }  // namespace sandbox