TEST_F(LocalSocketTest, smoke) { // Join two socketpairs with a chain of intermediate socketpairs. int first[2]; std::vector<std::array<int, 2>> intermediates; int last[2]; constexpr size_t INTERMEDIATE_COUNT = 50; constexpr size_t MESSAGE_LOOP_COUNT = 100; const std::string MESSAGE = "socket_test"; intermediates.resize(INTERMEDIATE_COUNT); ASSERT_EQ(0, adb_socketpair(first)) << strerror(errno); ASSERT_EQ(0, adb_socketpair(last)) << strerror(errno); asocket* prev_tail = create_local_socket(first[1]); ASSERT_NE(nullptr, prev_tail); auto connect = [](asocket* tail, asocket* head) { tail->peer = head; head->peer = tail; tail->ready(tail); }; for (auto& intermediate : intermediates) { ASSERT_EQ(0, adb_socketpair(intermediate.data())) << strerror(errno); asocket* head = create_local_socket(intermediate[0]); ASSERT_NE(nullptr, head); asocket* tail = create_local_socket(intermediate[1]); ASSERT_NE(nullptr, tail); connect(prev_tail, head); prev_tail = tail; } asocket* end = create_local_socket(last[0]); ASSERT_NE(nullptr, end); connect(prev_tail, end); PrepareThread(); adb_thread_t thread; ASSERT_TRUE(adb_thread_create(FdEventThreadFunc, nullptr, &thread)); for (size_t i = 0; i < MESSAGE_LOOP_COUNT; ++i) { std::string read_buffer = MESSAGE; std::string write_buffer(MESSAGE.size(), 'a'); ASSERT_TRUE(WriteFdExactly(first[0], &read_buffer[0], read_buffer.size())); ASSERT_TRUE(ReadFdExactly(last[1], &write_buffer[0], write_buffer.size())); ASSERT_EQ(read_buffer, write_buffer); } ASSERT_EQ(0, adb_close(first[0])); ASSERT_EQ(0, adb_close(last[1])); // Wait until the local sockets are closed. adb_sleep_ms(SLEEP_FOR_FDEVENT_IN_MS); ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count()); TerminateThread(thread); }
// This test checks if we can close local socket in the following situation: // The socket is not closed and has some packets. When it fails to write to // the socket's file handler because the other end is closed, we check if the // socket is closed. TEST_F(LocalSocketTest, write_error_when_having_packets) { int socket_fd[2]; ASSERT_EQ(0, adb_socketpair(socket_fd)); int cause_close_fd[2]; ASSERT_EQ(0, adb_socketpair(cause_close_fd)); CloseWithPacketArg arg; arg.socket_fd = socket_fd[1]; arg.cause_close_fd = cause_close_fd[1]; PrepareThread(); adb_thread_t thread; ASSERT_TRUE(adb_thread_create(reinterpret_cast<void (*)(void*)>(CloseWithPacketThreadFunc), &arg, &thread)); // Wait until the fdevent_loop() starts. adb_sleep_ms(100); EXPECT_EQ(3u, fdevent_installed_count()); ASSERT_EQ(0, adb_close(socket_fd[0])); TerminateThread(thread); }
// This test checks if we can close local socket in the following situation: // The socket is closing but having some packets, so it is not closed. Then // some write error happens in the socket's file handler, e.g., the file // handler is closed. TEST_F(LocalSocketTest, close_socket_with_packet) { int socket_fd[2]; ASSERT_EQ(0, adb_socketpair(socket_fd)); int cause_close_fd[2]; ASSERT_EQ(0, adb_socketpair(cause_close_fd)); CloseWithPacketArg arg; arg.socket_fd = socket_fd[1]; arg.cause_close_fd = cause_close_fd[1]; PrepareThread(); adb_thread_t thread; ASSERT_TRUE(adb_thread_create(reinterpret_cast<void (*)(void*)>(CloseWithPacketThreadFunc), &arg, &thread)); // Wait until the fdevent_loop() starts. adb_sleep_ms(SLEEP_FOR_FDEVENT_IN_MS); ASSERT_EQ(0, adb_close(cause_close_fd[0])); adb_sleep_ms(SLEEP_FOR_FDEVENT_IN_MS); EXPECT_EQ(1u + GetAdditionalLocalSocketCount(), fdevent_installed_count()); ASSERT_EQ(0, adb_close(socket_fd[0])); adb_sleep_ms(SLEEP_FOR_FDEVENT_IN_MS); ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count()); TerminateThread(thread); }