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 "base/bind.h"
  12 #include "base/callback.h"
  13 #include "base/file_util.h"
  14 #include "base/message_loop/message_loop.h"
  15 #include "base/posix/eintr_wrapper.h"
  16 #include "base/run_loop.h"
  17 #include "base/strings/string_util.h"
  18 #include "base/threading/thread.h"
  19 #include "chromeos/process_proxy/process_output_watcher.h"
  20
  21 namespace chromeos {
  22
  23 struct TestCase {
  24   TestCase(const std::string& input, bool send_terminating_null)
  25       : input(input),
  26         should_send_terminating_null(send_terminating_null),
  27         expected_output(input) {}
  28
  29   // Conctructor for cases where the output is not expected to be the same as
  30   // input.
  31   TestCase(const std::string& input,
  32            bool send_terminating_null,
  33            const std::string& expected_output)
  34       : input(input),
  35         should_send_terminating_null(send_terminating_null),
  36         expected_output(expected_output) {}
  37
  38   std::string input;
  39   bool should_send_terminating_null;
  40   std::string expected_output;
  41 };
  42
  43 class ProcessWatcherExpectations {
  44  public:
  45   ProcessWatcherExpectations() {}
  46
  47   void SetTestCase(const TestCase& test_case) {
  48     received_from_out_ = 0;
  49
  50     out_expectations_ = test_case.expected_output;
  51     if (test_case.should_send_terminating_null)
  52       out_expectations_.append(std::string("", 1));
  53   }
  54
  55   bool CheckExpectations(const std::string& data, ProcessOutputType type) {
  56     EXPECT_EQ(PROCESS_OUTPUT_TYPE_OUT, type);
  57     if (type != PROCESS_OUTPUT_TYPE_OUT)
  58       return false;
  59
  60     if (out_expectations_.length() == 0 && data.length() == 0)
  61       return true;
  62
  63     EXPECT_LT(received_from_out_, out_expectations_.length());
  64     if (received_from_out_ >= out_expectations_.length())
  65       return false;
  66
  67     EXPECT_EQ(received_from_out_,
  68               out_expectations_.find(data, received_from_out_));
  69     if (received_from_out_ != out_expectations_.find(data, received_from_out_))
  70       return false;
  71
  72     received_from_out_ += data.length();
  73     return true;
  74   }
  75
  76   bool IsDone() {
  77     return received_from_out_ >= out_expectations_.length();
  78   }
  79
  80  private:
  81   std::string out_expectations_;
  82   size_t received_from_out_;
  83 };
  84
  85 class ProcessOutputWatcherTest : public testing::Test {
  86  public:
  87   ProcessOutputWatcherTest() : output_watch_thread_started_(false),
  88                                failed_(false) {
  89   }
  90
  91   virtual ~ProcessOutputWatcherTest() {}
  92
  93   virtual void TearDown() OVERRIDE {
  94     if (output_watch_thread_started_)
  95       output_watch_thread_->Stop();
  96   }
  97
  98   void StartWatch(int pt, int stop) {
  99     // This will delete itself.
 100     ProcessOutputWatcher* crosh_watcher = new ProcessOutputWatcher(pt, stop,
 101         base::Bind(&ProcessOutputWatcherTest::OnRead, base::Unretained(this)));
 102     crosh_watcher->Start();
 103   }
 104
 105   void OnRead(ProcessOutputType type, const std::string& output) {
 106     ASSERT_FALSE(failed_);
 107     failed_ = !expectations_.CheckExpectations(output, type);
 108     if (failed_ || expectations_.IsDone()) {
 109       ASSERT_FALSE(test_case_done_callback_.is_null());
 110       message_loop_.PostTask(FROM_HERE, test_case_done_callback_);
 111       test_case_done_callback_.Reset();
 112     }
 113   }
 114
 115  protected:
 116   std::string VeryLongString() {
 117     std::string result = "0123456789";
 118     for (int i = 0; i < 8; i++)
 119       result = result.append(result);
 120     return result;
 121   }
 122
 123   void RunTest(const std::vector<TestCase>& test_cases) {
 124     ASSERT_FALSE(output_watch_thread_started_);
 125     output_watch_thread_.reset(new base::Thread("ProcessOutpuWatchThread"));
 126     output_watch_thread_started_ = output_watch_thread_->Start();
 127     ASSERT_TRUE(output_watch_thread_started_);
 128
 129     int pt_pipe[2], stop_pipe[2];
 130     ASSERT_FALSE(HANDLE_EINTR(pipe(pt_pipe)));
 131     ASSERT_FALSE(HANDLE_EINTR(pipe(stop_pipe)));
 132
 133     output_watch_thread_->message_loop()->PostTask(
 134         FROM_HERE,
 135         base::Bind(&ProcessOutputWatcherTest::StartWatch,
 136                    base::Unretained(this),
 137                    pt_pipe[0],
 138                    stop_pipe[0]));
 139
 140     for (size_t i = 0; i < test_cases.size(); i++) {
 141       expectations_.SetTestCase(test_cases[i]);
 142
 143       base::RunLoop run_loop;
 144       ASSERT_TRUE(test_case_done_callback_.is_null());
 145       test_case_done_callback_ = run_loop.QuitClosure();
 146
 147       const std::string& test_str = test_cases[i].input;
 148       // Let's make inputs not NULL terminated, unless other is specified in
 149       // the test case.
 150       ssize_t test_size = test_str.length() * sizeof(*test_str.c_str());
 151       if (test_cases[i].should_send_terminating_null)
 152         test_size += sizeof(*test_str.c_str());
 153       EXPECT_EQ(test_size,
 154                 base::WriteFileDescriptor(pt_pipe[1], test_str.c_str(),
 155                                           test_size));
 156
 157       run_loop.Run();
 158       EXPECT_TRUE(expectations_.IsDone());
 159       if (failed_)
 160         break;
 161     }
 162
 163     // Send stop signal. It is not important which string we send.
 164     EXPECT_EQ(1, base::WriteFileDescriptor(stop_pipe[1], "q", 1));
 165
 166     EXPECT_NE(-1, IGNORE_EINTR(close(stop_pipe[1])));
 167     EXPECT_NE(-1, IGNORE_EINTR(close(pt_pipe[1])));
 168   }
 169
 170  private:
 171   base::Closure test_case_done_callback_;
 172   base::MessageLoop message_loop_;
 173   scoped_ptr<base::Thread> output_watch_thread_;
 174   bool output_watch_thread_started_;
 175   bool failed_;
 176   ProcessWatcherExpectations expectations_;
 177   std::vector<TestCase> exp;
 178 };
 179
 180 // http://crbug.com/396496
 181 TEST_F(ProcessOutputWatcherTest, DISABLED_OutputWatcher) {
 182   std::vector<TestCase> test_cases;
 183   test_cases.push_back(TestCase("t", false));
 184   test_cases.push_back(TestCase("testing output\n", false));
 185   test_cases.push_back(TestCase("testing error\n", false));
 186   test_cases.push_back(TestCase("testing error1\n", false));
 187   test_cases.push_back(TestCase("testing output1\n", false));
 188   test_cases.push_back(TestCase("testing output2\n", false));
 189   test_cases.push_back(TestCase("testing output3\n", false));
 190   test_cases.push_back(TestCase(VeryLongString(), false));
 191   test_cases.push_back(TestCase("testing error2\n", false));
 192
 193   RunTest(test_cases);
 194 };
 195
 196 // http://crbug.com/396496
 197 TEST_F(ProcessOutputWatcherTest, DISABLED_SplitUTF8Character) {
 198   std::vector<TestCase> test_cases;
 199   test_cases.push_back(TestCase("test1\xc2", false, "test1"));
 200   test_cases.push_back(TestCase("\xb5test1", false, "\xc2\xb5test1"));
 201
 202   RunTest(test_cases);
 203 }
 204
 205 // http://crbug.com/396496
 206 TEST_F(ProcessOutputWatcherTest, DISABLED_SplitSoleUTF8Character) {
 207   std::vector<TestCase> test_cases;
 208   test_cases.push_back(TestCase("\xc2", false, ""));
 209   test_cases.push_back(TestCase("\xb5", false, "\xc2\xb5"));
 210
 211   RunTest(test_cases);
 212 }
 213
 214 // http://crbug.com/396496
 215 TEST_F(ProcessOutputWatcherTest, DISABLED_SplitUTF8CharacterLength3) {
 216   std::vector<TestCase> test_cases;
 217   test_cases.push_back(TestCase("test3\xe2\x82", false, "test3"));
 218   test_cases.push_back(TestCase("\xac", false, "\xe2\x82\xac"));
 219
 220   RunTest(test_cases);
 221 }
 222
 223 // http://crbug.com/396496
 224 TEST_F(ProcessOutputWatcherTest, DISABLED_SplitSoleUTF8CharacterThreeWays) {
 225   std::vector<TestCase> test_cases;
 226   test_cases.push_back(TestCase("\xe2", false, ""));
 227   test_cases.push_back(TestCase("\x82", false, ""));
 228   test_cases.push_back(TestCase("\xac", false, "\xe2\x82\xac"));
 229
 230   RunTest(test_cases);
 231 }
 232
 233 TEST_F(ProcessOutputWatcherTest, EndsWithThreeByteUTF8Character) {
 234   std::vector<TestCase> test_cases;
 235   test_cases.push_back(TestCase("test\xe2\x82\xac", false, "test\xe2\x82\xac"));
 236
 237   RunTest(test_cases);
 238 }
 239
 240 TEST_F(ProcessOutputWatcherTest, SoleThreeByteUTF8Character) {
 241   std::vector<TestCase> test_cases;
 242   test_cases.push_back(TestCase("\xe2\x82\xac", false, "\xe2\x82\xac"));
 243
 244   RunTest(test_cases);
 245 }
 246
 247 TEST_F(ProcessOutputWatcherTest, HasThreeByteUTF8Character) {
 248   std::vector<TestCase> test_cases;
 249   test_cases.push_back(
 250       TestCase("test\xe2\x82\xac_", false, "test\xe2\x82\xac_"));
 251
 252   RunTest(test_cases);
 253 }
 254
 255 TEST_F(ProcessOutputWatcherTest, MulitByteUTF8CharNullTerminated) {
 256   std::vector<TestCase> test_cases;
 257   test_cases.push_back(TestCase("test\xe2\x82\xac", true, "test\xe2\x82\xac"));
 258
 259   RunTest(test_cases);
 260 }
 261
 262 // http://crbug.com/396496
 263 TEST_F(ProcessOutputWatcherTest, DISABLED_MultipleMultiByteUTF8Characters) {
 264   std::vector<TestCase> test_cases;
 265   test_cases.push_back(
 266       TestCase("test\xe2\x82\xac\xc2", false, "test\xe2\x82\xac"));
 267   test_cases.push_back(TestCase("\xb5", false, "\xc2\xb5"));
 268
 269   RunTest(test_cases);
 270 }
 271
 272 TEST_F(ProcessOutputWatcherTest, ContainsInvalidUTF8) {
 273   std::vector<TestCase> test_cases;
 274   test_cases.push_back(TestCase("\xc2_", false, "\xc2_"));
 275
 276   RunTest(test_cases);
 277 }
 278
 279 // http://crbug.com/396496
 280 TEST_F(ProcessOutputWatcherTest, DISABLED_InvalidUTF8SeriesOfTrailingBytes) {
 281   std::vector<TestCase> test_cases;
 282   test_cases.push_back(TestCase("\x82\x82\x82", false, "\x82\x82\x82"));
 283   test_cases.push_back(TestCase("\x82\x82\x82", false, "\x82\x82\x82"));
 284
 285   RunTest(test_cases);
 286 }
 287
 288 TEST_F(ProcessOutputWatcherTest, EndsWithInvalidUTF8) {
 289   std::vector<TestCase> test_cases;
 290   test_cases.push_back(TestCase("\xff", false, "\xff"));
 291
 292   RunTest(test_cases);
 293 }
 294
 295 // http://crbug.com/396496
 296 TEST_F(ProcessOutputWatcherTest, DISABLED_FourByteUTF8) {
 297   std::vector<TestCase> test_cases;
 298   test_cases.push_back(TestCase("\xf0\xa4\xad", false, ""));
 299   test_cases.push_back(TestCase("\xa2", false, "\xf0\xa4\xad\xa2"));
 300
 301   RunTest(test_cases);
 302 };
 303
 304 // Verifies that sending '\0' generates PROCESS_OUTPUT_TYPE_OUT event and does
 305 // not terminate output watcher.
 306 // http://crbug.com/396496
 307 TEST_F(ProcessOutputWatcherTest, DISABLED_SendNull) {
 308   std::vector<TestCase> test_cases;
 309   // This will send '\0' to output watcher.
 310   test_cases.push_back(TestCase("", true));
 311   // Let's verify that next input also gets detected (i.e. output watcher does
 312   // not exit after seeing '\0' from previous test case).
 313   test_cases.push_back(TestCase("a", true));
 314
 315   RunTest(test_cases);
 316 };
 317
 318 }  // namespace chromeos