ash/system/power/backlights_forced_off_setter_unittest.cc

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

#include "ash/system/power/backlights_forced_off_setter.h"

#include <memory>
#include <utility>
#include <vector>

#include "ash/system/power/scoped_backlights_forced_off.h"
#include "ash/test/ash_test_base.h"
#include "base/macros.h"
#include "base/scoped_observer.h"
#include "chromeos/dbus/dbus_thread_manager.h"
#include "chromeos/dbus/fake_power_manager_client.h"

namespace ash {

namespace {

class TestObserver : public BacklightsForcedOffSetter::Observer {
 public:
  explicit TestObserver(BacklightsForcedOffSetter* backlights_forced_off_setter)
      : backlights_forced_off_setter_(backlights_forced_off_setter),
        scoped_observer_(this) {
    scoped_observer_.Add(backlights_forced_off_setter);
  }

  ~TestObserver() override = default;

  const std::vector<bool>& forced_off_states() const {
    return forced_off_states_;
  }

  void ClearForcedOffStates() { forced_off_states_.clear(); }

  // BacklightsForcedOffSetter::Observer:
  void OnBacklightsForcedOffChanged(bool backlights_forced_off) override {
    ASSERT_EQ(backlights_forced_off,
              backlights_forced_off_setter_->backlights_forced_off());
    forced_off_states_.push_back(backlights_forced_off);
  }

 private:
  BacklightsForcedOffSetter* const backlights_forced_off_setter_;

  std::vector<bool> forced_off_states_;

  ScopedObserver<BacklightsForcedOffSetter, BacklightsForcedOffSetter::Observer>
      scoped_observer_;

  DISALLOW_COPY_AND_ASSIGN(TestObserver);
};

}  // namespace

class BacklightsForcedOffSetterTest : public AshTestBase {
 public:
  BacklightsForcedOffSetterTest() = default;
  ~BacklightsForcedOffSetterTest() override = default;

  void SetUp() override {
    auto power_manager_client =
        std::make_unique<chromeos::FakePowerManagerClient>();
    power_manager_client_ = power_manager_client.get();
    chromeos::DBusThreadManager::GetSetterForTesting()->SetPowerManagerClient(
        std::move(power_manager_client));

    AshTestBase::SetUp();

    backlights_forced_off_setter_ =
        std::make_unique<BacklightsForcedOffSetter>();
    backlights_forced_off_observer_ =
        std::make_unique<TestObserver>(backlights_forced_off_setter_.get());
  }

  void TearDown() override {
    backlights_forced_off_observer_.reset();
    backlights_forced_off_setter_.reset();
    AshTestBase::TearDown();
  }

  void ResetBacklightsForcedOffSetter() {
    backlights_forced_off_observer_.reset();
    backlights_forced_off_setter_.reset();
  }

 protected:
  // Owned by DBusThreadManager.
  chromeos::FakePowerManagerClient* power_manager_client_ = nullptr;

  std::unique_ptr<BacklightsForcedOffSetter> backlights_forced_off_setter_;
  std::unique_ptr<TestObserver> backlights_forced_off_observer_;

 private:
  DISALLOW_COPY_AND_ASSIGN(BacklightsForcedOffSetterTest);
};

TEST_F(BacklightsForcedOffSetterTest, SingleForcedOffRequest) {
  ASSERT_FALSE(power_manager_client_->backlights_forced_off());

  std::unique_ptr<ScopedBacklightsForcedOff> scoped_forced_off =
      backlights_forced_off_setter_->ForceBacklightsOff();

  EXPECT_TRUE(power_manager_client_->backlights_forced_off());
  EXPECT_EQ(std::vector<bool>({true}),
            backlights_forced_off_observer_->forced_off_states());
  backlights_forced_off_observer_->ClearForcedOffStates();

  scoped_forced_off.reset();

  EXPECT_FALSE(power_manager_client_->backlights_forced_off());
  EXPECT_EQ(std::vector<bool>({false}),
            backlights_forced_off_observer_->forced_off_states());
}

TEST_F(BacklightsForcedOffSetterTest, BacklightsForcedOffSetterDeleted) {
  ASSERT_FALSE(power_manager_client_->backlights_forced_off());

  std::unique_ptr<ScopedBacklightsForcedOff> scoped_forced_off =
      backlights_forced_off_setter_->ForceBacklightsOff();

  EXPECT_TRUE(power_manager_client_->backlights_forced_off());
  EXPECT_EQ(std::vector<bool>({true}),
            backlights_forced_off_observer_->forced_off_states());
  backlights_forced_off_observer_->ClearForcedOffStates();

  ResetBacklightsForcedOffSetter();

  EXPECT_FALSE(power_manager_client_->backlights_forced_off());

  // Verify that deleting scoped forced off request does not affect
  // power manager state (nor cause a crash).
  scoped_forced_off.reset();
  EXPECT_FALSE(power_manager_client_->backlights_forced_off());
}

TEST_F(BacklightsForcedOffSetterTest,
       OverlappingRequests_SecondRequestResetFirst) {
  ASSERT_FALSE(power_manager_client_->backlights_forced_off());

  std::unique_ptr<ScopedBacklightsForcedOff> scoped_forced_off_1 =
      backlights_forced_off_setter_->ForceBacklightsOff();

  EXPECT_TRUE(power_manager_client_->backlights_forced_off());
  EXPECT_EQ(std::vector<bool>({true}),
            backlights_forced_off_observer_->forced_off_states());
  backlights_forced_off_observer_->ClearForcedOffStates();

  std::unique_ptr<ScopedBacklightsForcedOff> scoped_forced_off_2 =
      backlights_forced_off_setter_->ForceBacklightsOff();

  EXPECT_TRUE(power_manager_client_->backlights_forced_off());
  EXPECT_TRUE(backlights_forced_off_observer_->forced_off_states().empty());

  scoped_forced_off_2.reset();

  EXPECT_TRUE(power_manager_client_->backlights_forced_off());
  EXPECT_TRUE(backlights_forced_off_observer_->forced_off_states().empty());

  scoped_forced_off_1.reset();

  EXPECT_FALSE(power_manager_client_->backlights_forced_off());
  EXPECT_EQ(std::vector<bool>({false}),
            backlights_forced_off_observer_->forced_off_states());
}

TEST_F(BacklightsForcedOffSetterTest,
       OverlappingRequests_FirstRequestResetFirst) {
  ASSERT_FALSE(power_manager_client_->backlights_forced_off());

  std::unique_ptr<ScopedBacklightsForcedOff> scoped_forced_off_1 =
      backlights_forced_off_setter_->ForceBacklightsOff();

  EXPECT_TRUE(power_manager_client_->backlights_forced_off());
  EXPECT_EQ(std::vector<bool>({true}),
            backlights_forced_off_observer_->forced_off_states());
  backlights_forced_off_observer_->ClearForcedOffStates();

  std::unique_ptr<ScopedBacklightsForcedOff> scoped_forced_off_2 =
      backlights_forced_off_setter_->ForceBacklightsOff();

  EXPECT_TRUE(power_manager_client_->backlights_forced_off());
  EXPECT_TRUE(backlights_forced_off_observer_->forced_off_states().empty());

  scoped_forced_off_1.reset();

  EXPECT_TRUE(backlights_forced_off_observer_->forced_off_states().empty());

  scoped_forced_off_2.reset();

  EXPECT_FALSE(power_manager_client_->backlights_forced_off());
  EXPECT_EQ(std::vector<bool>({false}),
            backlights_forced_off_observer_->forced_off_states());
}

}  // namespace ash