[Chrome ELF] New NT registry API.

chrome_elf/chrome_elf_util_unittest.cc

 // Copyright 2014 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 "chrome_elf/chrome_elf_util.h"
 
 #include <tuple>
+#include <windows.h>
+#include <versionhelpers.h>  // windows.h must be before.
 
 #include "base/test/test_reg_util_win.h"
 #include "base/win/registry.h"
+#include "chrome_elf/chrome_elf_constants.h"
+#include "chrome_elf/chrome_elf_reg.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace {
 
 const wchar_t kRegPathClientState[] = L"Software\\Google\\Update\\ClientState";
 const wchar_t kRegPathClientStateMedium[] =
     L"Software\\Google\\Update\\ClientStateMedium";
 const wchar_t kRegValueUsageStats[] = L"usagestats";
 const wchar_t kUninstallArgumentsField[] = L"UninstallArguments";
@@ skipping 26 matching lines @@
   EXPECT_TRUE(IsSystemInstall(kChromeSystemExePath));
   EXPECT_FALSE(IsSystemInstall(kChromeUserExePath));
 }
 
 TEST(ChromeElfUtilTest, BrowserProcessTest) {
   EXPECT_EQ(ProcessType::UNINITIALIZED, g_process_type);
   InitializeProcessType();
   EXPECT_FALSE(IsNonBrowserProcess());
 }
 
+//------------------------------------------------------------------------------
+// NT registry API tests (chrome_elf_reg)
+//------------------------------------------------------------------------------
+
+TEST(ChromeElfUtilTest, NTRegistry) {
+  HANDLE key_handle;
+  wchar_t* dword_val_name = L"DwordTestValue";
+  DWORD dword_val = 1234;
+  wchar_t* sz_val_name = L"SzTestValue";
+  base::string16 sz_val = L"blah de blah de blahhhhh.";
+  wchar_t* sz_val_name2 = L"SzTestValueEmpty";
+  base::string16 sz_val2 = L"";
+  wchar_t* multisz_val_name = L"SzmultiTestValue";
+  std::vector<base::string16> multisz_val;
+  base::string16 multi1 = L"one";
+  base::string16 multi2 = L"two";
+  base::string16 multi3 = L"three";
+  wchar_t* multisz_val_name2 = L"SzmultiTestValueBad";
+  base::string16 multi_empty = L"";
+
+  // Create a temp key to play under.
+  ASSERT_TRUE(nt::CreateRegKey(nt::AUTO, elf_sec::kRegSecurityPath,
+                               KEY_ALL_ACCESS, &key_handle));
+
+  // Exercise the supported getter & setter functions.
+  EXPECT_TRUE(nt::SetRegValue_DWORD(key_handle, dword_val_name, dword_val));
+  EXPECT_TRUE(nt::SetRegValue_SZ(key_handle, sz_val_name, &sz_val));
+  EXPECT_TRUE(nt::SetRegValue_SZ(key_handle, sz_val_name2, &sz_val2));
+
+  DWORD get_dword = 0;
+  base::string16 get_sz;
+  EXPECT_TRUE(nt::GetRegValue_DWORD(key_handle, dword_val_name, &get_dword) &&
+              get_dword == dword_val);
+  EXPECT_TRUE(nt::GetRegValue_SZ(key_handle, sz_val_name, &get_sz) &&
+              get_sz.compare(sz_val) == 0);
+  EXPECT_TRUE(nt::GetRegValue_SZ(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::SetRegValue_MULTI_SZ(key_handle, multisz_val_name, &multisz_val));
+  multisz_val.clear();
+  multisz_val.push_back(multi_empty);
+  EXPECT_TRUE(
+      nt::SetRegValue_MULTI_SZ(key_handle, multisz_val_name2, &multisz_val));
+  multisz_val.clear();
+
+  EXPECT_TRUE(
+      nt::GetRegValue_MULTI_SZ(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::GetRegValue_MULTI_SZ(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);
+}
+
 // Parameterized test with paramters:
 // 1: product: "canary" or "google"
 // 2: install level: "user" or "system"
 // 3: install mode: "single" or "multi"
 class ChromeElfUtilTest :
     public testing::TestWithParam<std::tuple<const char*,
                                              const char*,
                                              const char*> > {
  protected:
   void SetUp() override {
-    override_manager_.OverrideRegistry(HKEY_LOCAL_MACHINE);
-    override_manager_.OverrideRegistry(HKEY_CURRENT_USER);
+    override_manager_.OverrideRegistry(HKEY_LOCAL_MACHINE, &nt::HKLM_override);
+    override_manager_.OverrideRegistry(HKEY_CURRENT_USER, &nt::HKCU_override);
+
     const char* app;
     const char* level;
     const char* mode;
     std::tie(app, level, mode) = GetParam();
     is_canary_ = (std::string(app) == "canary");
     system_level_ = (std::string(level) != "user");
     multi_install_ = (std::string(mode) != "single");
     if (is_canary_) {
       ASSERT_FALSE(system_level_);
       ASSERT_FALSE(multi_install_);
@@ skipping 102 matching lines @@
 INSTANTIATE_TEST_CASE_P(Canary, ChromeElfUtilTest,
                         testing::Combine(testing::Values("canary"),
                                          testing::Values("user"),
                                          testing::Values("single")));
 INSTANTIATE_TEST_CASE_P(GoogleChrome, ChromeElfUtilTest,
                         testing::Combine(testing::Values("google"),
                                          testing::Values("user", "system"),
                                          testing::Values("single", "multi")));
 
 }  // namespace