[chrome_elf] NTRegistry - added wow64 redirection support.

chrome_elf/nt_registry/nt_registry_unittest.cc

Index: chrome_elf/nt_registry/nt_registry_unittest.cc
diff --git a/chrome_elf/nt_registry/nt_registry_unittest.cc b/chrome_elf/nt_registry/nt_registry_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..30163ca832031f61dbf72a554f72b7b6ff6e4622
--- /dev/null
+++ b/chrome_elf/nt_registry/nt_registry_unittest.cc
@@ -0,0 +1,386 @@
+// Copyright 2016 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 <rpc.h>
+#include <stddef.h>
+#include <windows.h>
+
+#include "chrome_elf/nt_registry/nt_registry.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+void NtRegTestingRedirect(nt::ROOT_KEY key) {
+  UUID uuid = {};
+  RPC_STATUS status = UuidCreateSequential(&uuid);
+  if (status != RPC_S_OK && status != RPC_S_UUID_NO_ADDRESS)
+    return;
+  RPC_WSTR guid = nullptr;
+  if (UuidToStringW(&uuid, &guid) != RPC_S_OK)
+    return;
+
+  wchar_t temp_path[MAX_PATH] = L"SOFTWARE\\Chromium\\TempTestKeys\\";

[grt (UTC plus 2), 2016/09/26 11:49:18]

the RegistryOverrideManager in base was problematic once upon a time, as it
would leave data in the registry in case of test failures. over time, the
registry on the bots got clogged with tons of old test keys. this was fixed in
http://crrev.com/234367. today, the ROM will automatically delete stale values
on a machine each time it is used. do we not need something similar here?

[penny, 2016/09/28 22:36:51]

Sure.  I've added NtRegDeleteStaleTestKeys() that is run in the NtRegistryTest
class constructor.  It'll delete any keys not touched in 12 hours.

+  ::wcsncat(temp_path, reinterpret_cast<wchar_t*>(guid),
+            (MAX_PATH - ::wcslen(temp_path) - 1));
+  RpcStringFreeW(&guid);
+
+  if (key == nt::HKCU) {

[grt (UTC plus 2), 2016/09/26 11:49:18]

nit: omit braces

[penny, 2016/09/28 22:36:52]

Apparently we have a precheck that asks for braces in an "if/else if" block. 
That's why I added these for my first upload.

Having said that - now they need to be there for multi-lines.

[grt (UTC plus 2), 2016/09/29 10:30:21]

TIL...

+    ::wcsncpy(nt::HKCU_override, temp_path, nt::g_kRegMaxPathLen - 1);
+  } else if (key == nt::HKLM) {
+    ::wcsncpy(nt::HKLM_override, temp_path, nt::g_kRegMaxPathLen - 1);
+  }
+  // nt::AUTO should not be passed into this function.

[grt (UTC plus 2), 2016/09/26 11:49:18]

remove comment and ASSERT_NE(nt::AUTO, key); at the top of the fn

[penny, 2016/09/28 22:36:52]

Done.

+}
+
+void CancelNtRegTestingRedirect(nt::ROOT_KEY key) {
+  if (key == nt::HKCU) {

[grt (UTC plus 2), 2016/09/26 11:49:18]

nit: omit braces

[penny, 2016/09/28 22:36:52]

Apparently we have a precheck that asks for braces in an "if/else if" block. 
That's why I added these for my first upload.

Having said that - now they need to be there for multi-lines.

+    ::wcsncpy(nt::HKCU_override, L"", nt::g_kRegMaxPathLen - 1);
+  } else if (key == nt::HKLM) {
+    ::wcsncpy(nt::HKLM_override, L"", nt::g_kRegMaxPathLen - 1);
+  }
+  // nt::AUTO should not be passed into this function.

[grt (UTC plus 2), 2016/09/26 11:49:18]

same comment as above

[penny, 2016/09/28 22:36:52]

Done.

+}
+
+class NtRegistryTest : public testing::Test {

[grt (UTC plus 2), 2016/09/26 11:49:18]

prefer using TEST rather than TEST_F with an empty fixture.

[penny, 2016/09/28 22:36:52]

Acknowledged.

+ protected:
+  NtRegistryTest() {}
+};
+
+//------------------------------------------------------------------------------
+// NT registry API tests
+//------------------------------------------------------------------------------
+
+TEST_F(NtRegistryTest, API) {

[grt (UTC plus 2), 2016/09/26 11:49:18]

i this this function should be broken up into a number of small tests within a
single test fixture that each exhaustively test one thing. this will make it
easier to read and easier for another developer to understand future test
failures. in so doing, move the redirection into SetUpTestCase and
TearDownTestCase; otherwise, cancel will not be called in case of any test
failure. if it makes sense to, creation/deletion of the temp key could be moved
into the ctor/dtor or SetUp/TearDown overrides (prefer the former unless
restrictions require the latter; see
https://github.com/google/googletest/blob/master/googletest/docs/FAQ.md#shoul...).

[penny, 2016/09/28 22:36:51]

Done.

+  HANDLE key_handle;
+  const wchar_t* dword_val_name = L"DwordTestValue";
+  DWORD dword_val = 1234;
+  const wchar_t* sz_val_name = L"SzTestValue";
+  std::wstring sz_val = L"blah de blah de blahhhhh.";
+  const wchar_t* sz_val_name2 = L"SzTestValueEmpty";
+  std::wstring sz_val2 = L"";
+  const wchar_t* multisz_val_name = L"SzmultiTestValue";
+  std::vector<std::wstring> multisz_val;
+  std::wstring multi1 = L"one";
+  std::wstring multi2 = L"two";
+  std::wstring multi3 = L"three";
+  const wchar_t* multisz_val_name2 = L"SzmultiTestValueBad";
+  std::wstring multi_empty = L"";
+  const wchar_t* sz_new_key_1 = L"test\\new\\subkey";
+  const wchar_t* sz_new_key_2 = L"test\\new\\subkey\\blah\\";
+  const wchar_t* sz_new_key_3 = L"\\test\\new\\subkey\\\\blah2";
+
+  // Set up registry override for this test.
+  NtRegTestingRedirect(nt::HKCU);
+
+  // Create a temp key to play under.
+  ASSERT_TRUE(nt::CreateRegKey(nt::HKCU,
+                               L"SOFTWARE\\Testing\\Chrome\\NTRegistry",
+                               KEY_ALL_ACCESS, &key_handle));
+

[grt (UTC plus 2), 2016/09/26 11:49:18]

?
  EXPEC_NE(key_handle, INVALID_HANDLE_VALUE);

[penny, 2016/09/28 22:36:52]

nt::CreateRegKey does not touch |key_handle| unless it returns true and is
successful.

This function ASSERTS if the function returns false... also none of the follow
up calls will succeed without a valid handle.

But I can throw some checks in there.

Done in a couple places.

[grt (UTC plus 2), 2016/09/29 10:30:21]

Check.
Check.
This is exactly the point of having the test: it's obvious to you that the right
thing will happen. We need a test that will fail as early as possible if the
right thing doesn't happen so that a regression down the line will be extremely
easy to diagnose.
Thanks!

+  // Exercise the supported getter & setter functions.
+  EXPECT_TRUE(nt::SetRegValueDWORD(key_handle, dword_val_name, dword_val));
+  EXPECT_TRUE(nt::SetRegValueSZ(key_handle, sz_val_name, sz_val));
+  EXPECT_TRUE(nt::SetRegValueSZ(key_handle, sz_val_name2, sz_val2));
+
+  DWORD get_dword = 0;
+  std::wstring get_sz;
+  EXPECT_TRUE(nt::QueryRegValueDWORD(key_handle, dword_val_name, &get_dword) &&
+              get_dword == dword_val);

[grt (UTC plus 2), 2016/09/26 11:49:18]

break these up into two expectations so that the developer doesn't need to guess
which one failed

[penny, 2016/09/28 22:36:52]

Done. Got lazy there.

+  EXPECT_TRUE(nt::QueryRegValueSZ(key_handle, sz_val_name, &get_sz) &&
+              get_sz.compare(sz_val) == 0);
+  EXPECT_TRUE(nt::QueryRegValueSZ(key_handle, sz_val_name2, &get_sz) &&
+              get_sz.compare(sz_val2) == 0);
+
+  multisz_val.push_back(multi1);
+  multisz_val.push_back(multi2);
+  multisz_val.push_back(multi3);
+  EXPECT_TRUE(
+      nt::SetRegValueMULTISZ(key_handle, multisz_val_name, multisz_val));
+  multisz_val.clear();
+  multisz_val.push_back(multi_empty);
+  EXPECT_TRUE(
+      nt::SetRegValueMULTISZ(key_handle, multisz_val_name2, multisz_val));
+  multisz_val.clear();
+
+  EXPECT_TRUE(
+      nt::QueryRegValueMULTISZ(key_handle, multisz_val_name, &multisz_val));
+  if (multisz_val.size() == 3) {
+    EXPECT_TRUE(multi1.compare(multisz_val.at(0)) == 0);
+    EXPECT_TRUE(multi2.compare(multisz_val.at(1)) == 0);
+    EXPECT_TRUE(multi3.compare(multisz_val.at(2)) == 0);
+  } else {
+    EXPECT_TRUE(false);
+  }
+  multisz_val.clear();
+
+  EXPECT_TRUE(
+      nt::QueryRegValueMULTISZ(key_handle, multisz_val_name2, &multisz_val));
+  if (multisz_val.size() == 1) {
+    EXPECT_TRUE(multi_empty.compare(multisz_val.at(0)) == 0);
+  } else {
+    EXPECT_TRUE(false);
+  }
+  multisz_val.clear();
+
+  // Clean up
+  EXPECT_TRUE(nt::DeleteRegKey(key_handle));
+  nt::CloseRegKey(key_handle);
+
+  // More tests for CreateRegKey recursion.
+  ASSERT_TRUE(
+      nt::CreateRegKey(nt::HKCU, sz_new_key_1, KEY_ALL_ACCESS, nullptr));
+  EXPECT_TRUE(nt::OpenRegKey(nt::HKCU, sz_new_key_1, KEY_ALL_ACCESS,
+                             &key_handle, nullptr));
+  EXPECT_TRUE(nt::DeleteRegKey(key_handle));
+  nt::CloseRegKey(key_handle);
+
+  ASSERT_TRUE(
+      nt::CreateRegKey(nt::HKCU, sz_new_key_2, KEY_ALL_ACCESS, nullptr));
+  EXPECT_TRUE(nt::OpenRegKey(nt::HKCU, sz_new_key_2, KEY_ALL_ACCESS,
+                             &key_handle, nullptr));
+  EXPECT_TRUE(nt::DeleteRegKey(key_handle));
+  nt::CloseRegKey(key_handle);
+
+  ASSERT_TRUE(
+      nt::CreateRegKey(nt::HKCU, sz_new_key_3, KEY_ALL_ACCESS, nullptr));
+  EXPECT_TRUE(nt::OpenRegKey(nt::HKCU, L"test\\new\\subkey\\blah2",
+                             KEY_ALL_ACCESS, &key_handle, nullptr));
+  EXPECT_TRUE(nt::DeleteRegKey(key_handle));
+  nt::CloseRegKey(key_handle);
+
+  ASSERT_TRUE(nt::CreateRegKey(nt::HKCU, nullptr, KEY_ALL_ACCESS, &key_handle));
+  nt::CloseRegKey(key_handle);
+
+  // Cancel registry override for this test.
+  CancelNtRegTestingRedirect(nt::HKCU);
+}
+
+//------------------------------------------------------------------------------
+// WOW64 redirection tests
+//
+// - Only HKCU will be tested on the auto (try) bots.
+//   HKLM will be kept separate (and manual) for local testing only.
+//
+// NOTE: Currently no real WOW64 context testing, as building x86 projects
+//       during x64 builds is not currently supported for performance reasons.
+// https://cs.chromium.org/chromium/src/build/toolchain/win/BUILD.gn?sq%3Dpackage:chromium&l=314
+//------------------------------------------------------------------------------
+
+// Utility function for the WOW64 redirection test suites.
+// Note: Testing redirection through ADVAPI32 here as well, to get notice if
+//       expected behaviour changes!
+// If |redirected_path| == nullptr, no redirection is expected in any case.
+void DoRedirectTest(nt::ROOT_KEY nt_root_key,
+                    const wchar_t* path,
+                    const wchar_t* redirected_path OPTIONAL) {
+  HANDLE handle = INVALID_HANDLE_VALUE;
+  HKEY key_handle = nullptr;
+  ACCESS_MASK access = KEY_WRITE | DELETE;

[grt (UTC plus 2), 2016/09/26 11:49:18]

nit: const-ipate this and root_key:
  constexpr ACCESS_MASK kAccess = ...;  (kFoo since this is a compile-time
constant)
  const HKEY root_key = ...; (unix_hacker since this is a runtime constant)

[penny, 2016/09/28 22:36:52]

Done.

+  HKEY root_key =
+      (nt_root_key == nt::HKCU) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
+
+  // Make sure clean before starting.
+  nt::DeleteRegKey(nt_root_key, nt::NONE, path);

[grt (UTC plus 2), 2016/09/26 11:49:18]

wdyt of using advapi functions for all of the setup-and-verify code? with this
help ensure consistency?

[penny, 2016/09/28 22:36:52]

I don't actually think it'll make any difference.  I made a conscious decision
in this redirection test to only use advapi in these two CreateKey spots - where
I purposefully want to catch any MS behaviour changes.

I'd prefer to leave this as is.  The test will absolutely break if NTReg lib is
not behaving as expected.

+  if (redirected_path)
+    nt::DeleteRegKey(nt_root_key, nt::NONE, redirected_path);
+
+  //----------------------------------------------------------------------------
+  // No redirection through ADVAPI32 on straight x86 or x64.
+  ASSERT_EQ(ERROR_SUCCESS,
+            RegCreateKeyExW(root_key, path, 0, nullptr, REG_OPTION_NON_VOLATILE,
+                            access, nullptr, &key_handle, nullptr));
+  ASSERT_EQ(ERROR_SUCCESS, RegCloseKey(key_handle));
+  ASSERT_TRUE(nt::OpenRegKey(nt_root_key, path, access, &handle, nullptr));
+  ASSERT_TRUE(nt::DeleteRegKey(handle));
+  nt::CloseRegKey(handle);
+
+#ifdef _WIN64
+  //----------------------------------------------------------------------------
+  // Try forcing WOW64 redirection on x64 through ADVAPI32.
+  ASSERT_EQ(
+      ERROR_SUCCESS,
+      RegCreateKeyExW(root_key, path, 0, nullptr, REG_OPTION_NON_VOLATILE,
+                      access | KEY_WOW64_32KEY, nullptr, &key_handle, nullptr));
+  ASSERT_EQ(ERROR_SUCCESS, RegCloseKey(key_handle));
+  // Check path:
+  if (nt::OpenRegKey(nt_root_key, path, access, &handle, nullptr)) {
+    if (redirected_path)
+      ADD_FAILURE();
+    ASSERT_TRUE(nt::DeleteRegKey(handle));
+    nt::CloseRegKey(handle);
+  } else if (!redirected_path) {
+    // Should have succeeded.
+    ADD_FAILURE();
+  }
+  if (redirected_path) {
+    // Check redirected path:
+    if (nt::OpenRegKey(nt_root_key, redirected_path, access, &handle,
+                       nullptr)) {
+      if (!redirected_path)
+        ADD_FAILURE();
+      ASSERT_TRUE(nt::DeleteRegKey(handle));
+      nt::CloseRegKey(handle);
+    } else {
+      // Should have succeeded.
+      ADD_FAILURE();
+    }
+  }
+
+  //----------------------------------------------------------------------------
+  // Try forcing WOW64 redirection on x64 through NTDLL.
+  ASSERT_TRUE(
+      nt::CreateRegKey(nt_root_key, path, access | KEY_WOW64_32KEY, nullptr));
+  // Check path:
+  if (nt::OpenRegKey(nt_root_key, path, access, &handle, nullptr)) {
+    if (redirected_path)
+      ADD_FAILURE();
+    ASSERT_TRUE(nt::DeleteRegKey(handle));
+    nt::CloseRegKey(handle);
+  } else if (!redirected_path) {
+    // Should have succeeded.
+    ADD_FAILURE();
+  }
+  if (redirected_path) {
+    // Check redirected path:
+    if (nt::OpenRegKey(nt_root_key, redirected_path, access, &handle,
+                       nullptr)) {
+      if (!redirected_path)
+        ADD_FAILURE();
+      ASSERT_TRUE(nt::DeleteRegKey(handle));
+      nt::CloseRegKey(handle);
+    } else {
+      // Should have succeeded.
+      ADD_FAILURE();
+    }
+  }
+#endif  // _WIN64
+}
+
+// Hard-coding array size to match nt_registry.cc.  Easier to catch missing

[grt (UTC plus 2), 2016/09/26 11:49:18]

please make this comment directly reference the thing it needs to match in
nt_registry.cc, and put a corresponding comment there pointing the reader at
this. i don't see how putting the size in here makes it any less likely that
someone will edit one but not the other. (comment applies to hklm_no_redirects,
too)

[penny, 2016/09/28 22:36:51]

Done.

+// elements.
+const wchar_t* classes_redirects[10] = {

[grt (UTC plus 2), 2016/09/26 11:49:18]

nit: constexpr const wchar_t* kClassesRedirects[] = {
(similarly for hklm_no_redirects)

[penny, 2016/09/28 22:36:51]

Done.

+    L"SOFTWARE\\Classes\\CLSID\\chrome_testing",
+    L"SOFTWARE\\Classes\\WOW6432Node\\CLSID\\chrome_testing",
+    L"SOFTWARE\\Classes\\DirectShow\\chrome_testing",
+    L"SOFTWARE\\Classes\\WOW6432Node\\DirectShow\\chrome_testing",
+    L"SOFTWARE\\Classes\\Interface\\chrome_testing",
+    L"SOFTWARE\\Classes\\WOW6432Node\\Interface\\chrome_testing",
+    L"SOFTWARE\\Classes\\Media Type\\chrome_testing",
+    L"SOFTWARE\\Classes\\WOW6432Node\\Media Type\\chrome_testing",
+    L"SOFTWARE\\Classes\\MediaFoundation\\chrome_testing",
+    L"SOFTWARE\\Classes\\WOW6432Node\\MediaFoundation\\chrome_testing"};
+

[grt (UTC plus 2), 2016/09/26 11:49:18]

static_assert(_countof(kClassesRedirects) & 0x01 == 0, "must have an even number
of Classes redirects");

[penny, 2016/09/28 22:36:52]

Done.

+// This test does not use a testing registry_util::RegistryOverrideManager.
+// It requires Windows WOW64 redirection to take place, which would not
+// happen with a testing redirection layer.
+TEST_F(NtRegistryTest, Wow64RedirectionHKCU) {
+  size_t index = 0;
+  size_t array_size = sizeof(classes_redirects) / sizeof(classes_redirects[0]);
+
+  // Using two elements for each loop.
+  while (index < array_size) {

[grt (UTC plus 2), 2016/09/26 11:49:18]

?
  for (size_t index = 0; index < _countof(kClassesRedirects); index += 2)

(same on line 378)

[penny, 2016/09/28 22:36:52]

Done.

+    DoRedirectTest(nt::HKCU, classes_redirects[index],
+                   classes_redirects[index + 1]);
+    index += 2;
+  }
+}

[grt (UTC plus 2), 2016/09/26 11:49:18]

also test at least one key in Classes that should be shared?

[penny, 2016/09/28 22:36:52]

Done.

+
+// Hard-coding array size to match nt_registry.cc.  Easier to catch missing
+// elements.
+const wchar_t* hklm_no_redirects[49] = {

[grt (UTC plus 2), 2016/09/26 11:49:18]

constexpr const wchar_t*

[penny, 2016/09/28 22:36:52]

Done.

+    L"SOFTWARE\\Classes\\chrome_testing", L"SOFTWARE\\Clients\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\COM3\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Cryptography\\Calais\\Current\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Cryptography\\Calais\\Readers\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Cryptography\\Services\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\CTF\\SystemShared\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\CTF\\TIP\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\DFS\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Driver Signing\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\EnterpriseCertificates\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\EventSystem\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\MSMQ\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Non-Driver Signing\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Notepad\\DefaultFonts\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\OLE\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\RAS\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\RPC\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\SOFTWARE\\Microsoft\\Shared "
+    L"Tools\\MSInfo\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\SystemCertificates\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\TermServLicensing\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Transaction Server\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Control "
+    L"Panel\\Cursors\\Schemes\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\AutoplayHandlers"
+    L"\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\DriveIcons\\chrom"
+    L"e_testing",
+    L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\KindMap\\chrome_"
+    L"testing",
+    L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Group "
+    L"Policy\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\PreviewHandlers\\chrome_"
+    L"testing",
+    L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Locations\\chrom"
+    L"e_testing",
+    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Console\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\FontDpi\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows "
+    L"NT\\CurrentVersion\\FontLink\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows "
+    L"NT\\CurrentVersion\\FontMapper\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes\\chrome_"
+    L"testing",
+    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Gre_initialize\\chrome_"
+    L"testing",
+    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution "
+    L"Options\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows "
+    L"NT\\CurrentVersion\\LanguagePack\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\NetworkCards\\chrome_"
+    L"testing",
+    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Perflib\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Ports\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Print\\chrome_testing",
+    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList\\chrome_"
+    L"testing",
+    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time "
+    L"Zones\\chrome_testing",
+    L"SOFTWARE\\Policies\\chrome_testing",
+    L"SOFTWARE\\RegisteredApplications\\chrome_testing"};
+
+// Run from administrator command prompt!
+// Note: Disabled for automated testing (HKLM protection).  Local testing only.
+TEST_F(NtRegistryTest, DISABLED_Wow64RedirectionHKLM) {
+  // 1) SOFTWARE is redirected.
+  DoRedirectTest(nt::HKLM, L"SOFTWARE\\chrome_testing",
+                 L"SOFTWARE\\WOW6432Node\\chrome_testing");
+
+  // 2) Except some subkeys are not.
+  size_t index = 0;
+  size_t array_size = sizeof(hklm_no_redirects) / sizeof(hklm_no_redirects[0]);
+  while (index < array_size) {
+    DoRedirectTest(nt::HKLM, hklm_no_redirects[index], nullptr);
+    index++;
+  }
+
+  // 3) But then some Classes subkeys are redirected.
+  index = 0;
+  array_size = sizeof(classes_redirects) / sizeof(classes_redirects[0]);
+
+  // Using two elements for each loop.
+  while (index < array_size) {
+    DoRedirectTest(nt::HKLM, classes_redirects[index],
+                   classes_redirects[index + 1]);
+    index += 2;
+  }
+}
+
+//----------------------------------------------------------------------------

[grt (UTC plus 2), 2016/09/26 11:49:18]

nit: remove this

[penny, 2016/09/28 22:36:52]

Done.

+}  // namespace