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) {}