1/* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include "fdevent.h" 18 19#include <gtest/gtest.h> 20 21#include <limits> 22#include <queue> 23#include <string> 24#include <thread> 25#include <vector> 26 27#include "adb_io.h" 28#include "fdevent_test.h" 29 30class FdHandler { 31 public: 32 FdHandler(int read_fd, int write_fd) : read_fd_(read_fd), write_fd_(write_fd) { 33 fdevent_install(&read_fde_, read_fd_, FdEventCallback, this); 34 fdevent_add(&read_fde_, FDE_READ); 35 fdevent_install(&write_fde_, write_fd_, FdEventCallback, this); 36 } 37 38 ~FdHandler() { 39 fdevent_remove(&read_fde_); 40 fdevent_remove(&write_fde_); 41 } 42 43 private: 44 static void FdEventCallback(int fd, unsigned events, void* userdata) { 45 FdHandler* handler = reinterpret_cast<FdHandler*>(userdata); 46 ASSERT_EQ(0u, (events & ~(FDE_READ | FDE_WRITE))) << "unexpected events: " << events; 47 if (events & FDE_READ) { 48 ASSERT_EQ(fd, handler->read_fd_); 49 char c; 50 ASSERT_EQ(1, adb_read(fd, &c, 1)); 51 handler->queue_.push(c); 52 fdevent_add(&handler->write_fde_, FDE_WRITE); 53 } 54 if (events & FDE_WRITE) { 55 ASSERT_EQ(fd, handler->write_fd_); 56 ASSERT_FALSE(handler->queue_.empty()); 57 char c = handler->queue_.front(); 58 handler->queue_.pop(); 59 ASSERT_EQ(1, adb_write(fd, &c, 1)); 60 if (handler->queue_.empty()) { 61 fdevent_del(&handler->write_fde_, FDE_WRITE); 62 } 63 } 64 } 65 66 private: 67 const int read_fd_; 68 const int write_fd_; 69 fdevent read_fde_; 70 fdevent write_fde_; 71 std::queue<char> queue_; 72}; 73 74struct ThreadArg { 75 int first_read_fd; 76 int last_write_fd; 77 size_t middle_pipe_count; 78}; 79 80TEST_F(FdeventTest, fdevent_terminate) { 81 PrepareThread(); 82 83 std::thread thread(fdevent_loop); 84 TerminateThread(thread); 85} 86 87static void FdEventThreadFunc(ThreadArg* arg) { 88 std::vector<int> read_fds; 89 std::vector<int> write_fds; 90 91 read_fds.push_back(arg->first_read_fd); 92 for (size_t i = 0; i < arg->middle_pipe_count; ++i) { 93 int fds[2]; 94 ASSERT_EQ(0, adb_socketpair(fds)); 95 read_fds.push_back(fds[0]); 96 write_fds.push_back(fds[1]); 97 } 98 write_fds.push_back(arg->last_write_fd); 99 100 std::vector<std::unique_ptr<FdHandler>> fd_handlers; 101 for (size_t i = 0; i < read_fds.size(); ++i) { 102 fd_handlers.push_back(std::unique_ptr<FdHandler>(new FdHandler(read_fds[i], write_fds[i]))); 103 } 104 105 fdevent_loop(); 106} 107 108TEST_F(FdeventTest, smoke) { 109 const size_t PIPE_COUNT = 10; 110 const size_t MESSAGE_LOOP_COUNT = 100; 111 const std::string MESSAGE = "fdevent_test"; 112 int fd_pair1[2]; 113 int fd_pair2[2]; 114 ASSERT_EQ(0, adb_socketpair(fd_pair1)); 115 ASSERT_EQ(0, adb_socketpair(fd_pair2)); 116 ThreadArg thread_arg; 117 thread_arg.first_read_fd = fd_pair1[0]; 118 thread_arg.last_write_fd = fd_pair2[1]; 119 thread_arg.middle_pipe_count = PIPE_COUNT; 120 int writer = fd_pair1[1]; 121 int reader = fd_pair2[0]; 122 123 PrepareThread(); 124 std::thread thread(FdEventThreadFunc, &thread_arg); 125 126 for (size_t i = 0; i < MESSAGE_LOOP_COUNT; ++i) { 127 std::string read_buffer = MESSAGE; 128 std::string write_buffer(MESSAGE.size(), 'a'); 129 ASSERT_TRUE(WriteFdExactly(writer, read_buffer.c_str(), read_buffer.size())); 130 ASSERT_TRUE(ReadFdExactly(reader, &write_buffer[0], write_buffer.size())); 131 ASSERT_EQ(read_buffer, write_buffer); 132 } 133 134 TerminateThread(thread); 135 ASSERT_EQ(0, adb_close(writer)); 136 ASSERT_EQ(0, adb_close(reader)); 137} 138 139struct InvalidFdArg { 140 fdevent fde; 141 unsigned expected_events; 142 size_t* happened_event_count; 143}; 144 145static void InvalidFdEventCallback(int fd, unsigned events, void* userdata) { 146 InvalidFdArg* arg = reinterpret_cast<InvalidFdArg*>(userdata); 147 ASSERT_EQ(arg->expected_events, events); 148 fdevent_remove(&arg->fde); 149 if (++*(arg->happened_event_count) == 2) { 150 fdevent_terminate_loop(); 151 } 152} 153 154static void InvalidFdThreadFunc() { 155 const int INVALID_READ_FD = std::numeric_limits<int>::max() - 1; 156 size_t happened_event_count = 0; 157 InvalidFdArg read_arg; 158 read_arg.expected_events = FDE_READ | FDE_ERROR; 159 read_arg.happened_event_count = &happened_event_count; 160 fdevent_install(&read_arg.fde, INVALID_READ_FD, InvalidFdEventCallback, &read_arg); 161 fdevent_add(&read_arg.fde, FDE_READ); 162 163 const int INVALID_WRITE_FD = std::numeric_limits<int>::max(); 164 InvalidFdArg write_arg; 165 write_arg.expected_events = FDE_READ | FDE_ERROR; 166 write_arg.happened_event_count = &happened_event_count; 167 fdevent_install(&write_arg.fde, INVALID_WRITE_FD, InvalidFdEventCallback, &write_arg); 168 fdevent_add(&write_arg.fde, FDE_WRITE); 169 fdevent_loop(); 170} 171 172TEST_F(FdeventTest, invalid_fd) { 173 std::thread thread(InvalidFdThreadFunc); 174 thread.join(); 175} 176 177TEST_F(FdeventTest, run_on_main_thread) { 178 std::vector<int> vec; 179 180 PrepareThread(); 181 std::thread thread(fdevent_loop); 182 183 for (int i = 0; i < 100; ++i) { 184 fdevent_run_on_main_thread([i, &vec]() { 185 check_main_thread(); 186 vec.push_back(i); 187 }); 188 } 189 190 TerminateThread(thread); 191 192 ASSERT_EQ(100u, vec.size()); 193 for (int i = 0; i < 100; ++i) { 194 ASSERT_EQ(i, vec[i]); 195 } 196} 197