PM: Move Variable content testing logic into a common unittest module.
Testing the content of variables is done frequently when testing various
providers. This results in plenty of boilerplate code, as well as
numerous friend declarations in the different FooVariable class
definitions.
This CL introduces a PmTestUtils helper class providing common Variable
testing methods that test fixtures can use.
BUG=chromium:366259
TEST=Unit tests.
Change-Id: I7bb1cea080c3b79c203607550259f4c277e84f3b
Reviewed-on: https://chromium-review.googlesource.com/196529
Tested-by: Gilad Arnold <garnold@chromium.org>
Reviewed-by: Alex Deymo <deymo@chromium.org>
Commit-Queue: Gilad Arnold <garnold@chromium.org>
diff --git a/policy_manager/generic_variables.h b/policy_manager/generic_variables.h
index 9110c9a..5309519 100644
--- a/policy_manager/generic_variables.h
+++ b/policy_manager/generic_variables.h
@@ -69,9 +69,7 @@
: CopyVariable(name, poll_interval, ref, nullptr) {}
protected:
- friend class PmCopyVariableTest;
FRIEND_TEST(PmCopyVariableTest, SimpleTest);
- FRIEND_TEST(PmCopyVariableTest, SetFlagTest);
FRIEND_TEST(PmCopyVariableTest, UseCopyConstructorTest);
// Variable override.
@@ -109,9 +107,6 @@
: Variable<T>(name, kVariableModeConst), obj_(obj) {}
protected:
- friend class PmConstCopyVariableTest;
- FRIEND_TEST(PmConstCopyVariableTest, SimpleTest);
-
// Variable override.
virtual const T* GetValue(base::TimeDelta /* timeout */,
std::string* /* errmsg */) {
@@ -156,11 +151,6 @@
}
protected:
- friend class PmAsyncCopyVariableTest;
- FRIEND_TEST(PmAsyncCopyVariableTest, ConstructorTest);
- FRIEND_TEST(PmAsyncCopyVariableTest, SetValueTest);
- FRIEND_TEST(PmAsyncCopyVariableTest, UnsetValueTest);
-
// Variable override.
virtual const T* GetValue(base::TimeDelta /* timeout */,
std::string* errmsg) {
diff --git a/policy_manager/generic_variables_unittest.cc b/policy_manager/generic_variables_unittest.cc
index 490f949..8aad753 100644
--- a/policy_manager/generic_variables_unittest.cc
+++ b/policy_manager/generic_variables_unittest.cc
@@ -15,10 +15,7 @@
namespace chromeos_policy_manager {
-class PmCopyVariableTest : public ::testing::Test {
- protected:
- TimeDelta default_timeout_ = TimeDelta::FromSeconds(1);
-};
+class PmCopyVariableTest : public ::testing::Test {};
TEST_F(PmCopyVariableTest, SimpleTest) {
@@ -27,7 +24,8 @@
CopyVariable<int> var("var", kVariableModePoll, source);
// Generate and validate a copy.
- scoped_ptr<const int> copy_1(var.GetValue(default_timeout_, NULL));
+ scoped_ptr<const int> copy_1(var.GetValue(
+ PmTestUtils::DefaultTimeout(), NULL));
PMTEST_ASSERT_NOT_NULL(copy_1.get());
EXPECT_EQ(5, *copy_1);
@@ -38,9 +36,7 @@
EXPECT_EQ(5, *copy_1);
// Generate and validate a second copy.
- scoped_ptr<const int> copy_2(var.GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(copy_2.get());
- EXPECT_EQ(42, *copy_2);
+ PmTestUtils::ExpectVariableHasValue(42, &var);
}
TEST_F(PmCopyVariableTest, SetFlagTest) {
@@ -50,13 +46,11 @@
CopyVariable<int> var("var", kVariableModePoll, source, &is_set);
// Flag marked unset, nothing should be returned.
- PMTEST_ASSERT_NULL(var.GetValue(default_timeout_, NULL));
+ PmTestUtils::ExpectVariableNotSet(&var);
// Flag marked set, we should be getting a value.
is_set = true;
- scoped_ptr<const int> copy(var.GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(copy.get());
- EXPECT_EQ(5, *copy);
+ PmTestUtils::ExpectVariableHasValue(5, &var);
}
@@ -78,29 +72,22 @@
CopyVariable<CopyConstructorTestClass> var("var", kVariableModePoll, source);
scoped_ptr<const CopyConstructorTestClass> copy(
- var.GetValue(default_timeout_, NULL));
+ var.GetValue(PmTestUtils::DefaultTimeout(), NULL));
PMTEST_ASSERT_NOT_NULL(copy.get());
EXPECT_TRUE(copy->copied_);
}
-class PmConstCopyVariableTest : public ::testing::Test {
- protected:
- TimeDelta default_timeout_ = TimeDelta::FromSeconds(1);
-};
+class PmConstCopyVariableTest : public ::testing::Test {};
TEST_F(PmConstCopyVariableTest, SimpleTest) {
int source = 5;
ConstCopyVariable<int> var("var", source);
- scoped_ptr<const int> copy(var.GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(copy.get());
- EXPECT_EQ(5, *copy);
+ PmTestUtils::ExpectVariableHasValue(5, &var);
// Ensure the value is cached.
source = 42;
- copy.reset(var.GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(copy.get());
- EXPECT_EQ(5, *copy);
+ PmTestUtils::ExpectVariableHasValue(5, &var);
}
@@ -110,23 +97,18 @@
// No remaining event on the main loop.
EXPECT_EQ(0, RunGMainLoopMaxIterations(1));
}
-
- protected:
- TimeDelta default_timeout_ = TimeDelta::FromSeconds(1);
};
TEST_F(PmAsyncCopyVariableTest, ConstructorTest) {
AsyncCopyVariable<int> var("var");
- PMTEST_EXPECT_NULL(var.GetValue(default_timeout_, NULL));
+ PmTestUtils::ExpectVariableNotSet(&var);
EXPECT_EQ(kVariableModeAsync, var.GetMode());
}
TEST_F(PmAsyncCopyVariableTest, SetValueTest) {
AsyncCopyVariable<int> var("var");
var.SetValue(5);
- scoped_ptr<const int> copy(var.GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(copy.get());
- EXPECT_EQ(5, *copy);
+ PmTestUtils::ExpectVariableHasValue(5, &var);
// Execute all the pending observers.
RunGMainLoopMaxIterations(100);
}
@@ -134,7 +116,7 @@
TEST_F(PmAsyncCopyVariableTest, UnsetValueTest) {
AsyncCopyVariable<int> var("var", 42);
var.UnsetValue();
- PMTEST_EXPECT_NULL(var.GetValue(default_timeout_, NULL));
+ PmTestUtils::ExpectVariableNotSet(&var);
// Execute all the pending observers.
RunGMainLoopMaxIterations(100);
}
diff --git a/policy_manager/pmtest_utils.cc b/policy_manager/pmtest_utils.cc
new file mode 100644
index 0000000..569648e
--- /dev/null
+++ b/policy_manager/pmtest_utils.cc
@@ -0,0 +1,13 @@
+// Copyright (c) 2014 The Chromium OS 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 <base/time/time.h>
+
+#include "update_engine/policy_manager/pmtest_utils.h"
+
+namespace chromeos_policy_manager {
+
+const unsigned PmTestUtils::kDefaultTimeoutInSeconds = 1;
+
+} // namespace chromeos_policy_manager
diff --git a/policy_manager/pmtest_utils.h b/policy_manager/pmtest_utils.h
index ade85d8..b41eda8 100644
--- a/policy_manager/pmtest_utils.h
+++ b/policy_manager/pmtest_utils.h
@@ -5,6 +5,11 @@
#ifndef CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_PMTEST_UTILS_H_
#define CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_PMTEST_UTILS_H_
+#include <base/time/time.h>
+#include <gtest/gtest.h>
+
+#include "update_engine/policy_manager/variable.h"
+
// Convenience macros for checking null-ness of pointers.
//
// Purportedly, gtest should support pointer comparison when the first argument
@@ -20,4 +25,38 @@
#define PMTEST_EXPECT_NULL(p) EXPECT_EQ(NULL, p)
#define PMTEST_EXPECT_NOT_NULL(p) EXPECT_NE(reinterpret_cast<void*>(NULL), p)
+
+namespace chromeos_policy_manager {
+
+// A help class with common functionality for use in Policy Manager testing.
+class PmTestUtils {
+ public:
+ // A default timeout to use when making various queries.
+ static const base::TimeDelta DefaultTimeout() {
+ return base::TimeDelta::FromSeconds(kDefaultTimeoutInSeconds);
+ }
+
+ // Calls GetValue on |variable| and expects its result to be |expected|.
+ template<typename T>
+ static void ExpectVariableHasValue(const T& expected, Variable<T>* variable) {
+ PMTEST_ASSERT_NOT_NULL(variable);
+ scoped_ptr<const T> value(variable->GetValue(DefaultTimeout(), nullptr));
+ PMTEST_ASSERT_NOT_NULL(value.get()) << "Variable: " << variable->GetName();
+ EXPECT_EQ(expected, *value) << "Variable: " << variable->GetName();
+ }
+
+ // Calls GetValue on |variable| and expects its result to be null.
+ template<typename T>
+ static void ExpectVariableNotSet(Variable<T>* variable) {
+ PMTEST_ASSERT_NOT_NULL(variable);
+ scoped_ptr<const T> value(variable->GetValue(DefaultTimeout(), nullptr));
+ PMTEST_EXPECT_NULL(value.get()) << "Variable: " << variable->GetName();
+ }
+
+ private:
+ static const unsigned kDefaultTimeoutInSeconds;
+};
+
+} // namespace chromeos_policy_manager
+
#endif // CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_PMTEST_UTILS_H_
diff --git a/policy_manager/policy_manager.h b/policy_manager/policy_manager.h
index 3be8437..75e6082 100644
--- a/policy_manager/policy_manager.h
+++ b/policy_manager/policy_manager.h
@@ -77,7 +77,6 @@
}
private:
- friend class PmPolicyManagerTest;
FRIEND_TEST(PmPolicyManagerTest, PolicyRequestCallsPolicy);
FRIEND_TEST(PmPolicyManagerTest, PolicyRequestCallsDefaultOnError);
FRIEND_TEST(PmPolicyManagerTest, PolicyRequestDoesntBlock);
diff --git a/policy_manager/real_config_provider_unittest.cc b/policy_manager/real_config_provider_unittest.cc
index 37b480e..2ece08b 100644
--- a/policy_manager/real_config_provider_unittest.cc
+++ b/policy_manager/real_config_provider_unittest.cc
@@ -28,16 +28,6 @@
provider_->SetRootPrefix(root_dir_.path().value());
}
- // TODO(deymo): Merge this method into common unittest tools for PM.
- // Calls GetValue and expects its result to be the passed one.
- template<typename T>
- void ExpectVariableValue(const T& expected, Variable<T>* variable) {
- PMTEST_ASSERT_NOT_NULL(variable);
- scoped_ptr<const T> value(variable->GetValue(default_timeout_, nullptr));
- PMTEST_ASSERT_NOT_NULL(value.get()) << "Variable: " << variable->GetName();
- EXPECT_EQ(expected, *value) << "Variable: " << variable->GetName();
- }
-
void WriteStatefulConfig(const string& config) {
base::FilePath kFile(root_dir_.path().value()
+ chromeos_update_engine::kStatefulPartition
@@ -66,7 +56,7 @@
TEST_F(PmRealConfigProviderTest, NoFileFoundReturnsDefault) {
EXPECT_TRUE(provider_->Init());
- ExpectVariableValue(true, provider_->var_is_oobe_enabled());
+ PmTestUtils::ExpectVariableHasValue(true, provider_->var_is_oobe_enabled());
}
TEST_F(PmRealConfigProviderTest, DontReadStatefulInNormalMode) {
@@ -74,7 +64,7 @@
WriteStatefulConfig("is_oobe_enabled=false");
EXPECT_TRUE(provider_->Init());
- ExpectVariableValue(true, provider_->var_is_oobe_enabled());
+ PmTestUtils::ExpectVariableHasValue(true, provider_->var_is_oobe_enabled());
}
TEST_F(PmRealConfigProviderTest, ReadStatefulInDevMode) {
@@ -84,7 +74,7 @@
WriteStatefulConfig("is_oobe_enabled=false");
EXPECT_TRUE(provider_->Init());
- ExpectVariableValue(false, provider_->var_is_oobe_enabled());
+ PmTestUtils::ExpectVariableHasValue(false, provider_->var_is_oobe_enabled());
}
TEST_F(PmRealConfigProviderTest, ReadRootfsIfStatefulNotFound) {
@@ -92,7 +82,7 @@
WriteRootfsConfig("is_oobe_enabled=false");
EXPECT_TRUE(provider_->Init());
- ExpectVariableValue(false, provider_->var_is_oobe_enabled());
+ PmTestUtils::ExpectVariableHasValue(false, provider_->var_is_oobe_enabled());
}
} // namespace chromeos_policy_manager
diff --git a/policy_manager/real_device_policy_provider.h b/policy_manager/real_device_policy_provider.h
index cb0eb2b..dbd0879 100644
--- a/policy_manager/real_device_policy_provider.h
+++ b/policy_manager/real_device_policy_provider.h
@@ -66,7 +66,6 @@
}
private:
- friend class PmRealDevicePolicyProviderTest;
FRIEND_TEST(PmRealDevicePolicyProviderTest, RefreshScheduledTest);
FRIEND_TEST(PmRealDevicePolicyProviderTest, NonExistentDevicePolicyReloaded);
FRIEND_TEST(PmRealDevicePolicyProviderTest, ValuesUpdated);
diff --git a/policy_manager/real_device_policy_provider_unittest.cc b/policy_manager/real_device_policy_provider_unittest.cc
index 2d14bbc..6d6ccae 100644
--- a/policy_manager/real_device_policy_provider_unittest.cc
+++ b/policy_manager/real_device_policy_provider_unittest.cc
@@ -58,22 +58,6 @@
.WillByDefault(ReturnRef(mock_device_policy_));
}
- // Calls GetValue and expects its result to be the passed one.
- template<typename T>
- void ExpectVariableValue(const T& expected, Variable<T>* variable) {
- scoped_ptr<const T> value(variable->GetValue(default_timeout_, nullptr));
- PMTEST_ASSERT_NOT_NULL(value.get()) << "Variable: " << variable->GetName();
- EXPECT_EQ(expected, *value) << "Variable: " << variable->GetName();
- }
-
- // Calls GetValue and expects its result to be NULL.
- template<typename T>
- void ExpectVariableNotSet(Variable<T>* variable) {
- scoped_ptr<const T> value(variable->GetValue(default_timeout_, nullptr));
- PMTEST_EXPECT_NULL(value.get()) << "Variable: " << variable->GetName();
- }
-
- TimeDelta default_timeout_ = TimeDelta::FromSeconds(1);
testing::NiceMock<policy::MockDevicePolicy> mock_device_policy_;
testing::NiceMock<policy::MockPolicyProvider> mock_policy_provider_;
scoped_ptr<RealDevicePolicyProvider> provider_;
@@ -105,17 +89,19 @@
EXPECT_CALL(mock_policy_provider_, GetDevicePolicy()).Times(0);
EXPECT_TRUE(provider_->Init());
- ExpectVariableValue(false, provider_->var_device_policy_is_loaded());
+ PmTestUtils::ExpectVariableHasValue(false,
+ provider_->var_device_policy_is_loaded());
- ExpectVariableNotSet(provider_->var_release_channel());
- ExpectVariableNotSet(provider_->var_release_channel_delegated());
- ExpectVariableNotSet(provider_->var_update_disabled());
- ExpectVariableNotSet(provider_->var_target_version_prefix());
- ExpectVariableNotSet(provider_->var_scatter_factor());
- ExpectVariableNotSet(provider_->var_allowed_connection_types_for_update());
- ExpectVariableNotSet(provider_->var_get_owner());
- ExpectVariableNotSet(provider_->var_http_downloads_enabled());
- ExpectVariableNotSet(provider_->var_au_p2p_enabled());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_release_channel());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_release_channel_delegated());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_update_disabled());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_target_version_prefix());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_scatter_factor());
+ PmTestUtils::ExpectVariableNotSet(
+ provider_->var_allowed_connection_types_for_update());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_get_owner());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_http_downloads_enabled());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_au_p2p_enabled());
}
TEST_F(PmRealDevicePolicyProviderTest, ValuesUpdated) {
@@ -134,11 +120,14 @@
provider_->RefreshDevicePolicy();
- ExpectVariableValue(true, provider_->var_device_policy_is_loaded());
+ PmTestUtils::ExpectVariableHasValue(true,
+ provider_->var_device_policy_is_loaded());
// Test that at least one variable is set, to ensure the refresh ocurred.
- ExpectVariableValue(string("mychannel"), provider_->var_release_channel());
- ExpectVariableNotSet(provider_->var_allowed_connection_types_for_update());
+ PmTestUtils::ExpectVariableHasValue(string("mychannel"),
+ provider_->var_release_channel());
+ PmTestUtils::ExpectVariableNotSet(
+ provider_->var_allowed_connection_types_for_update());
}
TEST_F(PmRealDevicePolicyProviderTest, ScatterFactorConverted) {
@@ -147,8 +136,8 @@
.WillOnce(DoAll(SetArgumentPointee<0>(1234), Return(true)));
EXPECT_TRUE(provider_->Init());
- ExpectVariableValue(base::TimeDelta::FromSeconds(1234),
- provider_->var_scatter_factor());
+ PmTestUtils::ExpectVariableHasValue(base::TimeDelta::FromSeconds(1234),
+ provider_->var_scatter_factor());
}
TEST_F(PmRealDevicePolicyProviderTest, NegativeScatterFactorIgnored) {
@@ -157,7 +146,7 @@
.WillOnce(DoAll(SetArgumentPointee<0>(-1), Return(true)));
EXPECT_TRUE(provider_->Init());
- ExpectVariableNotSet(provider_->var_scatter_factor());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_scatter_factor());
}
TEST_F(PmRealDevicePolicyProviderTest, AllowedTypesConverted) {
@@ -168,9 +157,9 @@
Return(true)));
EXPECT_TRUE(provider_->Init());
- ExpectVariableValue(set<ConnectionType>{ConnectionType::kWifi,
- ConnectionType::kBluetooth},
- provider_->var_allowed_connection_types_for_update());
+ PmTestUtils::ExpectVariableHasValue(
+ set<ConnectionType>{ConnectionType::kWifi, ConnectionType::kBluetooth},
+ provider_->var_allowed_connection_types_for_update());
}
} // namespace chromeos_policy_manager
diff --git a/policy_manager/real_random_provider_unittest.cc b/policy_manager/real_random_provider_unittest.cc
index acd4bb0..f61dbba 100644
--- a/policy_manager/real_random_provider_unittest.cc
+++ b/policy_manager/real_random_provider_unittest.cc
@@ -3,7 +3,6 @@
// found in the LICENSE file.
#include <base/memory/scoped_ptr.h>
-#include <base/time/time.h>
#include <gtest/gtest.h>
#include "update_engine/policy_manager/pmtest_utils.h"
@@ -24,7 +23,6 @@
provider_->var_seed();
}
- const TimeDelta default_timeout_ = TimeDelta::FromSeconds(1);
scoped_ptr<RealRandomProvider> provider_;
};
@@ -36,7 +34,7 @@
TEST_F(PmRealRandomProviderTest, GetRandomValues) {
// Should not return the same random seed repeatedly.
scoped_ptr<const uint64_t> value(
- provider_->var_seed()->GetValue(default_timeout_, NULL));
+ provider_->var_seed()->GetValue(PmTestUtils::DefaultTimeout(), nullptr));
PMTEST_ASSERT_NOT_NULL(value.get());
// Test that at least the returned values are different. This test fails,
@@ -44,7 +42,8 @@
bool is_same_value = true;
for (int i = 0; i < 5; i++) {
scoped_ptr<const uint64_t> other_value(
- provider_->var_seed()->GetValue(default_timeout_, NULL));
+ provider_->var_seed()->GetValue(PmTestUtils::DefaultTimeout(),
+ nullptr));
PMTEST_ASSERT_NOT_NULL(other_value.get());
is_same_value = is_same_value && *other_value == *value;
}
diff --git a/policy_manager/real_shill_provider_unittest.cc b/policy_manager/real_shill_provider_unittest.cc
index 38f3905..42c2ef6 100644
--- a/policy_manager/real_shill_provider_unittest.cc
+++ b/policy_manager/real_shill_provider_unittest.cc
@@ -246,15 +246,9 @@
g_hash_table_unref(service_properties);
// Query the connection status, ensure last change time reported correctly.
- scoped_ptr<const bool> is_connected(
- provider_->var_is_connected()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(is_connected.get());
- EXPECT_TRUE(*is_connected);
-
- scoped_ptr<const Time> conn_last_changed(
- provider_->var_conn_last_changed()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(conn_last_changed.get());
- EXPECT_EQ(conn_change_time, *conn_last_changed);
+ PmTestUtils::ExpectVariableHasValue(true, provider_->var_is_connected());
+ PmTestUtils::ExpectVariableHasValue(conn_change_time,
+ provider_->var_conn_last_changed());
// Write the connection change time to the output argument.
if (conn_change_time_p)
@@ -274,15 +268,10 @@
&conn_change_time);
// Query the connection type, ensure last change time did not change.
- scoped_ptr<const ConnectionType> conn_type(
- provider_->var_conn_type()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(conn_type.get());
- EXPECT_EQ(expected_conn_type, *conn_type);
-
- scoped_ptr<const Time> conn_last_changed(
- provider_->var_conn_last_changed()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(conn_last_changed.get());
- EXPECT_EQ(conn_change_time, *conn_last_changed);
+ PmTestUtils::ExpectVariableHasValue(expected_conn_type,
+ provider_->var_conn_type());
+ PmTestUtils::ExpectVariableHasValue(conn_change_time,
+ provider_->var_conn_last_changed());
}
// Sets up a connection and tests that its tethering mode is being properly
@@ -297,18 +286,12 @@
shill_tethering_str, &conn_change_time);
// Query the connection tethering, ensure last change time did not change.
- scoped_ptr<const ConnectionTethering> conn_tethering(
- provider_->var_conn_tethering()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(conn_tethering.get());
- EXPECT_EQ(expected_conn_tethering, *conn_tethering);
-
- scoped_ptr<const Time> conn_last_changed(
- provider_->var_conn_last_changed()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(conn_last_changed.get());
- EXPECT_EQ(conn_change_time, *conn_last_changed);
+ PmTestUtils::ExpectVariableHasValue(expected_conn_tethering,
+ provider_->var_conn_tethering());
+ PmTestUtils::ExpectVariableHasValue(conn_change_time,
+ provider_->var_conn_last_changed());
}
- const TimeDelta default_timeout_ = TimeDelta::FromSeconds(1);
StrictMock<MockDBusWrapper> mock_dbus_;
FakeClock fake_clock_;
scoped_ptr<RealShillProvider> provider_;
@@ -320,19 +303,10 @@
// during initialization (no signals).
TEST_F(PmRealShillProviderTest, ReadBaseValues) {
// Query the provider variables.
- scoped_ptr<const bool> is_connected(
- provider_->var_is_connected()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(is_connected.get());
- EXPECT_FALSE(*is_connected);
-
- scoped_ptr<const ConnectionType> conn_type(
- provider_->var_conn_type()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NULL(conn_type.get());
-
- scoped_ptr<const Time> conn_last_changed(
- provider_->var_conn_last_changed()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(conn_last_changed.get());
- EXPECT_EQ(InitTime(), *conn_last_changed);
+ PmTestUtils::ExpectVariableHasValue(false, provider_->var_is_connected());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_conn_type());
+ PmTestUtils::ExpectVariableHasValue(InitTime(),
+ provider_->var_conn_last_changed());
}
// Test that Ethernet connection is identified correctly.
@@ -403,15 +377,10 @@
Time conn_change_time = SendDefaultServiceSignal(kFakeVpnServicePath);
// Query the connection type, ensure last change time reported correctly.
- scoped_ptr<const ConnectionType> conn_type(
- provider_->var_conn_type()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(conn_type.get());
- EXPECT_EQ(ConnectionType::kWifi, *conn_type);
-
- scoped_ptr<const Time> conn_last_changed(
- provider_->var_conn_last_changed()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(conn_last_changed.get());
- EXPECT_EQ(conn_change_time, *conn_last_changed);
+ PmTestUtils::ExpectVariableHasValue(ConnectionType::kWifi,
+ provider_->var_conn_type());
+ PmTestUtils::ExpectVariableHasValue(conn_change_time,
+ provider_->var_conn_last_changed());
// Release properties hash tables.
g_hash_table_unref(service_properties);
@@ -425,10 +394,8 @@
shill::kTypeEthernet,
ConnectionType::kEthernet);
- scoped_ptr<const ConnectionType> conn_type(
- provider_->var_conn_type()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(conn_type.get());
- EXPECT_EQ(ConnectionType::kEthernet, *conn_type);
+ PmTestUtils::ExpectVariableHasValue(ConnectionType::kEthernet,
+ provider_->var_conn_type());
}
// Ensure that the cached connection type remains valid even when a default
@@ -441,10 +408,8 @@
SendDefaultServiceSignal(kFakeEthernetServicePath);
- scoped_ptr<const ConnectionType> conn_type(
- provider_->var_conn_type()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(conn_type.get());
- EXPECT_EQ(ConnectionType::kEthernet, *conn_type);
+ PmTestUtils::ExpectVariableHasValue(ConnectionType::kEthernet,
+ provider_->var_conn_type());
}
// Ensure that the cached connection type is invalidated and re-read when the
@@ -500,10 +465,8 @@
shill::kTetheringNotDetectedState,
ConnectionTethering::kNotDetected);
- scoped_ptr<const ConnectionTethering> conn_tethering(
- provider_->var_conn_tethering()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(conn_tethering.get());
- EXPECT_EQ(ConnectionTethering::kNotDetected, *conn_tethering);
+ PmTestUtils::ExpectVariableHasValue(ConnectionTethering::kNotDetected,
+ provider_->var_conn_tethering());
}
// Ensure that the cached connection tethering mode remains valid even when a
@@ -516,10 +479,8 @@
SendDefaultServiceSignal(kFakeEthernetServicePath);
- scoped_ptr<const ConnectionTethering> conn_tethering(
- provider_->var_conn_tethering()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(conn_tethering.get());
- EXPECT_EQ(ConnectionTethering::kNotDetected, *conn_tethering);
+ PmTestUtils::ExpectVariableHasValue(ConnectionTethering::kNotDetected,
+ provider_->var_conn_tethering());
}
// Ensure that the cached connection tethering mode is invalidated and re-read
@@ -549,15 +510,9 @@
SendDefaultServiceSignal(kFakeEthernetServicePath);
// Query the connection status, ensure last change time reported correctly.
- scoped_ptr<const bool> is_connected(
- provider_->var_is_connected()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(is_connected.get());
- EXPECT_TRUE(*is_connected);
-
- scoped_ptr<const Time> conn_last_changed(
- provider_->var_conn_last_changed()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(conn_last_changed.get());
- EXPECT_EQ(conn_change_time, *conn_last_changed);
+ PmTestUtils::ExpectVariableHasValue(true, provider_->var_is_connected());
+ PmTestUtils::ExpectVariableHasValue(conn_change_time,
+ provider_->var_conn_last_changed());
}
// Make sure that the provider initializes correctly even if shill is not
@@ -566,12 +521,9 @@
TEST_F(PmRealShillProviderTest, NoInitConnStatusReadBaseValues) {
// Re-initialize the provider, no initial connection status response.
Init(false);
- PMTEST_ASSERT_NULL(provider_->var_is_connected()->GetValue(
- default_timeout_, NULL));
- PMTEST_ASSERT_NULL(provider_->var_conn_type()->GetValue(
- default_timeout_, NULL));
- PMTEST_ASSERT_NULL(provider_->var_conn_last_changed()->GetValue(
- default_timeout_, NULL));
+ PmTestUtils::ExpectVariableNotSet(provider_->var_is_connected());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_conn_type());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_conn_last_changed());
}
// Test that, once a signal is received, the connection status and other info
diff --git a/policy_manager/real_time_provider_unittest.cc b/policy_manager/real_time_provider_unittest.cc
index cec2ed6..e6594aa 100644
--- a/policy_manager/real_time_provider_unittest.cc
+++ b/policy_manager/real_time_provider_unittest.cc
@@ -40,30 +40,22 @@
return Time::FromLocalExploded(now_exp);
}
- const TimeDelta default_timeout_ = TimeDelta::FromSeconds(1);
FakeClock fake_clock_;
scoped_ptr<RealTimeProvider> provider_;
};
TEST_F(PmRealTimeProviderTest, CurrDateValid) {
const Time now = CurrTime();
- Time::Exploded expected;
- now.LocalExplode(&expected);
- fake_clock_.SetWallclockTime(now);
- scoped_ptr<const Time> curr_date(
- provider_->var_curr_date()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(curr_date.get());
+ Time::Exploded exploded;
+ now.LocalExplode(&exploded);
+ exploded.hour = 0;
+ exploded.minute = 0;
+ exploded.second = 0;
+ exploded.millisecond = 0;
+ const Time expected = Time::FromLocalExploded(exploded);
- Time::Exploded actual;
- curr_date->LocalExplode(&actual);
- EXPECT_EQ(expected.year, actual.year);
- EXPECT_EQ(expected.month, actual.month);
- EXPECT_EQ(expected.day_of_week, actual.day_of_week);
- EXPECT_EQ(expected.day_of_month, actual.day_of_month);
- EXPECT_EQ(0, actual.hour);
- EXPECT_EQ(0, actual.minute);
- EXPECT_EQ(0, actual.second);
- EXPECT_EQ(0, actual.millisecond);
+ fake_clock_.SetWallclockTime(now);
+ PmTestUtils::ExpectVariableHasValue(expected, provider_->var_curr_date());
}
TEST_F(PmRealTimeProviderTest, CurrHourValid) {
@@ -71,11 +63,8 @@
Time::Exploded expected;
now.LocalExplode(&expected);
fake_clock_.SetWallclockTime(now);
- scoped_ptr<const int> curr_hour(
- provider_->var_curr_hour()->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(curr_hour.get());
-
- EXPECT_EQ(expected.hour, *curr_hour);
+ PmTestUtils::ExpectVariableHasValue(expected.hour,
+ provider_->var_curr_hour());
}
} // namespace chromeos_policy_manager
diff --git a/policy_manager/real_updater_provider_unittest.cc b/policy_manager/real_updater_provider_unittest.cc
index b668900..1f8f86f 100644
--- a/policy_manager/real_updater_provider_unittest.cc
+++ b/policy_manager/real_updater_provider_unittest.cc
@@ -70,24 +70,6 @@
ASSERT_TRUE(provider_->Init());
}
- // Tests that the GetValue() method of variable |var| succeeds and the
- // returned value equals |expected|.
- template<typename T>
- void TestGetValueOkay(Variable<T>* var, T expected) {
- PMTEST_ASSERT_NOT_NULL(var);
- scoped_ptr<const T> actual(var->GetValue(default_timeout_, NULL));
- PMTEST_ASSERT_NOT_NULL(actual.get());
- EXPECT_EQ(expected, *actual);
- }
-
- // Tests that the GetValue() method of variable |var| fails, returning null.
- template<typename T>
- void TestGetValueFail(Variable<T>* var) {
- PMTEST_ASSERT_NOT_NULL(var);
- scoped_ptr<const T> actual(var->GetValue(default_timeout_, NULL));
- PMTEST_EXPECT_NULL(actual.get());
- }
-
// Sets up mock expectations for testing a variable that reads a Boolean pref
// |key|. |key_exists| determines whether the key is present. If it is, then
// |get_boolean_success| determines whether reading it is successful, and if
@@ -124,7 +106,6 @@
return kCurrWallclockTime - kDurationSinceUpdate;
}
- const TimeDelta default_timeout_ = TimeDelta::FromSeconds(1);
FakeSystemState fake_sys_state_;
FakeClock fake_clock_;
scoped_ptr<RealUpdaterProvider> provider_;
@@ -134,57 +115,57 @@
EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<0>(FixedTime().ToTimeT()), Return(true)));
- TestGetValueOkay(provider_->var_last_checked_time(),
- RoundedToSecond(FixedTime()));
+ PmTestUtils::ExpectVariableHasValue(RoundedToSecond(FixedTime()),
+ provider_->var_last_checked_time());
}
TEST_F(PmRealUpdaterProviderTest, GetLastCheckedTimeFailNoValue) {
EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
GetStatus(_, _, _, _, _))
.WillOnce(Return(false));
- TestGetValueFail(provider_->var_last_checked_time());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_last_checked_time());
}
TEST_F(PmRealUpdaterProviderTest, GetProgressOkayMin) {
EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<1>(0.0), Return(true)));
- TestGetValueOkay(provider_->var_progress(), 0.0);
+ PmTestUtils::ExpectVariableHasValue(0.0, provider_->var_progress());
}
TEST_F(PmRealUpdaterProviderTest, GetProgressOkayMid) {
EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<1>(0.3), Return(true)));
- TestGetValueOkay(provider_->var_progress(), 0.3);
+ PmTestUtils::ExpectVariableHasValue(0.3, provider_->var_progress());
}
TEST_F(PmRealUpdaterProviderTest, GetProgressOkayMax) {
EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<1>(1.0), Return(true)));
- TestGetValueOkay(provider_->var_progress(), 1.0);
+ PmTestUtils::ExpectVariableHasValue(1.0, provider_->var_progress());
}
TEST_F(PmRealUpdaterProviderTest, GetProgressFailNoValue) {
EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
GetStatus(_, _, _, _, _))
.WillOnce(Return(false));
- TestGetValueFail(provider_->var_progress());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_progress());
}
TEST_F(PmRealUpdaterProviderTest, GetProgressFailTooSmall) {
EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<1>(-2.0), Return(true)));
- TestGetValueFail(provider_->var_progress());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_progress());
}
TEST_F(PmRealUpdaterProviderTest, GetProgressFailTooBig) {
EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<1>(2.0), Return(true)));
- TestGetValueFail(provider_->var_progress());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_progress());
}
TEST_F(PmRealUpdaterProviderTest, GetStageOkayIdle) {
@@ -192,7 +173,7 @@
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<2>(update_engine::kUpdateStatusIdle),
Return(true)));
- TestGetValueOkay(provider_->var_stage(), Stage::kIdle);
+ PmTestUtils::ExpectVariableHasValue(Stage::kIdle, provider_->var_stage());
}
TEST_F(PmRealUpdaterProviderTest, GetStageOkayCheckingForUpdate) {
@@ -201,7 +182,8 @@
.WillOnce(DoAll(
SetArgPointee<2>(update_engine::kUpdateStatusCheckingForUpdate),
Return(true)));
- TestGetValueOkay(provider_->var_stage(), Stage::kCheckingForUpdate);
+ PmTestUtils::ExpectVariableHasValue(Stage::kCheckingForUpdate,
+ provider_->var_stage());
}
TEST_F(PmRealUpdaterProviderTest, GetStageOkayUpdateAvailable) {
@@ -210,7 +192,8 @@
.WillOnce(DoAll(
SetArgPointee<2>(update_engine::kUpdateStatusUpdateAvailable),
Return(true)));
- TestGetValueOkay(provider_->var_stage(), Stage::kUpdateAvailable);
+ PmTestUtils::ExpectVariableHasValue(Stage::kUpdateAvailable,
+ provider_->var_stage());
}
TEST_F(PmRealUpdaterProviderTest, GetStageOkayDownloading) {
@@ -218,7 +201,8 @@
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<2>(update_engine::kUpdateStatusDownloading),
Return(true)));
- TestGetValueOkay(provider_->var_stage(), Stage::kDownloading);
+ PmTestUtils::ExpectVariableHasValue(Stage::kDownloading,
+ provider_->var_stage());
}
TEST_F(PmRealUpdaterProviderTest, GetStageOkayVerifying) {
@@ -226,7 +210,8 @@
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<2>(update_engine::kUpdateStatusVerifying),
Return(true)));
- TestGetValueOkay(provider_->var_stage(), Stage::kVerifying);
+ PmTestUtils::ExpectVariableHasValue(Stage::kVerifying,
+ provider_->var_stage());
}
TEST_F(PmRealUpdaterProviderTest, GetStageOkayFinalizing) {
@@ -234,7 +219,8 @@
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<2>(update_engine::kUpdateStatusFinalizing),
Return(true)));
- TestGetValueOkay(provider_->var_stage(), Stage::kFinalizing);
+ PmTestUtils::ExpectVariableHasValue(Stage::kFinalizing,
+ provider_->var_stage());
}
TEST_F(PmRealUpdaterProviderTest, GetStageOkayUpdatedNeedReboot) {
@@ -243,7 +229,8 @@
.WillOnce(DoAll(
SetArgPointee<2>(update_engine::kUpdateStatusUpdatedNeedReboot),
Return(true)));
- TestGetValueOkay(provider_->var_stage(), Stage::kUpdatedNeedReboot);
+ PmTestUtils::ExpectVariableHasValue(Stage::kUpdatedNeedReboot,
+ provider_->var_stage());
}
TEST_F(PmRealUpdaterProviderTest, GetStageOkayReportingErrorEvent) {
@@ -252,7 +239,8 @@
.WillOnce(DoAll(
SetArgPointee<2>(update_engine::kUpdateStatusReportingErrorEvent),
Return(true)));
- TestGetValueOkay(provider_->var_stage(), Stage::kReportingErrorEvent);
+ PmTestUtils::ExpectVariableHasValue(Stage::kReportingErrorEvent,
+ provider_->var_stage());
}
TEST_F(PmRealUpdaterProviderTest, GetStageOkayAttemptingRollback) {
@@ -261,14 +249,15 @@
.WillOnce(DoAll(
SetArgPointee<2>(update_engine::kUpdateStatusAttemptingRollback),
Return(true)));
- TestGetValueOkay(provider_->var_stage(), Stage::kAttemptingRollback);
+ PmTestUtils::ExpectVariableHasValue(Stage::kAttemptingRollback,
+ provider_->var_stage());
}
TEST_F(PmRealUpdaterProviderTest, GetStageFailNoValue) {
EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
GetStatus(_, _, _, _, _))
.WillOnce(Return(false));
- TestGetValueFail(provider_->var_stage());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_stage());
}
TEST_F(PmRealUpdaterProviderTest, GetStageFailUnknown) {
@@ -276,35 +265,37 @@
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<2>("FooUpdateEngineState"),
Return(true)));
- TestGetValueFail(provider_->var_stage());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_stage());
}
TEST_F(PmRealUpdaterProviderTest, GetStageFailEmpty) {
EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<2>(""), Return(true)));
- TestGetValueFail(provider_->var_stage());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_stage());
}
TEST_F(PmRealUpdaterProviderTest, GetNewVersionOkay) {
EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<3>("1.2.0"), Return(true)));
- TestGetValueOkay(provider_->var_new_version(), string("1.2.0"));
+ PmTestUtils::ExpectVariableHasValue(string("1.2.0"),
+ provider_->var_new_version());
}
TEST_F(PmRealUpdaterProviderTest, GetNewVersionFailNoValue) {
EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
GetStatus(_, _, _, _, _))
.WillOnce(Return(false));
- TestGetValueFail(provider_->var_new_version());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_new_version());
}
TEST_F(PmRealUpdaterProviderTest, GetPayloadSizeOkayZero) {
EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<4>(static_cast<int64_t>(0)), Return(true)));
- TestGetValueOkay(provider_->var_payload_size(), static_cast<size_t>(0));
+ PmTestUtils::ExpectVariableHasValue(static_cast<size_t>(0),
+ provider_->var_payload_size());
}
TEST_F(PmRealUpdaterProviderTest, GetPayloadSizeOkayArbitrary) {
@@ -312,7 +303,8 @@
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<4>(static_cast<int64_t>(567890)),
Return(true)));
- TestGetValueOkay(provider_->var_payload_size(), static_cast<size_t>(567890));
+ PmTestUtils::ExpectVariableHasValue(static_cast<size_t>(567890),
+ provider_->var_payload_size());
}
TEST_F(PmRealUpdaterProviderTest, GetPayloadSizeOkayTwoGigabytes) {
@@ -320,14 +312,15 @@
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<4>(static_cast<int64_t>(1) << 31),
Return(true)));
- TestGetValueOkay(provider_->var_payload_size(), static_cast<size_t>(1) << 31);
+ PmTestUtils::ExpectVariableHasValue(static_cast<size_t>(1) << 31,
+ provider_->var_payload_size());
}
TEST_F(PmRealUpdaterProviderTest, GetPayloadSizeFailNoValue) {
EXPECT_CALL(*fake_sys_state_.mock_update_attempter(),
GetStatus(_, _, _, _, _))
.WillOnce(Return(false));
- TestGetValueFail(provider_->var_payload_size());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_payload_size());
}
TEST_F(PmRealUpdaterProviderTest, GetPayloadSizeFailNegative) {
@@ -335,7 +328,7 @@
GetStatus(_, _, _, _, _))
.WillOnce(DoAll(SetArgPointee<4>(static_cast<int64_t>(-1024)),
Return(true)));
- TestGetValueFail(provider_->var_payload_size());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_payload_size());
}
TEST_F(PmRealUpdaterProviderTest, GetCurrChannelOkay) {
@@ -344,7 +337,8 @@
request_params.Init("", "", false);
request_params.set_current_channel(kChannelName);
fake_sys_state_.set_request_params(&request_params);
- TestGetValueOkay(provider_->var_curr_channel(), kChannelName);
+ PmTestUtils::ExpectVariableHasValue(kChannelName,
+ provider_->var_curr_channel());
}
TEST_F(PmRealUpdaterProviderTest, GetCurrChannelFailEmpty) {
@@ -352,7 +346,7 @@
request_params.Init("", "", false);
request_params.set_current_channel("");
fake_sys_state_.set_request_params(&request_params);
- TestGetValueFail(provider_->var_curr_channel());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_curr_channel());
}
TEST_F(PmRealUpdaterProviderTest, GetNewChannelOkay) {
@@ -361,7 +355,8 @@
request_params.Init("", "", false);
request_params.set_target_channel(kChannelName);
fake_sys_state_.set_request_params(&request_params);
- TestGetValueOkay(provider_->var_new_channel(), kChannelName);
+ PmTestUtils::ExpectVariableHasValue(kChannelName,
+ provider_->var_new_channel());
}
TEST_F(PmRealUpdaterProviderTest, GetNewChannelFailEmpty) {
@@ -369,75 +364,76 @@
request_params.Init("", "", false);
request_params.set_target_channel("");
fake_sys_state_.set_request_params(&request_params);
- TestGetValueFail(provider_->var_new_channel());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_new_channel());
}
TEST_F(PmRealUpdaterProviderTest, GetP2PEnabledOkayPrefDoesntExist) {
SetupReadBooleanPref(chromeos_update_engine::kPrefsP2PEnabled,
false, false, false);
- TestGetValueOkay(provider_->var_p2p_enabled(), false);
+ PmTestUtils::ExpectVariableHasValue(false, provider_->var_p2p_enabled());
}
TEST_F(PmRealUpdaterProviderTest, GetP2PEnabledOkayPrefReadsFalse) {
SetupReadBooleanPref(chromeos_update_engine::kPrefsP2PEnabled,
true, true, false);
- TestGetValueOkay(provider_->var_p2p_enabled(), false);
+ PmTestUtils::ExpectVariableHasValue(false, provider_->var_p2p_enabled());
}
TEST_F(PmRealUpdaterProviderTest, GetP2PEnabledOkayPrefReadsTrue) {
SetupReadBooleanPref(chromeos_update_engine::kPrefsP2PEnabled,
true, true, true);
- TestGetValueOkay(provider_->var_p2p_enabled(), true);
+ PmTestUtils::ExpectVariableHasValue(true, provider_->var_p2p_enabled());
}
TEST_F(PmRealUpdaterProviderTest, GetP2PEnabledFailCannotReadPref) {
SetupReadBooleanPref(chromeos_update_engine::kPrefsP2PEnabled,
true, false, false);
- TestGetValueFail(provider_->var_p2p_enabled());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_p2p_enabled());
}
TEST_F(PmRealUpdaterProviderTest, GetCellularEnabledOkayPrefDoesntExist) {
SetupReadBooleanPref(
chromeos_update_engine::kPrefsUpdateOverCellularPermission,
false, false, false);
- TestGetValueOkay(provider_->var_cellular_enabled(), false);
+ PmTestUtils::ExpectVariableHasValue(false, provider_->var_cellular_enabled());
}
TEST_F(PmRealUpdaterProviderTest, GetCellularEnabledOkayPrefReadsFalse) {
SetupReadBooleanPref(
chromeos_update_engine::kPrefsUpdateOverCellularPermission,
true, true, false);
- TestGetValueOkay(provider_->var_cellular_enabled(), false);
+ PmTestUtils::ExpectVariableHasValue(false, provider_->var_cellular_enabled());
}
TEST_F(PmRealUpdaterProviderTest, GetCellularEnabledOkayPrefReadsTrue) {
SetupReadBooleanPref(
chromeos_update_engine::kPrefsUpdateOverCellularPermission,
true, true, true);
- TestGetValueOkay(provider_->var_cellular_enabled(), true);
+ PmTestUtils::ExpectVariableHasValue(true, provider_->var_cellular_enabled());
}
TEST_F(PmRealUpdaterProviderTest, GetCellularEnabledFailCannotReadPref) {
SetupReadBooleanPref(
chromeos_update_engine::kPrefsUpdateOverCellularPermission,
true, false, false);
- TestGetValueFail(provider_->var_cellular_enabled());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_cellular_enabled());
}
TEST_F(PmRealUpdaterProviderTest, GetUpdateCompletedTimeOkay) {
Time expected = SetupUpdateCompletedTime(true);
- TestGetValueOkay(provider_->var_update_completed_time(), expected);
+ PmTestUtils::ExpectVariableHasValue(expected,
+ provider_->var_update_completed_time());
}
TEST_F(PmRealUpdaterProviderTest, GetUpdateCompletedTimeFailNoValue) {
EXPECT_CALL(*fake_sys_state_.mock_update_attempter(), GetBootTimeAtUpdate(_))
.WillOnce(Return(false));
- TestGetValueFail(provider_->var_update_completed_time());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_update_completed_time());
}
TEST_F(PmRealUpdaterProviderTest, GetUpdateCompletedTimeFailInvalidValue) {
SetupUpdateCompletedTime(false);
- TestGetValueFail(provider_->var_update_completed_time());
+ PmTestUtils::ExpectVariableNotSet(provider_->var_update_completed_time());
}
} // namespace chromeos_policy_manager
diff --git a/policy_manager/variable.h b/policy_manager/variable.h
index e855e03..5b16b5d 100644
--- a/policy_manager/variable.h
+++ b/policy_manager/variable.h
@@ -115,7 +115,6 @@
private:
friend class PmEvaluationContextTest;
- friend class PmBaseVariableTest;
FRIEND_TEST(PmBaseVariableTest, RepeatedObserverTest);
FRIEND_TEST(PmBaseVariableTest, NotifyValueChangedTest);
FRIEND_TEST(PmBaseVariableTest, NotifyValueRemovesObserversTest);
@@ -174,25 +173,9 @@
// directly from the variable.
friend class EvaluationContext;
- friend class PmRealConfigProviderTest;
- friend class PmRealDevicePolicyProviderTest;
- FRIEND_TEST(PmRealDevicePolicyProviderTest,
- NonExistentDevicePolicyEmptyVariables);
- friend class PmRealRandomProviderTest;
+ // Needed to be able to verify variable contents during unit testing.
+ friend class PmTestUtils;
FRIEND_TEST(PmRealRandomProviderTest, GetRandomValues);
- friend class PmRealShillProviderTest;
- FRIEND_TEST(PmRealShillProviderTest, ReadBaseValues);
- FRIEND_TEST(PmRealShillProviderTest, ReadConnTypeVpn);
- FRIEND_TEST(PmRealShillProviderTest, ReadLastChangedTimeTwoSignals);
- FRIEND_TEST(PmRealShillProviderTest, ConnTypeCacheUsed);
- FRIEND_TEST(PmRealShillProviderTest, ConnTypeCacheRemainsValid);
- FRIEND_TEST(PmRealShillProviderTest, ConnTetheringCacheUsed);
- FRIEND_TEST(PmRealShillProviderTest, ConnTetheringCacheRemainsValid);
- FRIEND_TEST(PmRealShillProviderTest, NoInitConnStatusReadBaseValues);
- friend class PmRealTimeProviderTest;
- FRIEND_TEST(PmRealTimeProviderTest, CurrDateValid);
- FRIEND_TEST(PmRealTimeProviderTest, CurrHourValid);
- friend class PmRealUpdaterProviderTest;
Variable(const std::string& name, VariableMode mode)
: BaseVariable(name, mode) {}