// Copyright (C) 2022 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 <gmock/gmock.h>
#include <gtest/gtest.h>

#include "aemu/base/HealthMonitor.h"

#include <chrono>
#include <limits>
#include <vector>

#include "aemu/base/testing/TestClock.h"
#include "aemu/base/Metrics.h"

namespace emugl {

using android::base::MetricEventHang;
using android::base::MetricEventType;
using android::base::MetricEventUnHang;
using android::base::MetricsLogger;
using android::base::TestClock;
using emugl::kDefaultIntervalMs;
using emugl::kDefaultTimeoutMs;
using ::testing::_;
using ::testing::AllOf;
using ::testing::ByMove;
using ::testing::Contains;
using ::testing::DoAll;
using ::testing::Eq;
using ::testing::Field;
using ::testing::Ge;
using ::testing::HasSubstr;
using ::testing::InSequence;
using ::testing::IsNull;
using ::testing::Key;
using ::testing::Le;
using ::testing::MockFunction;
using ::testing::Ne;
using ::testing::Optional;
using ::testing::Pair;
using ::testing::Pointee;
using ::testing::Ref;
using ::testing::Return;
using ::testing::SaveArg;
using ::testing::StrEq;
using ::testing::Test;
using ::testing::VariantWith;

class HealthMonitorTest : public Test {
   protected:
    class MockLogger : public MetricsLogger {
       public:
        MOCK_METHOD(void, logMetricEvent, (MetricEventType eventType), (override));
        MOCK_METHOD(void, setCrashAnnotation, (const char* key, const char* value),
                    (override));  // Unused
    };

    HealthMonitorTest() : healthMonitor(logger, SToMs(1)) { TestClock::reset(); }

    ~HealthMonitorTest() { step(1); }

    void step(int seconds) {
        for (int i = 0; i < seconds; i++) {
            TestClock::advance(1);
            healthMonitor.poll().wait();
        }
    }

    int SToMs(int seconds) { return seconds * 1'000; }

    int defaultHangThresholdS = 5;
    MockLogger logger;
    HealthMonitor<TestClock> healthMonitor;
};

TEST_F(HealthMonitorTest, badTimeoutTimeTest) {
    int expectedHangThresholdS = 2;
    int expectedHangDurationS = 5;
    {
        InSequence s;
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(_))).Times(1);
        EXPECT_CALL(logger,
                    logMetricEvent(VariantWith<MetricEventUnHang>(Field(
                        &MetricEventUnHang::hung_ms, AllOf(Ge(SToMs(expectedHangDurationS - 1)),
                                                           Le(SToMs(expectedHangDurationS + 1)))))))
            .Times(1);
    }

    auto id =
        healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>(), std::nullopt, 1);
    step(expectedHangThresholdS + expectedHangDurationS);
    healthMonitor.stopMonitoringTask(id);
}

TEST_F(HealthMonitorTest, startTouchEndEventsTest) {
    EXPECT_CALL(logger, logMetricEvent(_)).Times(0);

    auto id = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    step(defaultHangThresholdS - 1);
    healthMonitor.touchMonitoredTask(id);
    step(defaultHangThresholdS - 1);
    healthMonitor.stopMonitoringTask(id);
}

TEST_F(HealthMonitorTest, hangingStartEventTest) {
    EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(_))).Times(1);

    healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    step(defaultHangThresholdS + 1);
}

TEST_F(HealthMonitorTest, lateEndEventTest) {
    int expectedHangDurationS = 5;
    {
        InSequence s;
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(_))).Times(1);
        EXPECT_CALL(logger,
                    logMetricEvent(VariantWith<MetricEventUnHang>(Field(
                        &MetricEventUnHang::hung_ms, AllOf(Ge(SToMs(expectedHangDurationS - 1)),
                                                           Le(SToMs(expectedHangDurationS + 1)))))))
            .Times(1);
    }

    auto id = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    step(defaultHangThresholdS + expectedHangDurationS);
    healthMonitor.stopMonitoringTask(id);
}

TEST_F(HealthMonitorTest, taskHangsTwiceTest) {
    int expectedHangDurationS1 = 3;
    int expectedHangDurationS2 = 5;
    {
        InSequence s;
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(_))).Times(1);
        EXPECT_CALL(
            logger,
            logMetricEvent(VariantWith<MetricEventUnHang>(
                Field(&MetricEventUnHang::hung_ms, AllOf(Ge(SToMs(expectedHangDurationS1 - 1)),
                                                         Le(SToMs(expectedHangDurationS1 + 1)))))))
            .Times(1);
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(_))).Times(1);
        EXPECT_CALL(
            logger,
            logMetricEvent(VariantWith<MetricEventUnHang>(
                Field(&MetricEventUnHang::hung_ms, AllOf(Ge(SToMs(expectedHangDurationS2 - 1)),
                                                         Le(SToMs(expectedHangDurationS2 + 1)))))))
            .Times(1);
    }

    auto id = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    step(defaultHangThresholdS + expectedHangDurationS1);
    healthMonitor.touchMonitoredTask(id);
    step(defaultHangThresholdS + expectedHangDurationS2);
    healthMonitor.stopMonitoringTask(id);
}

TEST_F(HealthMonitorTest, taskHangsThriceTest) {
    int expectedHangDurationS1 = 3;
    int expectedHangDurationS2 = 5;
    int expectedHangDurationS3 = 3;
    {
        InSequence s;
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(_))).Times(1);
        EXPECT_CALL(
            logger,
            logMetricEvent(VariantWith<MetricEventUnHang>(
                Field(&MetricEventUnHang::hung_ms, AllOf(Ge(SToMs(expectedHangDurationS1 - 1)),
                                                         Le(SToMs(expectedHangDurationS1 + 1)))))))
            .Times(1);
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(_))).Times(1);
        EXPECT_CALL(
            logger,
            logMetricEvent(VariantWith<MetricEventUnHang>(
                Field(&MetricEventUnHang::hung_ms, AllOf(Ge(SToMs(expectedHangDurationS2 - 1)),
                                                         Le(SToMs(expectedHangDurationS2 + 1)))))))
            .Times(1);
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(_))).Times(1);
        EXPECT_CALL(
            logger,
            logMetricEvent(VariantWith<MetricEventUnHang>(
                Field(&MetricEventUnHang::hung_ms, AllOf(Ge(SToMs(expectedHangDurationS3 - 1)),
                                                         Le(SToMs(expectedHangDurationS3 + 1)))))))
            .Times(1);
    }

    auto id = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    step(defaultHangThresholdS + expectedHangDurationS1);
    healthMonitor.touchMonitoredTask(id);
    step(defaultHangThresholdS + expectedHangDurationS2);
    healthMonitor.touchMonitoredTask(id);
    step(defaultHangThresholdS + expectedHangDurationS3);
    healthMonitor.stopMonitoringTask(id);
}

TEST_F(HealthMonitorTest, multipleHangingTasksTest) {
    {
        InSequence s;
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(
                                Field(&MetricEventHang::otherHungTasks, 0))))
            .Times(1);
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(
                                Field(&MetricEventHang::otherHungTasks, 1))))
            .Times(1);
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(
                                Field(&MetricEventHang::otherHungTasks, 2))))
            .Times(1);
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(
                                Field(&MetricEventHang::otherHungTasks, 3))))
            .Times(1);
    }

    healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    TestClock::advance(0.2);
    healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    TestClock::advance(0.2);
    healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    TestClock::advance(0.2);
    healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    step(defaultHangThresholdS + 1);
}

TEST_F(HealthMonitorTest, oneHangingTaskOutOfTwoTest) {
    EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(_))).Times(1);

    healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    auto id2 = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    step(defaultHangThresholdS - 1);
    healthMonitor.stopMonitoringTask(id2);
    step(2);
}

TEST_F(HealthMonitorTest, twoTasksHangNonOverlappingTest) {
    int expectedHangDurationS1 = 5;
    int hangThresholdS2 = 10;
    int expectedHangDurationS2 = 2;
    {
        InSequence s;
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(_))).Times(1);
        EXPECT_CALL(
            logger,
            logMetricEvent(VariantWith<MetricEventUnHang>(
                Field(&MetricEventUnHang::hung_ms, AllOf(Ge(SToMs(expectedHangDurationS1 - 1)),
                                                         Le(SToMs(expectedHangDurationS1 + 1)))))))
            .Times(1);
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(_))).Times(1);
        EXPECT_CALL(
            logger,
            logMetricEvent(VariantWith<MetricEventUnHang>(
                Field(&MetricEventUnHang::hung_ms, AllOf(Ge(SToMs(expectedHangDurationS2 - 1)),
                                                         Le(SToMs(expectedHangDurationS2 + 1)))))))
            .Times(1);
    }

    auto id = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    step(defaultHangThresholdS + expectedHangDurationS1);
    healthMonitor.stopMonitoringTask(id);
    step(1);
    id = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>(), std::nullopt,
                                           SToMs(hangThresholdS2));
    step(hangThresholdS2 + expectedHangDurationS2);
    healthMonitor.stopMonitoringTask(id);
}

TEST_F(HealthMonitorTest, twoTasksHangOverlappingTest) {
    int expectedHangDurationS1 = 5;
    int expectedHangDurationS2 = 8;
    {
        InSequence s;
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(
                                Field(&MetricEventHang::otherHungTasks, 0))))
            .Times(1);
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(
                                Field(&MetricEventHang::otherHungTasks, 1))))
            .Times(1);
        EXPECT_CALL(
            logger,
            logMetricEvent(VariantWith<MetricEventUnHang>(
                Field(&MetricEventUnHang::hung_ms, AllOf(Ge(SToMs(expectedHangDurationS1 - 1)),
                                                         Le(SToMs(expectedHangDurationS1 + 1)))))))
            .Times(1);
        EXPECT_CALL(
            logger,
            logMetricEvent(VariantWith<MetricEventUnHang>(
                Field(&MetricEventUnHang::hung_ms, AllOf(Ge(SToMs(expectedHangDurationS2 - 1)),
                                                         Le(SToMs(expectedHangDurationS2 + 1)))))))
            .Times(1);
    }

    auto id1 = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    step(3);
    auto id2 = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    step(7);
    healthMonitor.stopMonitoringTask(id1);
    step(5);
    healthMonitor.stopMonitoringTask(id2);
}

TEST_F(HealthMonitorTest, simultaneousTasks) {
    int expectedHangDurationS = 5;
    {
        InSequence s;
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(
                                Field(&MetricEventHang::otherHungTasks, 0))))
            .Times(1);
        EXPECT_CALL(logger, logMetricEvent(VariantWith<MetricEventHang>(
                                Field(&MetricEventHang::otherHungTasks, 1))))
            .Times(1);
        EXPECT_CALL(logger,
                    logMetricEvent(VariantWith<MetricEventUnHang>(Field(
                        &MetricEventUnHang::hung_ms, AllOf(Ge(SToMs(expectedHangDurationS - 1)),
                                                           Le(SToMs(expectedHangDurationS + 1)))))))
            .Times(1);
        EXPECT_CALL(logger,
                    logMetricEvent(VariantWith<MetricEventUnHang>(Field(
                        &MetricEventUnHang::hung_ms, AllOf(Ge(SToMs(expectedHangDurationS - 1)),
                                                           Le(SToMs(expectedHangDurationS + 1)))))))
            .Times(1);
    }
    auto id1 = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    auto id2 = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    step(defaultHangThresholdS + expectedHangDurationS);
    healthMonitor.stopMonitoringTask(id1);
    healthMonitor.stopMonitoringTask(id2);
}

TEST_F(HealthMonitorTest, taskHungWithAttachedCallback) {
    MockFunction<std::unique_ptr<HangAnnotations>()> mockCallback;
    std::unique_ptr<HangAnnotations> testAnnotations = std::make_unique<HangAnnotations>();
    testAnnotations->insert({{"key1", "value1"}, {"key2", "value2"}});
    int expectedHangDurationS = 5;
    {
        InSequence s;
        EXPECT_CALL(mockCallback, Call()).WillOnce(Return(ByMove(std::move(testAnnotations))));
        EXPECT_CALL(logger,
                    logMetricEvent(VariantWith<MetricEventHang>(Field(
                        &MetricEventHang::metadata,
                        Field(&EventHangMetadata::data,
                              Pointee(AllOf(Contains(Key("key1")), Contains(Key("key2")))))))))
            .Times(1);
        EXPECT_CALL(logger,
                    logMetricEvent(VariantWith<MetricEventUnHang>(Field(
                        &MetricEventUnHang::hung_ms, AllOf(Ge(SToMs(expectedHangDurationS - 1)),
                                                           Le(SToMs(expectedHangDurationS + 1)))))))
            .Times(1);
    }
    auto id = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>(),
                                                mockCallback.AsStdFunction());
    step(defaultHangThresholdS + expectedHangDurationS);
    healthMonitor.stopMonitoringTask(id);
}

TEST_F(HealthMonitorTest, healthyTaskWithParent) {
    EXPECT_CALL(logger, logMetricEvent(_)).Times(0);

    auto id = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    step(defaultHangThresholdS - 1);
    auto child = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>(),
                                                   std::nullopt, kDefaultTimeoutMs, id);
    step(defaultHangThresholdS - 1);
    healthMonitor.stopMonitoringTask(child);
    step(defaultHangThresholdS - 1);
    healthMonitor.stopMonitoringTask(id);
}

TEST_F(HealthMonitorTest, threeChainOfHungTasks) {
    {
        InSequence s;
        EXPECT_CALL(logger, logMetricEvent(
                                VariantWith<MetricEventHang>(Field(&MetricEventHang::taskId, 2))))
            .Times(1);
        EXPECT_CALL(logger, logMetricEvent(
                                VariantWith<MetricEventHang>(Field(&MetricEventHang::taskId, 1))))
            .Times(1);
        EXPECT_CALL(logger, logMetricEvent(
                                VariantWith<MetricEventHang>(Field(&MetricEventHang::taskId, 0))))
            .Times(1);
        EXPECT_CALL(
            logger,
            logMetricEvent(VariantWith<MetricEventUnHang>(Field(&MetricEventUnHang::taskId, 2))))
            .Times(1);
        EXPECT_CALL(
            logger,
            logMetricEvent(VariantWith<MetricEventUnHang>(Field(&MetricEventUnHang::taskId, 1))))
            .Times(1);
        EXPECT_CALL(
            logger,
            logMetricEvent(VariantWith<MetricEventUnHang>(Field(&MetricEventUnHang::taskId, 0))))
            .Times(1);
    }

    auto id = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    step(defaultHangThresholdS - 1);
    auto child = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>(),
                                                   std::nullopt, kDefaultTimeoutMs, id);
    step(defaultHangThresholdS - 1);
    auto grandchild = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>(),
                                                        std::nullopt, kDefaultTimeoutMs, child);
    step(defaultHangThresholdS + 1);
    healthMonitor.touchMonitoredTask(grandchild);
    step(1);
    healthMonitor.stopMonitoringTask(grandchild);
    healthMonitor.stopMonitoringTask(child);
    healthMonitor.stopMonitoringTask(id);
}

TEST_F(HealthMonitorTest, parentEndsBeforeChild) {
    {
        InSequence s;
        EXPECT_CALL(logger, logMetricEvent(
                                VariantWith<MetricEventHang>(Field(&MetricEventHang::taskId, 1))))
            .Times(1);
        EXPECT_CALL(
            logger,
            logMetricEvent(VariantWith<MetricEventUnHang>(Field(&MetricEventUnHang::taskId, 1))))
            .Times(1);
    }

    auto id = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    step(defaultHangThresholdS - 1);
    auto child = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>(),
                                                   std::nullopt, kDefaultTimeoutMs, id);
    healthMonitor.stopMonitoringTask(id);
    step(defaultHangThresholdS + 1);
    healthMonitor.stopMonitoringTask(child);
}

TEST_F(HealthMonitorTest, siblingsHangParentStillHealthy) {
    {
        InSequence s;
        EXPECT_CALL(logger, logMetricEvent(
                                VariantWith<MetricEventHang>(Field(&MetricEventHang::taskId, 1))))
            .Times(1);
        EXPECT_CALL(
            logger,
            logMetricEvent(VariantWith<MetricEventUnHang>(Field(&MetricEventUnHang::taskId, 1))))
            .Times(1);
        EXPECT_CALL(logger, logMetricEvent(
                                VariantWith<MetricEventHang>(Field(&MetricEventHang::taskId, 2))))
            .Times(1);
        EXPECT_CALL(
            logger,
            logMetricEvent(VariantWith<MetricEventUnHang>(Field(&MetricEventUnHang::taskId, 2))))
            .Times(1);
    }

    auto parent = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>());
    step(defaultHangThresholdS - 1);
    /* 1 */ auto child = healthMonitor.startMonitoringTask(std::make_unique<EventHangMetadata>(),
                                                           std::nullopt, kDefaultTimeoutMs, parent);
    step(defaultHangThresholdS - 1);
    /* 2 */ auto secondChild = healthMonitor.startMonitoringTask(
        std::make_unique<EventHangMetadata>(), std::nullopt, kDefaultTimeoutMs, parent);
    step(2);
    healthMonitor.stopMonitoringTask(child);
    step(defaultHangThresholdS - 1);
    healthMonitor.stopMonitoringTask(secondChild);
    healthMonitor.stopMonitoringTask(parent);
}

class MockHealthMonitor {
   public:
    using Id = uint32_t;
    MOCK_METHOD(
        Id, startMonitoringTask,
        (std::unique_ptr<EventHangMetadata> metadata,
         std::optional<std::function<std::unique_ptr<HangAnnotations>()>> onHangAnnotationsCallback,
         uint64_t timeout, std::optional<Id>));

    MOCK_METHOD(void, touchMonitoredTask, (Id));
    MOCK_METHOD(void, stopMonitoringTask, (Id));
};

TEST(HealthMonitorWatchdogBuilderTest, NullPointerTest) {
    const char message[] = "test message";
    MockHealthMonitor* monitor = nullptr;
    auto builder = WATCHDOG_BUILDER(monitor, message);
    auto watchdog = builder.build();
    EXPECT_EQ(watchdog->release(), std::nullopt);
}

TEST(HealthMonitorWatchdogBuilderTest, NullPointerCallbackTest) {
    const char message[] = "test message";
    MockFunction<std::unique_ptr<HangAnnotations>()> mockOnHangCallback;
    MockHealthMonitor* monitor = nullptr;
    WATCHDOG_BUILDER(monitor, "test message")
        .setOnHangCallback(mockOnHangCallback.AsStdFunction())
        .build();
    EXPECT_CALL(mockOnHangCallback, Call()).Times(0);
}

TEST(HealthMonitorWatchdogBuilderTest, SimpleBuildTest) {
    // Test simple build function and default values.
    MockHealthMonitor monitor;
    MockHealthMonitor::Id taskId = 0x8261;

    const char message[] = "test message";
    const int lineLowerBound = __LINE__;
    auto builder = WATCHDOG_BUILDER(&monitor, message);
    const int lineUpperBound = __LINE__;
    auto metadataMatcher = AllOf(
        Pointee(Field(&EventHangMetadata::file, StrEq(__FILE__))),
        Pointee(Field(&EventHangMetadata::function, StrEq(__func__))),
        Pointee(Field(&EventHangMetadata::msg, StrEq(message))),
        Pointee(Field(&EventHangMetadata::line, AllOf(Ge(lineLowerBound), Le(lineUpperBound)))),
        Pointee(Field(&EventHangMetadata::threadId, android::base::getCurrentThreadId())),
        Pointee(Field(&EventHangMetadata::data, IsNull())),
        Pointee(Field(&EventHangMetadata::hangType, EventHangMetadata::HangType::kOther)));
    EXPECT_CALL(monitor,
                startMonitoringTask(metadataMatcher, Eq(std::nullopt), kDefaultTimeoutMs, _))
        .Times(1)
        .WillOnce(Return(taskId));
    EXPECT_CALL(monitor, stopMonitoringTask(taskId)).Times(1);
    builder.build();
}

// Test different setters.
TEST(HealthMonitorWatchdogBuilderTest, HangTypeTest) {
    MockHealthMonitor monitor;
    MockHealthMonitor::Id taskId = 0x7213;

    auto hangType = EventHangMetadata::HangType::kRenderThread;
    EXPECT_CALL(monitor, startMonitoringTask(Pointee(Field(&EventHangMetadata::hangType, hangType)),
                                             Eq(std::nullopt), kDefaultTimeoutMs, _))
        .Times(1)
        .WillOnce(Return(taskId));
    EXPECT_CALL(monitor, stopMonitoringTask(taskId)).Times(1);
    WATCHDOG_BUILDER(&monitor, "test message")
        .setHangType(EventHangMetadata::HangType::kRenderThread)
        .build();
}

TEST(HealthMonitorWatchdogBuilderTest, TimeoutTest) {
    MockHealthMonitor monitor;
    MockHealthMonitor::Id taskId = 0x8749;
    uint32_t timeoutMs = 5483;

    EXPECT_CALL(monitor, startMonitoringTask(_, Eq(std::nullopt), timeoutMs, _))
        .Times(1)
        .WillOnce(Return(taskId));
    EXPECT_CALL(monitor, stopMonitoringTask(taskId)).Times(1);
    WATCHDOG_BUILDER(&monitor, "test message").setTimeoutMs(timeoutMs).build();
}

TEST(HealthMonitorWatchdogBuilderTest, OnHangCallbackTest) {
    MockHealthMonitor monitor;
    MockHealthMonitor::Id taskId = 0x2810;

    MockFunction<std::unique_ptr<HangAnnotations>()> mockOnHangCallback;
    std::optional<std::function<std::unique_ptr<HangAnnotations>()>> actualOnHangCallback;

    EXPECT_CALL(monitor, startMonitoringTask(_, Ne(std::nullopt), kDefaultTimeoutMs, _))
        .Times(1)
        .WillOnce(DoAll(SaveArg<1>(&actualOnHangCallback), Return(taskId)));
    EXPECT_CALL(monitor, stopMonitoringTask(taskId)).Times(1);
    WATCHDOG_BUILDER(&monitor, "test message")
        .setOnHangCallback(mockOnHangCallback.AsStdFunction())
        .build();
    EXPECT_CALL(mockOnHangCallback, Call()).Times(1);
    (*actualOnHangCallback)();
}

TEST(HealthMonitorWatchdogBuilderTest, AnnotationsTest) {
    MockHealthMonitor monitor;
    MockHealthMonitor::Id taskId = 0x9271;

    const char tag[] = "abcxyzalwi1943====";
    auto annotations = std::make_unique<HangAnnotations>();
    annotations->insert({{"tag", tag}});

    EXPECT_CALL(monitor, startMonitoringTask(
                             Pointee(Field(&EventHangMetadata::data,
                                           Pointee(Contains(Pair(StrEq("tag"), StrEq(tag)))))),
                             Eq(std::nullopt), kDefaultTimeoutMs, _))
        .Times(1)
        .WillOnce(Return(taskId));
    EXPECT_CALL(monitor, stopMonitoringTask(taskId)).Times(1);
    WATCHDOG_BUILDER(&monitor, "test message").setAnnotations(std::move(annotations)).build();
}

TEST(HealthMonitorWatchdogBuilderTest, MultipleSettersTest) {
    // Set multiple fields with chaining.
    MockHealthMonitor monitor;
    MockHealthMonitor::Id taskId = 0x9271;

    uint32_t timeoutMs = 5483;
    auto hangType = EventHangMetadata::HangType::kSyncThread;

    EXPECT_CALL(monitor, startMonitoringTask(Pointee(Field(&EventHangMetadata::hangType, hangType)),
                                             Eq(std::nullopt), timeoutMs, _))
        .Times(1)
        .WillOnce(Return(taskId));
    EXPECT_CALL(monitor, stopMonitoringTask(taskId)).Times(1);
    WATCHDOG_BUILDER(&monitor, "test message")
        .setHangType(hangType)
        .setTimeoutMs(timeoutMs)
        .build();
}

TEST(HealthMonitorWatchdogTest, ReleaseTest) {
    MockHealthMonitor monitor;
    MockHealthMonitor::Id taskId = 0x8271;
    EXPECT_CALL(monitor, startMonitoringTask(_, Eq(std::nullopt), kDefaultTimeoutMs, _))
        .Times(1)
        .WillOnce(Return(taskId));

    auto watchdog = WATCHDOG_BUILDER(&monitor, "test message").build();
    EXPECT_THAT(watchdog->release(), Optional(taskId));
    EXPECT_EQ(watchdog->release(), std::nullopt);

    EXPECT_CALL(monitor, stopMonitoringTask(_)).Times(0);
}

}  // namespace emugl