blob: fe40ce584cc72f2ec63ab622dd1486bd8e54550b [file] [log] [blame]
//
// Copyright (C) 2014 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 "update_engine/update_manager/variable.h"
#include <vector>
#include <brillo/message_loops/fake_message_loop.h>
#include <brillo/message_loops/message_loop.h>
#include <brillo/message_loops/message_loop_utils.h>
#include <gtest/gtest.h>
using base::TimeDelta;
using brillo::MessageLoop;
using brillo::MessageLoopRunMaxIterations;
using std::string;
using std::vector;
namespace chromeos_update_manager {
// Variable class that returns a value constructed with the default value.
template <typename T>
class DefaultVariable : public Variable<T> {
public:
DefaultVariable(const string& name, VariableMode mode)
: Variable<T>(name, mode) {}
DefaultVariable(const string& name, const TimeDelta& poll_interval)
: Variable<T>(name, poll_interval) {}
~DefaultVariable() override {}
protected:
const T* GetValue(TimeDelta /* timeout */, string* /* errmsg */) override {
return new T();
}
private:
DISALLOW_COPY_AND_ASSIGN(DefaultVariable);
};
class UmBaseVariableTest : public ::testing::Test {
protected:
void SetUp() override { loop_.SetAsCurrent(); }
brillo::FakeMessageLoop loop_{nullptr};
};
TEST_F(UmBaseVariableTest, GetNameTest) {
DefaultVariable<int> var("var", kVariableModeConst);
EXPECT_EQ(var.GetName(), string("var"));
}
TEST_F(UmBaseVariableTest, GetModeTest) {
DefaultVariable<int> var("var", kVariableModeConst);
EXPECT_EQ(var.GetMode(), kVariableModeConst);
DefaultVariable<int> other_var("other_var", kVariableModePoll);
EXPECT_EQ(other_var.GetMode(), kVariableModePoll);
}
TEST_F(UmBaseVariableTest, DefaultPollIntervalTest) {
DefaultVariable<int> const_var("const_var", kVariableModeConst);
EXPECT_EQ(const_var.GetPollInterval(), TimeDelta());
DefaultVariable<int> poll_var("poll_var", kVariableModePoll);
EXPECT_EQ(poll_var.GetPollInterval(), TimeDelta::FromMinutes(5));
}
TEST_F(UmBaseVariableTest, GetPollIntervalTest) {
DefaultVariable<int> var("var", TimeDelta::FromMinutes(3));
EXPECT_EQ(var.GetMode(), kVariableModePoll);
EXPECT_EQ(var.GetPollInterval(), TimeDelta::FromMinutes(3));
}
class BaseVariableObserver : public BaseVariable::ObserverInterface {
public:
void ValueChanged(BaseVariable* variable) { calls_.push_back(variable); }
// List of called functions.
vector<BaseVariable*> calls_;
};
TEST_F(UmBaseVariableTest, RepeatedObserverTest) {
DefaultVariable<int> var("var", kVariableModeAsync);
BaseVariableObserver observer;
var.AddObserver(&observer);
EXPECT_EQ(1U, var.observer_list_.size());
var.AddObserver(&observer);
EXPECT_EQ(1U, var.observer_list_.size());
var.RemoveObserver(&observer);
EXPECT_EQ(0U, var.observer_list_.size());
var.RemoveObserver(&observer);
EXPECT_EQ(0U, var.observer_list_.size());
}
TEST_F(UmBaseVariableTest, NotifyValueChangedTest) {
DefaultVariable<int> var("var", kVariableModeAsync);
BaseVariableObserver observer1;
var.AddObserver(&observer1);
// Simulate a value change on the variable's implementation.
var.NotifyValueChanged();
ASSERT_EQ(0U, observer1.calls_.size());
MessageLoopRunMaxIterations(MessageLoop::current(), 100);
ASSERT_EQ(1U, observer1.calls_.size());
// Check that the observer is called with the right argument.
EXPECT_EQ(&var, observer1.calls_[0]);
BaseVariableObserver observer2;
var.AddObserver(&observer2);
var.NotifyValueChanged();
MessageLoopRunMaxIterations(MessageLoop::current(), 100);
// Check that all the observers are called.
EXPECT_EQ(2U, observer1.calls_.size());
EXPECT_EQ(1U, observer2.calls_.size());
var.RemoveObserver(&observer1);
var.RemoveObserver(&observer2);
}
class BaseVariableObserverRemover : public BaseVariable::ObserverInterface {
public:
BaseVariableObserverRemover() : calls_(0) {}
void ValueChanged(BaseVariable* variable) override {
for (auto& observer : remove_observers_) {
variable->RemoveObserver(observer);
}
calls_++;
}
void OnCallRemoveObserver(BaseVariable::ObserverInterface* observer) {
remove_observers_.push_back(observer);
}
int get_calls() { return calls_; }
private:
vector<BaseVariable::ObserverInterface*> remove_observers_;
int calls_;
};
// Tests that we can remove an observer from a Variable on the ValueChanged()
// call to that observer.
TEST_F(UmBaseVariableTest, NotifyValueRemovesObserversTest) {
DefaultVariable<int> var("var", kVariableModeAsync);
BaseVariableObserverRemover observer1;
BaseVariableObserverRemover observer2;
var.AddObserver(&observer1);
var.AddObserver(&observer2);
// Make each observer remove both observers on ValueChanged.
observer1.OnCallRemoveObserver(&observer1);
observer1.OnCallRemoveObserver(&observer2);
observer2.OnCallRemoveObserver(&observer1);
observer2.OnCallRemoveObserver(&observer2);
var.NotifyValueChanged();
MessageLoopRunMaxIterations(MessageLoop::current(), 100);
EXPECT_EQ(1, observer1.get_calls() + observer2.get_calls());
}
} // namespace chromeos_update_manager