| 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
|
| index d2020429fadbc20d9da8ee412c54612e3bc15766..7bf75647029e093b36c76a8b6105994b832751da 100644
|
| --- a/chrome_elf/nt_registry/nt_registry_unittest.cc
|
| +++ b/chrome_elf/nt_registry/nt_registry_unittest.cc
|
| @@ -31,7 +31,6 @@ namespace {
|
| 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;
|
| constexpr ACCESS_MASK kAccess = KEY_WRITE | DELETE;
|
| const HKEY root_key =
|
| @@ -48,9 +47,12 @@ void DoRedirectTest(nt::ROOT_KEY nt_root_key,
|
| RegCreateKeyExW(root_key, path, 0, nullptr, REG_OPTION_NON_VOLATILE,
|
| kAccess, nullptr, &key_handle, nullptr));
|
| ASSERT_EQ(ERROR_SUCCESS, RegCloseKey(key_handle));
|
| - ASSERT_TRUE(nt::OpenRegKey(nt_root_key, path, kAccess, &handle, nullptr));
|
| - ASSERT_TRUE(nt::DeleteRegKey(handle));
|
| - nt::CloseRegKey(handle);
|
| + {
|
| + nt::ScopedHANDLE handle(
|
| + nt::OpenRegKey(nt_root_key, path, kAccess, nullptr));
|
| + ASSERT_TRUE(handle.is_valid());
|
| + ASSERT_TRUE(nt::DeleteRegKey(handle.get()));
|
| + }
|
|
|
| #ifdef _WIN64
|
| //----------------------------------------------------------------------------
|
| @@ -61,23 +63,26 @@ void DoRedirectTest(nt::ROOT_KEY nt_root_key,
|
| nullptr));
|
| ASSERT_EQ(ERROR_SUCCESS, RegCloseKey(key_handle));
|
| // Check path:
|
| - if (nt::OpenRegKey(nt_root_key, path, kAccess, &handle, nullptr)) {
|
| - if (redirected_path)
|
| + {
|
| + nt::ScopedHANDLE handle(
|
| + nt::OpenRegKey(nt_root_key, path, kAccess, nullptr));
|
| + if (handle.is_valid()) {
|
| + if (redirected_path)
|
| + ADD_FAILURE();
|
| + ASSERT_TRUE(nt::DeleteRegKey(handle.get()));
|
| + } else if (!redirected_path) {
|
| + // Should have succeeded.
|
| 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, kAccess, &handle,
|
| - nullptr)) {
|
| + nt::ScopedHANDLE handle(
|
| + nt::OpenRegKey(nt_root_key, redirected_path, kAccess, nullptr));
|
| + if (handle.is_valid()) {
|
| if (!redirected_path)
|
| ADD_FAILURE();
|
| - ASSERT_TRUE(nt::DeleteRegKey(handle));
|
| - nt::CloseRegKey(handle);
|
| + ASSERT_TRUE(nt::DeleteRegKey(handle.get()));
|
| } else {
|
| // Should have succeeded.
|
| ADD_FAILURE();
|
| @@ -86,26 +91,29 @@ void DoRedirectTest(nt::ROOT_KEY nt_root_key,
|
|
|
| //----------------------------------------------------------------------------
|
| // Try forcing WOW64 redirection on x64 through NTDLL.
|
| - ASSERT_TRUE(
|
| - nt::CreateRegKey(nt_root_key, path, kAccess | KEY_WOW64_32KEY, nullptr));
|
| + ASSERT_TRUE(nt::CreateRegKey(nt_root_key, path, kAccess | KEY_WOW64_32KEY)
|
| + .is_valid());
|
| // Check path:
|
| - if (nt::OpenRegKey(nt_root_key, path, kAccess, &handle, nullptr)) {
|
| - if (redirected_path)
|
| + {
|
| + nt::ScopedHANDLE handle(
|
| + nt::OpenRegKey(nt_root_key, path, kAccess, nullptr));
|
| + if (handle.is_valid()) {
|
| + if (redirected_path)
|
| + ADD_FAILURE();
|
| + ASSERT_TRUE(nt::DeleteRegKey(handle.get()));
|
| + } else if (!redirected_path) {
|
| + // Should have succeeded.
|
| 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, kAccess, &handle,
|
| - nullptr)) {
|
| + nt::ScopedHANDLE handle(
|
| + nt::OpenRegKey(nt_root_key, redirected_path, kAccess, nullptr));
|
| + if (handle.is_valid()) {
|
| if (!redirected_path)
|
| ADD_FAILURE();
|
| - ASSERT_TRUE(nt::DeleteRegKey(handle));
|
| - nt::CloseRegKey(handle);
|
| + ASSERT_TRUE(nt::DeleteRegKey(handle.get()));
|
| } else {
|
| // Should have succeeded.
|
| ADD_FAILURE();
|
| @@ -315,64 +323,62 @@ class NtRegistryTest : public testing::Test {
|
| //------------------------------------------------------------------------------
|
|
|
| TEST_F(NtRegistryTest, API_DWORD) {
|
| - HANDLE key_handle;
|
| const wchar_t* dword_val_name = L"DwordTestValue";
|
| DWORD dword_val = 1234;
|
|
|
| // Create a subkey to play under.
|
| - ASSERT_TRUE(nt::CreateRegKey(nt::HKCU, L"NTRegistry\\dword", KEY_ALL_ACCESS,
|
| - &key_handle));
|
| - ASSERT_NE(key_handle, INVALID_HANDLE_VALUE);
|
| - ASSERT_NE(key_handle, nullptr);
|
| + nt::ScopedHANDLE key_handle(
|
| + nt::CreateRegKey(nt::HKCU, L"NTRegistry\\dword", KEY_ALL_ACCESS));
|
| + ASSERT_TRUE(key_handle.is_valid());
|
| + ASSERT_NE(key_handle.get(), nullptr);
|
|
|
| DWORD get_dword = 0;
|
| - EXPECT_FALSE(nt::QueryRegValueDWORD(key_handle, dword_val_name, &get_dword));
|
| + EXPECT_FALSE(
|
| + nt::QueryRegValueDWORD(key_handle.get(), dword_val_name, &get_dword));
|
|
|
| // Set
|
| - EXPECT_TRUE(nt::SetRegValueDWORD(key_handle, dword_val_name, dword_val));
|
| + EXPECT_TRUE(
|
| + nt::SetRegValueDWORD(key_handle.get(), dword_val_name, dword_val));
|
|
|
| // Get
|
| - EXPECT_TRUE(nt::QueryRegValueDWORD(key_handle, dword_val_name, &get_dword));
|
| + EXPECT_TRUE(
|
| + nt::QueryRegValueDWORD(key_handle.get(), dword_val_name, &get_dword));
|
| EXPECT_TRUE(get_dword == dword_val);
|
|
|
| // Clean up
|
| - EXPECT_TRUE(nt::DeleteRegKey(key_handle));
|
| - nt::CloseRegKey(key_handle);
|
| + EXPECT_TRUE(nt::DeleteRegKey(key_handle.get()));
|
| }
|
|
|
| TEST_F(NtRegistryTest, API_SZ) {
|
| - HANDLE key_handle;
|
| 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"";
|
|
|
| // Create a subkey to play under.
|
| - ASSERT_TRUE(nt::CreateRegKey(nt::HKCU, L"NTRegistry\\sz", KEY_ALL_ACCESS,
|
| - &key_handle));
|
| - ASSERT_NE(key_handle, INVALID_HANDLE_VALUE);
|
| - ASSERT_NE(key_handle, nullptr);
|
| + nt::ScopedHANDLE key_handle(
|
| + nt::CreateRegKey(nt::HKCU, L"NTRegistry\\sz", KEY_ALL_ACCESS));
|
| + ASSERT_TRUE(key_handle.is_valid());
|
| + ASSERT_NE(key_handle.get(), nullptr);
|
|
|
| std::wstring get_sz;
|
| - EXPECT_FALSE(nt::QueryRegValueSZ(key_handle, sz_val_name, &get_sz));
|
| + EXPECT_FALSE(nt::QueryRegValueSZ(key_handle.get(), sz_val_name, &get_sz));
|
|
|
| // Set
|
| - EXPECT_TRUE(nt::SetRegValueSZ(key_handle, sz_val_name, sz_val));
|
| - EXPECT_TRUE(nt::SetRegValueSZ(key_handle, sz_val_name2, sz_val2));
|
| + EXPECT_TRUE(nt::SetRegValueSZ(key_handle.get(), sz_val_name, sz_val));
|
| + EXPECT_TRUE(nt::SetRegValueSZ(key_handle.get(), sz_val_name2, sz_val2));
|
|
|
| // Get
|
| - EXPECT_TRUE(nt::QueryRegValueSZ(key_handle, sz_val_name, &get_sz));
|
| + EXPECT_TRUE(nt::QueryRegValueSZ(key_handle.get(), sz_val_name, &get_sz));
|
| EXPECT_TRUE(get_sz.compare(sz_val) == 0);
|
| - EXPECT_TRUE(nt::QueryRegValueSZ(key_handle, sz_val_name2, &get_sz));
|
| + EXPECT_TRUE(nt::QueryRegValueSZ(key_handle.get(), sz_val_name2, &get_sz));
|
| EXPECT_TRUE(get_sz.compare(sz_val2) == 0);
|
|
|
| // Clean up
|
| - EXPECT_TRUE(nt::DeleteRegKey(key_handle));
|
| - nt::CloseRegKey(key_handle);
|
| + EXPECT_TRUE(nt::DeleteRegKey(key_handle.get()));
|
| }
|
|
|
| TEST_F(NtRegistryTest, API_MULTISZ) {
|
| - HANDLE key_handle;
|
| const wchar_t* multisz_val_name = L"SzmultiTestValue";
|
| std::vector<std::wstring> multisz_val;
|
| std::wstring multi1 = L"one";
|
| @@ -382,27 +388,27 @@ TEST_F(NtRegistryTest, API_MULTISZ) {
|
| std::wstring multi_empty = L"";
|
|
|
| // Create a subkey to play under.
|
| - ASSERT_TRUE(nt::CreateRegKey(nt::HKCU, L"NTRegistry\\multisz", KEY_ALL_ACCESS,
|
| - &key_handle));
|
| - ASSERT_NE(key_handle, INVALID_HANDLE_VALUE);
|
| - ASSERT_NE(key_handle, nullptr);
|
| + nt::ScopedHANDLE key_handle(
|
| + nt::CreateRegKey(nt::HKCU, L"NTRegistry\\multisz", KEY_ALL_ACCESS));
|
| + ASSERT_TRUE(key_handle.is_valid());
|
| + ASSERT_NE(key_handle.get(), nullptr);
|
|
|
| multisz_val.push_back(multi1);
|
| multisz_val.push_back(multi2);
|
| multisz_val.push_back(multi3);
|
| // Set
|
| EXPECT_TRUE(
|
| - nt::SetRegValueMULTISZ(key_handle, multisz_val_name, multisz_val));
|
| + nt::SetRegValueMULTISZ(key_handle.get(), multisz_val_name, multisz_val));
|
| multisz_val.clear();
|
| multisz_val.push_back(multi_empty);
|
| // Set
|
| EXPECT_TRUE(
|
| - nt::SetRegValueMULTISZ(key_handle, multisz_val_name2, multisz_val));
|
| + nt::SetRegValueMULTISZ(key_handle.get(), multisz_val_name2, multisz_val));
|
| multisz_val.clear();
|
|
|
| // Get
|
| - EXPECT_TRUE(
|
| - nt::QueryRegValueMULTISZ(key_handle, multisz_val_name, &multisz_val));
|
| + EXPECT_TRUE(nt::QueryRegValueMULTISZ(key_handle.get(), 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);
|
| @@ -413,8 +419,8 @@ TEST_F(NtRegistryTest, API_MULTISZ) {
|
| multisz_val.clear();
|
|
|
| // Get
|
| - EXPECT_TRUE(
|
| - nt::QueryRegValueMULTISZ(key_handle, multisz_val_name2, &multisz_val));
|
| + EXPECT_TRUE(nt::QueryRegValueMULTISZ(key_handle.get(), multisz_val_name2,
|
| + &multisz_val));
|
| if (multisz_val.size() == 1) {
|
| EXPECT_TRUE(multi_empty.compare(multisz_val.at(0)) == 0);
|
| } else {
|
| @@ -423,43 +429,58 @@ TEST_F(NtRegistryTest, API_MULTISZ) {
|
| multisz_val.clear();
|
|
|
| // Clean up
|
| - EXPECT_TRUE(nt::DeleteRegKey(key_handle));
|
| - nt::CloseRegKey(key_handle);
|
| + EXPECT_TRUE(nt::DeleteRegKey(key_handle.get()));
|
| }
|
|
|
| TEST_F(NtRegistryTest, CreateRegKeyRecursion) {
|
| - HANDLE key_handle;
|
| const wchar_t* sz_new_key_1 = L"test1\\new\\subkey";
|
| const wchar_t* sz_new_key_2 = L"test2\\new\\subkey\\blah\\";
|
| const wchar_t* sz_new_key_3 = L"\\test3\\new\\subkey\\\\blah2";
|
|
|
| // 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"test3\\new\\subkey\\blah2",
|
| - KEY_ALL_ACCESS, &key_handle, nullptr));
|
| - EXPECT_TRUE(nt::DeleteRegKey(key_handle));
|
| - nt::CloseRegKey(key_handle);
|
| + {
|
| + nt::ScopedHANDLE create_handle(
|
| + nt::CreateRegKey(nt::HKCU, sz_new_key_1, KEY_ALL_ACCESS));
|
| + ASSERT_TRUE(create_handle.is_valid());
|
| + }
|
| + {
|
| + nt::ScopedHANDLE key_handle(
|
| + nt::OpenRegKey(nt::HKCU, sz_new_key_1, KEY_ALL_ACCESS, nullptr));
|
| + EXPECT_TRUE(key_handle.is_valid());
|
| + EXPECT_TRUE(nt::DeleteRegKey(key_handle.get()));
|
| + }
|
| +
|
| + {
|
| + nt::ScopedHANDLE key_handle(
|
| + nt::CreateRegKey(nt::HKCU, sz_new_key_2, KEY_ALL_ACCESS));
|
| + ASSERT_TRUE(key_handle.is_valid());
|
| + }
|
| + {
|
| + nt::ScopedHANDLE key_handle(
|
| + nt::OpenRegKey(nt::HKCU, sz_new_key_2, KEY_ALL_ACCESS, nullptr));
|
| + EXPECT_TRUE(key_handle.is_valid());
|
| + EXPECT_TRUE(nt::DeleteRegKey(key_handle.get()));
|
| + }
|
| +
|
| + {
|
| + nt::ScopedHANDLE key_handle(
|
| + nt::CreateRegKey(nt::HKCU, sz_new_key_3, KEY_ALL_ACCESS));
|
| + ASSERT_TRUE(key_handle.is_valid());
|
| + }
|
| + {
|
| + nt::ScopedHANDLE key_handle(nt::OpenRegKey(
|
| + nt::HKCU, L"test3\\new\\subkey\\blah2", KEY_ALL_ACCESS, nullptr));
|
| + EXPECT_TRUE(key_handle.is_valid());
|
| + EXPECT_TRUE(nt::DeleteRegKey(key_handle.get()));
|
| + }
|
|
|
| // Subkey path can be null.
|
| - ASSERT_TRUE(nt::CreateRegKey(nt::HKCU, nullptr, KEY_ALL_ACCESS, &key_handle));
|
| - ASSERT_NE(key_handle, INVALID_HANDLE_VALUE);
|
| - ASSERT_NE(key_handle, nullptr);
|
| - nt::CloseRegKey(key_handle);
|
| + {
|
| + nt::ScopedHANDLE key_handle(
|
| + nt::CreateRegKey(nt::HKCU, nullptr, KEY_ALL_ACCESS));
|
| + ASSERT_TRUE(key_handle.is_valid());
|
| + ASSERT_NE(key_handle.get(), nullptr);
|
| + }
|
| }
|
|
|
| } // namespace
|
|
|