src/chromeos/process_proxy/process_output_watcher_unittest.cc

   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.
   4
   5 #include <gtest/gtest.h>
   6
   7 #include <queue>
   8 #include <string>
   9 #include <vector>
  10
  11 #include <sys/wait.h>
  12
  13 #include "base/bind.h"
  14 #include "base/file_util.h"
  15 #include "base/posix/eintr_wrapper.h"
  16 #include "base/synchronization/waitable_event.h"
  17 #include "base/threading/thread.h"
  18 #include "chromeos/process_proxy/process_output_watcher.h"
  19
  20 namespace chromeos {
  21
  22 struct TestCase {
  23   std::string str;
  24   bool should_send_terminating_null;
  25
  26   TestCase(const std::string& expected_string,
  27            bool send_terminating_null)
  28       : str(expected_string),
  29         should_send_terminating_null(send_terminating_null) {
  30   }
  31 };
  32
  33 class ProcessWatcherExpectations {
  34  public:
  35   ProcessWatcherExpectations() {}
  36
  37   void Init(const std::vector<TestCase>& expectations) {
  38     received_from_out_ = 0;
  39
  40     for (size_t i = 0; i < expectations.size(); i++) {
  41       out_expectations_.append(expectations[i].str);
  42       if (expectations[i].should_send_terminating_null)
  43         out_expectations_.append(std::string("", 1));
  44     }
  45   }
  46
  47   bool CheckExpectations(const std::string& data, ProcessOutputType type) {
  48     EXPECT_EQ(PROCESS_OUTPUT_TYPE_OUT, type);
  49     if (type != PROCESS_OUTPUT_TYPE_OUT)
  50       return false;
  51
  52     EXPECT_LT(received_from_out_, out_expectations_.length());
  53     if (received_from_out_ >= out_expectations_.length())
  54       return false;
  55
  56     EXPECT_EQ(received_from_out_,
  57               out_expectations_.find(data, received_from_out_));
  58
  59     received_from_out_ += data.length();
  60     return true;
  61   }
  62
  63   bool IsDone() {
  64     return received_from_out_ >= out_expectations_.length();
  65   }
  66
  67  private:
  68   std::string out_expectations_;
  69   size_t received_from_out_;
  70 };
  71
  72 class ProcessOutputWatcherTest : public testing::Test {
  73 public:
  74   void StartWatch(int pt, int stop,
  75                   const std::vector<TestCase>& expectations) {
  76     expectations_.Init(expectations);
  77
  78     // This will delete itself.
  79     ProcessOutputWatcher* crosh_watcher = new ProcessOutputWatcher(pt, stop,
  80         base::Bind(&ProcessOutputWatcherTest::OnRead, base::Unretained(this)));
  81     crosh_watcher->Start();
  82   }
  83
  84   void OnRead(ProcessOutputType type, const std::string& output) {
  85     bool success = expectations_.CheckExpectations(output, type);
  86     if (!success || expectations_.IsDone())
  87       all_data_received_->Signal();
  88   }
  89
  90  protected:
  91   std::string VeryLongString() {
  92     std::string result = "0123456789";
  93     for (int i = 0; i < 8; i++)
  94       result = result.append(result);
  95     return result;
  96   }
  97
  98   void RunTest(const std::vector<TestCase>& test_cases) {
  99     all_data_received_.reset(new base::WaitableEvent(true, false));
 100
 101     base::Thread output_watch_thread("ProcessOutpuWatchThread");
 102     ASSERT_TRUE(output_watch_thread.Start());
 103
 104     int pt_pipe[2], stop_pipe[2];
 105     ASSERT_FALSE(HANDLE_EINTR(pipe(pt_pipe)));
 106     ASSERT_FALSE(HANDLE_EINTR(pipe(stop_pipe)));
 107
 108     output_watch_thread.message_loop()->PostTask(FROM_HERE,
 109         base::Bind(&ProcessOutputWatcherTest::StartWatch,
 110                    base::Unretained(this),
 111                    pt_pipe[0], stop_pipe[0], test_cases));
 112
 113     for (size_t i = 0; i < test_cases.size(); i++) {
 114       const std::string& test_str = test_cases[i].str;
 115       // Let's make inputs not NULL terminated, unless other is specified in
 116       // the test case.
 117       ssize_t test_size = test_str.length() * sizeof(*test_str.c_str());
 118       if (test_cases[i].should_send_terminating_null)
 119         test_size += sizeof(*test_str.c_str());
 120       EXPECT_EQ(test_size,
 121                 file_util::WriteFileDescriptor(pt_pipe[1], test_str.c_str(),
 122                                                test_size));
 123     }
 124
 125     all_data_received_->Wait();
 126
 127     // Send stop signal. It is not important which string we send.
 128     EXPECT_EQ(1, file_util::WriteFileDescriptor(stop_pipe[1], "q", 1));
 129
 130     EXPECT_NE(-1, HANDLE_EINTR(close(stop_pipe[1])));
 131     EXPECT_NE(-1, HANDLE_EINTR(close(pt_pipe[1])));
 132
 133     output_watch_thread.Stop();
 134   }
 135
 136   scoped_ptr<base::WaitableEvent> all_data_received_;
 137
 138  private:
 139   ProcessWatcherExpectations expectations_;
 140   std::vector<TestCase> exp;
 141 };
 142
 143
 144 TEST_F(ProcessOutputWatcherTest, OutputWatcher) {
 145   std::vector<TestCase> test_cases;
 146   test_cases.push_back(TestCase("testing output\n", false));
 147   test_cases.push_back(TestCase("testing error\n", false));
 148   test_cases.push_back(TestCase("testing error1\n", false));
 149   test_cases.push_back(TestCase("testing output1\n", false));
 150   test_cases.push_back(TestCase("testing output2\n", false));
 151   test_cases.push_back(TestCase("testing output3\n", false));
 152   test_cases.push_back(TestCase(VeryLongString(), false));
 153   test_cases.push_back(TestCase("testing error2\n", false));
 154
 155   RunTest(test_cases);
 156 };
 157
 158 // Verifies that sending '\0' generates PROCESS_OUTPUT_TYPE_OUT event and does
 159 // not terminate output watcher.
 160 TEST_F(ProcessOutputWatcherTest, SendNull) {
 161   std::vector<TestCase> test_cases;
 162   // This will send '\0' to output wathcer.
 163   test_cases.push_back(TestCase("", true));
 164   // Let's verify that next input also gets detected (i.e. output watcher does
 165   // not exit after seeing '\0' from previous test case).
 166   test_cases.push_back(TestCase("a", true));
 167
 168   RunTest(test_cases);
 169 };
 170
 171 }  // namespace chromeos