1 /*
2 * Copyright 2020 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 "MockCarWatchdogServiceForSystem.h"
18 #include "MockWatchdogServiceHelper.h"
19 #include "WatchdogProcessService.h"
20 #include "WatchdogServiceHelper.h"
21
22 #include <android/automotive/watchdog/internal/BnCarWatchdogServiceForSystem.h>
23 #include <gmock/gmock.h>
24
25 namespace android {
26 namespace automotive {
27 namespace watchdog {
28
29 namespace aawi = ::android::automotive::watchdog::internal;
30
31 using ::android::IBinder;
32 using ::android::sp;
33 using ::android::binder::Status;
34 using ::testing::_;
35 using ::testing::Return;
36
37 namespace {
38
39 class MockCarWatchdogClient : public ICarWatchdogClientDefault {
40 public:
MockCarWatchdogClient()41 MockCarWatchdogClient() { mBinder = new MockBinder(); }
getBinder() const42 sp<MockBinder> getBinder() const { return mBinder; }
43
44 MOCK_METHOD(IBinder*, onAsBinder, (), (override));
45
46 private:
47 sp<MockBinder> mBinder;
48 };
49
50 class MockCarWatchdogMonitor : public aawi::ICarWatchdogMonitorDefault {
51 public:
MockCarWatchdogMonitor()52 MockCarWatchdogMonitor() { mBinder = new MockBinder(); }
getBinder() const53 sp<MockBinder> getBinder() const { return mBinder; }
54
55 MOCK_METHOD(IBinder*, onAsBinder, (), (override));
56
57 private:
58 sp<MockBinder> mBinder;
59 };
60
61 } // namespace
62
63 class WatchdogProcessServiceTest : public ::testing::Test {
64 protected:
SetUp()65 void SetUp() override {
66 sp<Looper> looper(Looper::prepare(/*opts=*/0));
67 mWatchdogProcessService = new WatchdogProcessService(looper);
68 }
69
TearDown()70 void TearDown() override { mWatchdogProcessService.clear(); }
71
72 sp<WatchdogProcessService> mWatchdogProcessService;
73 };
74
createMockCarWatchdogClient(status_t linkToDeathResult)75 sp<MockCarWatchdogClient> createMockCarWatchdogClient(status_t linkToDeathResult) {
76 sp<MockCarWatchdogClient> client = new MockCarWatchdogClient();
77 sp<MockBinder> binder = client->getBinder();
78 EXPECT_CALL(*binder, linkToDeath(_, nullptr, 0)).WillRepeatedly(Return(linkToDeathResult));
79 EXPECT_CALL(*binder, unlinkToDeath(_, nullptr, 0, nullptr)).WillRepeatedly(Return(OK));
80 EXPECT_CALL(*client, onAsBinder()).WillRepeatedly(Return(binder.get()));
81 return client;
82 }
83
createMockCarWatchdogMonitor(status_t linkToDeathResult)84 sp<MockCarWatchdogMonitor> createMockCarWatchdogMonitor(status_t linkToDeathResult) {
85 sp<MockCarWatchdogMonitor> monitor = new MockCarWatchdogMonitor();
86 sp<MockBinder> binder = monitor->getBinder();
87 EXPECT_CALL(*binder, linkToDeath(_, nullptr, 0)).WillRepeatedly(Return(linkToDeathResult));
88 EXPECT_CALL(*binder, unlinkToDeath(_, nullptr, 0, nullptr)).WillRepeatedly(Return(OK));
89 EXPECT_CALL(*monitor, onAsBinder()).WillRepeatedly(Return(binder.get()));
90 return monitor;
91 }
92
expectNormalCarWatchdogClient()93 sp<MockCarWatchdogClient> expectNormalCarWatchdogClient() {
94 return createMockCarWatchdogClient(OK);
95 }
96
expectCarWatchdogClientBinderDied()97 sp<MockCarWatchdogClient> expectCarWatchdogClientBinderDied() {
98 return createMockCarWatchdogClient(DEAD_OBJECT);
99 }
100
expectNormalCarWatchdogMonitor()101 sp<MockCarWatchdogMonitor> expectNormalCarWatchdogMonitor() {
102 return createMockCarWatchdogMonitor(OK);
103 }
104
expectCarWatchdogMonitorBinderDied()105 sp<MockCarWatchdogMonitor> expectCarWatchdogMonitorBinderDied() {
106 return createMockCarWatchdogMonitor(DEAD_OBJECT);
107 }
108
TEST_F(WatchdogProcessServiceTest,TestRegisterClient)109 TEST_F(WatchdogProcessServiceTest, TestRegisterClient) {
110 sp<MockCarWatchdogClient> client = expectNormalCarWatchdogClient();
111 Status status =
112 mWatchdogProcessService->registerClient(client, TimeoutLength::TIMEOUT_CRITICAL);
113 ASSERT_TRUE(status.isOk()) << status;
114 status = mWatchdogProcessService->registerClient(client, TimeoutLength::TIMEOUT_CRITICAL);
115 ASSERT_TRUE(status.isOk()) << status;
116 }
117
TEST_F(WatchdogProcessServiceTest,TestUnregisterClient)118 TEST_F(WatchdogProcessServiceTest, TestUnregisterClient) {
119 sp<MockCarWatchdogClient> client = expectNormalCarWatchdogClient();
120 mWatchdogProcessService->registerClient(client, TimeoutLength::TIMEOUT_CRITICAL);
121 Status status = mWatchdogProcessService->unregisterClient(client);
122 ASSERT_TRUE(status.isOk()) << status;
123 ASSERT_FALSE(mWatchdogProcessService->unregisterClient(client).isOk())
124 << "Unregistering an unregistered client shoud return an error";
125 }
126
TEST_F(WatchdogProcessServiceTest,TestErrorOnRegisterClientWithDeadBinder)127 TEST_F(WatchdogProcessServiceTest, TestErrorOnRegisterClientWithDeadBinder) {
128 sp<MockCarWatchdogClient> client = expectCarWatchdogClientBinderDied();
129 ASSERT_FALSE(
130 mWatchdogProcessService->registerClient(client, TimeoutLength::TIMEOUT_CRITICAL).isOk())
131 << "When linkToDeath fails, registerClient should return an error";
132 }
133
TEST_F(WatchdogProcessServiceTest,TestRegisterCarWatchdogService)134 TEST_F(WatchdogProcessServiceTest, TestRegisterCarWatchdogService) {
135 sp<MockWatchdogServiceHelper> mockServiceHelper = new MockWatchdogServiceHelper();
136 ASSERT_RESULT_OK(mWatchdogProcessService->registerWatchdogServiceHelper(mockServiceHelper));
137
138 sp<MockCarWatchdogServiceForSystem> mockService = new MockCarWatchdogServiceForSystem();
139 sp<IBinder> binder = mockService->getBinder();
140
141 Status status = mWatchdogProcessService->registerCarWatchdogService(binder);
142 ASSERT_TRUE(status.isOk()) << status;
143
144 status = mWatchdogProcessService->registerCarWatchdogService(binder);
145 ASSERT_TRUE(status.isOk()) << status;
146 }
147
TEST_F(WatchdogProcessServiceTest,TestErrorOnRegisterCarWatchdogServiceWithUninitializedWatchdogServiceHelper)148 TEST_F(WatchdogProcessServiceTest,
149 TestErrorOnRegisterCarWatchdogServiceWithUninitializedWatchdogServiceHelper) {
150 sp<MockCarWatchdogServiceForSystem> mockService = new MockCarWatchdogServiceForSystem();
151 sp<IBinder> binder = mockService->getBinder();
152
153 ASSERT_FALSE(mWatchdogProcessService->registerCarWatchdogService(binder).isOk())
154 << "Registering car watchdog service should fail when watchdog service helper is "
155 "uninitialized";
156 }
157
TEST_F(WatchdogProcessServiceTest,TestRegisterMonitor)158 TEST_F(WatchdogProcessServiceTest, TestRegisterMonitor) {
159 sp<aawi::ICarWatchdogMonitor> monitorOne = expectNormalCarWatchdogMonitor();
160 sp<aawi::ICarWatchdogMonitor> monitorTwo = expectNormalCarWatchdogMonitor();
161 Status status = mWatchdogProcessService->registerMonitor(monitorOne);
162 ASSERT_TRUE(status.isOk()) << status;
163 status = mWatchdogProcessService->registerMonitor(monitorOne);
164 ASSERT_TRUE(status.isOk()) << status;
165 status = mWatchdogProcessService->registerMonitor(monitorTwo);
166 ASSERT_TRUE(status.isOk()) << status;
167 }
168
TEST_F(WatchdogProcessServiceTest,TestErrorOnRegisterMonitorWithDeadBinder)169 TEST_F(WatchdogProcessServiceTest, TestErrorOnRegisterMonitorWithDeadBinder) {
170 sp<MockCarWatchdogMonitor> monitor = expectCarWatchdogMonitorBinderDied();
171 ASSERT_FALSE(mWatchdogProcessService->registerMonitor(monitor).isOk())
172 << "When linkToDeath fails, registerMonitor should return an error";
173 }
174
TEST_F(WatchdogProcessServiceTest,TestUnregisterMonitor)175 TEST_F(WatchdogProcessServiceTest, TestUnregisterMonitor) {
176 sp<aawi::ICarWatchdogMonitor> monitor = expectNormalCarWatchdogMonitor();
177 mWatchdogProcessService->registerMonitor(monitor);
178 Status status = mWatchdogProcessService->unregisterMonitor(monitor);
179 ASSERT_TRUE(status.isOk()) << status;
180 ASSERT_FALSE(mWatchdogProcessService->unregisterMonitor(monitor).isOk())
181 << "Unregistering an unregistered monitor should return an error";
182 }
183
TEST_F(WatchdogProcessServiceTest,TestTellClientAlive)184 TEST_F(WatchdogProcessServiceTest, TestTellClientAlive) {
185 sp<ICarWatchdogClient> client = expectNormalCarWatchdogClient();
186 mWatchdogProcessService->registerClient(client, TimeoutLength::TIMEOUT_CRITICAL);
187 ASSERT_FALSE(mWatchdogProcessService->tellClientAlive(client, 1234).isOk())
188 << "tellClientAlive not synced with checkIfAlive should return an error";
189 }
190
TEST_F(WatchdogProcessServiceTest,TestTellCarWatchdogServiceAlive)191 TEST_F(WatchdogProcessServiceTest, TestTellCarWatchdogServiceAlive) {
192 sp<MockWatchdogServiceHelper> mockServiceHelper = new MockWatchdogServiceHelper();
193 ASSERT_RESULT_OK(mWatchdogProcessService->registerWatchdogServiceHelper(mockServiceHelper));
194
195 sp<MockCarWatchdogServiceForSystem> mockService = new MockCarWatchdogServiceForSystem();
196
197 std::vector<int32_t> pids = {111, 222};
198 ASSERT_FALSE(
199 mWatchdogProcessService->tellCarWatchdogServiceAlive(mockService, pids, 1234).isOk())
200 << "tellCarWatchdogServiceAlive not synced with checkIfAlive should return an error";
201 }
202
TEST_F(WatchdogProcessServiceTest,TestTellDumpFinished)203 TEST_F(WatchdogProcessServiceTest, TestTellDumpFinished) {
204 sp<aawi::ICarWatchdogMonitor> monitor = expectNormalCarWatchdogMonitor();
205 ASSERT_FALSE(mWatchdogProcessService->tellDumpFinished(monitor, 1234).isOk())
206 << "Unregistered monitor cannot call tellDumpFinished";
207 mWatchdogProcessService->registerMonitor(monitor);
208 Status status = mWatchdogProcessService->tellDumpFinished(monitor, 1234);
209 ASSERT_TRUE(status.isOk()) << status;
210 }
211
212 } // namespace watchdog
213 } // namespace automotive
214 } // namespace android
215