1021 lines
43 KiB
C++
1021 lines
43 KiB
C++
/*
|
|
* 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 "ProcPidDir.h"
|
|
#include "UidProcStatsCollector.h"
|
|
#include "UidProcStatsCollectorTestUtils.h"
|
|
|
|
#include <android-base/file.h>
|
|
#include <android-base/stringprintf.h>
|
|
#include <gmock/gmock.h>
|
|
|
|
#include <inttypes.h>
|
|
|
|
#include <algorithm>
|
|
#include <string>
|
|
|
|
namespace android {
|
|
namespace automotive {
|
|
namespace watchdog {
|
|
|
|
using ::android::automotive::watchdog::testing::populateProcPidDir;
|
|
using ::android::base::StringAppendF;
|
|
using ::android::base::StringPrintf;
|
|
using ::testing::UnorderedPointwise;
|
|
|
|
namespace {
|
|
|
|
MATCHER(UidProcStatsByUidEq, "") {
|
|
const auto& actual = std::get<0>(arg);
|
|
const auto& expected = std::get<1>(arg);
|
|
return actual.first == expected.first &&
|
|
ExplainMatchResult(UidProcStatsEq(expected.second), actual.second, result_listener);
|
|
}
|
|
|
|
std::string pidStatusStr(pid_t pid, uid_t uid) {
|
|
return StringPrintf("Pid:\t%" PRIu32 "\nTgid:\t%" PRIu32 "\nUid:\t%" PRIu32 "\n", pid, pid,
|
|
uid);
|
|
}
|
|
|
|
std::string toString(const std::unordered_map<uid_t, UidProcStats>& uidProcStatsByUid) {
|
|
std::string buffer;
|
|
StringAppendF(&buffer, "Number of UIDs: %" PRIi32 "\n",
|
|
static_cast<int>(uidProcStatsByUid.size()));
|
|
for (const auto& [uid, stats] : uidProcStatsByUid) {
|
|
StringAppendF(&buffer, "{UID: %d, %s}", uid, stats.toString().c_str());
|
|
}
|
|
return buffer;
|
|
}
|
|
|
|
int64_t ticksToMillis(int32_t clockTicks) {
|
|
return (clockTicks * 1000) / sysconf(_SC_CLK_TCK);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
TEST(UidProcStatsCollectorTest, TestValidStatFiles) {
|
|
std::unordered_map<pid_t, std::vector<pid_t>> pidToTids = {
|
|
{1, {1, 453}},
|
|
{1000, {1000, 1100}},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 220 0 6 4 0 0 0 0 2 0 19\n"},
|
|
{1000, "1000 (system_server) D 1 0 0 0 0 0 0 0 600 0 8000 4000 0 0 0 0 2 0 13400\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStatus = {
|
|
{1, pidStatusStr(1, 0)},
|
|
{1000, pidStatusStr(1000, 10001234)},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 3 2 0 0 0 0 2 0 19\n"},
|
|
{453, "453 (init) D 0 0 0 0 0 0 0 0 20 0 3 2 0 0 0 0 2 0 275\n"},
|
|
{1000, "1000 (system_server) D 1 0 0 0 0 0 0 0 250 0 4000 2000 0 0 0 0 2 0 13400\n"},
|
|
{1100, "1100 (system_server) D 1 0 0 0 0 0 0 0 350 0 4000 2000 0 0 0 0 2 0 13900\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadTimeInState = {
|
|
{1, "cpu0\n300000 5\n1700000 0\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
{453, "cpu0\n300000 0\n1700000 0\ncpu4\n710000 0\n1800000 5\ncpu7\n2000000 0"},
|
|
{1000,
|
|
"cpu0\n300000 0\n1700000 1000\ncpu4\n710000 1000\n1800000 3000\ncpu7\n2000000 6000"},
|
|
{1100, "cpu0\n300000 0\n1700000 0\ncpu4\n710000 0\n1800000 1000\ncpu7\n2000000 0"},
|
|
};
|
|
|
|
std::unordered_map<uid_t, UidProcStats> expected =
|
|
{{0,
|
|
UidProcStats{.cpuTimeMillis = ticksToMillis(10),
|
|
.cpuCycles = 105000000,
|
|
.totalMajorFaults = 220,
|
|
.totalTasksCount = 2,
|
|
.ioBlockedTasksCount = 1,
|
|
.processStatsByPid = {{1,
|
|
{"init",
|
|
ticksToMillis(19),
|
|
ticksToMillis(10),
|
|
105000000,
|
|
220,
|
|
2,
|
|
1,
|
|
{{1, 15000000}, {453, 90000000}}}}}}},
|
|
{10001234,
|
|
UidProcStats{.cpuTimeMillis = ticksToMillis(12'000),
|
|
.cpuCycles = 216100000000,
|
|
.totalMajorFaults = 600,
|
|
.totalTasksCount = 2,
|
|
.ioBlockedTasksCount = 2,
|
|
.processStatsByPid = {
|
|
{1000,
|
|
{"system_server",
|
|
ticksToMillis(13'400),
|
|
ticksToMillis(12'000),
|
|
216100000000,
|
|
600,
|
|
2,
|
|
2,
|
|
{{1000, 198100000000}, {1100, 18000000000}}}}}}}};
|
|
|
|
TemporaryDir firstSnapshot;
|
|
ASSERT_RESULT_OK(populateProcPidDir(firstSnapshot.path, pidToTids, perProcessStat,
|
|
perProcessStatus, perThreadStat, perThreadTimeInState));
|
|
|
|
UidProcStatsCollector collector(firstSnapshot.path);
|
|
collector.init();
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << firstSnapshot.path << "` are inaccessible";
|
|
ASSERT_RESULT_OK(collector.collect());
|
|
|
|
auto actual = collector.deltaStats();
|
|
|
|
EXPECT_THAT(actual, UnorderedPointwise(UidProcStatsByUidEq(), expected))
|
|
<< "First snapshot doesn't match.\nExpected:\n"
|
|
<< toString(expected) << "\nActual:\n"
|
|
<< toString(actual);
|
|
|
|
pidToTids = {
|
|
{1, {1, 453}}, {1000, {1000, 1400}}, // TID 1100 terminated and 1400 instantiated.
|
|
};
|
|
|
|
perProcessStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 920 0 10 10 0 0 0 0 2 0 19\n"},
|
|
{1000, "1000 (system_server) R 1 0 0 0 0 0 0 0 1550 0 10000 8000 0 0 0 0 2 0 13400\n"},
|
|
};
|
|
|
|
perThreadStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 600 0 5 5 0 0 0 0 2 0 19\n"},
|
|
{453, "453 (init) S 0 0 0 0 0 0 0 0 320 0 5 5 0 0 0 0 2 0 275\n"},
|
|
{1000, "1000 (system_server) R 1 0 0 0 0 0 0 0 600 0 5000 2000 0 0 0 0 2 0 13400\n"},
|
|
// TID 1100 hits +400 major page faults before terminating. This is counted against
|
|
// PID 1000's perProcessStat.
|
|
{1400, "1400 (system_server) S 1 0 0 0 0 0 0 0 200 0 5000 2000 0 0 0 0 2 0 8977476\n"},
|
|
};
|
|
|
|
perThreadTimeInState = {
|
|
{1, "cpu0\n300000 5\n1700000 0\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 10"},
|
|
{453, "cpu0\n300000 0\n1700000 0\ncpu4\n710000 0\n1800000 5\ncpu7\n2000000 0"},
|
|
{1000,
|
|
"cpu0\n300000 0\n1700000 1000\ncpu4\n710000 1000\n1800000 3000\ncpu7\n2000000 6000"},
|
|
{1400, "cpu0\n300000 6000\n1700000 0\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
};
|
|
|
|
expected = {{0,
|
|
{.cpuTimeMillis = ticksToMillis(10),
|
|
.cpuCycles = 200'000'000,
|
|
.totalMajorFaults = 700,
|
|
.totalTasksCount = 2,
|
|
.ioBlockedTasksCount = 0,
|
|
.processStatsByPid = {{1,
|
|
{"init",
|
|
ticksToMillis(19),
|
|
ticksToMillis(10),
|
|
200'000'000,
|
|
700,
|
|
2,
|
|
0,
|
|
{{1, 200'000'000}, {453, 0}}}}}}},
|
|
{10001234,
|
|
{.cpuTimeMillis = ticksToMillis(6'000),
|
|
.cpuCycles = 18'000'000'000,
|
|
.totalMajorFaults = 950,
|
|
.totalTasksCount = 2,
|
|
.ioBlockedTasksCount = 0,
|
|
.processStatsByPid = {{1000,
|
|
{"system_server",
|
|
ticksToMillis(13'400),
|
|
ticksToMillis(6'000),
|
|
18'000'000'000,
|
|
950,
|
|
2,
|
|
0,
|
|
{{1000, 0}, {1400, 18'000'000'000}}}}}}}};
|
|
|
|
TemporaryDir secondSnapshot;
|
|
ASSERT_RESULT_OK(populateProcPidDir(secondSnapshot.path, pidToTids, perProcessStat,
|
|
perProcessStatus, perThreadStat, perThreadTimeInState));
|
|
|
|
collector.mPath = secondSnapshot.path;
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << secondSnapshot.path << "` are inaccessible";
|
|
ASSERT_RESULT_OK(collector.collect());
|
|
|
|
actual = collector.deltaStats();
|
|
EXPECT_THAT(actual, UnorderedPointwise(UidProcStatsByUidEq(), expected))
|
|
<< "Second snapshot doesn't match.\nExpected:\n"
|
|
<< toString(expected) << "\nActual:\n"
|
|
<< toString(actual);
|
|
}
|
|
|
|
TEST(UidProcStatsCollectorTest, TestHandlesProcessTerminationBetweenScanningAndParsing) {
|
|
std::unordered_map<pid_t, std::vector<pid_t>> pidToTids = {
|
|
{1, {1}},
|
|
{100, {100}}, // Process terminates after scanning PID directory.
|
|
{1000, {1000}}, // Process terminates after reading stat file.
|
|
{2000, {2000}}, // Process terminates after scanning task directory.
|
|
{3000, {3000, 3300}}, // TID 3300 terminates after scanning task directory.
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 220 0 10 10 0 0 0 0 1 0 19\n"},
|
|
// Process 100 terminated.
|
|
{1000, "1000 (system_server) R 1 0 0 0 0 0 0 0 600 0 20 20 0 0 0 0 1 0 1000\n"},
|
|
{2000, "2000 (logd) R 1 0 0 0 0 0 0 0 1200 0 30 30 0 0 0 0 1 0 4567\n"},
|
|
{3000, "3000 (disk I/O) R 1 0 0 0 0 0 0 0 10300 0 40 40 0 0 0 0 2 0 67890\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStatus = {
|
|
{1, pidStatusStr(1, 0)},
|
|
// Process 1000 terminated.
|
|
{2000, pidStatusStr(2000, 10001234)},
|
|
{3000, pidStatusStr(3000, 10001234)},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 10 10 0 0 0 0 1 0 19\n"},
|
|
// Process 2000 terminated.
|
|
{3000, "3000 (disk I/O) R 1 0 0 0 0 0 0 0 2400 0 30 30 0 0 0 0 2 0 67890\n"},
|
|
// TID 3300 terminated.
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadTimeInState = {
|
|
{1, "cpu0\n300000 10\n1700000 10\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
// Process 3000 terminated.
|
|
};
|
|
|
|
std::unordered_map<uid_t, UidProcStats> expected =
|
|
{{0,
|
|
UidProcStats{.cpuTimeMillis = ticksToMillis(20),
|
|
.cpuCycles = 200'000'000,
|
|
.totalMajorFaults = 220,
|
|
.totalTasksCount = 1,
|
|
.ioBlockedTasksCount = 0,
|
|
.processStatsByPid = {{1,
|
|
{"init",
|
|
ticksToMillis(19),
|
|
ticksToMillis(20),
|
|
200'000'000,
|
|
220,
|
|
1,
|
|
0,
|
|
{{1, 200'000'000}}}}}}},
|
|
{10001234,
|
|
UidProcStats{.cpuTimeMillis = ticksToMillis(140),
|
|
.cpuCycles = 0,
|
|
.totalMajorFaults = 11500,
|
|
.totalTasksCount = 2,
|
|
.ioBlockedTasksCount = 0,
|
|
.processStatsByPid = {{2000,
|
|
{"logd",
|
|
ticksToMillis(4567),
|
|
ticksToMillis(60),
|
|
0,
|
|
1200,
|
|
1,
|
|
0,
|
|
{}}},
|
|
{3000,
|
|
{"disk I/O",
|
|
ticksToMillis(67890),
|
|
ticksToMillis(80),
|
|
0,
|
|
10'300,
|
|
1,
|
|
0,
|
|
{}}}}}}};
|
|
|
|
TemporaryDir procDir;
|
|
ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
|
|
perThreadStat, perThreadTimeInState));
|
|
|
|
UidProcStatsCollector collector(procDir.path);
|
|
collector.init();
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << procDir.path << "` are inaccessible";
|
|
ASSERT_RESULT_OK(collector.collect());
|
|
|
|
auto actual = collector.deltaStats();
|
|
EXPECT_THAT(actual, UnorderedPointwise(UidProcStatsByUidEq(), expected))
|
|
<< "Proc pid contents doesn't match.\nExpected:\n"
|
|
<< toString(expected) << "\nActual:\n"
|
|
<< toString(actual);
|
|
}
|
|
|
|
TEST(UidProcStatsCollectorTest, TestHandlesPidTidReuse) {
|
|
std::unordered_map<pid_t, std::vector<pid_t>> pidToTids = {
|
|
{1, {1, 367, 453, 589}},
|
|
{1000, {1000}},
|
|
{2345, {2345}},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 1200 0 40 40 0 0 0 0 4 0 19\n"},
|
|
{1000, "1000 (system_server) R 1 0 0 0 0 0 0 0 250 0 10 10 0 0 0 0 1 0 1000\n"},
|
|
{2345, "2345 (logd) R 1 0 0 0 0 0 0 0 54354 0 10 10 0 0 0 0 1 0 456\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStatus = {
|
|
{1, pidStatusStr(1, 0)},
|
|
{1000, pidStatusStr(1000, 10001234)},
|
|
{2345, pidStatusStr(2345, 10001234)},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 10 10 0 0 0 0 4 0 19\n"},
|
|
{367, "367 (init) S 0 0 0 0 0 0 0 0 400 0 10 10 0 0 0 0 4 0 100\n"},
|
|
{453, "453 (init) S 0 0 0 0 0 0 0 0 100 0 10 10 0 0 0 0 4 0 275\n"},
|
|
{589, "589 (init) D 0 0 0 0 0 0 0 0 500 0 10 10 0 0 0 0 4 0 600\n"},
|
|
{1000, "1000 (system_server) R 1 0 0 0 0 0 0 0 250 0 10 10 0 0 0 0 1 0 1000\n"},
|
|
{2345, "2345 (logd) R 1 0 0 0 0 0 0 0 54354 0 10 10 0 0 0 0 1 0 456\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadTimeInState = {
|
|
{1, "cpu0\n300000 20\n1700000 0\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
{367, "cpu0\n300000 0\n1700000 20\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
{453, "cpu0\n300000 0\n1700000 0\ncpu4\n710000 0\n1800000 20\ncpu7\n2000000 0"},
|
|
{589, "cpu0\n300000 0\n1700000 0\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 20"},
|
|
{1000, "cpu0\n300000 20\n1700000 0\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
{2345, "cpu0\n300000 0\n1700000 0\ncpu4\n710000 0\n1800000 20\ncpu7\n2000000 0"},
|
|
};
|
|
|
|
std::unordered_map<uid_t, UidProcStats> expected =
|
|
{{0,
|
|
UidProcStats{.cpuTimeMillis = ticksToMillis(80),
|
|
.cpuCycles = 1'160'000'000,
|
|
.totalMajorFaults = 1200,
|
|
.totalTasksCount = 4,
|
|
.ioBlockedTasksCount = 1,
|
|
.processStatsByPid = {{1,
|
|
{"init",
|
|
ticksToMillis(19),
|
|
ticksToMillis(80),
|
|
1'160'000'000,
|
|
1200,
|
|
4,
|
|
1,
|
|
{{1, 60'000'000},
|
|
{367, 340'000'000},
|
|
{453, 360'000'000},
|
|
{589, 400'000'000}}}}}}},
|
|
{10001234,
|
|
UidProcStats{.cpuTimeMillis = ticksToMillis(40),
|
|
.cpuCycles = 420'000'000,
|
|
.totalMajorFaults = 54'604,
|
|
.totalTasksCount = 2,
|
|
.ioBlockedTasksCount = 0,
|
|
.processStatsByPid = {{1000,
|
|
{"system_server",
|
|
ticksToMillis(1000),
|
|
ticksToMillis(20),
|
|
60'000'000,
|
|
250,
|
|
1,
|
|
0,
|
|
{{1000, 60'000'000}}}},
|
|
{2345,
|
|
{"logd",
|
|
ticksToMillis(456),
|
|
ticksToMillis(20),
|
|
360'000'000,
|
|
54'354,
|
|
1,
|
|
0,
|
|
{{2345, 360'000'000}}}}}}}};
|
|
|
|
TemporaryDir firstSnapshot;
|
|
ASSERT_RESULT_OK(populateProcPidDir(firstSnapshot.path, pidToTids, perProcessStat,
|
|
perProcessStatus, perThreadStat, perThreadTimeInState));
|
|
|
|
UidProcStatsCollector collector(firstSnapshot.path);
|
|
collector.init();
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << firstSnapshot.path << "` are inaccessible";
|
|
ASSERT_RESULT_OK(collector.collect());
|
|
|
|
auto actual = collector.deltaStats();
|
|
|
|
EXPECT_THAT(actual, UnorderedPointwise(UidProcStatsByUidEq(), expected))
|
|
<< "First snapshot doesn't match.\nExpected:\n"
|
|
<< toString(expected) << "\nActual:\n"
|
|
<< toString(actual);
|
|
|
|
pidToTids = {
|
|
{1, {1, 589}}, // TID 589 reused by the same process.
|
|
{367, {367, 2000}}, // TID 367 reused as a PID. PID 2000 reused as a TID.
|
|
// PID 1000 reused as a new PID. TID 453 reused by a different PID.
|
|
{1000, {1000, 453}},
|
|
};
|
|
|
|
perProcessStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 1800 0 60 60 0 0 0 0 2 0 19\n"},
|
|
{367, "367 (system_server) R 1 0 0 0 0 0 0 0 100 0 30 30 0 0 0 0 2 0 3450\n"},
|
|
{1000, "1000 (logd) R 1 0 0 0 0 0 0 0 2000 0 20 20 0 0 0 0 2 0 4650\n"},
|
|
};
|
|
|
|
perProcessStatus = {
|
|
{1, pidStatusStr(1, 0)},
|
|
{367, pidStatusStr(367, 10001234)},
|
|
{1000, pidStatusStr(1000, 10001234)},
|
|
};
|
|
|
|
perThreadStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 500 0 20 20 0 0 0 0 2 0 19\n"},
|
|
{589, "589 (init) S 0 0 0 0 0 0 0 0 300 0 10 10 0 0 0 0 2 0 2345\n"},
|
|
{367, "367 (system_server) R 1 0 0 0 0 0 0 0 50 0 15 15 0 0 0 0 2 0 3450\n"},
|
|
{2000, "2000 (system_server) R 1 0 0 0 0 0 0 0 50 0 15 15 0 0 0 0 2 0 3670\n"},
|
|
{1000, "1000 (logd) R 1 0 0 0 0 0 0 0 200 0 10 10 0 0 0 0 2 0 4650\n"},
|
|
{453, "453 (logd) D 1 0 0 0 0 0 0 0 1800 0 10 10 0 0 0 0 2 0 4770\n"},
|
|
};
|
|
|
|
perThreadTimeInState = {
|
|
{1, "cpu0\n300000 20\n1700000 20\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
{589, "cpu0\n300000 20\n1700000 0\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 20"},
|
|
{367, "cpu0\n300000 0\n1700000 0\ncpu4\n710000 30\n1800000 0\ncpu7\n2000000 0"},
|
|
{2000, "cpu0\n300000 0\n1700000 0\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 30"},
|
|
{1000, "cpu0\n300000 0\n1700000 0\ncpu4\n710000 0\n1800000 20\ncpu7\n2000000 0"},
|
|
{453, "cpu0\n300000 20\n1700000 0\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
};
|
|
|
|
expected = {{0,
|
|
UidProcStats{.cpuTimeMillis = ticksToMillis(40),
|
|
.cpuCycles = 400'000'000,
|
|
.totalMajorFaults = 600,
|
|
.totalTasksCount = 2,
|
|
.ioBlockedTasksCount = 0,
|
|
.processStatsByPid = {{1,
|
|
{"init",
|
|
ticksToMillis(19),
|
|
ticksToMillis(40),
|
|
400'000'000,
|
|
600,
|
|
2,
|
|
0,
|
|
{{1, 340'000'000}, {589, 60'000'000}}}}}}},
|
|
{10001234,
|
|
UidProcStats{.cpuTimeMillis = ticksToMillis(100),
|
|
.cpuCycles = 1'233'000'000,
|
|
.totalMajorFaults = 2100,
|
|
.totalTasksCount = 4,
|
|
.ioBlockedTasksCount = 1,
|
|
.processStatsByPid = {{367,
|
|
{"system_server",
|
|
ticksToMillis(3450),
|
|
ticksToMillis(60),
|
|
813'000'000,
|
|
100,
|
|
2,
|
|
0,
|
|
{{367, 213'000'000}, {2000, 600'000'000}}}},
|
|
{1000,
|
|
{"logd",
|
|
ticksToMillis(4650),
|
|
ticksToMillis(40),
|
|
420'000'000,
|
|
2000,
|
|
2,
|
|
1,
|
|
{{1000, 360'000'000},
|
|
{453, 60'000'000}}}}}}}};
|
|
|
|
TemporaryDir secondSnapshot;
|
|
ASSERT_RESULT_OK(populateProcPidDir(secondSnapshot.path, pidToTids, perProcessStat,
|
|
perProcessStatus, perThreadStat, perThreadTimeInState));
|
|
|
|
collector.mPath = secondSnapshot.path;
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << secondSnapshot.path << "` are inaccessible";
|
|
ASSERT_RESULT_OK(collector.collect());
|
|
|
|
actual = collector.deltaStats();
|
|
|
|
EXPECT_THAT(actual, UnorderedPointwise(UidProcStatsByUidEq(), expected))
|
|
<< "Second snapshot doesn't match.\nExpected:\n"
|
|
<< toString(expected) << "\nActual:\n"
|
|
<< toString(actual);
|
|
}
|
|
|
|
TEST(UidProcStatsCollectorTest, TestErrorOnCorruptedProcessStatFile) {
|
|
std::unordered_map<pid_t, std::vector<pid_t>> pidToTids = {
|
|
{1, {1}},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 0 0 CORRUPTED DATA\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStatus = {
|
|
{1, pidStatusStr(1, 0)},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 0 0 0 0 0 0 1 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadTimeInState = {
|
|
{1, "cpu0\n300000 0\n1700000 10\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
};
|
|
|
|
TemporaryDir procDir;
|
|
ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
|
|
perThreadStat, perThreadTimeInState));
|
|
|
|
UidProcStatsCollector collector(procDir.path);
|
|
collector.init();
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << procDir.path << "` are inaccessible";
|
|
ASSERT_FALSE(collector.collect().ok()) << "No error returned for invalid process stat file";
|
|
}
|
|
|
|
TEST(UidProcStatsCollectorTest, TestErrorOnCorruptedProcessStatusFile) {
|
|
std::unordered_map<pid_t, std::vector<pid_t>> pidToTids = {
|
|
{1, {1}},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 0 0 0 0 0 0 1 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStatus = {
|
|
{1, "Pid:\t1\nTgid:\t1\nCORRUPTED DATA\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 0 0 0 0 0 0 1 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadTimeInState = {
|
|
{1, "cpu0\n300000 0\n1700000 10\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
};
|
|
|
|
TemporaryDir procDir;
|
|
ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
|
|
perThreadStat, perThreadTimeInState));
|
|
|
|
UidProcStatsCollector collector(procDir.path);
|
|
collector.init();
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << procDir.path << "` are inaccessible";
|
|
ASSERT_FALSE(collector.collect().ok()) << "No error returned for invalid process status file";
|
|
}
|
|
|
|
TEST(UidProcStatsCollectorTest, TestErrorOnProcessStatusFileWithNoUid) {
|
|
std::unordered_map<pid_t, std::vector<pid_t>> pidToTids = {
|
|
{1, {1}},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 0 0 0 0 0 0 1 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStatus = {
|
|
{1, "Pid:\t1\nTgid:\t1\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 0 0 0 0 0 0 1 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadTimeInState = {
|
|
{1, "cpu0\n300000 0\n1700000 10\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
};
|
|
|
|
TemporaryDir procDir;
|
|
ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
|
|
perThreadStat, perThreadTimeInState));
|
|
|
|
UidProcStatsCollector collector(procDir.path);
|
|
collector.init();
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << procDir.path << "` are inaccessible";
|
|
ASSERT_FALSE(collector.collect().ok())
|
|
<< "No error returned for process status file without uid";
|
|
}
|
|
|
|
TEST(UidProcStatsCollectorTest, TestErrorOnProcessStatusFileWithNoTgid) {
|
|
std::unordered_map<pid_t, std::vector<pid_t>> pidToTids = {
|
|
{1, {1}},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 0 0 0 0 0 0 1 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStatus = {
|
|
{1, "Pid:\t1\nUid:\t1\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 0 0 0 0 0 0 1 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadTimeInState = {
|
|
{1, "cpu0\n300000 0\n1700000 10\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
};
|
|
|
|
TemporaryDir procDir;
|
|
ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
|
|
perThreadStat, perThreadTimeInState));
|
|
|
|
UidProcStatsCollector collector(procDir.path);
|
|
collector.init();
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << procDir.path << "` are inaccessible";
|
|
ASSERT_FALSE(collector.collect().ok())
|
|
<< "No error returned for process status file without tgid";
|
|
}
|
|
|
|
TEST(UidProcStatsCollectorTest, TestErrorOnCorruptedThreadStatFile) {
|
|
std::unordered_map<pid_t, std::vector<pid_t>> pidToTids = {
|
|
{1, {1, 234}},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 0 0 0 0 0 0 2 0 678\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStatus = {
|
|
{1, pidStatusStr(1, 0)},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 0 0 0 0 0 0 2 0 678\n"},
|
|
{234, "234 (init) D 0 0 0 0 0 0 0 0 200 0 0 0 CORRUPTED DATA\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadTimeInState = {
|
|
{1, "cpu0\n300000 0\n1700000 10\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
};
|
|
|
|
TemporaryDir procDir;
|
|
ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
|
|
perThreadStat, perThreadTimeInState));
|
|
|
|
UidProcStatsCollector collector(procDir.path);
|
|
collector.init();
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << procDir.path << "` are inaccessible";
|
|
ASSERT_FALSE(collector.collect().ok()) << "No error returned for invalid thread stat file";
|
|
}
|
|
|
|
TEST(UidProcStatsCollectorTest, TestErrorOnCorruptedThreadTimeInStateFile) {
|
|
std::unordered_map<pid_t, std::vector<pid_t>> pidToTids = {
|
|
{1, {1, 234}},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 0 0 0 0 0 0 2 0 678\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStatus = {
|
|
{1, pidStatusStr(1, 0)},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 0 0 0 0 0 0 2 0 678\n"},
|
|
{234, "234 (init) D 0 0 0 0 0 0 0 0 200 0 0 0 0 0 0 0 2 0 500\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadTimeInState = {
|
|
{1, "cpu0\n300000 0\n1700000 10\ncpu4\n710000 0\n1800000 0\n"},
|
|
{234, "cpu0\n300000 0\n1700000 10\ncpu4\n710000 0\n1800000 CORRUPTED\n DATA"},
|
|
};
|
|
|
|
TemporaryDir procDir;
|
|
ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
|
|
perThreadStat, perThreadTimeInState));
|
|
|
|
UidProcStatsCollector collector(procDir.path);
|
|
collector.init();
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << procDir.path << "` are inaccessible";
|
|
ASSERT_FALSE(collector.collect().ok()) << "No error returned for invalid thread stat file";
|
|
}
|
|
|
|
TEST(UidProcStatsCollectorTest, TestHandlesSpaceInCommName) {
|
|
std::unordered_map<pid_t, std::vector<pid_t>> pidToTids = {
|
|
{1, {1}},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStat = {
|
|
{1,
|
|
"1 (random process name with space) S 0 0 0 0 0 0 0 0 200 0 10 10 0 0 0 0 1 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStatus = {
|
|
{1, pidStatusStr(1, 0)},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadStat = {
|
|
{1,
|
|
"1 (random process name with space) S 0 0 0 0 0 0 0 0 200 0 10 10 0 0 0 0 1 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadTimeInState = {
|
|
{1, "cpu0\n300000 0\n1700000 20\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
};
|
|
|
|
std::unordered_map<uid_t, UidProcStats> expected = {
|
|
{0,
|
|
UidProcStats{.cpuTimeMillis = ticksToMillis(20),
|
|
.cpuCycles = 340'000'000,
|
|
.totalMajorFaults = 200,
|
|
.totalTasksCount = 1,
|
|
.ioBlockedTasksCount = 0,
|
|
.processStatsByPid = {{1,
|
|
{"random process name with space",
|
|
ticksToMillis(19),
|
|
ticksToMillis(20),
|
|
340'000'000,
|
|
200,
|
|
1,
|
|
0,
|
|
{{1, 340'000'000}}}}}}}};
|
|
|
|
TemporaryDir procDir;
|
|
ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
|
|
perThreadStat, perThreadTimeInState));
|
|
|
|
UidProcStatsCollector collector(procDir.path);
|
|
collector.init();
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << procDir.path << "` are inaccessible";
|
|
ASSERT_RESULT_OK(collector.collect());
|
|
|
|
auto actual = collector.deltaStats();
|
|
|
|
EXPECT_THAT(actual, UnorderedPointwise(UidProcStatsByUidEq(), expected))
|
|
<< "Proc pid contents doesn't match.\nExpected:\n"
|
|
<< toString(expected) << "\nActual:\n"
|
|
<< toString(actual);
|
|
}
|
|
|
|
TEST(UidProcStatsCollectorTest, TestHandlesTimeInStateFileDisabledWithNoFile) {
|
|
std::unordered_map<pid_t, std::vector<pid_t>> pidToTids = {
|
|
{1, {1}},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 10 10 0 0 0 0 1 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStatus = {
|
|
{1, pidStatusStr(1, 0)},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 10 10 0 0 0 0 1 0 19\n"},
|
|
};
|
|
|
|
// No time_in_state file present in procfs
|
|
|
|
std::unordered_map<uid_t, UidProcStats> expected = {
|
|
{0,
|
|
UidProcStats{.cpuTimeMillis = ticksToMillis(20),
|
|
.cpuCycles = 0,
|
|
.totalMajorFaults = 200,
|
|
.totalTasksCount = 1,
|
|
.ioBlockedTasksCount = 0,
|
|
.processStatsByPid = {{1,
|
|
{"init",
|
|
ticksToMillis(19),
|
|
ticksToMillis(20),
|
|
0,
|
|
200,
|
|
1,
|
|
0,
|
|
{}}}}}}};
|
|
|
|
TemporaryDir procDir;
|
|
ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
|
|
perThreadStat, {}));
|
|
|
|
UidProcStatsCollector collector(procDir.path);
|
|
collector.init();
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << procDir.path << "` are inaccessible";
|
|
ASSERT_RESULT_OK(collector.collect());
|
|
|
|
auto actual = collector.deltaStats();
|
|
|
|
EXPECT_THAT(actual, UnorderedPointwise(UidProcStatsByUidEq(), expected))
|
|
<< "Proc pid contents doesn't match.\nExpected:\n"
|
|
<< toString(expected) << "\nActual:\n"
|
|
<< toString(actual);
|
|
}
|
|
|
|
TEST(UidProcStatsCollectorTest, TestHandlesTimeInStateFileDisabledWithEmptyFile) {
|
|
std::unordered_map<pid_t, std::vector<pid_t>> pidToTids = {
|
|
{1, {1}},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 10 10 0 0 0 0 1 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStatus = {
|
|
{1, pidStatusStr(1, 0)},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 10 10 0 0 0 0 1 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadTimeInState = {
|
|
{1, ""},
|
|
};
|
|
|
|
std::unordered_map<uid_t, UidProcStats> expected = {
|
|
{0,
|
|
UidProcStats{.cpuTimeMillis = ticksToMillis(20),
|
|
.cpuCycles = 0,
|
|
.totalMajorFaults = 200,
|
|
.totalTasksCount = 1,
|
|
.ioBlockedTasksCount = 0,
|
|
.processStatsByPid = {{1,
|
|
{"init",
|
|
ticksToMillis(19),
|
|
ticksToMillis(20),
|
|
0,
|
|
200,
|
|
1,
|
|
0,
|
|
{}}}}}}};
|
|
|
|
TemporaryDir procDir;
|
|
ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
|
|
perThreadStat, {}));
|
|
|
|
UidProcStatsCollector collector(procDir.path);
|
|
collector.init();
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << procDir.path << "` are inaccessible";
|
|
ASSERT_RESULT_OK(collector.collect());
|
|
|
|
auto actual = collector.deltaStats();
|
|
|
|
EXPECT_THAT(actual, UnorderedPointwise(UidProcStatsByUidEq(), expected))
|
|
<< "Proc pid contents doesn't match.\nExpected:\n"
|
|
<< toString(expected) << "\nActual:\n"
|
|
<< toString(actual);
|
|
}
|
|
|
|
TEST(UidProcStatsCollectorTest, TestHandlesTimeInStateFileDisabledWithZeroCpuCycles) {
|
|
std::unordered_map<pid_t, std::vector<pid_t>> pidToTids = {
|
|
{1, {1}},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 10 10 0 0 0 0 1 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStatus = {
|
|
{1, pidStatusStr(1, 0)},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 10 10 0 0 0 0 1 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadTimeInState = {
|
|
{1, "cpu0\n300000 0\n1700000 0\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
};
|
|
|
|
std::unordered_map<uid_t, UidProcStats> expected = {
|
|
{0,
|
|
UidProcStats{.cpuTimeMillis = ticksToMillis(20),
|
|
.cpuCycles = 0,
|
|
.totalMajorFaults = 200,
|
|
.totalTasksCount = 1,
|
|
.ioBlockedTasksCount = 0,
|
|
.processStatsByPid = {{1,
|
|
{"init",
|
|
ticksToMillis(19),
|
|
ticksToMillis(20),
|
|
0,
|
|
200,
|
|
1,
|
|
0,
|
|
{}}}}}}};
|
|
|
|
TemporaryDir procDir;
|
|
ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
|
|
perThreadStat, {}));
|
|
|
|
UidProcStatsCollector collector(procDir.path);
|
|
collector.init();
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << procDir.path << "` are inaccessible";
|
|
ASSERT_RESULT_OK(collector.collect());
|
|
|
|
auto actual = collector.deltaStats();
|
|
|
|
EXPECT_THAT(actual, UnorderedPointwise(UidProcStatsByUidEq(), expected))
|
|
<< "Proc pid contents doesn't match.\nExpected:\n"
|
|
<< toString(expected) << "\nActual:\n"
|
|
<< toString(actual);
|
|
}
|
|
|
|
TEST(UidProcStatsCollectorTest, TestHandlesNoTimeInStateFileDuringCollection) {
|
|
std::unordered_map<pid_t, std::vector<pid_t>> pidToTids = {
|
|
{1, {1, 234}},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 210 0 15 15 0 0 0 0 2 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perProcessStatus = {
|
|
{1, pidStatusStr(1, 0)},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadStat = {
|
|
{1, "1 (init) S 0 0 0 0 0 0 0 0 200 0 10 10 0 0 0 0 2 0 19\n"},
|
|
{234, "1 (init) S 0 0 0 0 0 0 0 0 10 0 5 5 0 0 0 0 2 0 19\n"},
|
|
};
|
|
|
|
std::unordered_map<pid_t, std::string> perThreadTimeInState = {
|
|
{1, "cpu0\n300000 0\n1700000 20\ncpu4\n710000 0\n1800000 0\ncpu7\n2000000 0"},
|
|
// No time_in_state file present for TID 234
|
|
};
|
|
|
|
std::unordered_map<uid_t, UidProcStats> expected = {
|
|
{0,
|
|
UidProcStats{.cpuTimeMillis = ticksToMillis(30),
|
|
.cpuCycles = 340'000'000,
|
|
.totalMajorFaults = 210,
|
|
.totalTasksCount = 2,
|
|
.ioBlockedTasksCount = 0,
|
|
.processStatsByPid = {{1,
|
|
{"init",
|
|
ticksToMillis(19),
|
|
ticksToMillis(30),
|
|
340'000'000,
|
|
210,
|
|
2,
|
|
0,
|
|
{{1, 340'000'000}}}}}}}};
|
|
|
|
TemporaryDir procDir;
|
|
ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
|
|
perThreadStat, perThreadTimeInState));
|
|
|
|
UidProcStatsCollector collector(procDir.path);
|
|
collector.init();
|
|
|
|
ASSERT_TRUE(collector.enabled())
|
|
<< "Files under the path `" << procDir.path << "` are inaccessible";
|
|
ASSERT_RESULT_OK(collector.collect());
|
|
|
|
auto actual = collector.deltaStats();
|
|
|
|
EXPECT_THAT(actual, UnorderedPointwise(UidProcStatsByUidEq(), expected))
|
|
<< "Proc pid contents doesn't match.\nExpected:\n"
|
|
<< toString(expected) << "\nActual:\n"
|
|
<< toString(actual);
|
|
}
|
|
|
|
TEST(UidProcStatsCollectorTest, TestUidProcStatsCollectorContentsFromDevice) {
|
|
UidProcStatsCollector collector;
|
|
collector.init();
|
|
|
|
ASSERT_TRUE(collector.enabled()) << "/proc/[pid]/.* files are inaccessible";
|
|
ASSERT_RESULT_OK(collector.collect());
|
|
|
|
const auto& processStats = collector.deltaStats();
|
|
|
|
// The below check should pass because there should be at least one process.
|
|
EXPECT_GT(processStats.size(), static_cast<size_t>(0));
|
|
}
|
|
|
|
} // namespace watchdog
|
|
} // namespace automotive
|
|
} // namespace android
|