1 /**
2  * Copyright (c) 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 "MockAIBinderDeathRegistrationWrapper.h"
18 #include "MockCarWatchdogServiceForSystem.h"
19 #include "MockWatchdogProcessService.h"
20 #include "PackageInfoTestUtils.h"
21 #include "WatchdogServiceHelper.h"
22 
23 #include <binder/IBinder.h>
24 #include <gmock/gmock.h>
25 #include <gtest/gtest.h>
26 #include <utils/RefBase.h>
27 
28 namespace android {
29 namespace automotive {
30 namespace watchdog {
31 
32 namespace {
33 
34 using ::aidl::android::automotive::watchdog::TimeoutLength;
35 using ::aidl::android::automotive::watchdog::internal::ApplicationCategoryType;
36 using ::aidl::android::automotive::watchdog::internal::ComponentType;
37 using ::aidl::android::automotive::watchdog::internal::ICarWatchdogServiceForSystem;
38 using ::aidl::android::automotive::watchdog::internal::PackageInfo;
39 using ::aidl::android::automotive::watchdog::internal::PackageIoOveruseStats;
40 using ::aidl::android::automotive::watchdog::internal::ResourceOveruseStats;
41 using ::aidl::android::automotive::watchdog::internal::ResourceStats;
42 using ::aidl::android::automotive::watchdog::internal::ResourceUsageStats;
43 using ::aidl::android::automotive::watchdog::internal::UidType;
44 using ::aidl::android::automotive::watchdog::internal::UserPackageIoUsageStats;
45 using ::android::RefBase;
46 using ::android::sp;
47 using ::android::base::Error;
48 using ::android::base::Result;
49 using ::ndk::ScopedAStatus;
50 using ::ndk::SharedRefBase;
51 using ::testing::_;
52 using ::testing::ByMove;
53 using ::testing::DoAll;
54 using ::testing::Eq;
55 using ::testing::IsEmpty;
56 using ::testing::Return;
57 using ::testing::SetArgPointee;
58 using ::testing::UnorderedElementsAreArray;
59 
60 using InternalTimeoutLength = ::aidl::android::automotive::watchdog::internal::TimeoutLength;
61 
62 constexpr const char kFailOnNoCarWatchdogServiceMessage[] =
63         "should fail when no car watchdog service registered with the helper";
64 constexpr const char kFailOnCarWatchdogServiceErrMessage[] =
65         "should fail when car watchdog service API return error";
66 
67 }  // namespace
68 
69 namespace internal {
70 
71 class WatchdogServiceHelperPeer : public RefBase {
72 public:
WatchdogServiceHelperPeer(const sp<WatchdogServiceHelper> & helper)73     explicit WatchdogServiceHelperPeer(const sp<WatchdogServiceHelper>& helper) : mHelper(helper) {}
~WatchdogServiceHelperPeer()74     ~WatchdogServiceHelperPeer() { mHelper.clear(); }
75 
init(const sp<WatchdogProcessServiceInterface> & watchdogProcessService,const sp<AIBinderDeathRegistrationWrapperInterface> & deathRegistrationWrapper)76     Result<void> init(
77             const sp<WatchdogProcessServiceInterface>& watchdogProcessService,
78             const sp<AIBinderDeathRegistrationWrapperInterface>& deathRegistrationWrapper) {
79         mHelper->mDeathRegistrationWrapper = deathRegistrationWrapper;
80         return mHelper->init(watchdogProcessService);
81     }
82 
terminate()83     void terminate() { mHelper->terminate(); }
84 
85 private:
86     sp<WatchdogServiceHelper> mHelper;
87 };
88 
89 }  // namespace internal
90 
91 class WatchdogServiceHelperTest : public ::testing::Test {
92 protected:
SetUp()93     virtual void SetUp() {
94         mMockWatchdogProcessService = sp<MockWatchdogProcessService>::make();
95         mMockDeathRegistrationWrapper = sp<MockAIBinderDeathRegistrationWrapper>::make();
96         mWatchdogServiceHelper = sp<WatchdogServiceHelper>::make();
97         mWatchdogServiceHelperPeer =
98                 sp<internal::WatchdogServiceHelperPeer>::make(mWatchdogServiceHelper);
99         mMockCarWatchdogServiceForSystem = SharedRefBase::make<MockCarWatchdogServiceForSystem>();
100 
101         auto result = mWatchdogServiceHelperPeer->init(mMockWatchdogProcessService,
102                                                        mMockDeathRegistrationWrapper);
103         ASSERT_RESULT_OK(result);
104     }
105 
TearDown()106     virtual void TearDown() {
107         if (mWatchdogServiceHelper->isServiceConnected()) {
108             expectUnlinkToDeath(mMockCarWatchdogServiceForSystem->asBinder().get(),
109                                 ScopedAStatus::ok());
110             EXPECT_CALL(*mMockWatchdogProcessService, unregisterCarWatchdogService(_)).Times(1);
111         }
112         mWatchdogServiceHelperPeer->terminate();
113         mWatchdogServiceHelperPeer.clear();
114         mWatchdogServiceHelper.clear();
115 
116         mMockWatchdogProcessService.clear();
117         mMockDeathRegistrationWrapper.clear();
118         mMockCarWatchdogServiceForSystem.reset();
119         mWatchdogServiceHelperPeer.clear();
120     }
121 
registerCarWatchdogService()122     void registerCarWatchdogService() {
123         expectLinkToDeath(mMockCarWatchdogServiceForSystem->asBinder().get(), ScopedAStatus::ok());
124         EXPECT_CALL(*mMockWatchdogProcessService, registerCarWatchdogService(_, _))
125                 .WillOnce(Return(ByMove(ScopedAStatus::ok())));
126 
127         auto status = mWatchdogServiceHelper->registerService(mMockCarWatchdogServiceForSystem);
128 
129         ASSERT_TRUE(status.isOk()) << status.getMessage();
130         ASSERT_TRUE(mWatchdogServiceHelper->isServiceConnected());
131     }
132 
getCarWatchdogServiceForSystemCookie()133     void* getCarWatchdogServiceForSystemCookie() {
134         return static_cast<void*>(mMockCarWatchdogServiceForSystem->asBinder().get());
135     }
136 
expectLinkToDeath(AIBinder * aiBinder,ndk::ScopedAStatus expectedStatus)137     void expectLinkToDeath(AIBinder* aiBinder, ndk::ScopedAStatus expectedStatus) {
138         EXPECT_CALL(*mMockDeathRegistrationWrapper,
139                     linkToDeath(Eq(aiBinder), _, static_cast<void*>(aiBinder)))
140                 .WillOnce(Return(ByMove(std::move(expectedStatus))));
141     }
142 
expectUnlinkToDeath(AIBinder * aiBinder,ndk::ScopedAStatus expectedStatus)143     void expectUnlinkToDeath(AIBinder* aiBinder, ndk::ScopedAStatus expectedStatus) {
144         EXPECT_CALL(*mMockDeathRegistrationWrapper,
145                     unlinkToDeath(Eq(aiBinder), _, static_cast<void*>(aiBinder)))
146                 .WillOnce(Return(ByMove(std::move(expectedStatus))));
147     }
148 
expectNoLinkToDeath(AIBinder * aiBinder)149     void expectNoLinkToDeath(AIBinder* aiBinder) {
150         EXPECT_CALL(*mMockDeathRegistrationWrapper,
151                     linkToDeath(Eq(aiBinder), _, static_cast<void*>(aiBinder)))
152                 .Times(0);
153     }
154 
expectNoUnlinkToDeath(AIBinder * aiBinder)155     void expectNoUnlinkToDeath(AIBinder* aiBinder) {
156         EXPECT_CALL(*mMockDeathRegistrationWrapper,
157                     unlinkToDeath(Eq(aiBinder), _, static_cast<void*>(aiBinder)))
158                 .Times(0);
159     }
160 
161     sp<WatchdogServiceHelper> mWatchdogServiceHelper;
162     sp<MockWatchdogProcessService> mMockWatchdogProcessService;
163     sp<MockAIBinderDeathRegistrationWrapper> mMockDeathRegistrationWrapper;
164     std::shared_ptr<MockCarWatchdogServiceForSystem> mMockCarWatchdogServiceForSystem;
165     sp<internal::WatchdogServiceHelperPeer> mWatchdogServiceHelperPeer;
166 };
167 
TEST_F(WatchdogServiceHelperTest,TestInit)168 TEST_F(WatchdogServiceHelperTest, TestInit) {
169     sp<WatchdogServiceHelper> helper = sp<WatchdogServiceHelper>::make();
170     sp<MockWatchdogProcessService> mockWatchdogProcessService =
171             sp<MockWatchdogProcessService>::make();
172 
173     ASSERT_RESULT_OK(helper->init(mockWatchdogProcessService));
174 }
175 
TEST_F(WatchdogServiceHelperTest,TestErrorOnInitWithNullWatchdogProcessServiceInstance)176 TEST_F(WatchdogServiceHelperTest, TestErrorOnInitWithNullWatchdogProcessServiceInstance) {
177     sp<WatchdogServiceHelper> helper = sp<WatchdogServiceHelper>::make();
178 
179     auto result = helper->init(nullptr);
180 
181     ASSERT_FALSE(result.ok())
182             << "Watchdog service helper init should fail on null watchdog process service instance";
183 }
184 
TEST_F(WatchdogServiceHelperTest,TestTerminate)185 TEST_F(WatchdogServiceHelperTest, TestTerminate) {
186     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
187     expectUnlinkToDeath(mMockCarWatchdogServiceForSystem->asBinder().get(), ScopedAStatus::ok());
188 
189     mWatchdogServiceHelper->terminate();
190 
191     ASSERT_EQ(mWatchdogServiceHelper->mService, nullptr);
192 }
193 
TEST_F(WatchdogServiceHelperTest,TestRegisterService)194 TEST_F(WatchdogServiceHelperTest, TestRegisterService) {
195     auto binder = mMockCarWatchdogServiceForSystem->asBinder();
196     auto serviceHelperInterface = sp<WatchdogServiceHelperInterface>(mWatchdogServiceHelper);
197 
198     expectLinkToDeath(binder.get(), ScopedAStatus::ok());
199     EXPECT_CALL(*mMockWatchdogProcessService,
200                 registerCarWatchdogService(binder, serviceHelperInterface))
201             .WillOnce(Return(ByMove(ScopedAStatus::ok())));
202 
203     auto status = mWatchdogServiceHelper->registerService(mMockCarWatchdogServiceForSystem);
204     ASSERT_TRUE(status.isOk()) << status.getMessage();
205     ASSERT_TRUE(mWatchdogServiceHelper->isServiceConnected());
206 
207     expectNoLinkToDeath(binder.get());
208     EXPECT_CALL(*mMockWatchdogProcessService, registerCarWatchdogService(_, _)).Times(0);
209 
210     status = mWatchdogServiceHelper->registerService(mMockCarWatchdogServiceForSystem);
211     ASSERT_TRUE(status.isOk()) << status.getMessage();
212     ASSERT_TRUE(mWatchdogServiceHelper->isServiceConnected());
213 }
214 
TEST_F(WatchdogServiceHelperTest,TestErrorOnRegisterServiceWithBinderDied)215 TEST_F(WatchdogServiceHelperTest, TestErrorOnRegisterServiceWithBinderDied) {
216     auto binder = mMockCarWatchdogServiceForSystem->asBinder();
217     auto serviceHelperInterface = sp<WatchdogServiceHelperInterface>(mWatchdogServiceHelper);
218     expectLinkToDeath(binder.get(), ScopedAStatus::fromExceptionCode(EX_TRANSACTION_FAILED));
219     EXPECT_CALL(*mMockWatchdogProcessService,
220                 registerCarWatchdogService(binder, serviceHelperInterface))
221             .WillOnce(Return(ByMove(ScopedAStatus::ok())));
222     EXPECT_CALL(*mMockWatchdogProcessService, unregisterCarWatchdogService(binder)).Times(1);
223 
224     ASSERT_FALSE(mWatchdogServiceHelper->registerService(mMockCarWatchdogServiceForSystem).isOk())
225             << "Failed to return error on register service with dead binder";
226     ASSERT_FALSE(mWatchdogServiceHelper->isServiceConnected());
227 }
228 
TEST_F(WatchdogServiceHelperTest,TestErrorOnRegisterServiceWithWatchdogProcessServiceError)229 TEST_F(WatchdogServiceHelperTest, TestErrorOnRegisterServiceWithWatchdogProcessServiceError) {
230     auto binder = mMockCarWatchdogServiceForSystem->asBinder();
231     auto serviceHelperInterface = sp<WatchdogServiceHelperInterface>(mWatchdogServiceHelper);
232     expectNoLinkToDeath(binder.get());
233     expectNoUnlinkToDeath(binder.get());
234     EXPECT_CALL(*mMockWatchdogProcessService,
235                 registerCarWatchdogService(binder, serviceHelperInterface))
236             .WillOnce(Return(ByMove(ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE))));
237 
238     ASSERT_FALSE(mWatchdogServiceHelper->registerService(mMockCarWatchdogServiceForSystem).isOk())
239             << "Failed to return error on error from watchdog process service";
240     ASSERT_FALSE(mWatchdogServiceHelper->isServiceConnected());
241 }
242 
TEST_F(WatchdogServiceHelperTest,TestErrorOnRegisterServiceWithDeadBinder)243 TEST_F(WatchdogServiceHelperTest, TestErrorOnRegisterServiceWithDeadBinder) {
244     auto binder = mMockCarWatchdogServiceForSystem->asBinder();
245     auto serviceHelperInterface = sp<WatchdogServiceHelperInterface>(mWatchdogServiceHelper);
246     expectLinkToDeath(binder.get(), ScopedAStatus::fromExceptionCode(EX_TRANSACTION_FAILED));
247     EXPECT_CALL(*mMockWatchdogProcessService,
248                 registerCarWatchdogService(binder, serviceHelperInterface))
249             .WillOnce(Return(ByMove(ScopedAStatus::ok())));
250     EXPECT_CALL(*mMockWatchdogProcessService, unregisterCarWatchdogService(binder)).Times(1);
251 
252     ASSERT_FALSE(mWatchdogServiceHelper->registerService(mMockCarWatchdogServiceForSystem).isOk())
253             << "Failed to return error on register service with dead binder";
254     ASSERT_FALSE(mWatchdogServiceHelper->isServiceConnected());
255 }
256 
TEST_F(WatchdogServiceHelperTest,TestUnregisterService)257 TEST_F(WatchdogServiceHelperTest, TestUnregisterService) {
258     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
259 
260     auto binder = mMockCarWatchdogServiceForSystem->asBinder();
261     expectUnlinkToDeath(binder.get(), ScopedAStatus::ok());
262     EXPECT_CALL(*mMockWatchdogProcessService, unregisterCarWatchdogService(binder)).Times(1);
263 
264     auto status = mWatchdogServiceHelper->unregisterService(mMockCarWatchdogServiceForSystem);
265 
266     ASSERT_TRUE(status.isOk()) << status.getMessage();
267     ASSERT_FALSE(mWatchdogServiceHelper->isServiceConnected());
268 
269     expectNoUnlinkToDeath(binder.get());
270     EXPECT_CALL(*mMockWatchdogProcessService, unregisterCarWatchdogService(_)).Times(0);
271 
272     ASSERT_FALSE(mWatchdogServiceHelper->unregisterService(mMockCarWatchdogServiceForSystem).isOk())
273             << "Unregistering an unregistered service should return an error";
274 }
275 
TEST_F(WatchdogServiceHelperTest,TestHandleBinderDeath)276 TEST_F(WatchdogServiceHelperTest, TestHandleBinderDeath) {
277     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
278 
279     auto binder = mMockCarWatchdogServiceForSystem->asBinder();
280     EXPECT_CALL(*mMockWatchdogProcessService, unregisterCarWatchdogService(binder)).Times(1);
281 
282     mWatchdogServiceHelper->handleBinderDeath(static_cast<void*>(binder.get()));
283 
284     ASSERT_FALSE(mWatchdogServiceHelper->isServiceConnected());
285 
286     EXPECT_CALL(*mMockWatchdogProcessService, unregisterCarWatchdogService(_)).Times(0);
287 
288     ASSERT_FALSE(mWatchdogServiceHelper->unregisterService(mMockCarWatchdogServiceForSystem).isOk())
289             << "Unregistering a dead service should return an error";
290 }
291 
TEST_F(WatchdogServiceHelperTest,TestCheckIfAlive)292 TEST_F(WatchdogServiceHelperTest, TestCheckIfAlive) {
293     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
294 
295     EXPECT_CALL(*mMockCarWatchdogServiceForSystem,
296                 checkIfAlive(0, InternalTimeoutLength::TIMEOUT_CRITICAL))
297             .WillOnce(Return(ByMove(ScopedAStatus::ok())));
298 
299     auto status = mWatchdogServiceHelper->checkIfAlive(mMockCarWatchdogServiceForSystem->asBinder(),
300                                                        0, TimeoutLength::TIMEOUT_CRITICAL);
301 
302     ASSERT_TRUE(status.isOk()) << status.getMessage();
303 }
304 
TEST_F(WatchdogServiceHelperTest,TestErrorOnCheckIfAliveWithNotRegisteredCarWatchdogServiceBinder)305 TEST_F(WatchdogServiceHelperTest,
306        TestErrorOnCheckIfAliveWithNotRegisteredCarWatchdogServiceBinder) {
307     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
308 
309     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, checkIfAlive(_, _)).Times(0);
310 
311     auto notRegisteredService = SharedRefBase::make<MockCarWatchdogServiceForSystem>();
312     auto status = mWatchdogServiceHelper->checkIfAlive(notRegisteredService->asBinder(), 0,
313                                                        TimeoutLength::TIMEOUT_CRITICAL);
314 
315     ASSERT_FALSE(status.isOk()) << "checkIfAlive should fail when the given car watchdog service"
316                                    "binder is not registered with the helper";
317 }
318 
TEST_F(WatchdogServiceHelperTest,TestErrorOnCheckIfAliveWithNoCarWatchdogServiceRegistered)319 TEST_F(WatchdogServiceHelperTest, TestErrorOnCheckIfAliveWithNoCarWatchdogServiceRegistered) {
320     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, checkIfAlive(_, _)).Times(0);
321 
322     auto status = mWatchdogServiceHelper->checkIfAlive(mMockCarWatchdogServiceForSystem->asBinder(),
323                                                        0, TimeoutLength::TIMEOUT_CRITICAL);
324 
325     ASSERT_FALSE(status.isOk()) << "checkIfAlive " << kFailOnNoCarWatchdogServiceMessage;
326 }
327 
TEST_F(WatchdogServiceHelperTest,TestErrorOnCheckIfAliveWithErrorStatusFromCarWatchdogService)328 TEST_F(WatchdogServiceHelperTest, TestErrorOnCheckIfAliveWithErrorStatusFromCarWatchdogService) {
329     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
330 
331     EXPECT_CALL(*mMockCarWatchdogServiceForSystem,
332                 checkIfAlive(0, InternalTimeoutLength::TIMEOUT_CRITICAL))
333             .WillOnce(Return(ByMove(ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_STATE,
334                                                                                 "Illegal state"))));
335 
336     auto status = mWatchdogServiceHelper->checkIfAlive(mMockCarWatchdogServiceForSystem->asBinder(),
337                                                        0, TimeoutLength::TIMEOUT_CRITICAL);
338     ASSERT_FALSE(status.isOk()) << "checkIfAlive " << kFailOnCarWatchdogServiceErrMessage;
339 }
340 
TEST_F(WatchdogServiceHelperTest,TestPrepareProcessTermination)341 TEST_F(WatchdogServiceHelperTest, TestPrepareProcessTermination) {
342     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
343 
344     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, prepareProcessTermination())
345             .WillOnce(Return(ByMove(ScopedAStatus::ok())));
346 
347     EXPECT_CALL(*mMockWatchdogProcessService, unregisterCarWatchdogService(_)).Times(0);
348 
349     auto status = mWatchdogServiceHelper->prepareProcessTermination(
350             mMockCarWatchdogServiceForSystem->asBinder());
351 
352     ASSERT_TRUE(status.isOk()) << status.getMessage();
353 
354     ASSERT_FALSE(mWatchdogServiceHelper->isServiceConnected());
355 }
356 
TEST_F(WatchdogServiceHelperTest,TestErrorOnPrepareProcessTerminationWithNotRegisteredCarWatchdogServiceBinder)357 TEST_F(WatchdogServiceHelperTest,
358        TestErrorOnPrepareProcessTerminationWithNotRegisteredCarWatchdogServiceBinder) {
359     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
360 
361     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, prepareProcessTermination()).Times(0);
362 
363     EXPECT_CALL(*mMockWatchdogProcessService, unregisterCarWatchdogService(_)).Times(0);
364 
365     auto notRegisteredService = SharedRefBase::make<MockCarWatchdogServiceForSystem>();
366     auto status =
367             mWatchdogServiceHelper->prepareProcessTermination(notRegisteredService->asBinder());
368 
369     ASSERT_FALSE(status.isOk()) << "prepareProcessTermination should fail when the given car "
370                                    "watchdog service binder is not registered with the helper";
371 }
372 
TEST_F(WatchdogServiceHelperTest,TestErrorOnPrepareProcessTerminationWithNoCarWatchdogServiceRegistered)373 TEST_F(WatchdogServiceHelperTest,
374        TestErrorOnPrepareProcessTerminationWithNoCarWatchdogServiceRegistered) {
375     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, prepareProcessTermination()).Times(0);
376 
377     EXPECT_CALL(*mMockWatchdogProcessService, unregisterCarWatchdogService(_)).Times(0);
378 
379     ASSERT_FALSE(mWatchdogServiceHelper
380                          ->prepareProcessTermination(mMockCarWatchdogServiceForSystem->asBinder())
381                          .isOk())
382             << "prepareProcessTermination " << kFailOnNoCarWatchdogServiceMessage;
383 }
384 
TEST_F(WatchdogServiceHelperTest,TestErrorOnPrepareProcessTerminationWithErrorStatusFromCarWatchdogService)385 TEST_F(WatchdogServiceHelperTest,
386        TestErrorOnPrepareProcessTerminationWithErrorStatusFromCarWatchdogService) {
387     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
388 
389     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, prepareProcessTermination())
390             .WillOnce(Return(ByMove(ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_STATE,
391                                                                                 "Illegal state"))));
392 
393     EXPECT_CALL(*mMockWatchdogProcessService, unregisterCarWatchdogService(_)).Times(0);
394 
395     ASSERT_FALSE(mWatchdogServiceHelper
396                          ->prepareProcessTermination(mMockCarWatchdogServiceForSystem->asBinder())
397                          .isOk())
398             << "prepareProcessTermination " << kFailOnCarWatchdogServiceErrMessage;
399 }
400 
TEST_F(WatchdogServiceHelperTest,TestGetPackageInfosForUids)401 TEST_F(WatchdogServiceHelperTest, TestGetPackageInfosForUids) {
402     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
403 
404     std::vector<int32_t> uids = {1000};
405     std::vector<std::string> prefixesStr = {"vendor.package"};
406     std::vector<PackageInfo> expectedPackageInfo{
407             constructPackageInfo("vendor.package.A", 120000, UidType::NATIVE, ComponentType::VENDOR,
408                                  ApplicationCategoryType::OTHERS),
409             constructPackageInfo("third_party.package.B", 130000, UidType::APPLICATION,
410                                  ComponentType::THIRD_PARTY, ApplicationCategoryType::OTHERS),
411     };
412 
413     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, getPackageInfosForUids(uids, prefixesStr, _))
414             .WillOnce(DoAll(SetArgPointee<2>(expectedPackageInfo),
415                             Return(ByMove(ScopedAStatus::ok()))));
416 
417     std::vector<PackageInfo> actualPackageInfo;
418     auto status =
419             mWatchdogServiceHelper->getPackageInfosForUids(uids, prefixesStr, &actualPackageInfo);
420 
421     ASSERT_TRUE(status.isOk()) << status.getMessage();
422     EXPECT_THAT(actualPackageInfo, UnorderedElementsAreArray(expectedPackageInfo));
423 }
424 
TEST_F(WatchdogServiceHelperTest,TestErrorOnGetPackageInfosForUidsWithNoCarWatchdogServiceRegistered)425 TEST_F(WatchdogServiceHelperTest,
426        TestErrorOnGetPackageInfosForUidsWithNoCarWatchdogServiceRegistered) {
427     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, getPackageInfosForUids(_, _, _)).Times(0);
428 
429     std::vector<int32_t> uids;
430     std::vector<std::string> prefixes;
431     std::vector<PackageInfo> actualPackageInfo;
432     auto status =
433             mWatchdogServiceHelper->getPackageInfosForUids(uids, prefixes, &actualPackageInfo);
434 
435     ASSERT_FALSE(status.isOk()) << "getPackageInfosForUids " << kFailOnNoCarWatchdogServiceMessage;
436     EXPECT_THAT(actualPackageInfo, IsEmpty());
437 }
438 
TEST_F(WatchdogServiceHelperTest,TestErrorOnGetPackageInfosForUidsWithErrorStatusFromCarWatchdogService)439 TEST_F(WatchdogServiceHelperTest,
440        TestErrorOnGetPackageInfosForUidsWithErrorStatusFromCarWatchdogService) {
441     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
442 
443     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, getPackageInfosForUids(_, _, _))
444             .WillOnce(Return(ByMove(ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_STATE,
445                                                                                 "Illegal state"))));
446 
447     std::vector<int32_t> uids;
448     std::vector<std::string> prefixes;
449     std::vector<PackageInfo> actualPackageInfo;
450     auto status =
451             mWatchdogServiceHelper->getPackageInfosForUids(uids, prefixes, &actualPackageInfo);
452 
453     ASSERT_FALSE(status.isOk()) << "getPackageInfosForUids " << kFailOnCarWatchdogServiceErrMessage;
454     ASSERT_TRUE(actualPackageInfo.empty());
455 }
456 
TEST_F(WatchdogServiceHelperTest,TestResetResourceOveruseStats)457 TEST_F(WatchdogServiceHelperTest, TestResetResourceOveruseStats) {
458     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
459 
460     std::vector<std::string> packageNames = {"system.daemon"};
461     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, resetResourceOveruseStats(packageNames))
462             .WillOnce(Return(ByMove(ScopedAStatus::ok())));
463 
464     auto status = mWatchdogServiceHelper->resetResourceOveruseStats(packageNames);
465 
466     ASSERT_TRUE(status.isOk()) << status.getMessage();
467 }
468 
TEST_F(WatchdogServiceHelperTest,TestErrorsOnResetResourceOveruseStatsWithNoCarWatchdogServiceRegistered)469 TEST_F(WatchdogServiceHelperTest,
470        TestErrorsOnResetResourceOveruseStatsWithNoCarWatchdogServiceRegistered) {
471     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, resetResourceOveruseStats(_)).Times(0);
472 
473     ASSERT_FALSE(mWatchdogServiceHelper->resetResourceOveruseStats({}).isOk())
474             << "resetResourceOveruseStats " << kFailOnNoCarWatchdogServiceMessage;
475 }
476 
TEST_F(WatchdogServiceHelperTest,TestErrorsOnResetResourceOveruseStatsWithErrorStatusFromCarWatchdogService)477 TEST_F(WatchdogServiceHelperTest,
478        TestErrorsOnResetResourceOveruseStatsWithErrorStatusFromCarWatchdogService) {
479     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
480 
481     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, resetResourceOveruseStats(_))
482             .WillOnce(Return(ByMove(ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_STATE,
483                                                                                 "Illegal state"))));
484 
485     ASSERT_FALSE(mWatchdogServiceHelper->resetResourceOveruseStats({}).isOk())
486             << "resetResourceOveruseStats " << kFailOnCarWatchdogServiceErrMessage;
487 }
488 
TEST_F(WatchdogServiceHelperTest,TestRequestTodayIoUsageStats)489 TEST_F(WatchdogServiceHelperTest, TestRequestTodayIoUsageStats) {
490     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
491 
492     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, requestTodayIoUsageStats())
493             .WillOnce(Return(ByMove(ScopedAStatus::ok())));
494 
495     auto status = mWatchdogServiceHelper->requestTodayIoUsageStats();
496 
497     ASSERT_TRUE(status.isOk()) << status.getMessage();
498 }
499 
TEST_F(WatchdogServiceHelperTest,TestErrorOnRequestTodayIoUsageStatsWithNoCarWatchdogServiceRegistered)500 TEST_F(WatchdogServiceHelperTest,
501        TestErrorOnRequestTodayIoUsageStatsWithNoCarWatchdogServiceRegistered) {
502     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, requestTodayIoUsageStats()).Times(0);
503 
504     ASSERT_FALSE(mWatchdogServiceHelper->requestTodayIoUsageStats().isOk())
505             << "requestTodayIoUsageStats " << kFailOnNoCarWatchdogServiceMessage;
506 }
507 
TEST_F(WatchdogServiceHelperTest,TestErrorOnRequestTodayIoUsageStatsWithErrorStatusFromCarWatchdogService)508 TEST_F(WatchdogServiceHelperTest,
509        TestErrorOnRequestTodayIoUsageStatsWithErrorStatusFromCarWatchdogService) {
510     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
511 
512     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, requestTodayIoUsageStats())
513             .WillOnce(Return(ByMove(ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_STATE,
514                                                                                 "Illegal state"))));
515 
516     ASSERT_FALSE(mWatchdogServiceHelper->requestTodayIoUsageStats().isOk())
517             << "requestTodayIoUsageStats " << kFailOnCarWatchdogServiceErrMessage;
518 }
519 
TEST_F(WatchdogServiceHelperTest,TestOnLatestResourceStats)520 TEST_F(WatchdogServiceHelperTest, TestOnLatestResourceStats) {
521     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
522 
523     PackageIoOveruseStats stats;
524     stats.uid = 101000;
525     stats.ioOveruseStats.killableOnOveruse = true;
526     stats.ioOveruseStats.startTime = 99898;
527     stats.ioOveruseStats.durationInSeconds = 12345;
528     stats.ioOveruseStats.totalOveruses = 10;
529     stats.shouldNotify = true;
530     std::vector<PackageIoOveruseStats> expectedIoOveruseStats = {stats};
531 
532     std::vector<ResourceStats> expectedResourceStats;
533     expectedResourceStats.push_back({
534             .resourceOveruseStats = std::make_optional<ResourceOveruseStats>({
535                     .packageIoOveruseStats = expectedIoOveruseStats,
536             }),
537     });
538 
539     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, onLatestResourceStats(expectedResourceStats))
540             .WillOnce(Return(ByMove(ScopedAStatus::ok())));
541 
542     auto status = mWatchdogServiceHelper->onLatestResourceStats(expectedResourceStats);
543 
544     ASSERT_TRUE(status.isOk()) << status.getMessage();
545 }
546 
TEST_F(WatchdogServiceHelperTest,TestErrorsOnLatestResourceStatsWithNoCarWatchdogServiceRegistered)547 TEST_F(WatchdogServiceHelperTest,
548        TestErrorsOnLatestResourceStatsWithNoCarWatchdogServiceRegistered) {
549     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, onLatestResourceStats(_)).Times(0);
550 
551     ASSERT_FALSE(mWatchdogServiceHelper->onLatestResourceStats({}).isOk())
552             << "onLatestResourceStats " << kFailOnNoCarWatchdogServiceMessage;
553 }
554 
TEST_F(WatchdogServiceHelperTest,TestErrorsOnLatestResourceStatsWithErrorStatusFromCarWatchdogService)555 TEST_F(WatchdogServiceHelperTest,
556        TestErrorsOnLatestResourceStatsWithErrorStatusFromCarWatchdogService) {
557     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
558 
559     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, onLatestResourceStats(_))
560             .WillOnce(Return(ByMove(ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_STATE,
561                                                                                 "Illegal state"))));
562 
563     ASSERT_FALSE(mWatchdogServiceHelper->onLatestResourceStats({}).isOk())
564             << "onLatestResourceStats " << kFailOnCarWatchdogServiceErrMessage;
565 }
566 
TEST_F(WatchdogServiceHelperTest,TestRequestAidlVhalPid)567 TEST_F(WatchdogServiceHelperTest, TestRequestAidlVhalPid) {
568     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
569 
570     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, requestAidlVhalPid())
571             .WillOnce(Return(ByMove(ScopedAStatus::ok())));
572 
573     auto status = mWatchdogServiceHelper->requestAidlVhalPid();
574 
575     ASSERT_TRUE(status.isOk()) << status.getMessage();
576 }
577 
TEST_F(WatchdogServiceHelperTest,TestRequestAidlVhalPidWithNoCarWatchdogServiceRegistered)578 TEST_F(WatchdogServiceHelperTest, TestRequestAidlVhalPidWithNoCarWatchdogServiceRegistered) {
579     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, requestAidlVhalPid()).Times(0);
580 
581     ASSERT_FALSE(mWatchdogServiceHelper->requestAidlVhalPid().isOk())
582             << "requestAidlVhalPid " << kFailOnNoCarWatchdogServiceMessage;
583 }
584 
TEST_F(WatchdogServiceHelperTest,TestRequestAidlVhalPidWithErrorStatusFromCarWatchdogService)585 TEST_F(WatchdogServiceHelperTest, TestRequestAidlVhalPidWithErrorStatusFromCarWatchdogService) {
586     ASSERT_NO_FATAL_FAILURE(registerCarWatchdogService());
587 
588     EXPECT_CALL(*mMockCarWatchdogServiceForSystem, requestAidlVhalPid())
589             .WillOnce(Return(ByMove(ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_STATE,
590                                                                                 "Illegal state"))));
591 
592     ASSERT_FALSE(mWatchdogServiceHelper->requestAidlVhalPid().isOk())
593             << "requestAidlVhalPid " << kFailOnCarWatchdogServiceErrMessage;
594 }
595 
596 }  // namespace watchdog
597 }  // namespace automotive
598 }  // namespace android
599