1/*
2 * Copyright (C) 2016 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 <gtest/gtest.h>
18#include <unistd.h>
19#include <atomic>
20
21#include "adb_io.h"
22#include "sysdeps.h"
23
24static void increment_atomic_int(void* c) {
25    sleep(1);
26    reinterpret_cast<std::atomic<int>*>(c)->fetch_add(1);
27}
28
29TEST(sysdeps_thread, smoke) {
30    std::atomic<int> counter(0);
31
32    for (int i = 0; i < 100; ++i) {
33        ASSERT_TRUE(adb_thread_create(increment_atomic_int, &counter));
34    }
35
36    sleep(2);
37    ASSERT_EQ(100, counter.load());
38}
39
40TEST(sysdeps_thread, join) {
41    std::atomic<int> counter(0);
42    std::vector<adb_thread_t> threads(500);
43    for (size_t i = 0; i < threads.size(); ++i) {
44        ASSERT_TRUE(adb_thread_create(increment_atomic_int, &counter, &threads[i]));
45    }
46
47    int current = counter.load();
48    ASSERT_GE(current, 0);
49    // Make sure that adb_thread_create actually creates threads, and doesn't do something silly
50    // like synchronously run the function passed in. The sleep in increment_atomic_int should be
51    // enough to keep this from being flakey.
52    ASSERT_LT(current, 500);
53
54    for (const auto& thread : threads) {
55        ASSERT_TRUE(adb_thread_join(thread));
56    }
57
58    ASSERT_EQ(500, counter.load());
59}
60
61TEST(sysdeps_thread, exit) {
62    adb_thread_t thread;
63    ASSERT_TRUE(adb_thread_create(
64        [](void*) {
65            adb_thread_exit();
66            for (;;) continue;
67        },
68        nullptr, &thread));
69    ASSERT_TRUE(adb_thread_join(thread));
70}
71
72TEST(sysdeps_socketpair, smoke) {
73    int fds[2];
74    ASSERT_EQ(0, adb_socketpair(fds)) << strerror(errno);
75    ASSERT_TRUE(WriteFdExactly(fds[0], "foo", 4));
76    ASSERT_TRUE(WriteFdExactly(fds[1], "bar", 4));
77
78    char buf[4];
79    ASSERT_TRUE(ReadFdExactly(fds[1], buf, 4));
80    ASSERT_STREQ(buf, "foo");
81    ASSERT_TRUE(ReadFdExactly(fds[0], buf, 4));
82    ASSERT_STREQ(buf, "bar");
83    ASSERT_EQ(0, adb_close(fds[0]));
84    ASSERT_EQ(0, adb_close(fds[1]));
85}
86
87TEST(sysdeps_fd, exhaustion) {
88    std::vector<int> fds;
89    int socketpair[2];
90
91    while (adb_socketpair(socketpair) == 0) {
92        fds.push_back(socketpair[0]);
93        fds.push_back(socketpair[1]);
94    }
95
96    ASSERT_EQ(EMFILE, errno) << strerror(errno);
97    for (int fd : fds) {
98        ASSERT_EQ(0, adb_close(fd));
99    }
100    ASSERT_EQ(0, adb_socketpair(socketpair));
101    ASSERT_EQ(socketpair[0], fds[0]);
102    ASSERT_EQ(socketpair[1], fds[1]);
103    ASSERT_EQ(0, adb_close(socketpair[0]));
104    ASSERT_EQ(0, adb_close(socketpair[1]));
105}
106
107class sysdeps_poll : public ::testing::Test {
108  protected:
109    int fds[2];
110    void SetUp() override {
111        ASSERT_EQ(0, adb_socketpair(fds)) << strerror(errno);
112    }
113
114    void TearDown() override {
115        if (fds[0] >= 0) {
116            ASSERT_EQ(0, adb_close(fds[0]));
117        }
118        if (fds[1] >= 0) {
119            ASSERT_EQ(0, adb_close(fds[1]));
120        }
121    }
122};
123
124TEST_F(sysdeps_poll, smoke) {
125    adb_pollfd pfd[2] = {};
126    pfd[0].fd = fds[0];
127    pfd[0].events = POLLRDNORM;
128    pfd[1].fd = fds[1];
129    pfd[1].events = POLLWRNORM;
130
131    pfd[0].revents = -1;
132    pfd[1].revents = -1;
133    EXPECT_EQ(1, adb_poll(pfd, 2, 0));
134    EXPECT_EQ(0, pfd[0].revents);
135    EXPECT_EQ(POLLWRNORM, pfd[1].revents);
136
137    ASSERT_TRUE(WriteFdExactly(fds[1], "foo", 4));
138
139    // Wait for the socketpair to be flushed.
140    pfd[0].revents = -1;
141    EXPECT_EQ(1, adb_poll(pfd, 1, 100));
142    EXPECT_EQ(POLLRDNORM, pfd[0].revents);
143    pfd[0].revents = -1;
144    pfd[1].revents = -1;
145    EXPECT_EQ(2, adb_poll(pfd, 2, 0));
146    EXPECT_EQ(POLLRDNORM, pfd[0].revents);
147    EXPECT_EQ(POLLWRNORM, pfd[1].revents);
148}
149
150TEST_F(sysdeps_poll, timeout) {
151    adb_pollfd pfd = {};
152    pfd.fd = fds[0];
153    pfd.events = POLLRDNORM;
154
155    EXPECT_EQ(0, adb_poll(&pfd, 1, 100));
156    EXPECT_EQ(0, pfd.revents);
157
158    ASSERT_TRUE(WriteFdExactly(fds[1], "foo", 4));
159
160    EXPECT_EQ(1, adb_poll(&pfd, 1, 100));
161    EXPECT_EQ(POLLRDNORM, pfd.revents);
162}
163
164TEST_F(sysdeps_poll, invalid_fd) {
165    adb_pollfd pfd[3] = {};
166    pfd[0].fd = fds[0];
167    pfd[0].events = POLLRDNORM;
168    pfd[1].fd = INT_MAX;
169    pfd[1].events = POLLRDNORM;
170    pfd[2].fd = fds[1];
171    pfd[2].events = POLLWRNORM;
172
173    ASSERT_TRUE(WriteFdExactly(fds[1], "foo", 4));
174
175    // Wait for the socketpair to be flushed.
176    EXPECT_EQ(1, adb_poll(pfd, 1, 100));
177    EXPECT_EQ(POLLRDNORM, pfd[0].revents);
178
179    EXPECT_EQ(3, adb_poll(pfd, 3, 0));
180    EXPECT_EQ(POLLRDNORM, pfd[0].revents);
181    EXPECT_EQ(POLLNVAL, pfd[1].revents);
182    EXPECT_EQ(POLLWRNORM, pfd[2].revents);
183}
184
185TEST_F(sysdeps_poll, duplicate_fd) {
186    adb_pollfd pfd[2] = {};
187    pfd[0].fd = fds[0];
188    pfd[0].events = POLLRDNORM;
189    pfd[1] = pfd[0];
190
191    EXPECT_EQ(0, adb_poll(pfd, 2, 0));
192    EXPECT_EQ(0, pfd[0].revents);
193    EXPECT_EQ(0, pfd[1].revents);
194
195    ASSERT_TRUE(WriteFdExactly(fds[1], "foo", 4));
196
197    EXPECT_EQ(2, adb_poll(pfd, 2, 100));
198    EXPECT_EQ(POLLRDNORM, pfd[0].revents);
199    EXPECT_EQ(POLLRDNORM, pfd[1].revents);
200}
201
202TEST_F(sysdeps_poll, disconnect) {
203    adb_pollfd pfd = {};
204    pfd.fd = fds[0];
205    pfd.events = POLLIN;
206
207    EXPECT_EQ(0, adb_poll(&pfd, 1, 0));
208    EXPECT_EQ(0, pfd.revents);
209
210    EXPECT_EQ(0, adb_close(fds[1]));
211    fds[1] = -1;
212
213    EXPECT_EQ(1, adb_poll(&pfd, 1, 100));
214
215    // Linux returns POLLIN | POLLHUP, Windows returns just POLLHUP.
216    EXPECT_EQ(POLLHUP, pfd.revents & POLLHUP);
217}
218
219TEST_F(sysdeps_poll, fd_count) {
220    // https://code.google.com/p/android/issues/detail?id=12141
221    static constexpr int num_sockets = 512;
222    std::vector<int> sockets;
223    std::vector<adb_pollfd> pfds;
224    sockets.resize(num_sockets * 2);
225    for (int32_t i = 0; i < num_sockets; ++i) {
226        ASSERT_EQ(0, adb_socketpair(&sockets[i * 2])) << strerror(errno);
227        ASSERT_TRUE(WriteFdExactly(sockets[i * 2], &i, sizeof(i)));
228        adb_pollfd pfd;
229        pfd.events = POLLIN;
230        pfd.fd = sockets[i * 2 + 1];
231        pfds.push_back(pfd);
232    }
233
234    ASSERT_EQ(num_sockets, adb_poll(pfds.data(), pfds.size(), 0));
235    for (int i = 0; i < num_sockets; ++i) {
236        ASSERT_NE(0, pfds[i].revents & POLLIN);
237
238        int32_t buf[2] = { -1, -1 };
239        ASSERT_EQ(adb_read(pfds[i].fd, buf, sizeof(buf)), static_cast<ssize_t>(sizeof(int32_t)));
240        ASSERT_EQ(i, buf[0]);
241    }
242
243    for (int fd : sockets) {
244        adb_close(fd);
245    }
246}
247
248#include "sysdeps/mutex.h"
249TEST(sysdeps_mutex, mutex_smoke) {
250    static std::atomic<bool> finished(false);
251    static std::mutex &m = *new std::mutex();
252    m.lock();
253    ASSERT_FALSE(m.try_lock());
254    adb_thread_create([](void*) {
255        ASSERT_FALSE(m.try_lock());
256        m.lock();
257        finished.store(true);
258        adb_sleep_ms(200);
259        m.unlock();
260    }, nullptr);
261
262    ASSERT_FALSE(finished.load());
263    adb_sleep_ms(100);
264    ASSERT_FALSE(finished.load());
265    m.unlock();
266    adb_sleep_ms(100);
267    m.lock();
268    ASSERT_TRUE(finished.load());
269    m.unlock();
270}
271
272// Our implementation on Windows aborts on double lock.
273#if defined(_WIN32)
274TEST(sysdeps_mutex, mutex_reentrant_lock) {
275    std::mutex &m = *new std::mutex();
276
277    m.lock();
278    ASSERT_FALSE(m.try_lock());
279    EXPECT_DEATH(m.lock(), "non-recursive mutex locked reentrantly");
280}
281#endif
282
283TEST(sysdeps_mutex, recursive_mutex_smoke) {
284    static std::recursive_mutex &m = *new std::recursive_mutex();
285
286    m.lock();
287    ASSERT_TRUE(m.try_lock());
288    m.unlock();
289
290    adb_thread_create([](void*) {
291        ASSERT_FALSE(m.try_lock());
292        m.lock();
293        adb_sleep_ms(500);
294        m.unlock();
295    }, nullptr);
296
297    adb_sleep_ms(100);
298    m.unlock();
299    adb_sleep_ms(100);
300    ASSERT_FALSE(m.try_lock());
301    m.lock();
302    m.unlock();
303}
304