blob: 5e28f760103813538c615917c976fc39fd00db9d [file] [log] [blame]
Yabin Cui2ce9d562015-09-15 16:27:09 -07001/*
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
Josh Gao511763b2016-02-10 14:49:00 -080021#include <array>
Yabin Cui2ce9d562015-09-15 16:27:09 -070022#include <limits>
23#include <queue>
24#include <string>
Elliott Hughes73925982016-11-15 12:37:32 -080025#include <thread>
Yabin Cui2ce9d562015-09-15 16:27:09 -070026#include <vector>
27
Yabin Cui2ce9d562015-09-15 16:27:09 -070028#include <unistd.h>
29
30#include "adb.h"
31#include "adb_io.h"
Josh Gao511763b2016-02-10 14:49:00 -080032#include "fdevent_test.h"
Yabin Cui2ce9d562015-09-15 16:27:09 -070033#include "socket.h"
34#include "sysdeps.h"
Josh Gao70267e42016-11-15 18:55:47 -080035#include "sysdeps/chrono.h"
Yabin Cui2ce9d562015-09-15 16:27:09 -070036
Josh Gao8d49e122018-12-19 13:37:41 -080037using namespace std::string_literals;
38using namespace std::string_view_literals;
39
Yabin Cui2ce9d562015-09-15 16:27:09 -070040struct ThreadArg {
41 int first_read_fd;
42 int last_write_fd;
43 size_t middle_pipe_count;
44};
45
Josh Gao511763b2016-02-10 14:49:00 -080046class LocalSocketTest : public FdeventTest {};
Yabin Cui2ce9d562015-09-15 16:27:09 -070047
Yabin Cui2ce9d562015-09-15 16:27:09 -070048TEST_F(LocalSocketTest, smoke) {
Josh Gao511763b2016-02-10 14:49:00 -080049 // Join two socketpairs with a chain of intermediate socketpairs.
50 int first[2];
51 std::vector<std::array<int, 2>> intermediates;
52 int last[2];
53
54 constexpr size_t INTERMEDIATE_COUNT = 50;
55 constexpr size_t MESSAGE_LOOP_COUNT = 100;
Yabin Cui2ce9d562015-09-15 16:27:09 -070056 const std::string MESSAGE = "socket_test";
Yabin Cui2ce9d562015-09-15 16:27:09 -070057
Josh Gao511763b2016-02-10 14:49:00 -080058 intermediates.resize(INTERMEDIATE_COUNT);
59 ASSERT_EQ(0, adb_socketpair(first)) << strerror(errno);
60 ASSERT_EQ(0, adb_socketpair(last)) << strerror(errno);
Josh Gaoc2705962019-01-23 15:36:42 -080061 asocket* prev_tail = create_local_socket(unique_fd(first[1]));
Josh Gao511763b2016-02-10 14:49:00 -080062 ASSERT_NE(nullptr, prev_tail);
Yabin Cui2ce9d562015-09-15 16:27:09 -070063
Josh Gao511763b2016-02-10 14:49:00 -080064 auto connect = [](asocket* tail, asocket* head) {
65 tail->peer = head;
66 head->peer = tail;
67 tail->ready(tail);
68 };
69
70 for (auto& intermediate : intermediates) {
71 ASSERT_EQ(0, adb_socketpair(intermediate.data())) << strerror(errno);
72
Josh Gaoc2705962019-01-23 15:36:42 -080073 asocket* head = create_local_socket(unique_fd(intermediate[0]));
Josh Gao511763b2016-02-10 14:49:00 -080074 ASSERT_NE(nullptr, head);
75
Josh Gaoc2705962019-01-23 15:36:42 -080076 asocket* tail = create_local_socket(unique_fd(intermediate[1]));
Josh Gao511763b2016-02-10 14:49:00 -080077 ASSERT_NE(nullptr, tail);
78
79 connect(prev_tail, head);
80 prev_tail = tail;
81 }
82
Josh Gaoc2705962019-01-23 15:36:42 -080083 asocket* end = create_local_socket(unique_fd(last[0]));
Josh Gao511763b2016-02-10 14:49:00 -080084 ASSERT_NE(nullptr, end);
85 connect(prev_tail, end);
86
87 PrepareThread();
Josh Gao511763b2016-02-10 14:49:00 -080088
Yabin Cui2ce9d562015-09-15 16:27:09 -070089 for (size_t i = 0; i < MESSAGE_LOOP_COUNT; ++i) {
90 std::string read_buffer = MESSAGE;
91 std::string write_buffer(MESSAGE.size(), 'a');
Josh Gao511763b2016-02-10 14:49:00 -080092 ASSERT_TRUE(WriteFdExactly(first[0], &read_buffer[0], read_buffer.size()));
93 ASSERT_TRUE(ReadFdExactly(last[1], &write_buffer[0], write_buffer.size()));
Yabin Cui2ce9d562015-09-15 16:27:09 -070094 ASSERT_EQ(read_buffer, write_buffer);
95 }
Yabin Cui2ce9d562015-09-15 16:27:09 -070096
Josh Gao511763b2016-02-10 14:49:00 -080097 ASSERT_EQ(0, adb_close(first[0]));
98 ASSERT_EQ(0, adb_close(last[1]));
99
100 // Wait until the local sockets are closed.
Josh Gaocd608202018-03-28 18:53:30 -0700101 WaitForFdeventLoop();
Yabin Cui40a47272016-04-25 19:48:19 -0700102 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count());
Josh Gaoc7bdb6d2018-03-29 16:27:13 -0700103 TerminateThread();
Yabin Cui2ce9d562015-09-15 16:27:09 -0700104}
105
106struct CloseWithPacketArg {
Josh Gaoc2705962019-01-23 15:36:42 -0800107 unique_fd socket_fd;
Yabin Cui2ce9d562015-09-15 16:27:09 -0700108 size_t bytes_written;
Josh Gaoc2705962019-01-23 15:36:42 -0800109 unique_fd cause_close_fd;
Yabin Cui2ce9d562015-09-15 16:27:09 -0700110};
111
Josh Gaoc7bdb6d2018-03-29 16:27:13 -0700112static void CreateCloser(CloseWithPacketArg* arg) {
113 fdevent_run_on_main_thread([arg]() {
Josh Gaoc2705962019-01-23 15:36:42 -0800114 asocket* s = create_local_socket(std::move(arg->socket_fd));
Josh Gaoc7bdb6d2018-03-29 16:27:13 -0700115 ASSERT_TRUE(s != nullptr);
116 arg->bytes_written = 0;
Josh Gaod5e56ce2018-03-19 15:36:17 -0700117
Josh Gao205a8f42018-03-30 14:05:40 -0700118 // On platforms that implement sockets via underlying sockets (e.g. Wine),
119 // a socket can appear to be full, and then become available for writes
120 // again without read being called on the other end. Loop and sleep after
121 // each write to give the underlying implementation time to flush.
122 bool socket_filled = false;
123 for (int i = 0; i < 128; ++i) {
Josh Gaocd2a5292018-03-07 16:52:28 -0800124 apacket::payload_type data;
Josh Gao205a8f42018-03-30 14:05:40 -0700125 data.resize(MAX_PAYLOAD);
126 arg->bytes_written += data.size();
127 int ret = s->enqueue(s, std::move(data));
128 if (ret == 1) {
129 socket_filled = true;
130 break;
131 }
132 ASSERT_NE(-1, ret);
133
134 std::this_thread::sleep_for(250ms);
135 }
136 ASSERT_TRUE(socket_filled);
Yabin Cui2ce9d562015-09-15 16:27:09 -0700137
Josh Gaoc2705962019-01-23 15:36:42 -0800138 asocket* cause_close_s = create_local_socket(std::move(arg->cause_close_fd));
Josh Gaoc7bdb6d2018-03-29 16:27:13 -0700139 ASSERT_TRUE(cause_close_s != nullptr);
140 cause_close_s->peer = s;
141 s->peer = cause_close_s;
142 cause_close_s->ready(cause_close_s);
143 });
144 WaitForFdeventLoop();
Yabin Cui2ce9d562015-09-15 16:27:09 -0700145}
146
147// This test checks if we can close local socket in the following situation:
148// The socket is closing but having some packets, so it is not closed. Then
149// some write error happens in the socket's file handler, e.g., the file
150// handler is closed.
Yabin Cuiec2e7d82015-09-29 12:25:33 -0700151TEST_F(LocalSocketTest, close_socket_with_packet) {
Yabin Cui2ce9d562015-09-15 16:27:09 -0700152 int socket_fd[2];
153 ASSERT_EQ(0, adb_socketpair(socket_fd));
154 int cause_close_fd[2];
155 ASSERT_EQ(0, adb_socketpair(cause_close_fd));
156 CloseWithPacketArg arg;
Josh Gaoc2705962019-01-23 15:36:42 -0800157 arg.socket_fd.reset(socket_fd[1]);
158 arg.cause_close_fd.reset(cause_close_fd[1]);
Yabin Cui2ce9d562015-09-15 16:27:09 -0700159
Josh Gao511763b2016-02-10 14:49:00 -0800160 PrepareThread();
Josh Gaoc7bdb6d2018-03-29 16:27:13 -0700161 CreateCloser(&arg);
Josh Gaocd608202018-03-28 18:53:30 -0700162
Josh Gao511763b2016-02-10 14:49:00 -0800163 ASSERT_EQ(0, adb_close(cause_close_fd[0]));
Josh Gaocd608202018-03-28 18:53:30 -0700164
165 WaitForFdeventLoop();
Yabin Cui40a47272016-04-25 19:48:19 -0700166 EXPECT_EQ(1u + GetAdditionalLocalSocketCount(), fdevent_installed_count());
Josh Gao511763b2016-02-10 14:49:00 -0800167 ASSERT_EQ(0, adb_close(socket_fd[0]));
Josh Gaocd608202018-03-28 18:53:30 -0700168
169 WaitForFdeventLoop();
Yabin Cui40a47272016-04-25 19:48:19 -0700170 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count());
Josh Gaoc7bdb6d2018-03-29 16:27:13 -0700171 TerminateThread();
Yabin Cui2ce9d562015-09-15 16:27:09 -0700172}
173
Yabin Cui2ce9d562015-09-15 16:27:09 -0700174// This test checks if we can read packets from a closing local socket.
Yabin Cuiec2e7d82015-09-29 12:25:33 -0700175TEST_F(LocalSocketTest, read_from_closing_socket) {
Yabin Cui2ce9d562015-09-15 16:27:09 -0700176 int socket_fd[2];
177 ASSERT_EQ(0, adb_socketpair(socket_fd));
178 int cause_close_fd[2];
179 ASSERT_EQ(0, adb_socketpair(cause_close_fd));
180 CloseWithPacketArg arg;
Josh Gaoc2705962019-01-23 15:36:42 -0800181 arg.socket_fd.reset(socket_fd[1]);
182 arg.cause_close_fd.reset(cause_close_fd[1]);
Yabin Cui2ce9d562015-09-15 16:27:09 -0700183
Josh Gao511763b2016-02-10 14:49:00 -0800184 PrepareThread();
Josh Gaoc7bdb6d2018-03-29 16:27:13 -0700185 CreateCloser(&arg);
Josh Gaocd608202018-03-28 18:53:30 -0700186
187 WaitForFdeventLoop();
Yabin Cui2ce9d562015-09-15 16:27:09 -0700188 ASSERT_EQ(0, adb_close(cause_close_fd[0]));
Josh Gaocd608202018-03-28 18:53:30 -0700189
190 WaitForFdeventLoop();
Yabin Cui40a47272016-04-25 19:48:19 -0700191 EXPECT_EQ(1u + GetAdditionalLocalSocketCount(), fdevent_installed_count());
Yabin Cui2ce9d562015-09-15 16:27:09 -0700192
193 // Verify if we can read successfully.
194 std::vector<char> buf(arg.bytes_written);
Josh Gao511763b2016-02-10 14:49:00 -0800195 ASSERT_NE(0u, arg.bytes_written);
Yabin Cui2ce9d562015-09-15 16:27:09 -0700196 ASSERT_EQ(true, ReadFdExactly(socket_fd[0], buf.data(), buf.size()));
197 ASSERT_EQ(0, adb_close(socket_fd[0]));
198
Josh Gaocd608202018-03-28 18:53:30 -0700199 WaitForFdeventLoop();
Yabin Cui40a47272016-04-25 19:48:19 -0700200 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count());
Josh Gaoc7bdb6d2018-03-29 16:27:13 -0700201 TerminateThread();
Yabin Cui2ce9d562015-09-15 16:27:09 -0700202}
203
204// This test checks if we can close local socket in the following situation:
205// The socket is not closed and has some packets. When it fails to write to
206// the socket's file handler because the other end is closed, we check if the
207// socket is closed.
208TEST_F(LocalSocketTest, write_error_when_having_packets) {
209 int socket_fd[2];
210 ASSERT_EQ(0, adb_socketpair(socket_fd));
211 int cause_close_fd[2];
212 ASSERT_EQ(0, adb_socketpair(cause_close_fd));
213 CloseWithPacketArg arg;
Josh Gaoc2705962019-01-23 15:36:42 -0800214 arg.socket_fd.reset(socket_fd[1]);
215 arg.cause_close_fd.reset(cause_close_fd[1]);
Yabin Cui2ce9d562015-09-15 16:27:09 -0700216
Josh Gao511763b2016-02-10 14:49:00 -0800217 PrepareThread();
Josh Gaoc7bdb6d2018-03-29 16:27:13 -0700218 CreateCloser(&arg);
Josh Gaocd608202018-03-28 18:53:30 -0700219
220 WaitForFdeventLoop();
Yabin Cui40a47272016-04-25 19:48:19 -0700221 EXPECT_EQ(2u + GetAdditionalLocalSocketCount(), fdevent_installed_count());
Yabin Cui2ce9d562015-09-15 16:27:09 -0700222 ASSERT_EQ(0, adb_close(socket_fd[0]));
223
Josh Gao18f7a5c2019-01-11 14:42:08 -0800224 std::this_thread::sleep_for(2s);
225
Josh Gaocd608202018-03-28 18:53:30 -0700226 WaitForFdeventLoop();
Yabin Cui40a47272016-04-25 19:48:19 -0700227 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count());
Josh Gaoc7bdb6d2018-03-29 16:27:13 -0700228 TerminateThread();
Yabin Cui2ce9d562015-09-15 16:27:09 -0700229}
230
Josh Gao80206022018-03-15 15:28:55 -0700231// Ensure that if we fail to write output to an fd, we will still flush data coming from it.
232TEST_F(LocalSocketTest, flush_after_shutdown) {
233 int head_fd[2];
234 int tail_fd[2];
235 ASSERT_EQ(0, adb_socketpair(head_fd));
236 ASSERT_EQ(0, adb_socketpair(tail_fd));
237
Josh Gaoc2705962019-01-23 15:36:42 -0800238 asocket* head = create_local_socket(unique_fd(head_fd[1]));
239 asocket* tail = create_local_socket(unique_fd(tail_fd[1]));
Josh Gao80206022018-03-15 15:28:55 -0700240
241 head->peer = tail;
242 head->ready(head);
243
244 tail->peer = head;
245 tail->ready(tail);
246
247 PrepareThread();
Josh Gao80206022018-03-15 15:28:55 -0700248
Josh Gaod5e56ce2018-03-19 15:36:17 -0700249 EXPECT_TRUE(WriteFdExactly(head_fd[0], "foo", 3));
Josh Gao80206022018-03-15 15:28:55 -0700250
Josh Gaod5e56ce2018-03-19 15:36:17 -0700251 EXPECT_EQ(0, adb_shutdown(head_fd[0], SHUT_RD));
252 const char* str = "write succeeds, but local_socket will fail to write";
253 EXPECT_TRUE(WriteFdExactly(tail_fd[0], str, strlen(str)));
254 EXPECT_TRUE(WriteFdExactly(head_fd[0], "bar", 3));
255
256 char buf[6];
257 EXPECT_TRUE(ReadFdExactly(tail_fd[0], buf, 6));
258 EXPECT_EQ(0, memcmp(buf, "foobar", 6));
Josh Gao80206022018-03-15 15:28:55 -0700259
260 adb_close(head_fd[0]);
261 adb_close(tail_fd[0]);
262
Josh Gaocd608202018-03-28 18:53:30 -0700263 WaitForFdeventLoop();
Josh Gao80206022018-03-15 15:28:55 -0700264 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count());
Josh Gaoc7bdb6d2018-03-29 16:27:13 -0700265 TerminateThread();
Josh Gao80206022018-03-15 15:28:55 -0700266}
Josh Gao80206022018-03-15 15:28:55 -0700267
Yabin Cuiec2e7d82015-09-29 12:25:33 -0700268#if defined(__linux__)
269
270static void ClientThreadFunc() {
271 std::string error;
272 int fd = network_loopback_client(5038, SOCK_STREAM, &error);
273 ASSERT_GE(fd, 0) << error;
Josh Gaoc7bdb6d2018-03-29 16:27:13 -0700274 std::this_thread::sleep_for(1s);
Yabin Cuiec2e7d82015-09-29 12:25:33 -0700275 ASSERT_EQ(0, adb_close(fd));
276}
277
Yabin Cuiec2e7d82015-09-29 12:25:33 -0700278// This test checks if we can close sockets in CLOSE_WAIT state.
279TEST_F(LocalSocketTest, close_socket_in_CLOSE_WAIT_state) {
Josh Gao511763b2016-02-10 14:49:00 -0800280 std::string error;
281 int listen_fd = network_inaddr_any_server(5038, SOCK_STREAM, &error);
282 ASSERT_GE(listen_fd, 0);
Yabin Cui2ce9d562015-09-15 16:27:09 -0700283
Josh Gao0f3312a2017-04-12 17:00:49 -0700284 std::thread client_thread(ClientThreadFunc);
Josh Gao511763b2016-02-10 14:49:00 -0800285
Elliott Hughes97a035c2016-08-23 12:50:00 -0700286 int accept_fd = adb_socket_accept(listen_fd, nullptr, nullptr);
Josh Gao511763b2016-02-10 14:49:00 -0800287 ASSERT_GE(accept_fd, 0);
Josh Gao511763b2016-02-10 14:49:00 -0800288
289 PrepareThread();
Josh Gaoc7bdb6d2018-03-29 16:27:13 -0700290
291 fdevent_run_on_main_thread([accept_fd]() {
Josh Gaoc2705962019-01-23 15:36:42 -0800292 asocket* s = create_local_socket(unique_fd(accept_fd));
Josh Gaoc7bdb6d2018-03-29 16:27:13 -0700293 ASSERT_TRUE(s != nullptr);
294 });
Josh Gao511763b2016-02-10 14:49:00 -0800295
Josh Gaocd608202018-03-28 18:53:30 -0700296 WaitForFdeventLoop();
Yabin Cui40a47272016-04-25 19:48:19 -0700297 EXPECT_EQ(1u + GetAdditionalLocalSocketCount(), fdevent_installed_count());
Josh Gao511763b2016-02-10 14:49:00 -0800298
299 // Wait until the client closes its socket.
Josh Gao0f3312a2017-04-12 17:00:49 -0700300 client_thread.join();
Josh Gao511763b2016-02-10 14:49:00 -0800301
Josh Gaocd608202018-03-28 18:53:30 -0700302 WaitForFdeventLoop();
Yabin Cui40a47272016-04-25 19:48:19 -0700303 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count());
Josh Gaoc7bdb6d2018-03-29 16:27:13 -0700304 TerminateThread();
Yabin Cui2ce9d562015-09-15 16:27:09 -0700305}
Yabin Cuiec2e7d82015-09-29 12:25:33 -0700306
307#endif // defined(__linux__)
David Pursellc929c6f2016-03-01 08:58:26 -0800308
309#if ADB_HOST
310
Josh Gao8d49e122018-12-19 13:37:41 -0800311#define VerifyParseHostServiceFailed(s) \
312 do { \
313 std::string service(s); \
314 std::string_view serial, command; \
315 bool result = internal::parse_host_service(&serial, &command, service); \
316 EXPECT_FALSE(result); \
317 } while (0)
318
319#define VerifyParseHostService(s, expected_serial, expected_command) \
320 do { \
321 std::string service(s); \
322 std::string_view serial, command; \
323 bool result = internal::parse_host_service(&serial, &command, service); \
324 EXPECT_TRUE(result); \
325 EXPECT_EQ(std::string(expected_serial), std::string(serial)); \
326 EXPECT_EQ(std::string(expected_command), std::string(command)); \
327 } while (0);
David Pursellc929c6f2016-03-01 08:58:26 -0800328
329// Check [tcp:|udp:]<serial>[:<port>]:<command> format.
Josh Gao8d49e122018-12-19 13:37:41 -0800330TEST(socket_test, test_parse_host_service) {
David Pursellc929c6f2016-03-01 08:58:26 -0800331 for (const std::string& protocol : {"", "tcp:", "udp:"}) {
Josh Gao8d49e122018-12-19 13:37:41 -0800332 VerifyParseHostServiceFailed(protocol);
333 VerifyParseHostServiceFailed(protocol + "foo");
David Pursellc929c6f2016-03-01 08:58:26 -0800334
Josh Gao8d49e122018-12-19 13:37:41 -0800335 {
336 std::string serial = protocol + "foo";
337 VerifyParseHostService(serial + ":bar", serial, "bar");
338 VerifyParseHostService(serial + " :bar:baz", serial, "bar:baz");
339 }
David Pursellc929c6f2016-03-01 08:58:26 -0800340
Josh Gao8d49e122018-12-19 13:37:41 -0800341 {
342 // With port.
343 std::string serial = protocol + "foo:123";
344 VerifyParseHostService(serial + ":bar", serial, "bar");
345 VerifyParseHostService(serial + ":456", serial, "456");
346 VerifyParseHostService(serial + ":bar:baz", serial, "bar:baz");
347 }
David Pursellc929c6f2016-03-01 08:58:26 -0800348
349 // Don't register a port unless it's all numbers and ends with ':'.
Josh Gao8d49e122018-12-19 13:37:41 -0800350 VerifyParseHostService(protocol + "foo:123", protocol + "foo", "123");
351 VerifyParseHostService(protocol + "foo:123bar:baz", protocol + "foo", "123bar:baz");
David Pursell24b62a72016-09-21 12:08:37 -0700352
Josh Gao8d49e122018-12-19 13:37:41 -0800353 std::string addresses[] = {"100.100.100.100", "[0123:4567:89ab:CDEF:0:9:a:f]", "[::1]"};
354 for (const std::string& address : addresses) {
355 std::string serial = protocol + address;
356 std::string serial_with_port = protocol + address + ":5555";
357 VerifyParseHostService(serial + ":foo", serial, "foo");
358 VerifyParseHostService(serial_with_port + ":foo", serial_with_port, "foo");
359 }
David Pursell24b62a72016-09-21 12:08:37 -0700360
361 // If we can't find both [] then treat it as a normal serial with [ in it.
Josh Gao8d49e122018-12-19 13:37:41 -0800362 VerifyParseHostService(protocol + "[0123:foo", protocol + "[0123", "foo");
David Pursell24b62a72016-09-21 12:08:37 -0700363
364 // Don't be fooled by random IPv6 addresses in the command string.
Josh Gao8d49e122018-12-19 13:37:41 -0800365 VerifyParseHostService(protocol + "foo:ping [0123:4567:89ab:CDEF:0:9:a:f]:5555",
366 protocol + "foo", "ping [0123:4567:89ab:CDEF:0:9:a:f]:5555");
367
368 // Handle embedded NULs properly.
369 VerifyParseHostService(protocol + "foo:echo foo\0bar"s, protocol + "foo",
370 "echo foo\0bar"sv);
David Pursellc929c6f2016-03-01 08:58:26 -0800371 }
372}
373
374// Check <prefix>:<serial>:<command> format.
Josh Gao8d49e122018-12-19 13:37:41 -0800375TEST(socket_test, test_parse_host_service_prefix) {
David Pursellc929c6f2016-03-01 08:58:26 -0800376 for (const std::string& prefix : {"usb:", "product:", "model:", "device:"}) {
Josh Gao8d49e122018-12-19 13:37:41 -0800377 VerifyParseHostServiceFailed(prefix);
378 VerifyParseHostServiceFailed(prefix + "foo");
David Pursellc929c6f2016-03-01 08:58:26 -0800379
Josh Gao8d49e122018-12-19 13:37:41 -0800380 VerifyParseHostService(prefix + "foo:bar", prefix + "foo", "bar");
381 VerifyParseHostService(prefix + "foo:bar:baz", prefix + "foo", "bar:baz");
382 VerifyParseHostService(prefix + "foo:123:bar", prefix + "foo", "123:bar");
David Pursellc929c6f2016-03-01 08:58:26 -0800383 }
384}
385
386#endif // ADB_HOST