// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <stdint.h>

#include "chrome/browser/task_manager/test_task_manager.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace task_manager {

namespace {

// Defines a concrete observer that will be used for testing.
class TestObserver : public TaskManagerObserver {
 public:
  TestObserver(base::TimeDelta refresh_time, int64_t resources_flags)
      : TaskManagerObserver(refresh_time, resources_flags) {}

  TestObserver(const TestObserver&) = delete;
  TestObserver& operator=(const TestObserver&) = delete;
  ~TestObserver() override = default;

  // Expose protected mutators for testing.
  using TaskManagerObserver::AddRefreshType;
  using TaskManagerObserver::RemoveRefreshType;
  using TaskManagerObserver::SetRefreshTypesFlags;

  // task_manager::TaskManagerObserver:
  void OnTaskAdded(TaskId id) override {}
  void OnTaskToBeRemoved(TaskId id) override {}
  void OnTasksRefreshed(const TaskIdList& task_ids) override {}
};

// Defines a test to validate the behavior of the task manager in response to
// adding and removing different kind of observers.
class TaskManagerObserverTest : public testing::Test {
 public:
  TaskManagerObserverTest() = default;
  TaskManagerObserverTest(const TaskManagerObserverTest&) = delete;
  TaskManagerObserverTest& operator=(const TaskManagerObserverTest&) = delete;
  ~TaskManagerObserverTest() override = default;

  TestTaskManager& task_manager() { return task_manager_; }

 private:
  TestTaskManager task_manager_;
};

}  // namespace

// Validates that the minimum refresh time to be requested is one second. Also
// validates the desired resource flags.
TEST_F(TaskManagerObserverTest, Basic) {
  base::TimeDelta refresh_time1 = base::Seconds(2);
  base::TimeDelta refresh_time2 = base::Milliseconds(999);
  int64_t flags1 = RefreshType::REFRESH_TYPE_CPU |
                   RefreshType::REFRESH_TYPE_WEBCACHE_STATS |
                   RefreshType::REFRESH_TYPE_HANDLES;
  int64_t flags2 = RefreshType::REFRESH_TYPE_MEMORY_FOOTPRINT;

  TestObserver observer1(refresh_time1, flags1);
  TestObserver observer2(refresh_time2, flags2);

  EXPECT_EQ(refresh_time1, observer1.desired_refresh_time());
  EXPECT_EQ(base::Seconds(1), observer2.desired_refresh_time());
  EXPECT_EQ(flags1, observer1.desired_resources_flags());
  EXPECT_EQ(flags2, observer2.desired_resources_flags());
}

TEST_F(TaskManagerObserverTest, IsResourceRefreshEnabled) {
  const int flags =
      RefreshType::REFRESH_TYPE_CPU | RefreshType::REFRESH_TYPE_HANDLES;
  EXPECT_TRUE(
      TaskManagerObserver::IsResourceRefreshEnabled(REFRESH_TYPE_CPU, flags));
  EXPECT_TRUE(TaskManagerObserver::IsResourceRefreshEnabled(
      REFRESH_TYPE_HANDLES, flags));
  EXPECT_FALSE(
      TaskManagerObserver::IsResourceRefreshEnabled(REFRESH_TYPE_NONE, flags));
  // All non-set bits should evaluate to false.
  EXPECT_FALSE(TaskManagerObserver::IsResourceRefreshEnabled(
      static_cast<RefreshType>(~flags), flags));
}

TEST_F(TaskManagerObserverTest, AddRefreshType) {
  const int64_t initial_flags = RefreshType::REFRESH_TYPE_CPU;
  TestObserver observer(base::Seconds(2), initial_flags);

  task_manager().AddObserver(&observer);
  EXPECT_EQ(initial_flags, task_manager().GetEnabledFlags());

  observer.AddRefreshType(REFRESH_TYPE_GPU_MEMORY);
  EXPECT_EQ(initial_flags | REFRESH_TYPE_GPU_MEMORY,
            task_manager().GetEnabledFlags());

  task_manager().RemoveObserver(&observer);
}

TEST_F(TaskManagerObserverTest, RemoveRefreshType) {
  const int64_t initial_flags =
      RefreshType::REFRESH_TYPE_CPU | RefreshType::REFRESH_TYPE_HANDLES;
  TestObserver observer(base::Seconds(2), initial_flags);

  task_manager().AddObserver(&observer);
  EXPECT_EQ(initial_flags, task_manager().GetEnabledFlags());

  observer.RemoveRefreshType(REFRESH_TYPE_HANDLES);
  EXPECT_EQ(static_cast<int64_t>(REFRESH_TYPE_CPU),
            task_manager().GetEnabledFlags());

  task_manager().RemoveObserver(&observer);
}

TEST_F(TaskManagerObserverTest, SetRefreshTypesFlags) {
  const int64_t initial_flags = RefreshType::REFRESH_TYPE_CPU;
  TestObserver observer(base::Seconds(2), initial_flags);

  task_manager().AddObserver(&observer);
  EXPECT_EQ(initial_flags, task_manager().GetEnabledFlags());

  const int64_t new_flags =
      RefreshType::REFRESH_TYPE_V8_MEMORY | RefreshType::REFRESH_TYPE_HANDLES;
  observer.SetRefreshTypesFlags(new_flags);
  EXPECT_EQ(new_flags, task_manager().GetEnabledFlags());

  task_manager().RemoveObserver(&observer);
}

TEST_F(TaskManagerObserverTest, AddRefreshTypeDuplicate) {
  const int64_t initial_flags = RefreshType::REFRESH_TYPE_CPU;
  TestObserver observer(base::Seconds(2), initial_flags);

  task_manager().AddObserver(&observer);
  observer.AddRefreshType(REFRESH_TYPE_CPU);
  EXPECT_EQ(initial_flags, task_manager().GetEnabledFlags());

  task_manager().RemoveObserver(&observer);
}

TEST_F(TaskManagerObserverTest, RemoveRefreshTypeNotSet) {
  const int64_t initial_flags = RefreshType::REFRESH_TYPE_CPU;
  TestObserver observer(base::Seconds(2), initial_flags);

  task_manager().AddObserver(&observer);
  observer.RemoveRefreshType(REFRESH_TYPE_GPU_MEMORY);
  EXPECT_EQ(initial_flags, task_manager().GetEnabledFlags());

  task_manager().RemoveObserver(&observer);
}

TEST_F(TaskManagerObserverTest, DestructorAutoRemoves) {
  {
    TestObserver observer(base::Seconds(2), RefreshType::REFRESH_TYPE_CPU);
    task_manager().AddObserver(&observer);
    EXPECT_NE(base::TimeDelta::Max(), task_manager().GetRefreshTime());
    EXPECT_NE(0, task_manager().GetEnabledFlags());
  }
  EXPECT_EQ(base::TimeDelta::Max(), task_manager().GetRefreshTime());
  EXPECT_EQ(0, task_manager().GetEnabledFlags());
}

// Validates the behavior of the task manager in response to adding and
// removing observers.
TEST_F(TaskManagerObserverTest, TaskManagerResponseToObservers) {
  EXPECT_EQ(base::TimeDelta::Max(), task_manager().GetRefreshTime());
  EXPECT_EQ(0, task_manager().GetEnabledFlags());

  // Add a bunch of observers and make sure the task manager responds correctly.
  base::TimeDelta refresh_time1 = base::Seconds(3);
  base::TimeDelta refresh_time2 = base::Seconds(10);
  base::TimeDelta refresh_time3 = base::Seconds(3);
  base::TimeDelta refresh_time4 = base::Seconds(2);
  int64_t flags1 = RefreshType::REFRESH_TYPE_CPU |
                   RefreshType::REFRESH_TYPE_WEBCACHE_STATS |
                   RefreshType::REFRESH_TYPE_HANDLES;
  int64_t flags2 = RefreshType::REFRESH_TYPE_MEMORY_FOOTPRINT;
  int64_t flags3 = RefreshType::REFRESH_TYPE_MEMORY_FOOTPRINT |
                   RefreshType::REFRESH_TYPE_CPU;
  int64_t flags4 = RefreshType::REFRESH_TYPE_GPU_MEMORY;

  TestObserver observer1(refresh_time1, flags1);
  TestObserver observer2(refresh_time2, flags2);
  TestObserver observer3(refresh_time3, flags3);
  TestObserver observer4(refresh_time4, flags4);

  task_manager().AddObserver(&observer1);
  task_manager().AddObserver(&observer2);
  task_manager().AddObserver(&observer3);
  task_manager().AddObserver(&observer4);

  EXPECT_EQ(refresh_time4, task_manager().GetRefreshTime());
  EXPECT_EQ(flags1 | flags2 | flags3 | flags4,
            task_manager().GetEnabledFlags());

  // Removing observers should also reflect on the refresh time and resource
  // flags.
  task_manager().RemoveObserver(&observer4);
  EXPECT_EQ(refresh_time3, task_manager().GetRefreshTime());
  EXPECT_EQ(flags1 | flags2 | flags3, task_manager().GetEnabledFlags());
  task_manager().RemoveObserver(&observer3);
  EXPECT_EQ(refresh_time1, task_manager().GetRefreshTime());
  EXPECT_EQ(flags1 | flags2, task_manager().GetEnabledFlags());
  task_manager().RemoveObserver(&observer2);
  EXPECT_EQ(refresh_time1, task_manager().GetRefreshTime());
  EXPECT_EQ(flags1, task_manager().GetEnabledFlags());
  task_manager().RemoveObserver(&observer1);
  EXPECT_EQ(base::TimeDelta::Max(), task_manager().GetRefreshTime());
  EXPECT_EQ(0, task_manager().GetEnabledFlags());
}

}  // namespace task_manager