components/user_prefs/tracked/registry_hash_store_contents_win_unittest.cc - Issue 2782803002: Move tracked prefs into services/preferences/tracked.

Side by Side Diff: components/user_prefs/tracked/registry_hash_store_contents_win_unittest.cc

Issue 2782803002: Move tracked prefs into services/preferences/tracked. (Closed)

Patch Set: Created 3 years, 8 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

« chrome/test/BUILD.gn ('K') | « components/user_prefs/tracked/registry_hash_store_contents_win.cc ('k') | components/user_prefs/tracked/segregated_pref_store.h » ('j') | services/preferences/public/cpp/tracked/BUILD.gn » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
1 // Copyright (c) 2016 The Chromium Authors. All rights reserved.

2 // Use of this source code is governed by a BSD-style license that can be

3 // found in the LICENSE file.

4

5 #include "components/user_prefs/tracked/registry_hash_store_contents_win.h"

6

7 #include "base/strings/string16.h"

8 #include "base/strings/utf_string_conversions.h"

9 #include "base/test/test_reg_util_win.h"

10 #include "base/values.h"

11 #include "base/win/registry.h"

12 #include "testing/gtest/include/gtest/gtest.h"

13

14 namespace {

15

16 constexpr base::char16 kRegistryPath[] = L"Foo\\TestStore";

17 constexpr base::char16 kStoreKey[] = L"test_store_key";

18

19 // Hex-encoded MACs are 64 characters long.

20 constexpr char kTestStringA[] =

21 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";

22 constexpr char kTestStringB[] =

23 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";

24

25 constexpr char kAtomicPrefPath[] = "path1";

26 constexpr char kSplitPrefPath[] = "extension";

27

28 class RegistryHashStoreContentsWinTest : public testing::Test {

29 protected:

30 RegistryHashStoreContentsWinTest() {}

31

32 void SetUp() override {

33 ASSERT_NO_FATAL_FAILURE(

34 registry_override_manager_.OverrideRegistry(HKEY_CURRENT_USER));

35

36 contents.reset(new RegistryHashStoreContentsWin(kRegistryPath, kStoreKey));

37 }

38

39 std::unique_ptr<HashStoreContents> contents;

40

41 private:

42 registry_util::RegistryOverrideManager registry_override_manager_;

43

44 DISALLOW_COPY_AND_ASSIGN(RegistryHashStoreContentsWinTest);

45 };

46

47 } // namespace

48

49 TEST_F(RegistryHashStoreContentsWinTest, TestSetAndGetMac) {

50 std::string stored_mac;

51 EXPECT_FALSE(contents->GetMac(kAtomicPrefPath, &stored_mac));

52

53 contents->SetMac(kAtomicPrefPath, kTestStringA);

54

55 EXPECT_TRUE(contents->GetMac(kAtomicPrefPath, &stored_mac));

56 EXPECT_EQ(kTestStringA, stored_mac);

57 }

58

59 TEST_F(RegistryHashStoreContentsWinTest, TestSetAndGetSplitMacs) {

60 std::map<std::string, std::string> split_macs;

61 EXPECT_FALSE(contents->GetSplitMacs(kSplitPrefPath, &split_macs));

62

63 contents->SetSplitMac(kSplitPrefPath, "a", kTestStringA);

64 contents->SetSplitMac(kSplitPrefPath, "b", kTestStringB);

65

66 EXPECT_TRUE(contents->GetSplitMacs(kSplitPrefPath, &split_macs));

67 EXPECT_EQ(2U, split_macs.size());

68 EXPECT_EQ(kTestStringA, split_macs.at("a"));

69 EXPECT_EQ(kTestStringB, split_macs.at("b"));

70 }

71

72 TEST_F(RegistryHashStoreContentsWinTest, TestRemoveAtomicMac) {

73 contents->SetMac(kAtomicPrefPath, kTestStringA);

74

75 std::string stored_mac;

76 EXPECT_TRUE(contents->GetMac(kAtomicPrefPath, &stored_mac));

77 EXPECT_EQ(kTestStringA, stored_mac);

78

79 contents->RemoveEntry(kAtomicPrefPath);

80

81 EXPECT_FALSE(contents->GetMac(kAtomicPrefPath, &stored_mac));

82 }

83

84 TEST_F(RegistryHashStoreContentsWinTest, TestRemoveSplitMacs) {

85 contents->SetSplitMac(kSplitPrefPath, "a", kTestStringA);

86 contents->SetSplitMac(kSplitPrefPath, "b", kTestStringB);

87

88 std::map<std::string, std::string> split_macs;

89 EXPECT_TRUE(contents->GetSplitMacs(kSplitPrefPath, &split_macs));

90 EXPECT_EQ(2U, split_macs.size());

91

92 contents->RemoveEntry(kSplitPrefPath);

93

94 split_macs.clear();

95 EXPECT_FALSE(contents->GetSplitMacs(kSplitPrefPath, &split_macs));

96 EXPECT_EQ(0U, split_macs.size());

97 }

98

99 TEST_F(RegistryHashStoreContentsWinTest, TestReset) {

100 contents->SetMac(kAtomicPrefPath, kTestStringA);

101 contents->SetSplitMac(kSplitPrefPath, "a", kTestStringA);

102

103 std::string stored_mac;

104 EXPECT_TRUE(contents->GetMac(kAtomicPrefPath, &stored_mac));

105 EXPECT_EQ(kTestStringA, stored_mac);

106

107 std::map<std::string, std::string> split_macs;

108 EXPECT_TRUE(contents->GetSplitMacs(kSplitPrefPath, &split_macs));

109 EXPECT_EQ(1U, split_macs.size());

110

111 contents->Reset();

112

113 stored_mac.clear();

114 EXPECT_FALSE(contents->GetMac(kAtomicPrefPath, &stored_mac));

115 EXPECT_TRUE(stored_mac.empty());

116

117 split_macs.clear();

118 EXPECT_FALSE(contents->GetSplitMacs(kSplitPrefPath, &split_macs));

119 EXPECT_EQ(0U, split_macs.size());

120 }

OLD	NEW