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
increment_atomic_int(void * c)24 static void increment_atomic_int(void* c) {
25 sleep(1);
26 reinterpret_cast<std::atomic<int>*>(c)->fetch_add(1);
27 }
28
TEST(sysdeps_thread,smoke)29 TEST(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
TEST(sysdeps_thread,join)40 TEST(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
TEST(sysdeps_thread,exit)61 TEST(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
TEST(sysdeps_socketpair,smoke)72 TEST(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
TEST(sysdeps_fd,exhaustion)87 TEST(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
107 class sysdeps_poll : public ::testing::Test {
108 protected:
109 int fds[2];
SetUp()110 void SetUp() override {
111 ASSERT_EQ(0, adb_socketpair(fds)) << strerror(errno);
112 }
113
TearDown()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
TEST_F(sysdeps_poll,smoke)124 TEST_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
TEST_F(sysdeps_poll,timeout)150 TEST_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
TEST_F(sysdeps_poll,invalid_fd)164 TEST_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
TEST_F(sysdeps_poll,duplicate_fd)185 TEST_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
TEST_F(sysdeps_poll,disconnect)202 TEST_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
TEST_F(sysdeps_poll,fd_count)219 TEST_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"
TEST(sysdeps_mutex,mutex_smoke)249 TEST(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)
TEST(sysdeps_mutex,mutex_reentrant_lock)274 TEST(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
TEST(sysdeps_mutex,recursive_mutex_smoke)283 TEST(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