Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(603)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: base/registry_monitor_manager_unittest.cc

Issue 624713003: Keep only base/extractor.[cc|h]. (Closed) Base URL: https://chromium.googlesource.com/external/omaha.git@master
Patch Set: Created 6 years, 2 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:
View unified diff | Download patch
« no previous file with comments | « base/registry_monitor_manager.cc ('k') | base/registry_store.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright 2008-2009 Google Inc.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 // ========================================================================
15
16 #include <windows.h>
17 #include <limits.h>
18 #include "base/basictypes.h"
19 #include "omaha/base/scoped_any.h"
20 #include "omaha/base/reactor.h"
21 #include "omaha/base/reg_key.h"
22 #include "omaha/base/registry_monitor_manager.h"
23 #include "omaha/base/thread.h"
24 #include "omaha/base/utils.h"
25 #include "omaha/testing/unit_test.h"
26
27 namespace omaha {
28
29 namespace {
30
31 const TCHAR kKeyNameFull[] = _T("HKCU\\key");
32 const TCHAR kKeyName[] = _T("key");
33 const TCHAR kValueName[] = _T("value");
34
35 } // namespace
36
37 class RegistryMonitorTest : public testing::Test {
38 protected:
39 RegistryMonitorTest() {}
40
41 virtual void SetUp() {
42 // Override HKCU.
43 RegKey::DeleteKey(kRegistryHiveOverrideRoot);
44 OverrideSpecifiedRegistryHives(kRegistryHiveOverrideRoot, false, true);
45 reset(registry_changed_event_, ::CreateEvent(NULL, true, false, NULL));
46 }
47
48 virtual void TearDown() {
49 reset(registry_changed_event_);
50 RestoreRegistryHives();
51 RegKey::DeleteKey(kRegistryHiveOverrideRoot);
52 }
53
54 static void RegistryDeleteCallback(const TCHAR* key_name,
55 const TCHAR* value_name,
56 RegistryChangeType change_type,
57 const void* new_value_data,
58 void* user_data) {
59 EXPECT_STREQ(kKeyName, key_name);
60 EXPECT_STREQ(kValueName, value_name);
61 EXPECT_EQ(REGISTRY_CHANGE_TYPE_DELETE, change_type);
62 EXPECT_TRUE(new_value_data);
63 EXPECT_TRUE(user_data);
64 RegistryMonitorTest* object = static_cast<RegistryMonitorTest*>(user_data);
65 DWORD actual_value = reinterpret_cast<DWORD>(new_value_data);
66 EXPECT_EQ(ULONG_MAX, actual_value);
67 EXPECT_TRUE(::SetEvent(get(object->registry_changed_event_)));
68 }
69
70 static void RegistryChangeCallback(const TCHAR* key_name,
71 const TCHAR* value_name,
72 RegistryChangeType change_type,
73 const void* new_value_data,
74 void* user_data) {
75 EXPECT_STREQ(kKeyName, key_name);
76 EXPECT_STREQ(kValueName, value_name);
77 EXPECT_EQ(REGISTRY_CHANGE_TYPE_UPDATE, change_type);
78 EXPECT_TRUE(new_value_data);
79 EXPECT_TRUE(user_data);
80 RegistryMonitorTest* object = static_cast<RegistryMonitorTest*>(user_data);
81 const TCHAR* actual_value = static_cast<const TCHAR*>(new_value_data);
82 EXPECT_STREQ(_T("foo"), actual_value);
83 EXPECT_TRUE(::SetEvent(get(object->registry_changed_event_)));
84 }
85
86 static void RegistryChangesCallback(const TCHAR* key_name,
87 const TCHAR* value_name,
88 RegistryChangeType change_type,
89 const void* new_value_data,
90 void* user_data) {
91 EXPECT_STREQ(kKeyName, key_name);
92 EXPECT_STREQ(kValueName, value_name);
93 EXPECT_EQ(REGISTRY_CHANGE_TYPE_UPDATE, change_type);
94 EXPECT_TRUE(new_value_data);
95 EXPECT_TRUE(user_data);
96 RegistryMonitorTest* object = static_cast<RegistryMonitorTest*>(user_data);
97 EXPECT_TRUE(::SetEvent(get(object->registry_changed_event_)));
98 }
99
100 static void RegistryCreateCallback(const TCHAR* key_name,
101 const TCHAR* value_name,
102 RegistryChangeType change_type,
103 const void* new_value_data,
104 void* user_data) {
105 EXPECT_STREQ(kKeyName, key_name);
106 EXPECT_STREQ(kValueName, value_name);
107 EXPECT_EQ(REGISTRY_CHANGE_TYPE_CREATE, change_type);
108 EXPECT_TRUE(new_value_data);
109 EXPECT_TRUE(user_data);
110 RegistryMonitorTest* object = static_cast<RegistryMonitorTest*>(user_data);
111 DWORD actual_value = reinterpret_cast<DWORD>(new_value_data);
112 EXPECT_EQ(1, actual_value);
113 EXPECT_TRUE(::SetEvent(get(object->registry_changed_event_)));
114 }
115
116 static void RegistryKeyCallback(const TCHAR* key_name, void* user_data) {
117 EXPECT_STREQ(kKeyName, key_name);
118 RegistryMonitorTest* object = static_cast<RegistryMonitorTest*>(user_data);
119 EXPECT_TRUE(::SetEvent(get(object->registry_changed_event_)));
120 }
121
122 scoped_event registry_changed_event_;
123
124 static DWORD const kWaitForChangeMs = 5000;
125 };
126
127 TEST_F(RegistryMonitorTest, DeleteValue) {
128 DWORD value = 0;
129 ASSERT_HRESULT_SUCCEEDED(RegKey::SetValue(kKeyNameFull, kValueName, value));
130 RegistryMonitor registry_monitor;
131 ASSERT_HRESULT_SUCCEEDED(registry_monitor.Initialize());
132 ASSERT_HRESULT_SUCCEEDED(registry_monitor.MonitorValue(
133 HKEY_CURRENT_USER, kKeyName, kValueName, REG_DWORD,
134 RegistryDeleteCallback, this));
135 ASSERT_HRESULT_SUCCEEDED(registry_monitor.StartMonitoring());
136
137 EXPECT_HRESULT_SUCCEEDED(RegKey::DeleteValue(kKeyNameFull, kValueName));
138 EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(get(registry_changed_event_),
139 kWaitForChangeMs));
140 }
141
142 TEST_F(RegistryMonitorTest, ChangeValue) {
143 ASSERT_HRESULT_SUCCEEDED(RegKey::SetValue(kKeyNameFull, kValueName, _T("")));
144 RegistryMonitor registry_monitor;
145 ASSERT_HRESULT_SUCCEEDED(registry_monitor.Initialize());
146 ASSERT_HRESULT_SUCCEEDED(registry_monitor.MonitorValue(
147 HKEY_CURRENT_USER, kKeyName, kValueName, REG_SZ,
148 RegistryChangeCallback, this));
149 ASSERT_HRESULT_SUCCEEDED(registry_monitor.StartMonitoring());
150
151 ASSERT_HRESULT_SUCCEEDED(RegKey::SetValue(kKeyNameFull,
152 kValueName,
153 _T("foo")));
154 EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(get(registry_changed_event_),
155 kWaitForChangeMs));
156 }
157
158 // Tests changing the same value two times. This is useful to detect if
159 // the key is registered back for notification after a succesful callback.
160 TEST_F(RegistryMonitorTest, ChangeValues) {
161 ASSERT_HRESULT_SUCCEEDED(RegKey::SetValue(kKeyNameFull,
162 kValueName,
163 _T("")));
164
165 RegistryMonitor registry_monitor;
166 ASSERT_HRESULT_SUCCEEDED(registry_monitor.Initialize());
167 ASSERT_HRESULT_SUCCEEDED(registry_monitor.MonitorValue(
168 HKEY_CURRENT_USER, kKeyName, kValueName, REG_SZ,
169 RegistryChangesCallback, this));
170 ASSERT_HRESULT_SUCCEEDED(registry_monitor.StartMonitoring());
171
172 ASSERT_HRESULT_SUCCEEDED(RegKey::SetValue(kKeyNameFull,
173 kValueName,
174 _T("foo")));
175 EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(get(registry_changed_event_),
176 kWaitForChangeMs));
177 EXPECT_TRUE(::ResetEvent(get(registry_changed_event_)));
178
179 ASSERT_HRESULT_SUCCEEDED(RegKey::SetValue(kKeyNameFull,
180 kValueName,
181 _T("bar")));
182 EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(get(registry_changed_event_),
183 kWaitForChangeMs));
184 }
185
186 TEST_F(RegistryMonitorTest, CreateValue) {
187 RegistryMonitor registry_monitor;
188 ASSERT_HRESULT_SUCCEEDED(registry_monitor.Initialize());
189 ASSERT_HRESULT_SUCCEEDED(RegKey::CreateKey(kKeyNameFull));
190 ASSERT_HRESULT_SUCCEEDED(registry_monitor.MonitorValue(
191 HKEY_CURRENT_USER, kKeyName, kValueName, REG_DWORD,
192 RegistryCreateCallback, this));
193 ASSERT_HRESULT_SUCCEEDED(registry_monitor.StartMonitoring());
194
195 DWORD value = 1;
196 ASSERT_HRESULT_SUCCEEDED(RegKey::SetValue(kKeyNameFull, kValueName, value));
197 EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(get(registry_changed_event_),
198 kWaitForChangeMs));
199 }
200
201 // Monitoring values under the same key pair is allowed.
202 TEST_F(RegistryMonitorTest, MonitorSame) {
203 RegistryMonitor registry_monitor;
204 ASSERT_HRESULT_SUCCEEDED(registry_monitor.Initialize());
205 ASSERT_HRESULT_SUCCEEDED(RegKey::CreateKey(kKeyNameFull));
206 ASSERT_HRESULT_SUCCEEDED(registry_monitor.MonitorValue(
207 HKEY_CURRENT_USER, kKeyName, kValueName, REG_DWORD,
208 RegistryCreateCallback, this));
209 ASSERT_HRESULT_SUCCEEDED(registry_monitor.MonitorValue(
210 HKEY_CURRENT_USER, kKeyName, kValueName, REG_DWORD,
211 RegistryCreateCallback, this));
212 }
213
214 TEST_F(RegistryMonitorTest, MonitorKey) {
215 EXPECT_HRESULT_SUCCEEDED(RegKey::CreateKey(kKeyNameFull));
216
217 RegistryMonitor registry_monitor;
218 EXPECT_HRESULT_SUCCEEDED(registry_monitor.Initialize());
219 EXPECT_HRESULT_SUCCEEDED(registry_monitor.MonitorKey(
220 HKEY_CURRENT_USER, kKeyName, RegistryKeyCallback, this));
221
222 EXPECT_HRESULT_SUCCEEDED(registry_monitor.StartMonitoring());
223
224 EXPECT_HRESULT_SUCCEEDED(RegKey::CreateKey(_T("HKCU\\key\\subkey")));
225 EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(get(registry_changed_event_),
226 kWaitForChangeMs));
227
228 EXPECT_TRUE(::ResetEvent(get(registry_changed_event_)));
229 EXPECT_HRESULT_SUCCEEDED(RegKey::DeleteKey(_T("HKCU\\key\\subkey")));
230 EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(get(registry_changed_event_),
231 kWaitForChangeMs));
232 }
233
234 } // namespace omaha
235
OLDNEW
« no previous file with comments | « base/registry_monitor_manager.cc ('k') | base/registry_store.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698