Fail tests fast if Windows registry key override fails

components/policy/core/common/policy_loader_win_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/policy/core/common/policy_loader_win.h"
 
 #include <windows.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <userenv.h>
@@ skipping 137 matching lines @@
 // Registry implementing Group Policy. It prepares two temporary sandbox keys,
 // one for HKLM and one for HKCU. A test's calls to the registry are redirected
 // by Windows to these sandboxes, allowing the tests to manipulate and access
 // policy as if it were active, but without actually changing the parts of the
 // Registry that are managed by Group Policy.
 class ScopedGroupPolicyRegistrySandbox {
  public:
   ScopedGroupPolicyRegistrySandbox();
   ~ScopedGroupPolicyRegistrySandbox();
 
+  // Activates the registry keys overrides. This must be called before doing any
+  // writes to registry and the call should be wrapped in
+  // ASSERT_NO_FATAL_FAILURE.
+  void ActivateOverrides();
+
  private:
-  void ActivateOverrides();
   void RemoveOverrides();
 
   // Deletes the sandbox keys.
   void DeleteKeys();
 
   base::string16 key_name_;
 
   // Keys are created for the lifetime of a test to contain
   // the sandboxed HKCU and HKLM hives, respectively.
   RegKey temp_hkcu_hive_key_;
@@ skipping 118 matching lines @@
                               const std::string& key,
                               const base::Value* value);
 
   base::ScopedTempDir temp_dir_;
   base::FilePath preg_file_path_;
   GROUP_POLICY_OBJECT gpo_;
 
   DISALLOW_COPY_AND_ASSIGN(PRegTestHarness);
 };
 
-ScopedGroupPolicyRegistrySandbox::ScopedGroupPolicyRegistrySandbox() {
+ScopedGroupPolicyRegistrySandbox::ScopedGroupPolicyRegistrySandbox() {}
+
+ScopedGroupPolicyRegistrySandbox::~ScopedGroupPolicyRegistrySandbox() {
+  RemoveOverrides();
+  DeleteKeys();
+}
+
+void ScopedGroupPolicyRegistrySandbox::ActivateOverrides() {
   // Generate a unique registry key for the override for each test. This
   // makes sure that tests executing in parallel won't delete each other's
   // key, at DeleteKeys().
   key_name_ = base::ASCIIToUTF16(base::StringPrintf(
         "SOFTWARE\\chromium unittest %d", base::GetCurrentProcId()));
   std::wstring hklm_key_name = key_name_ + L"\\HKLM";
   std::wstring hkcu_key_name = key_name_ + L"\\HKCU";
 
+  // Delete the registry test keys if they already exist (this could happen if
+  // the process id got recycled and the last test running under the same
+  // process id crashed ).
+  DeleteKeys();
+
   // Create the subkeys to hold the overridden HKLM and HKCU
   // policy settings.
   temp_hklm_hive_key_.Create(HKEY_CURRENT_USER,
                              hklm_key_name.c_str(),
                              KEY_ALL_ACCESS);
   temp_hkcu_hive_key_.Create(HKEY_CURRENT_USER,
                              hkcu_key_name.c_str(),
                              KEY_ALL_ACCESS);
 
-  ActivateOverrides();
-}
+  auto result_override_hklm =
+      RegOverridePredefKey(HKEY_LOCAL_MACHINE, temp_hklm_hive_key_.Handle());
+  auto result_override_hkcu =
+      RegOverridePredefKey(HKEY_CURRENT_USER, temp_hkcu_hive_key_.Handle());
 
-ScopedGroupPolicyRegistrySandbox::~ScopedGroupPolicyRegistrySandbox() {
-  RemoveOverrides();
-  DeleteKeys();
-}
+  if (result_override_hklm != ERROR_SUCCESS ||
+      result_override_hkcu != ERROR_SUCCESS) {
+    // We need to remove the overrides first in case one succeeded and one
+    // failed, otherwise deleting the keys fails.
+    RemoveOverrides();
+    DeleteKeys();
 
-void ScopedGroupPolicyRegistrySandbox::ActivateOverrides() {
-  ASSERT_HRESULT_SUCCEEDED(RegOverridePredefKey(HKEY_LOCAL_MACHINE,
-                                                temp_hklm_hive_key_.Handle()));
-  ASSERT_HRESULT_SUCCEEDED(RegOverridePredefKey(HKEY_CURRENT_USER,
-                                                temp_hkcu_hive_key_.Handle()));
+    // Assert on the actual results to print the error code in failure case.
+    ASSERT_HRESULT_SUCCEEDED(result_override_hklm);
+    ASSERT_HRESULT_SUCCEEDED(result_override_hkcu);
+  }
 }
 
 void ScopedGroupPolicyRegistrySandbox::RemoveOverrides() {
   ASSERT_HRESULT_SUCCEEDED(RegOverridePredefKey(HKEY_LOCAL_MACHINE, 0));
   ASSERT_HRESULT_SUCCEEDED(RegOverridePredefKey(HKEY_CURRENT_USER, 0));
 }
 
 void ScopedGroupPolicyRegistrySandbox::DeleteKeys() {
   RegKey key(HKEY_CURRENT_USER, key_name_.c_str(), KEY_ALL_ACCESS);
   ASSERT_TRUE(key.Valid());
   key.DeleteKey(L"");
 }
 
 RegistryTestHarness::RegistryTestHarness(HKEY hive, PolicyScope scope)
     : PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY, scope,
                                 POLICY_SOURCE_PLATFORM),
       hive_(hive) {
 }
 
 RegistryTestHarness::~RegistryTestHarness() {}
 
-void RegistryTestHarness::SetUp() {}
+void RegistryTestHarness::SetUp() {
+  // SetUp is called at gtest SetUp time, and gtest documentation guarantees
+  // that the test will not be executed if SetUp has a fatal failure. This is
+  // important, see crbug.com/721691.
+  ASSERT_NO_FATAL_FAILURE(registry_sandbox_.ActivateOverrides());
+}
 
 ConfigurationPolicyProvider* RegistryTestHarness::CreateProvider(
     SchemaRegistry* registry,
     scoped_refptr<base::SequencedTaskRunner> task_runner) {
   base::win::SetDomainStateForTesting(true);
   std::unique_ptr<AsyncPolicyLoader> loader(
       new PolicyLoaderWin(task_runner, kTestPolicyKey, this));
   return new AsyncPolicyProvider(registry, std::move(loader));
 }
 
@@ skipping 346 matching lines @@
 
   PolicyLoaderWinTest()
       : gpo_list_(NULL),
         gpo_list_status_(ERROR_ACCESS_DENIED) {}
   ~PolicyLoaderWinTest() override {}
 
   void SetUp() override {
     base::win::SetDomainStateForTesting(false);
     PolicyTestBase::SetUp();
 
+    // Activate overrides of registry keys. gtest documentation guarantees
+    // that the test will not be executed if SetUp has a fatal failure. This is
+    // important, see crbug.com/721691.
+    ASSERT_NO_FATAL_FAILURE(registry_sandbox_.ActivateOverrides());
+
     ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &test_data_dir_));
     test_data_dir_ = test_data_dir_.AppendASCII("chrome")
                                    .AppendASCII("test")
                                    .AppendASCII("data")
                                    .AppendASCII("policy")
                                    .AppendASCII("gpo");
 
     gpo_list_provider_ = this;
   }
 
@@ skipping 461 matching lines @@
   expected.Get(ns_a).LoadFrom(&expected_a, POLICY_LEVEL_MANDATORY,
                               POLICY_SCOPE_MACHINE, POLICY_SOURCE_PLATFORM);
   base::DictionaryValue expected_b;
   expected_b.SetInteger("policy 1", 2);
   expected.Get(ns_b).LoadFrom(&expected_b, POLICY_LEVEL_MANDATORY,
                               POLICY_SCOPE_MACHINE, POLICY_SOURCE_PLATFORM);
   EXPECT_TRUE(Matches(expected));
 }
 
 }  // namespace policy