/*
 * 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 "ProcPidStat.h"

#include "ProcPidDir.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;

namespace {

std::string toString(const PidStat& stat) {
    return StringPrintf("PID: %" PRIu32 ", PPID: %" PRIu32 ", Comm: %s, State: %s, "
                        "Major page faults: %" PRIu64 ", Num threads: %" PRIu32
                        ", Start time: %" PRIu64,
                        stat.pid, stat.ppid, stat.comm.c_str(), stat.state.c_str(),
                        stat.majorFaults, stat.numThreads, stat.startTime);
}

std::string toString(const ProcessStats& stats) {
    std::string buffer;
    StringAppendF(&buffer,
                  "Tgid: %" PRIi64 ", UID: %" PRIi64 ", VmPeak: %" PRIu64 ", VmSize: %" PRIu64
                  ", VmHWM: %" PRIu64 ", VmRSS: %" PRIu64 ", %s\n",
                  stats.tgid, stats.uid, stats.vmPeakKb, stats.vmSizeKb, stats.vmHwmKb,
                  stats.vmRssKb, toString(stats.process).c_str());
    StringAppendF(&buffer, "\tThread stats:\n");
    for (const auto& it : stats.threads) {
        StringAppendF(&buffer, "\t\t%s\n", toString(it.second).c_str());
    }
    StringAppendF(&buffer, "\n");
    return buffer;
}

std::string toString(const std::vector<ProcessStats>& stats) {
    std::string buffer;
    StringAppendF(&buffer, "Number of processes: %d\n", static_cast<int>(stats.size()));
    for (const auto& it : stats) {
        StringAppendF(&buffer, "%s", toString(it).c_str());
    }
    return buffer;
}

bool isEqual(const PidStat& lhs, const PidStat& rhs) {
    return lhs.pid == rhs.pid && lhs.comm == rhs.comm && lhs.state == rhs.state &&
            lhs.ppid == rhs.ppid && lhs.majorFaults == rhs.majorFaults &&
            lhs.numThreads == rhs.numThreads && lhs.startTime == rhs.startTime;
}

bool isEqual(std::vector<ProcessStats>* lhs, std::vector<ProcessStats>* rhs) {
    if (lhs->size() != rhs->size()) {
        return false;
    }
    std::sort(lhs->begin(), lhs->end(), [&](const ProcessStats& l, const ProcessStats& r) -> bool {
        return l.process.pid < r.process.pid;
    });
    std::sort(rhs->begin(), rhs->end(), [&](const ProcessStats& l, const ProcessStats& r) -> bool {
        return l.process.pid < r.process.pid;
    });
    return std::equal(lhs->begin(), lhs->end(), rhs->begin(),
                      [&](const ProcessStats& l, const ProcessStats& r) -> bool {
                          if (l.tgid != r.tgid || l.uid != r.uid || l.vmPeakKb != r.vmPeakKb ||
                              l.vmSizeKb != r.vmSizeKb || l.vmHwmKb != r.vmHwmKb ||
                              l.vmRssKb != r.vmRssKb || !isEqual(l.process, r.process) ||
                              l.threads.size() != r.threads.size()) {
                              return false;
                          }
                          for (const auto& lIt : l.threads) {
                              const auto& rIt = r.threads.find(lIt.first);
                              if (rIt == r.threads.end()) {
                                  return false;
                              }
                              if (!isEqual(lIt.second, rIt->second)) {
                                  return false;
                              }
                          }
                          return true;
                      });
}

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 pidStatusStr(pid_t pid, uid_t uid, uint64_t vmPeakKb, uint64_t vmSizeKb,
                         uint64_t vmHwmKb, uint64_t vmRssKb) {
    return StringPrintf("%sVmPeak:\t%" PRIu64 "\nVmSize:\t%" PRIu64 "\nVmHWM:\t%" PRIu64
                        "\nVmRSS:\t%" PRIu64 "\n",
                        pidStatusStr(pid, uid).c_str(), vmPeakKb, vmSizeKb, vmHwmKb, vmRssKb);
}

}  // namespace

TEST(ProcPidStatTest, 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 0 0 0 0 0 0 2 0 0\n"},
            {1000, "1000 (system_server) R 1 0 0 0 0 0 0 0 600 0 0 0 0 0 0 0 2 0 1000\n"},
    };

    std::unordered_map<pid_t, std::string> perProcessStatus = {
            {1, pidStatusStr(1, 0, 123, 456, 789, 345)},
            {1000, pidStatusStr(1000, 10001234, 234, 567, 890, 123)},
    };

    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 0\n"},
            {453, "453 (init) S 0 0 0 0 0 0 0 0 20 0 0 0 0 0 0 0 2 0 275\n"},
            {1000, "1000 (system_server) R 1 0 0 0 0 0 0 0 250 0 0 0 0 0 0 0 2 0 1000\n"},
            {1100, "1100 (system_server) S 1 0 0 0 0 0 0 0 350 0 0 0 0 0 0 0 2 0 1200\n"},
    };

    std::vector<ProcessStats> expected = {
            {.tgid = 1,
             .uid = 0,
             .vmPeakKb = 123,
             .vmSizeKb = 456,
             .vmHwmKb = 789,
             .vmRssKb = 345,
             .process = {1, "init", "S", 0, 220, 2, 0},
             .threads = {{1, {1, "init", "S", 0, 200, 2, 0}},
                         {453, {453, "init", "S", 0, 20, 2, 275}}}},
            {.tgid = 1000,
             .uid = 10001234,
             .vmPeakKb = 234,
             .vmSizeKb = 567,
             .vmHwmKb = 890,
             .vmRssKb = 123,
             .process = {1000, "system_server", "R", 1, 600, 2, 1000},
             .threads = {{1000, {1000, "system_server", "R", 1, 250, 2, 1000}},
                         {1100, {1100, "system_server", "S", 1, 350, 2, 1200}}}},
    };

    TemporaryDir firstSnapshot;
    ASSERT_RESULT_OK(populateProcPidDir(firstSnapshot.path, pidToTids, perProcessStat,
                                        perProcessStatus, perThreadStat));

    ProcPidStat procPidStat(firstSnapshot.path);
    ASSERT_TRUE(procPidStat.enabled())
            << "Files under the path `" << firstSnapshot.path << "` are inaccessible";
    ASSERT_RESULT_OK(procPidStat.collect());

    auto actual = std::vector<ProcessStats>(procPidStat.deltaStats());
    EXPECT_TRUE(isEqual(&expected, &actual)) << "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 0 0 0 0 0 0 2 0 0\n"},
            {1000, "1000 (system_server) R 1 0 0 0 0 0 0 0 1550 0 0 0 0 0 0 0 2 0 1000\n"},
    };

    perThreadStat = {
            {1, "1 (init) S 0 0 0 0 0 0 0 0 600 0 0 0 0 0 0 0 2 0 0\n"},
            {453, "453 (init) S 0 0 0 0 0 0 0 0 320 0 0 0 0 0 0 0 2 0 275\n"},
            {1000, "1000 (system_server) R 1 0 0 0 0 0 0 0 600 0 0 0 0 0 0 0 2 0 1000\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 0 0 0 0 0 0 2 0 8977476\n"},
    };

    expected = {
            {.tgid = 1,
             .uid = 0,
             .vmPeakKb = 123,
             .vmSizeKb = 456,
             .vmHwmKb = 789,
             .vmRssKb = 345,
             .process = {1, "init", "S", 0, 700, 2, 0},
             .threads = {{1, {1, "init", "S", 0, 400, 2, 0}},
                         {453, {453, "init", "S", 0, 300, 2, 275}}}},
            {.tgid = 1000,
             .uid = 10001234,
             .vmPeakKb = 234,
             .vmSizeKb = 567,
             .vmHwmKb = 890,
             .vmRssKb = 123,
             .process = {1000, "system_server", "R", 1, 950, 2, 1000},
             .threads = {{1000, {1000, "system_server", "R", 1, 350, 2, 1000}},
                         {1400, {1400, "system_server", "S", 1, 200, 2, 8977476}}}},
    };

    TemporaryDir secondSnapshot;
    ASSERT_RESULT_OK(populateProcPidDir(secondSnapshot.path, pidToTids, perProcessStat,
                                        perProcessStatus, perThreadStat));

    procPidStat.mPath = secondSnapshot.path;
    ASSERT_TRUE(procPidStat.enabled())
            << "Files under the path `" << secondSnapshot.path << "` are inaccessible";
    ASSERT_RESULT_OK(procPidStat.collect());

    actual = std::vector<ProcessStats>(procPidStat.deltaStats());
    EXPECT_TRUE(isEqual(&expected, &actual)) << "Second snapshot doesn't match.\nExpected:\n"
                                             << toString(expected) << "\nActual:\n"
                                             << toString(actual);
}

TEST(ProcPidStatTest, 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 0 0 0 0 0 0 1 0 0\n"},
            // Process 100 terminated.
            {1000, "1000 (system_server) R 1 0 0 0 0 0 0 0 600 0 0 0 0 0 0 0 1 0 1000\n"},
            {2000, "2000 (logd) R 1 0 0 0 0 0 0 0 1200 0 0 0 0 0 0 0 1 0 4567\n"},
            {3000, "3000 (disk I/O) R 1 0 0 0 0 0 0 0 10300 0 0 0 0 0 0 0 2 0 67890\n"},
    };

    std::unordered_map<pid_t, std::string> perProcessStatus = {
            {1, "Pid:\t1\nTgid:\t1\nUid:\t0\t0\t0\t0\n"},
            // 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 0 0 0 0 0 0 1 0 0\n"},
            // Process 2000 terminated.
            {3000, "3000 (disk I/O) R 1 0 0 0 0 0 0 0 2400 0 0 0 0 0 0 0 2 0 67890\n"},
            // TID 3300 terminated.
    };

    std::vector<ProcessStats> expected = {
            {.tgid = 1,
             .uid = 0,
             .process = {1, "init", "S", 0, 220, 1, 0},
             .threads = {{1, {1, "init", "S", 0, 200, 1, 0}}}},
            {.tgid = -1,
             .uid = -1,
             .process = {1000, "system_server", "R", 1, 600, 1, 1000},
             // Stats common between process and main-thread are copied when
             // main-thread stats are not available.
             .threads = {{1000, {1000, "system_server", "R", 1, 0, 1, 1000}}}},
            {.tgid = 2000,
             .uid = 10001234,
             .process = {2000, "logd", "R", 1, 1200, 1, 4567},
             .threads = {{2000, {2000, "logd", "R", 1, 0, 1, 4567}}}},
            {.tgid = 3000,
             .uid = 10001234,
             .process = {3000, "disk I/O", "R", 1, 10300, 2, 67890},
             .threads = {{3000, {3000, "disk I/O", "R", 1, 2400, 2, 67890}}}},
    };

    TemporaryDir procDir;
    ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
                                        perThreadStat));

    ProcPidStat procPidStat(procDir.path);
    ASSERT_TRUE(procPidStat.enabled())
            << "Files under the path `" << procDir.path << "` are inaccessible";
    ASSERT_RESULT_OK(procPidStat.collect());

    auto actual = std::vector<ProcessStats>(procPidStat.deltaStats());
    EXPECT_TRUE(isEqual(&expected, &actual)) << "Proc pid contents doesn't match.\nExpected:\n"
                                             << toString(expected) << "\nActual:\n"
                                             << toString(actual);
}

TEST(ProcPidStatTest, 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 0 0 0 0 0 0 4 0 0\n"},
            {1000, "1000 (system_server) R 1 0 0 0 0 0 0 0 250 0 0 0 0 0 0 0 1 0 1000\n"},
            {2345, "2345 (logd) R 1 0 0 0 0 0 0 0 54354 0 0 0 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 0 0 0 0 0 0 4 0 0\n"},
            {367, "367 (init) S 0 0 0 0 0 0 0 0 400 0 0 0 0 0 0 0 4 0 100\n"},
            {453, "453 (init) S 0 0 0 0 0 0 0 0 100 0 0 0 0 0 0 0 4 0 275\n"},
            {589, "589 (init) S 0 0 0 0 0 0 0 0 500 0 0 0 0 0 0 0 4 0 600\n"},
            {1000, "1000 (system_server) R 1 0 0 0 0 0 0 0 250 0 0 0 0 0 0 0 1 0 1000\n"},
            {2345, "2345 (logd) R 1 0 0 0 0 0 0 0 54354 0 0 0 0 0 0 0 1 0 456\n"},
    };

    std::vector<ProcessStats> expected = {
            {.tgid = 1,
             .uid = 0,
             .process = {1, "init", "S", 0, 1200, 4, 0},
             .threads = {{1, {1, "init", "S", 0, 200, 4, 0}},
                         {367, {367, "init", "S", 0, 400, 4, 100}},
                         {453, {453, "init", "S", 0, 100, 4, 275}},
                         {589, {589, "init", "S", 0, 500, 4, 600}}}},
            {.tgid = 1000,
             .uid = 10001234,
             .process = {1000, "system_server", "R", 1, 250, 1, 1000},
             .threads = {{1000, {1000, "system_server", "R", 1, 250, 1, 1000}}}},
            {.tgid = 2345,
             .uid = 10001234,
             .process = {2345, "logd", "R", 1, 54354, 1, 456},
             .threads = {{2345, {2345, "logd", "R", 1, 54354, 1, 456}}}},
    };

    TemporaryDir firstSnapshot;
    ASSERT_RESULT_OK(populateProcPidDir(firstSnapshot.path, pidToTids, perProcessStat,
                                        perProcessStatus, perThreadStat));

    ProcPidStat procPidStat(firstSnapshot.path);
    ASSERT_TRUE(procPidStat.enabled())
            << "Files under the path `" << firstSnapshot.path << "` are inaccessible";
    ASSERT_RESULT_OK(procPidStat.collect());

    auto actual = std::vector<ProcessStats>(procPidStat.deltaStats());
    EXPECT_TRUE(isEqual(&expected, &actual)) << "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 0 0 0 0 0 0 2 0 0\n"},
            {367, "367 (system_server) R 1 0 0 0 0 0 0 0 100 0 0 0 0 0 0 0 2 0 3450\n"},
            {1000, "1000 (logd) R 1 0 0 0 0 0 0 0 2000 0 0 0 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 0 0 0 0 0 0 2 0 0\n"},
            {589, "589 (init) S 0 0 0 0 0 0 0 0 300 0 0 0 0 0 0 0 2 0 2345\n"},
            {367, "367 (system_server) R 1 0 0 0 0 0 0 0 50 0 0 0 0 0 0 0 2 0 3450\n"},
            {2000, "2000 (system_server) R 1 0 0 0 0 0 0 0 50 0 0 0 0 0 0 0 2 0 3670\n"},
            {1000, "1000 (logd) R 1 0 0 0 0 0 0 0 200 0 0 0 0 0 0 0 2 0 4650\n"},
            {453, "453 (logd) D 1 0 0 0 0 0 0 0 1800 0 0 0 0 0 0 0 2 0 4770\n"},
    };

    expected = {
            {.tgid = 1,
             .uid = 0,
             .process = {1, "init", "S", 0, 600, 2, 0},
             .threads = {{1, {1, "init", "S", 0, 300, 2, 0}},
                         {589, {589, "init", "S", 0, 300, 2, 2345}}}},
            {.tgid = 367,
             .uid = 10001234,
             .process = {367, "system_server", "R", 1, 100, 2, 3450},
             .threads = {{367, {367, "system_server", "R", 1, 50, 2, 3450}},
                         {2000, {2000, "system_server", "R", 1, 50, 2, 3670}}}},
            {.tgid = 1000,
             .uid = 10001234,
             .process = {1000, "logd", "R", 1, 2000, 2, 4650},
             .threads = {{1000, {1000, "logd", "R", 1, 200, 2, 4650}},
                         {453, {453, "logd", "D", 1, 1800, 2, 4770}}}},
    };

    TemporaryDir secondSnapshot;
    ASSERT_RESULT_OK(populateProcPidDir(secondSnapshot.path, pidToTids, perProcessStat,
                                        perProcessStatus, perThreadStat));

    procPidStat.mPath = secondSnapshot.path;
    ASSERT_TRUE(procPidStat.enabled())
            << "Files under the path `" << secondSnapshot.path << "` are inaccessible";
    ASSERT_RESULT_OK(procPidStat.collect());

    actual = std::vector<ProcessStats>(procPidStat.deltaStats());
    EXPECT_TRUE(isEqual(&expected, &actual)) << "Second snapshot doesn't match.\nExpected:\n"
                                             << toString(expected) << "\nActual:\n"
                                             << toString(actual);
}

TEST(ProcPidStatTest, 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 0\n"},
    };

    TemporaryDir procDir;
    ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
                                        perThreadStat));

    ProcPidStat procPidStat(procDir.path);
    ASSERT_TRUE(procPidStat.enabled())
            << "Files under the path `" << procDir.path << "` are inaccessible";
    ASSERT_FALSE(procPidStat.collect().ok()) << "No error returned for invalid process stat file";
}

TEST(ProcPidStatTest, 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 0\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 0\n"},
    };

    TemporaryDir procDir;
    ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
                                        perThreadStat));

    ProcPidStat procPidStat(procDir.path);
    ASSERT_TRUE(procPidStat.enabled())
            << "Files under the path `" << procDir.path << "` are inaccessible";
    ASSERT_FALSE(procPidStat.collect().ok()) << "No error returned for invalid process status file";
}

TEST(ProcPidStatTest, TestErrorOnCorruptedThreadStatFile) {
    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 0\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 CORRUPTED DATA\n"},
    };

    TemporaryDir procDir;
    ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
                                        perThreadStat));

    ProcPidStat procPidStat(procDir.path);
    ASSERT_TRUE(procPidStat.enabled())
            << "Files under the path `" << procDir.path << "` are inaccessible";
    ASSERT_FALSE(procPidStat.collect().ok()) << "No error returned for invalid thread stat file";
}

TEST(ProcPidStatTest, 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 0 0 0 0 0 0 1 0 0\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 0 0 0 0 0 0 1 0 0\n"},
    };

    std::vector<ProcessStats> expected = {
            {.tgid = 1,
             .uid = 0,
             .process = {1, "random process name with space", "S", 0, 200, 1, 0},
             .threads = {{1, {1, "random process name with space", "S", 0, 200, 1, 0}}}},
    };

    TemporaryDir procDir;
    ASSERT_RESULT_OK(populateProcPidDir(procDir.path, pidToTids, perProcessStat, perProcessStatus,
                                        perThreadStat));

    ProcPidStat procPidStat(procDir.path);
    ASSERT_TRUE(procPidStat.enabled())
            << "Files under the path `" << procDir.path << "` are inaccessible";
    ASSERT_RESULT_OK(procPidStat.collect());

    auto actual = std::vector<ProcessStats>(procPidStat.deltaStats());
    EXPECT_TRUE(isEqual(&expected, &actual)) << "Proc pid contents doesn't match.\nExpected:\n"
                                             << toString(expected) << "\nActual:\n"
                                             << toString(actual);
}

TEST(ProcPidStatTest, TestProcPidStatContentsFromDevice) {
    ProcPidStat procPidStat;
    ASSERT_TRUE(procPidStat.enabled()) << "/proc/[pid]/.* files are inaccessible";
    ASSERT_RESULT_OK(procPidStat.collect());

    const auto& processStats = procPidStat.deltaStats();
    // The below check should pass because there should be at least one process.
    EXPECT_GT(processStats.size(), 0);
}

}  // namespace watchdog
}  // namespace automotive
}  // namespace android