blob: 39b97d3ca0dc5f1f7a330f14d5649723ffa4bdd6 [file] [log] [blame]
Yifan Hong9881df92017-05-10 14:33:05 -07001/*
2 * Copyright (C) 2017 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#define LOG_TAG "Lshal"
18#include <android-base/logging.h>
19
20#include <sstream>
21#include <string>
22#include <thread>
23#include <vector>
24
25#include <gtest/gtest.h>
26#include <gmock/gmock.h>
27#include <android/hardware/tests/baz/1.0/IQuux.h>
28#include <hidl/HidlTransportSupport.h>
Yifan Hong8bf73162017-09-07 18:06:13 -070029#include <vintf/parse_xml.h>
Yifan Hong9881df92017-05-10 14:33:05 -070030
Yifan Hongb2a2ecb2017-09-07 15:08:22 -070031#include "ListCommand.h"
Yifan Hong9881df92017-05-10 14:33:05 -070032#include "Lshal.h"
33
34#define NELEMS(array) static_cast<int>(sizeof(array) / sizeof(array[0]))
35
36using namespace testing;
37
Yifan Hong8bf73162017-09-07 18:06:13 -070038using ::android::hidl::base::V1_0::DebugInfo;
Yifan Hong9881df92017-05-10 14:33:05 -070039using ::android::hidl::base::V1_0::IBase;
40using ::android::hidl::manager::V1_0::IServiceManager;
41using ::android::hidl::manager::V1_0::IServiceNotification;
42using ::android::hardware::hidl_death_recipient;
43using ::android::hardware::hidl_handle;
44using ::android::hardware::hidl_string;
45using ::android::hardware::hidl_vec;
46
Yifan Hong8bf73162017-09-07 18:06:13 -070047using InstanceDebugInfo = IServiceManager::InstanceDebugInfo;
48
Yifan Hong9881df92017-05-10 14:33:05 -070049namespace android {
50namespace hardware {
51namespace tests {
52namespace baz {
53namespace V1_0 {
54namespace implementation {
55struct Quux : android::hardware::tests::baz::V1_0::IQuux {
56 ::android::hardware::Return<void> debug(const hidl_handle& hh, const hidl_vec<hidl_string>& options) override {
57 const native_handle_t *handle = hh.getNativeHandle();
58 if (handle->numFds < 1) {
59 return Void();
60 }
61 int fd = handle->data[0];
62 std::string content{descriptor};
63 for (const auto &option : options) {
64 content += "\n";
65 content += option.c_str();
66 }
67 ssize_t written = write(fd, content.c_str(), content.size());
68 if (written != (ssize_t)content.size()) {
69 LOG(WARNING) << "SERVER(Quux) debug writes " << written << " bytes < "
70 << content.size() << " bytes, errno = " << errno;
71 }
72 return Void();
73 }
74};
75
76} // namespace implementation
77} // namespace V1_0
78} // namespace baz
79} // namespace tests
80} // namespace hardware
81
82namespace lshal {
83
Yifan Hong9881df92017-05-10 14:33:05 -070084class MockServiceManager : public IServiceManager {
85public:
86 template<typename T>
87 using R = ::android::hardware::Return<T>;
88 using String = const hidl_string&;
89 ~MockServiceManager() = default;
90
91#define MOCK_METHOD_CB(name) MOCK_METHOD1(name, R<void>(IServiceManager::name##_cb))
92
93 MOCK_METHOD2(get, R<sp<IBase>>(String, String));
94 MOCK_METHOD2(add, R<bool>(String, const sp<IBase>&));
95 MOCK_METHOD2(getTransport, R<IServiceManager::Transport>(String, String));
96 MOCK_METHOD_CB(list);
97 MOCK_METHOD2(listByInterface, R<void>(String, listByInterface_cb));
98 MOCK_METHOD3(registerForNotifications, R<bool>(String, String, const sp<IServiceNotification>&));
99 MOCK_METHOD_CB(debugDump);
100 MOCK_METHOD2(registerPassthroughClient, R<void>(String, String));
101 MOCK_METHOD_CB(interfaceChain);
102 MOCK_METHOD2(debug, R<void>(const hidl_handle&, const hidl_vec<hidl_string>&));
103 MOCK_METHOD_CB(interfaceDescriptor);
104 MOCK_METHOD_CB(getHashChain);
105 MOCK_METHOD0(setHalInstrumentation, R<void>());
106 MOCK_METHOD2(linkToDeath, R<bool>(const sp<hidl_death_recipient>&, uint64_t));
107 MOCK_METHOD0(ping, R<void>());
108 MOCK_METHOD_CB(getDebugInfo);
109 MOCK_METHOD0(notifySyspropsChanged, R<void>());
110 MOCK_METHOD1(unlinkToDeath, R<bool>(const sp<hidl_death_recipient>&));
111
112};
113
Yifan Hongbf20a262017-09-07 11:10:58 -0700114class DebugTest : public ::testing::Test {
Yifan Hong9881df92017-05-10 14:33:05 -0700115public:
116 void SetUp() override {
117 using ::android::hardware::tests::baz::V1_0::IQuux;
118 using ::android::hardware::tests::baz::V1_0::implementation::Quux;
119
120 err.str("");
121 out.str("");
122 serviceManager = new testing::NiceMock<MockServiceManager>();
123 ON_CALL(*serviceManager, get(_, _)).WillByDefault(Invoke(
124 [](const auto &iface, const auto &inst) -> ::android::hardware::Return<sp<IBase>> {
125 if (iface == IQuux::descriptor && inst == "default")
126 return new Quux();
127 return nullptr;
128 }));
Yifan Hongbf20a262017-09-07 11:10:58 -0700129
130 lshal = std::make_unique<Lshal>(out, err, serviceManager, serviceManager);
Yifan Hong9881df92017-05-10 14:33:05 -0700131 }
132 void TearDown() override {}
133
134 std::stringstream err;
135 std::stringstream out;
136 sp<MockServiceManager> serviceManager;
Yifan Hongbf20a262017-09-07 11:10:58 -0700137
138 std::unique_ptr<Lshal> lshal;
Yifan Hong9881df92017-05-10 14:33:05 -0700139};
140
Yifan Hongbf20a262017-09-07 11:10:58 -0700141static Arg createArg(const std::vector<const char*>& args) {
142 return Arg{static_cast<int>(args.size()), const_cast<char**>(args.data())};
143}
144
145template<typename T>
146static Status callMain(const std::unique_ptr<T>& lshal, const std::vector<const char*>& args) {
147 return lshal->main(createArg(args));
148}
149
150TEST_F(DebugTest, Debug) {
151 EXPECT_EQ(0u, callMain(lshal, {
Yifan Hong9881df92017-05-10 14:33:05 -0700152 "lshal", "debug", "android.hardware.tests.baz@1.0::IQuux/default", "foo", "bar"
Yifan Hongbf20a262017-09-07 11:10:58 -0700153 }));
Yifan Hong9881df92017-05-10 14:33:05 -0700154 EXPECT_THAT(out.str(), StrEq("android.hardware.tests.baz@1.0::IQuux\nfoo\nbar"));
155 EXPECT_THAT(err.str(), IsEmpty());
156}
157
Yifan Hongbf20a262017-09-07 11:10:58 -0700158TEST_F(DebugTest, Debug2) {
159 EXPECT_EQ(0u, callMain(lshal, {
Yifan Hong9881df92017-05-10 14:33:05 -0700160 "lshal", "debug", "android.hardware.tests.baz@1.0::IQuux", "baz", "quux"
Yifan Hongbf20a262017-09-07 11:10:58 -0700161 }));
Yifan Hong9881df92017-05-10 14:33:05 -0700162 EXPECT_THAT(out.str(), StrEq("android.hardware.tests.baz@1.0::IQuux\nbaz\nquux"));
163 EXPECT_THAT(err.str(), IsEmpty());
164}
165
Yifan Hongbf20a262017-09-07 11:10:58 -0700166TEST_F(DebugTest, Debug3) {
167 EXPECT_NE(0u, callMain(lshal, {
Yifan Hong9881df92017-05-10 14:33:05 -0700168 "lshal", "debug", "android.hardware.tests.doesnotexist@1.0::IDoesNotExist",
Yifan Hongbf20a262017-09-07 11:10:58 -0700169 }));
Yifan Hong9881df92017-05-10 14:33:05 -0700170 EXPECT_THAT(err.str(), HasSubstr("does not exist"));
171}
172
Yifan Hongb2a2ecb2017-09-07 15:08:22 -0700173class MockLshal : public Lshal {
174public:
175 MockLshal() {}
176 ~MockLshal() = default;
177 MOCK_CONST_METHOD0(out, NullableOStream<std::ostream>());
178 MOCK_CONST_METHOD0(err, NullableOStream<std::ostream>());
179};
180
181// expose protected fields and methods for ListCommand
182class MockListCommand : public ListCommand {
183public:
184 MockListCommand(Lshal* lshal) : ListCommand(*lshal) {}
185
Yifan Honga8bedc62017-09-08 18:00:31 -0700186 Status parseArgs(const Arg& arg) { return ListCommand::parseArgs(arg); }
187 Status main(const Arg& arg) { return ListCommand::main(arg); }
Yifan Hong93b8bff2017-09-14 16:02:52 -0700188 void forEachTable(const std::function<void(Table &)> &f) {
189 return ListCommand::forEachTable(f);
190 }
Yifan Hongb2a2ecb2017-09-07 15:08:22 -0700191 void forEachTable(const std::function<void(const Table &)> &f) const {
192 return ListCommand::forEachTable(f);
193 }
Yifan Hong8bf73162017-09-07 18:06:13 -0700194 Status fetch() { return ListCommand::fetch(); }
195 void dumpVintf(const NullableOStream<std::ostream>& out) {
196 return ListCommand::dumpVintf(out);
197 }
Yifan Hong93b8bff2017-09-14 16:02:52 -0700198 void internalPostprocess() { ListCommand::postprocess(); }
Yifan Hong8bf73162017-09-07 18:06:13 -0700199
Yifan Hong93b8bff2017-09-14 16:02:52 -0700200 MOCK_METHOD0(postprocess, void());
Yifan Hong8bf73162017-09-07 18:06:13 -0700201 MOCK_CONST_METHOD2(getPidInfo, bool(pid_t, PidInfo*));
202 MOCK_CONST_METHOD1(parseCmdline, std::string(pid_t));
Yifan Hongb2a2ecb2017-09-07 15:08:22 -0700203};
204
205class ListParseArgsTest : public ::testing::Test {
206public:
207 void SetUp() override {
208 mockLshal = std::make_unique<NiceMock<MockLshal>>();
209 mockList = std::make_unique<MockListCommand>(mockLshal.get());
210 // ListCommand::parseArgs should parse arguments from the second element
211 optind = 1;
212 }
213 std::unique_ptr<MockLshal> mockLshal;
214 std::unique_ptr<MockListCommand> mockList;
215 std::stringstream output;
216};
217
218TEST_F(ListParseArgsTest, Default) {
219 // default args
220 EXPECT_EQ(0u, mockList->parseArgs(createArg({})));
221 mockList->forEachTable([](const Table& table) {
222 EXPECT_EQ(SelectedColumns({TableColumnType::INTERFACE_NAME, TableColumnType::THREADS,
223 TableColumnType::SERVER_PID, TableColumnType::CLIENT_PIDS}),
224 table.getSelectedColumns());
225 });
226}
227
228TEST_F(ListParseArgsTest, Args) {
229 EXPECT_EQ(0u, mockList->parseArgs(createArg({"lshal", "-p", "-i", "-a", "-c"})));
230 mockList->forEachTable([](const Table& table) {
231 EXPECT_EQ(SelectedColumns({TableColumnType::SERVER_PID, TableColumnType::INTERFACE_NAME,
232 TableColumnType::SERVER_ADDR, TableColumnType::CLIENT_PIDS}),
233 table.getSelectedColumns());
234 });
235}
236
237TEST_F(ListParseArgsTest, Cmds) {
238 EXPECT_EQ(0u, mockList->parseArgs(createArg({"lshal", "-m"})));
239 mockList->forEachTable([](const Table& table) {
240 EXPECT_EQ(SelectedColumns({TableColumnType::INTERFACE_NAME, TableColumnType::THREADS,
241 TableColumnType::SERVER_CMD, TableColumnType::CLIENT_CMDS}),
242 table.getSelectedColumns());
243 });
244}
245
246TEST_F(ListParseArgsTest, DebugAndNeat) {
247 ON_CALL(*mockLshal, err()).WillByDefault(Return(NullableOStream<std::ostream>(output)));
248 EXPECT_NE(0u, mockList->parseArgs(createArg({"lshal", "--neat", "-d"})));
249 EXPECT_THAT(output.str(), StrNe(""));
250}
251
Yifan Hong8bf73162017-09-07 18:06:13 -0700252/// Fetch Test
253
254// A set of deterministic functions to generate fake debug infos.
255static uint64_t getPtr(pid_t serverId) { return 10000 + serverId; }
256static std::vector<pid_t> getClients(pid_t serverId) {
257 return {serverId + 1, serverId + 3};
258}
259static PidInfo getPidInfoFromId(pid_t serverId) {
260 PidInfo info;
261 info.refPids[getPtr(serverId)] = getClients(serverId);
262 info.threadUsage = 10 + serverId;
263 info.threadCount = 20 + serverId;
264 return info;
265}
266static std::string getInterfaceName(pid_t serverId) {
267 return "a.h.foo" + std::to_string(serverId) + "@" + std::to_string(serverId) + ".0::IFoo";
268}
269static std::string getInstanceName(pid_t serverId) {
270 return std::to_string(serverId);
271}
272static pid_t getIdFromInstanceName(const hidl_string& instance) {
273 return atoi(instance.c_str());
274}
275static std::string getFqInstanceName(pid_t serverId) {
276 return getInterfaceName(serverId) + "/" + getInstanceName(serverId);
277}
278static std::string getCmdlineFromId(pid_t serverId) {
279 if (serverId == NO_PID) return "";
280 return "command_line_" + std::to_string(serverId);
281}
282
283// Fake service returned by mocked IServiceManager::get.
284class TestService : public IBase {
285public:
286 TestService(DebugInfo&& info) : mInfo(std::move(info)) {}
287 hardware::Return<void> getDebugInfo(getDebugInfo_cb cb) override {
288 cb(mInfo);
289 return hardware::Void();
290 }
291private:
292 DebugInfo mInfo;
293};
294
295class ListTest : public ::testing::Test {
296public:
297 void SetUp() override {
298 initMockServiceManager();
299 lshal = std::make_unique<Lshal>(out, err, serviceManager, passthruManager);
300 initMockList();
301 }
302
303 void initMockList() {
304 mockList = std::make_unique<NiceMock<MockListCommand>>(lshal.get());
305 ON_CALL(*mockList, getPidInfo(_,_)).WillByDefault(Invoke(
306 [](pid_t serverPid, PidInfo* info) {
307 *info = getPidInfoFromId(serverPid);
308 return true;
309 }));
310 ON_CALL(*mockList, parseCmdline(_)).WillByDefault(Invoke(&getCmdlineFromId));
Yifan Hong93b8bff2017-09-14 16:02:52 -0700311 ON_CALL(*mockList, postprocess()).WillByDefault(Invoke([&]() {
312 mockList->internalPostprocess();
313 size_t i = 0;
314 mockList->forEachTable([&](Table& table) {
315 table.setDescription("[fake description " + std::to_string(i++) + "]");
316 });
317 }));
Yifan Hong8bf73162017-09-07 18:06:13 -0700318 }
319
320 void initMockServiceManager() {
321 serviceManager = new testing::NiceMock<MockServiceManager>();
322 passthruManager = new testing::NiceMock<MockServiceManager>();
323 using A = DebugInfo::Architecture;
324 ON_CALL(*serviceManager, list(_)).WillByDefault(Invoke(
325 [] (IServiceManager::list_cb cb) {
326 cb({ getFqInstanceName(1), getFqInstanceName(2) });
327 return hardware::Void();
328 }));
329
330 ON_CALL(*serviceManager, get(_, _)).WillByDefault(Invoke(
331 [&](const hidl_string&, const hidl_string& instance) {
332 int id = getIdFromInstanceName(instance);
333 return sp<IBase>(new TestService({ id /* pid */, getPtr(id), A::IS_64BIT }));
334 }));
335
336 ON_CALL(*serviceManager, debugDump(_)).WillByDefault(Invoke(
337 [] (IServiceManager::debugDump_cb cb) {
338 cb({InstanceDebugInfo{getInterfaceName(3), getInstanceName(3), 3,
339 getClients(3), A::IS_32BIT},
340 InstanceDebugInfo{getInterfaceName(4), getInstanceName(4), 4,
341 getClients(4), A::IS_32BIT}});
342 return hardware::Void();
343 }));
344
345 ON_CALL(*passthruManager, debugDump(_)).WillByDefault(Invoke(
346 [] (IServiceManager::debugDump_cb cb) {
347 cb({InstanceDebugInfo{getInterfaceName(5), getInstanceName(5), 5,
348 getClients(5), A::IS_32BIT},
349 InstanceDebugInfo{getInterfaceName(6), getInstanceName(6), 6,
350 getClients(6), A::IS_32BIT}});
351 return hardware::Void();
352 }));
353 }
354
355 std::stringstream err;
356 std::stringstream out;
357 std::unique_ptr<Lshal> lshal;
358 std::unique_ptr<MockListCommand> mockList;
359 sp<MockServiceManager> serviceManager;
360 sp<MockServiceManager> passthruManager;
361};
362
363TEST_F(ListTest, Fetch) {
364 EXPECT_EQ(0u, mockList->fetch());
365 std::array<std::string, 6> transports{{"hwbinder", "hwbinder", "passthrough",
366 "passthrough", "passthrough", "passthrough"}};
367 std::array<Architecture, 6> archs{{ARCH64, ARCH64, ARCH32, ARCH32, ARCH32, ARCH32}};
368 int id = 1;
369 mockList->forEachTable([&](const Table& table) {
370 ASSERT_EQ(2u, table.size());
371 for (const auto& entry : table) {
372 const auto& transport = transports[id - 1];
373 TableEntry expected{
374 .interfaceName = getFqInstanceName(id),
375 .transport = transport,
376 .serverPid = transport == "hwbinder" ? id : NO_PID,
377 .threadUsage = transport == "hwbinder" ? getPidInfoFromId(id).threadUsage : 0,
378 .threadCount = transport == "hwbinder" ? getPidInfoFromId(id).threadCount : 0,
379 .serverCmdline = {},
380 .serverObjectAddress = transport == "hwbinder" ? getPtr(id) : NO_PTR,
381 .clientPids = getClients(id),
382 .clientCmdlines = {},
383 .arch = archs[id - 1],
384 };
385 EXPECT_EQ(expected, entry) << expected.to_string() << " vs. " << entry.to_string();
386
387 ++id;
388 }
389 });
390
391}
392
393TEST_F(ListTest, DumpVintf) {
394 const std::string expected =
395 "<!-- \n"
396 " This is a skeleton device manifest. Notes: \n"
397 " 1. android.hidl.*, android.frameworks.*, android.system.* are not included.\n"
398 " 2. If a HAL is supported in both hwbinder and passthrough transport, \n"
399 " only hwbinder is shown.\n"
400 " 3. It is likely that HALs in passthrough transport does not have\n"
401 " <interface> declared; users will have to write them by hand.\n"
402 " 4. A HAL with lower minor version can be overridden by a HAL with\n"
403 " higher minor version if they have the same name and major version.\n"
404 " 5. sepolicy version is set to 0.0. It is recommended that the entry\n"
405 " is removed from the manifest file and written by assemble_vintf\n"
406 " at build time.\n"
407 "-->\n"
408 "<manifest version=\"1.0\" type=\"device\">\n"
409 " <hal format=\"hidl\">\n"
410 " <name>a.h.foo1</name>\n"
411 " <transport>hwbinder</transport>\n"
412 " <version>1.0</version>\n"
413 " <interface>\n"
414 " <name>IFoo</name>\n"
415 " <instance>1</instance>\n"
416 " </interface>\n"
417 " </hal>\n"
418 " <hal format=\"hidl\">\n"
419 " <name>a.h.foo2</name>\n"
420 " <transport>hwbinder</transport>\n"
421 " <version>2.0</version>\n"
422 " <interface>\n"
423 " <name>IFoo</name>\n"
424 " <instance>2</instance>\n"
425 " </interface>\n"
426 " </hal>\n"
427 " <hal format=\"hidl\">\n"
428 " <name>a.h.foo3</name>\n"
429 " <transport arch=\"32\">passthrough</transport>\n"
430 " <version>3.0</version>\n"
431 " <interface>\n"
432 " <name>IFoo</name>\n"
433 " <instance>3</instance>\n"
434 " </interface>\n"
435 " </hal>\n"
436 " <hal format=\"hidl\">\n"
437 " <name>a.h.foo4</name>\n"
438 " <transport arch=\"32\">passthrough</transport>\n"
439 " <version>4.0</version>\n"
440 " <interface>\n"
441 " <name>IFoo</name>\n"
442 " <instance>4</instance>\n"
443 " </interface>\n"
444 " </hal>\n"
445 " <hal format=\"hidl\">\n"
446 " <name>a.h.foo5</name>\n"
447 " <transport arch=\"32\">passthrough</transport>\n"
448 " <version>5.0</version>\n"
449 " </hal>\n"
450 " <hal format=\"hidl\">\n"
451 " <name>a.h.foo6</name>\n"
452 " <transport arch=\"32\">passthrough</transport>\n"
453 " <version>6.0</version>\n"
454 " </hal>\n"
455 " <sepolicy>\n"
456 " <version>0.0</version>\n"
457 " </sepolicy>\n"
458 "</manifest>\n";
459
460 optind = 1; // mimic Lshal::parseArg()
461 EXPECT_EQ(0u, mockList->main(createArg({"lshal", "--init-vintf"})));
462 EXPECT_EQ(expected, out.str());
463 EXPECT_EQ("", err.str());
464
465 vintf::HalManifest m;
466 EXPECT_EQ(true, vintf::gHalManifestConverter(&m, out.str()))
467 << "--init-vintf does not emit valid HAL manifest: "
468 << vintf::gHalManifestConverter.lastError();
469}
470
471TEST_F(ListTest, Dump) {
472 const std::string expected =
Yifan Hong93b8bff2017-09-14 16:02:52 -0700473 "[fake description 0]\n"
Yifan Hong8bf73162017-09-07 18:06:13 -0700474 "Interface Transport Arch Thread Use Server PTR Clients\n"
475 "a.h.foo1@1.0::IFoo/1 hwbinder 64 11/21 1 0000000000002711 2 4\n"
476 "a.h.foo2@2.0::IFoo/2 hwbinder 64 12/22 2 0000000000002712 3 5\n"
477 "\n"
Yifan Hong93b8bff2017-09-14 16:02:52 -0700478 "[fake description 1]\n"
Yifan Hong8bf73162017-09-07 18:06:13 -0700479 "Interface Transport Arch Thread Use Server PTR Clients\n"
480 "a.h.foo3@3.0::IFoo/3 passthrough 32 N/A N/A N/A 4 6\n"
481 "a.h.foo4@4.0::IFoo/4 passthrough 32 N/A N/A N/A 5 7\n"
482 "\n"
Yifan Hong93b8bff2017-09-14 16:02:52 -0700483 "[fake description 2]\n"
Yifan Hong8bf73162017-09-07 18:06:13 -0700484 "Interface Transport Arch Thread Use Server PTR Clients\n"
485 "a.h.foo5@5.0::IFoo/5 passthrough 32 N/A N/A N/A 6 8\n"
486 "a.h.foo6@6.0::IFoo/6 passthrough 32 N/A N/A N/A 7 9\n"
487 "\n";
488
489 optind = 1; // mimic Lshal::parseArg()
490 EXPECT_EQ(0u, mockList->main(createArg({"lshal", "-itrepac"})));
491 EXPECT_EQ(expected, out.str());
492 EXPECT_EQ("", err.str());
493}
494
495TEST_F(ListTest, DumpCmdline) {
496 const std::string expected =
Yifan Hong93b8bff2017-09-14 16:02:52 -0700497 "[fake description 0]\n"
Yifan Hong8bf73162017-09-07 18:06:13 -0700498 "Interface Transport Arch Thread Use Server CMD PTR Clients CMD\n"
499 "a.h.foo1@1.0::IFoo/1 hwbinder 64 11/21 command_line_1 0000000000002711 command_line_2;command_line_4\n"
500 "a.h.foo2@2.0::IFoo/2 hwbinder 64 12/22 command_line_2 0000000000002712 command_line_3;command_line_5\n"
501 "\n"
Yifan Hong93b8bff2017-09-14 16:02:52 -0700502 "[fake description 1]\n"
Yifan Hong8bf73162017-09-07 18:06:13 -0700503 "Interface Transport Arch Thread Use Server CMD PTR Clients CMD\n"
504 "a.h.foo3@3.0::IFoo/3 passthrough 32 N/A N/A command_line_4;command_line_6\n"
505 "a.h.foo4@4.0::IFoo/4 passthrough 32 N/A N/A command_line_5;command_line_7\n"
506 "\n"
Yifan Hong93b8bff2017-09-14 16:02:52 -0700507 "[fake description 2]\n"
Yifan Hong8bf73162017-09-07 18:06:13 -0700508 "Interface Transport Arch Thread Use Server CMD PTR Clients CMD\n"
509 "a.h.foo5@5.0::IFoo/5 passthrough 32 N/A N/A command_line_6;command_line_8\n"
510 "a.h.foo6@6.0::IFoo/6 passthrough 32 N/A N/A command_line_7;command_line_9\n"
511 "\n";
512
513 optind = 1; // mimic Lshal::parseArg()
514 EXPECT_EQ(0u, mockList->main(createArg({"lshal", "-itrepacm"})));
515 EXPECT_EQ(expected, out.str());
516 EXPECT_EQ("", err.str());
517}
518
519TEST_F(ListTest, DumpNeat) {
520 const std::string expected =
521 "a.h.foo1@1.0::IFoo/1 11/21 1 2 4\n"
522 "a.h.foo2@2.0::IFoo/2 12/22 2 3 5\n"
523 "a.h.foo3@3.0::IFoo/3 N/A N/A 4 6\n"
524 "a.h.foo4@4.0::IFoo/4 N/A N/A 5 7\n"
525 "a.h.foo5@5.0::IFoo/5 N/A N/A 6 8\n"
526 "a.h.foo6@6.0::IFoo/6 N/A N/A 7 9\n";
527
528 optind = 1; // mimic Lshal::parseArg()
529 EXPECT_EQ(0u, mockList->main(createArg({"lshal", "--neat"})));
530 EXPECT_EQ(expected, out.str());
531 EXPECT_EQ("", err.str());
532}
Yifan Honga8bedc62017-09-08 18:00:31 -0700533
534class HelpTest : public ::testing::Test {
535public:
536 void SetUp() override {
537 lshal = std::make_unique<Lshal>(out, err, new MockServiceManager() /* serviceManager */,
538 new MockServiceManager() /* passthruManager */);
539 }
540
541 std::stringstream err;
542 std::stringstream out;
543 std::unique_ptr<Lshal> lshal;
544};
545
546TEST_F(HelpTest, GlobalUsage) {
547 (void)callMain(lshal, {"lshal", "--help"}); // ignore return
548 std::string errStr = err.str();
549 EXPECT_THAT(errStr, ContainsRegex("(^|\n)commands:($|\n)"))
550 << "`lshal --help` does not contain global usage";
551 EXPECT_THAT(errStr, ContainsRegex("(^|\n)list:($|\n)"))
552 << "`lshal --help` does not contain usage for 'list' command";
553 EXPECT_THAT(errStr, ContainsRegex("(^|\n)debug:($|\n)"))
554 << "`lshal --help` does not contain usage for 'debug' command";
555 EXPECT_THAT(errStr, ContainsRegex("(^|\n)help:($|\n)"))
556 << "`lshal --help` does not contain usage for 'help' command";
557
558 err.str("");
559 (void)callMain(lshal, {"lshal", "help"}); // ignore return
560 EXPECT_EQ(errStr, err.str()) << "`lshal help` should have the same output as `lshal --help`";
561
562 err.str("");
563 EXPECT_NE(0u, callMain(lshal, {"lshal", "--unknown-option"}));
564 EXPECT_THAT(err.str(), ContainsRegex("unrecognized option"));
565 EXPECT_THAT(err.str(), EndsWith(errStr))
566 << "`lshal --unknown-option` should have the same output as `lshal --help`";
567 EXPECT_EQ("", out.str());
568}
569
570TEST_F(HelpTest, UnknownOptionList1) {
571 (void)callMain(lshal, {"lshal", "help", "list"});
572 EXPECT_THAT(err.str(), ContainsRegex("(^|\n)list:($|\n)"))
573 << "`lshal help list` does not contain usage for 'list' command";
574}
575
576TEST_F(HelpTest, UnknownOptionList2) {
577 EXPECT_NE(0u, callMain(lshal, {"lshal", "list", "--unknown-option"}));
578 EXPECT_THAT(err.str(), ContainsRegex("unrecognized option"));
579 EXPECT_THAT(err.str(), ContainsRegex("(^|\n)list:($|\n)"))
580 << "`lshal list --unknown-option` does not contain usage for 'list' command";
581 EXPECT_EQ("", out.str());
582}
583
584TEST_F(HelpTest, UnknownOptionHelp1) {
585 (void)callMain(lshal, {"lshal", "help", "help"});
586 EXPECT_THAT(err.str(), ContainsRegex("(^|\n)help:($|\n)"))
587 << "`lshal help help` does not contain usage for 'help' command";
588}
589
590TEST_F(HelpTest, UnknownOptionHelp2) {
591 (void)callMain(lshal, {"lshal", "help", "--unknown-option"});
592 EXPECT_THAT(err.str(), ContainsRegex("(^|\n)help:($|\n)"))
593 << "`lshal help --unknown-option` does not contain usage for 'help' command";
594 EXPECT_EQ("", out.str());
595}
596
Yifan Hong9881df92017-05-10 14:33:05 -0700597} // namespace lshal
598} // namespace android
599
600int main(int argc, char **argv) {
601 ::testing::InitGoogleMock(&argc, argv);
602 return RUN_ALL_TESTS();
603}