king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '8f4c154c05'
${ noResults }
v811_spc009/packages/services/Car/cpp/watchdog/server/tests/WatchdogPerfServiceTest.cpp

647 lines
27 KiB
Raw Normal View History Unescape

v811_spc009_project
4 months ago
/*
* Copyright 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "LooperStub.h"
#include "MockDataProcessor.h"
#include "MockProcDiskStats.h"
#include "MockProcPidStat.h"
#include "MockProcStat.h"
#include "MockUidIoStats.h"
#include "ProcPidDir.h"
#include "ProcPidStat.h"
#include "ProcStat.h"
#include "UidIoStats.h"
#include "WatchdogPerfService.h"
#include <WatchdogProperties.sysprop.h>
#include <android-base/file.h>
#include <gmock/gmock.h>
#include <future> // NOLINT(build/c++11)
#include <queue>
#include <string>
#include <vector>
namespace android {
namespace automotive {
namespace watchdog {
using ::android::sp;
using ::android::String16;
using ::android::wp;
using ::android::automotive::watchdog::internal::PowerCycle;
using ::android::automotive::watchdog::testing::LooperStub;
using ::android::base::Error;
using ::android::base::Result;
using ::testing::_;
using ::testing::DefaultValue;
using ::testing::InSequence;
using ::testing::Mock;
using ::testing::NiceMock;
using ::testing::Return;
using ::testing::StrictMock;
using ::testing::UnorderedElementsAreArray;
constexpr std::chrono::seconds kTestBoottimeCollectionInterval = 1s;
constexpr std::chrono::seconds kTestPeriodicCollectionInterval = 5s;
constexpr std::chrono::seconds kTestCustomCollectionInterval = 3s;
constexpr std::chrono::seconds kTestCustomCollectionDuration = 11s;
constexpr std::chrono::seconds kTestPeriodicMonitorInterval = 2s;
namespace internal {
class WatchdogPerfServicePeer {
public:
explicit WatchdogPerfServicePeer(sp<WatchdogPerfService> service) : service(service) {}
WatchdogPerfServicePeer() = delete;
~WatchdogPerfServicePeer() { service->terminate(); }
void injectFakes() {
looperStub = sp<LooperStub>::make();
mockUidIoStats = sp<NiceMock<MockUidIoStats>>::make();
mockProcDiskStats = sp<NiceMock<MockProcDiskStats>>::make();
mockProcStat = sp<NiceMock<MockProcStat>>::make();
mockProcPidStat = sp<NiceMock<MockProcPidStat>>::make();
mockDataProcessor = sp<StrictMock<MockDataProcessor>>::make();
{
Mutex::Autolock lock(service->mMutex);
service->mHandlerLooper = looperStub;
service->mUidIoStats = mockUidIoStats;
service->mProcDiskStats = mockProcDiskStats;
service->mProcStat = mockProcStat;
service->mProcPidStat = mockProcPidStat;
}
EXPECT_CALL(*mockDataProcessor, init()).Times(1);
ASSERT_RESULT_OK(service->registerDataProcessor(mockDataProcessor));
}
Result<void> start() {
if (auto ret = service->start(); !ret.ok()) {
return ret;
}
Mutex::Autolock lock(service->mMutex);
service->mBoottimeCollection.interval = kTestBoottimeCollectionInterval;
service->mPeriodicCollection.interval = kTestPeriodicCollectionInterval;
service->mPeriodicMonitor.interval = kTestPeriodicMonitorInterval;
return {};
}
EventType getCurrCollectionEvent() {
Mutex::Autolock lock(service->mMutex);
return service->mCurrCollectionEvent;
}
std::future<void> joinCollectionThread() {
return std::async([&]() {
if (service->mCollectionThread.joinable()) {
service->mCollectionThread.join();
}
});
}
void verifyAndClearExpectations() {
Mock::VerifyAndClearExpectations(mockUidIoStats.get());
Mock::VerifyAndClearExpectations(mockProcStat.get());
Mock::VerifyAndClearExpectations(mockProcPidStat.get());
Mock::VerifyAndClearExpectations(mockDataProcessor.get());
}
sp<WatchdogPerfService> service;
// Below fields are populated only on injectFakes.
sp<LooperStub> looperStub;
sp<MockUidIoStats> mockUidIoStats;
sp<MockProcDiskStats> mockProcDiskStats;
sp<MockProcStat> mockProcStat;
sp<MockProcPidStat> mockProcPidStat;
sp<MockDataProcessor> mockDataProcessor;
};
} // namespace internal
namespace {
void startPeriodicCollection(internal::WatchdogPerfServicePeer* servicePeer) {
ASSERT_NO_FATAL_FAILURE(servicePeer->injectFakes());
ASSERT_RESULT_OK(servicePeer->start());
EXPECT_CALL(*servicePeer->mockUidIoStats, collect()).Times(2);
EXPECT_CALL(*servicePeer->mockProcStat, collect()).Times(2);
EXPECT_CALL(*servicePeer->mockProcPidStat, collect()).Times(2);
EXPECT_CALL(*servicePeer->mockDataProcessor,
onBoottimeCollection(_, wp<UidIoStats>(servicePeer->mockUidIoStats),
wp<ProcStat>(servicePeer->mockProcStat),
wp<ProcPidStat>(servicePeer->mockProcPidStat)))
.Times(2);
// Make sure the collection event changes from EventType::INIT to
// EventType::BOOT_TIME_COLLECTION.
ASSERT_RESULT_OK(servicePeer->looperStub->pollCache());
// Mark boot complete.
ASSERT_RESULT_OK(servicePeer->service->onBootFinished());
// Process |SwitchMessage::END_BOOTTIME_COLLECTION| and switch to periodic collection.
ASSERT_RESULT_OK(servicePeer->looperStub->pollCache());
ASSERT_EQ(servicePeer->getCurrCollectionEvent(), EventType::PERIODIC_COLLECTION)
<< "Invalid collection event";
servicePeer->verifyAndClearExpectations();
}
void skipPeriodicMonitorEvents(internal::WatchdogPerfServicePeer* servicePeer) {
EXPECT_CALL(*servicePeer->mockDataProcessor, onPeriodicMonitor(_, _, _)).Times(2);
ASSERT_RESULT_OK(servicePeer->looperStub->pollCache());
ASSERT_RESULT_OK(servicePeer->looperStub->pollCache());
}
} // namespace
TEST(WatchdogPerfServiceTest, TestServiceStartAndTerminate) {
sp<WatchdogPerfService> service = sp<WatchdogPerfService>::make();
sp<MockDataProcessor> mockDataProcessor = sp<MockDataProcessor>::make();
EXPECT_CALL(*mockDataProcessor, init()).Times(1);
ASSERT_RESULT_OK(service->registerDataProcessor(mockDataProcessor));
ASSERT_RESULT_OK(service->start());
ASSERT_TRUE(service->mCollectionThread.joinable()) << "Collection thread not created";
ASSERT_FALSE(service->start().ok())
<< "No error returned when WatchdogPerfService was started more than once";
ASSERT_TRUE(sysprop::boottimeCollectionInterval().has_value());
ASSERT_EQ(std::chrono::duration_cast<std::chrono::seconds>(
service->mBoottimeCollection.interval)
.count(),
sysprop::boottimeCollectionInterval().value());
ASSERT_TRUE(sysprop::periodicCollectionInterval().has_value());
ASSERT_EQ(std::chrono::duration_cast<std::chrono::seconds>(
service->mPeriodicCollection.interval)
.count(),
sysprop::periodicCollectionInterval().value());
service->terminate();
ASSERT_FALSE(service->mCollectionThread.joinable()) << "Collection thread did not terminate";
}
TEST(WatchdogPerfServiceTest, TestValidCollectionSequence) {
sp<WatchdogPerfService> service = sp<WatchdogPerfService>::make();
internal::WatchdogPerfServicePeer servicePeer(service);
ASSERT_NO_FATAL_FAILURE(servicePeer.injectFakes());
ASSERT_RESULT_OK(servicePeer.start());
wp<UidIoStats> uidIoStats(servicePeer.mockUidIoStats);
wp<IProcDiskStatsInterface> procDiskStats(servicePeer.mockProcDiskStats);
wp<ProcStat> procStat(servicePeer.mockProcStat);
wp<ProcPidStat> procPidStat(servicePeer.mockProcPidStat);
// #1 Boot-time collection
EXPECT_CALL(*servicePeer.mockUidIoStats, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcPidStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockDataProcessor,
onBoottimeCollection(_, uidIoStats, procStat, procPidStat))
.Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.looperStub->numSecondsElapsed(), 0)
<< "Boot-time collection didn't start immediately";
ASSERT_EQ(servicePeer.getCurrCollectionEvent(), EventType::BOOT_TIME_COLLECTION)
<< "Invalid collection event";
servicePeer.verifyAndClearExpectations();
// #2 Boot-time collection
EXPECT_CALL(*servicePeer.mockUidIoStats, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcPidStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockDataProcessor,
onBoottimeCollection(_, uidIoStats, procStat, procPidStat))
.Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.looperStub->numSecondsElapsed(), kTestBoottimeCollectionInterval.count())
<< "Subsequent boot-time collection didn't happen at "
<< kTestBoottimeCollectionInterval.count() << " seconds interval";
ASSERT_EQ(servicePeer.getCurrCollectionEvent(), EventType::BOOT_TIME_COLLECTION)
<< "Invalid collection event";
servicePeer.verifyAndClearExpectations();
// #3 Last boot-time collection
EXPECT_CALL(*servicePeer.mockUidIoStats, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcPidStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockDataProcessor,
onBoottimeCollection(_, uidIoStats, procStat, procPidStat))
.Times(1);
ASSERT_RESULT_OK(service->onBootFinished());
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.looperStub->numSecondsElapsed(), 0)
<< "Last boot-time collection didn't happen immediately after receiving boot complete "
<< "notification";
ASSERT_EQ(servicePeer.getCurrCollectionEvent(), EventType::PERIODIC_COLLECTION)
<< "Invalid collection event";
servicePeer.verifyAndClearExpectations();
// #4 Periodic monitor
EXPECT_CALL(*servicePeer.mockProcDiskStats, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockDataProcessor, onPeriodicMonitor(_, procDiskStats, _)).Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.looperStub->numSecondsElapsed(), kTestPeriodicMonitorInterval.count())
<< "First periodic monitor didn't happen at " << kTestPeriodicMonitorInterval.count()
<< " seconds interval";
servicePeer.verifyAndClearExpectations();
// #5 Periodic monitor
EXPECT_CALL(*servicePeer.mockProcDiskStats, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockDataProcessor, onPeriodicMonitor(_, procDiskStats, _)).Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.looperStub->numSecondsElapsed(), kTestPeriodicMonitorInterval.count())
<< "Second periodic monitor didn't happen at " << kTestPeriodicMonitorInterval.count()
<< " seconds interval";
servicePeer.verifyAndClearExpectations();
// #6 Periodic collection
EXPECT_CALL(*servicePeer.mockUidIoStats, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcPidStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockDataProcessor,
onPeriodicCollection(_, SystemState::NORMAL_MODE, uidIoStats, procStat,
procPidStat))
.Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.looperStub->numSecondsElapsed(), 1)
<< "First periodic collection didn't happen at 1 second interval";
ASSERT_EQ(servicePeer.getCurrCollectionEvent(), EventType::PERIODIC_COLLECTION)
<< "Invalid collection event";
servicePeer.verifyAndClearExpectations();
// #7 Custom collection
Vector<String16> args;
args.push_back(String16(kStartCustomCollectionFlag));
args.push_back(String16(kIntervalFlag));
args.push_back(String16(std::to_string(kTestCustomCollectionInterval.count()).c_str()));
args.push_back(String16(kMaxDurationFlag));
args.push_back(String16(std::to_string(kTestCustomCollectionDuration.count()).c_str()));
ASSERT_RESULT_OK(service->onCustomCollection(-1, args));
EXPECT_CALL(*servicePeer.mockUidIoStats, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcPidStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockDataProcessor,
onCustomCollection(_, SystemState::NORMAL_MODE, _, uidIoStats, procStat,
procPidStat))
.Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.looperStub->numSecondsElapsed(), 0)
<< "Custom collection didn't start immediately";
ASSERT_EQ(servicePeer.getCurrCollectionEvent(), EventType::CUSTOM_COLLECTION)
<< "Invalid collection event";
servicePeer.verifyAndClearExpectations();
// #8 Custom collection
EXPECT_CALL(*servicePeer.mockUidIoStats, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcPidStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockDataProcessor,
onCustomCollection(_, SystemState::NORMAL_MODE, _, uidIoStats, procStat,
procPidStat))
.Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.looperStub->numSecondsElapsed(), kTestCustomCollectionInterval.count())
<< "Subsequent custom collection didn't happen at "
<< kTestCustomCollectionInterval.count() << " seconds interval";
ASSERT_EQ(servicePeer.getCurrCollectionEvent(), EventType::CUSTOM_COLLECTION)
<< "Invalid collection event";
servicePeer.verifyAndClearExpectations();
// #9 End custom collection
TemporaryFile customDump;
{
InSequence s;
EXPECT_CALL(*servicePeer.mockDataProcessor, onCustomCollectionDump(customDump.fd)).Times(1);
EXPECT_CALL(*servicePeer.mockDataProcessor, onCustomCollectionDump(-1)).Times(1);
}
args.clear();
args.push_back(String16(kEndCustomCollectionFlag));
ASSERT_RESULT_OK(service->onCustomCollection(customDump.fd, args));
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.getCurrCollectionEvent(), EventType::PERIODIC_COLLECTION)
<< "Invalid collection event";
// #10 Switch to periodic collection
EXPECT_CALL(*servicePeer.mockUidIoStats, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcPidStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockDataProcessor,
onPeriodicCollection(_, SystemState::NORMAL_MODE, uidIoStats, procStat,
procPidStat))
.Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.looperStub->numSecondsElapsed(), 0)
<< "Periodic collection didn't start immediately after ending custom collection";
ASSERT_EQ(servicePeer.getCurrCollectionEvent(), EventType::PERIODIC_COLLECTION)
<< "Invalid collection event";
servicePeer.verifyAndClearExpectations();
// #11 Periodic monitor.
EXPECT_CALL(*servicePeer.mockProcDiskStats, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockDataProcessor, onPeriodicMonitor(_, procDiskStats, _)).Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.looperStub->numSecondsElapsed(), kTestPeriodicMonitorInterval.count());
servicePeer.verifyAndClearExpectations();
EXPECT_CALL(*servicePeer.mockDataProcessor, terminate()).Times(1);
}
TEST(WatchdogPerfServiceTest, TestCollectionTerminatesOnZeroEnabledCollectors) {
sp<WatchdogPerfService> service = sp<WatchdogPerfService>::make();
internal::WatchdogPerfServicePeer servicePeer(service);
ASSERT_NO_FATAL_FAILURE(servicePeer.injectFakes());
ASSERT_RESULT_OK(servicePeer.start());
ON_CALL(*servicePeer.mockUidIoStats, enabled()).WillByDefault(Return(false));
ON_CALL(*servicePeer.mockProcStat, enabled()).WillByDefault(Return(false));
ON_CALL(*servicePeer.mockProcPidStat, enabled()).WillByDefault(Return(false));
// Collection should terminate and call data processor's terminate method on error.
EXPECT_CALL(*servicePeer.mockDataProcessor, terminate()).Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.joinCollectionThread().wait_for(1s), std::future_status::ready)
<< "Collection thread didn't terminate within 1 second.";
ASSERT_EQ(servicePeer.getCurrCollectionEvent(), EventType::TERMINATED);
}
TEST(WatchdogPerfServiceTest, TestCollectionTerminatesOnDataCollectorError) {
sp<WatchdogPerfService> service = sp<WatchdogPerfService>::make();
internal::WatchdogPerfServicePeer servicePeer(service);
ASSERT_NO_FATAL_FAILURE(servicePeer.injectFakes());
ASSERT_RESULT_OK(servicePeer.start());
// Inject data collector error.
Result<void> errorRes = Error() << "Failed to collect data";
EXPECT_CALL(*servicePeer.mockUidIoStats, collect()).WillOnce(Return(errorRes));
// Collection should terminate and call data processor's terminate method on error.
EXPECT_CALL(*servicePeer.mockDataProcessor, terminate()).Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.joinCollectionThread().wait_for(1s), std::future_status::ready)
<< "Collection thread didn't terminate within 1 second.";
ASSERT_EQ(servicePeer.getCurrCollectionEvent(), EventType::TERMINATED);
}
TEST(WatchdogPerfServiceTest, TestCollectionTerminatesOnDataProcessorError) {
sp<WatchdogPerfService> service = sp<WatchdogPerfService>::make();
internal::WatchdogPerfServicePeer servicePeer(service);
ASSERT_NO_FATAL_FAILURE(servicePeer.injectFakes());
EXPECT_CALL(*servicePeer.mockDataProcessor, name()).Times(1);
ASSERT_RESULT_OK(servicePeer.start());
// Inject data processor error.
Result<void> errorRes = Error() << "Failed to process data";
EXPECT_CALL(*servicePeer.mockDataProcessor,
onBoottimeCollection(_, wp<UidIoStats>(servicePeer.mockUidIoStats),
wp<ProcStat>(servicePeer.mockProcStat),
wp<ProcPidStat>(servicePeer.mockProcPidStat)))
.WillOnce(Return(errorRes));
// Collection should terminate and call data processor's terminate method on error.
EXPECT_CALL(*servicePeer.mockDataProcessor, terminate()).Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.joinCollectionThread().wait_for(1s), std::future_status::ready)
<< "Collection thread didn't terminate within 1 second.";
ASSERT_EQ(servicePeer.getCurrCollectionEvent(), EventType::TERMINATED);
}
TEST(WatchdogPerfServiceTest, TestCustomCollection) {
sp<WatchdogPerfService> service = sp<WatchdogPerfService>::make();
internal::WatchdogPerfServicePeer servicePeer(service);
ASSERT_NO_FATAL_FAILURE(startPeriodicCollection(&servicePeer));
// Start custom collection with filter packages option.
Vector<String16> args;
args.push_back(String16(kStartCustomCollectionFlag));
args.push_back(String16(kIntervalFlag));
args.push_back(String16(std::to_string(kTestCustomCollectionInterval.count()).c_str()));
args.push_back(String16(kMaxDurationFlag));
args.push_back(String16(std::to_string(kTestCustomCollectionDuration.count()).c_str()));
args.push_back(String16(kFilterPackagesFlag));
args.push_back(String16("android.car.cts,system_server"));
ASSERT_RESULT_OK(service->onCustomCollection(-1, args));
// Poll until custom collection auto terminates.
int maxIterations = static_cast<int>(kTestCustomCollectionDuration.count() /
kTestCustomCollectionInterval.count());
for (int i = 0; i <= maxIterations; ++i) {
EXPECT_CALL(*servicePeer.mockUidIoStats, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcPidStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockDataProcessor,
onCustomCollection(_, SystemState::NORMAL_MODE,
UnorderedElementsAreArray(
{"android.car.cts", "system_server"}),
wp<UidIoStats>(servicePeer.mockUidIoStats),
wp<ProcStat>(servicePeer.mockProcStat),
wp<ProcPidStat>(servicePeer.mockProcPidStat)))
.Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
int secondsElapsed = (i == 0 ? 0 : kTestCustomCollectionInterval.count());
ASSERT_EQ(servicePeer.looperStub->numSecondsElapsed(), secondsElapsed)
<< "Custom collection didn't happen at " << secondsElapsed
<< " seconds interval in iteration " << i;
ASSERT_EQ(servicePeer.getCurrCollectionEvent(), EventType::CUSTOM_COLLECTION)
<< "Invalid collection event";
servicePeer.verifyAndClearExpectations();
}
EXPECT_CALL(*servicePeer.mockDataProcessor, onCustomCollectionDump(-1)).Times(1);
// Next looper message was injected during startCustomCollection to end the custom collection
// after |kTestCustomCollectionDuration|. On processing this message, the custom collection
// should auto terminate.
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.looperStub->numSecondsElapsed(),
kTestCustomCollectionDuration.count() % kTestCustomCollectionInterval.count())
<< "Custom collection did't end after " << kTestCustomCollectionDuration.count()
<< " seconds";
ASSERT_EQ(servicePeer.getCurrCollectionEvent(), EventType::PERIODIC_COLLECTION)
<< "Invalid collection event";
EXPECT_CALL(*servicePeer.mockDataProcessor, terminate()).Times(1);
}
TEST(WatchdogPerfServiceTest, TestPeriodicMonitorRequestsCollection) {
sp<WatchdogPerfService> service = sp<WatchdogPerfService>::make();
internal::WatchdogPerfServicePeer servicePeer(service);
ASSERT_NO_FATAL_FAILURE(startPeriodicCollection(&servicePeer));
wp<UidIoStats> uidIoStats(servicePeer.mockUidIoStats);
wp<IProcDiskStatsInterface> procDiskStats(servicePeer.mockProcDiskStats);
wp<ProcStat> procStat(servicePeer.mockProcStat);
wp<ProcPidStat> procPidStat(servicePeer.mockProcPidStat);
// Periodic monitor issuing an alert to start new collection.
EXPECT_CALL(*servicePeer.mockProcDiskStats, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockDataProcessor, onPeriodicMonitor(_, procDiskStats, _))
.WillOnce([&](auto, auto, const auto& alertHandler) -> Result<void> {
alertHandler();
return {};
});
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.looperStub->numSecondsElapsed(), kTestPeriodicMonitorInterval.count())
<< "First periodic monitor didn't happen at " << kTestPeriodicMonitorInterval.count()
<< " seconds interval";
servicePeer.verifyAndClearExpectations();
EXPECT_CALL(*servicePeer.mockUidIoStats, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockProcPidStat, collect()).Times(1);
EXPECT_CALL(*servicePeer.mockDataProcessor,
onPeriodicCollection(_, SystemState::NORMAL_MODE, uidIoStats, procStat,
procPidStat))
.Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
ASSERT_EQ(servicePeer.looperStub->numSecondsElapsed(), 0)
<< "First periodic collection didn't happen immediately after the alert";
servicePeer.verifyAndClearExpectations();
EXPECT_CALL(*servicePeer.mockDataProcessor, terminate()).Times(1);
}
TEST(WatchdogPerfServiceTest, TestSystemStateSwitch) {
sp<WatchdogPerfService> service = sp<WatchdogPerfService>::make();
internal::WatchdogPerfServicePeer servicePeer(service);
ASSERT_NO_FATAL_FAILURE(startPeriodicCollection(&servicePeer));
ASSERT_NO_FATAL_FAILURE(skipPeriodicMonitorEvents(&servicePeer));
EXPECT_CALL(*servicePeer.mockDataProcessor,
onPeriodicCollection(_, SystemState::NORMAL_MODE, _, _, _))
.Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
servicePeer.verifyAndClearExpectations();
ASSERT_NO_FATAL_FAILURE(skipPeriodicMonitorEvents(&servicePeer));
service->setSystemState(SystemState::GARAGE_MODE);
EXPECT_CALL(*servicePeer.mockDataProcessor,
onPeriodicCollection(_, SystemState::GARAGE_MODE, _, _, _))
.Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
servicePeer.verifyAndClearExpectations();
ASSERT_NO_FATAL_FAILURE(skipPeriodicMonitorEvents(&servicePeer));
service->setSystemState(SystemState::NORMAL_MODE);
EXPECT_CALL(*servicePeer.mockDataProcessor,
onPeriodicCollection(_, SystemState::NORMAL_MODE, _, _, _))
.Times(1);
ASSERT_RESULT_OK(servicePeer.looperStub->pollCache());
servicePeer.verifyAndClearExpectations();
EXPECT_CALL(*servicePeer.mockDataProcessor, terminate()).Times(1);
}
TEST(WatchdogPerfServiceTest, TestHandlesInvalidDumpArguments) {
sp<WatchdogPerfService> service = sp<WatchdogPerfService>::make();
Vector<String16> args;
args.push_back(String16(kStartCustomCollectionFlag));
args.push_back(String16("Invalid flag"));
args.push_back(String16("Invalid value"));
ASSERT_FALSE(service->onCustomCollection(-1, args).ok());
args.clear();
args.push_back(String16(kStartCustomCollectionFlag));
args.push_back(String16(kIntervalFlag));
args.push_back(String16("Invalid interval"));
ASSERT_FALSE(service->onCustomCollection(-1, args).ok());
args.clear();
args.push_back(String16(kStartCustomCollectionFlag));
args.push_back(String16(kMaxDurationFlag));
args.push_back(String16("Invalid duration"));
ASSERT_FALSE(service->onCustomCollection(-1, args).ok());
args.clear();
args.push_back(String16(kEndCustomCollectionFlag));
args.push_back(String16(kMaxDurationFlag));
args.push_back(String16(std::to_string(kTestCustomCollectionDuration.count()).c_str()));
ASSERT_FALSE(service->onCustomCollection(-1, args).ok());
args.clear();
args.push_back(String16("Invalid flag"));
ASSERT_FALSE(service->onCustomCollection(-1, args).ok());
service->terminate();
}
} // namespace watchdog
} // namespace automotive
} // namespace android