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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: common/app_registry_utils_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 | « common/app_registry_utils.cc ('k') | common/build.scons » ('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 2007-2010 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 "omaha/base/reg_key.h"
17 #include "omaha/common/app_registry_utils.h"
18 #include "omaha/common/const_goopdate.h"
19 #include "omaha/testing/unit_test.h"
20
21 namespace omaha {
22
23 namespace {
24
25 #define APP_GUID _T("{B7BAF788-9D64-49c3-AFDC-B336AB12F332}")
26 const TCHAR* const kAppGuid = APP_GUID;
27 const TCHAR* const kAppMachineClientStatePath =
28 _T("HKLM\\Software\\") SHORT_COMPANY_NAME _T("\\") PRODUCT_NAME
29 _T("\\ClientState\\") APP_GUID;
30 const TCHAR* const kAppUserClientStatePath =
31 _T("HKCU\\Software\\") SHORT_COMPANY_NAME _T("\\") PRODUCT_NAME
32 _T("\\ClientState\\") APP_GUID;
33 const TCHAR* const kAppMachineClientStateMediumPath =
34 _T("HKLM\\Software\\") SHORT_COMPANY_NAME _T("\\") PRODUCT_NAME
35 _T("\\ClientStateMedium\\") APP_GUID;
36
37 // This should never exist. This contant is only used to verify it is not used.
38 const TCHAR* const kAppUserClientStateMediumPath =
39 _T("HKCU\\Software\\") SHORT_COMPANY_NAME _T("\\") PRODUCT_NAME
40 _T("\\ClientStateMedium\\") APP_GUID;
41
42 const TCHAR* const kOmahaMachineClientsPath =
43 _T("HKLM\\Software\\") SHORT_COMPANY_NAME _T("\\") PRODUCT_NAME
44 _T("\\Clients\\") GOOPDATE_APP_ID;
45
46 const TCHAR* const kOmahaUserClientsPath =
47 _T("HKCU\\Software\\") SHORT_COMPANY_NAME _T("\\") PRODUCT_NAME
48 _T("\\Clients\\") GOOPDATE_APP_ID;
49
50 const TCHAR* const kOmahaMachineClientStatePath =
51 _T("HKLM\\Software\\") SHORT_COMPANY_NAME _T("\\") PRODUCT_NAME
52 _T("\\ClientState\\") GOOPDATE_APP_ID;
53
54 const TCHAR* const kOmahaUserClientStatePath =
55 _T("HKCU\\Software\\") SHORT_COMPANY_NAME _T("\\") PRODUCT_NAME
56 _T("\\ClientState\\") GOOPDATE_APP_ID;
57
58 } // namespace
59
60 namespace app_registry_utils {
61
62 TEST(AppRegistryUtilsTest, GetAppClientsKey) {
63 const TCHAR kAppGuid[] = _T("{F998D7E0-0CD3-434e-96B9-B8D3A295C3FB}");
64
65 EXPECT_STREQ(_T("HKCU\\Software\\") SHORT_COMPANY_NAME
66 _T("\\") PRODUCT_NAME _T("\\Clients\\")
67 _T("{F998D7E0-0CD3-434e-96B9-B8D3A295C3FB}"),
68 GetAppClientsKey(false, kAppGuid));
69 EXPECT_STREQ(_T("HKLM\\Software\\") SHORT_COMPANY_NAME
70 _T("\\") PRODUCT_NAME _T("\\Clients\\")
71 _T("{F998D7E0-0CD3-434e-96B9-B8D3A295C3FB}"),
72 GetAppClientsKey(true, kAppGuid));
73 }
74
75 TEST(AppRegistryUtilsTest, GetAppClientStateKey) {
76 const TCHAR kAppGuid[] = _T("{F998D7E0-0CD3-434e-96B9-B8D3A295C3FB}");
77
78 EXPECT_STREQ(_T("HKCU\\Software\\") SHORT_COMPANY_NAME
79 _T("\\") PRODUCT_NAME _T("\\ClientState\\")
80 _T("{F998D7E0-0CD3-434e-96B9-B8D3A295C3FB}"),
81 GetAppClientStateKey(false, kAppGuid));
82 EXPECT_STREQ(_T("HKLM\\Software\\") SHORT_COMPANY_NAME
83 _T("\\") PRODUCT_NAME _T("\\ClientState\\")
84 _T("{F998D7E0-0CD3-434e-96B9-B8D3A295C3FB}"),
85 GetAppClientStateKey(true, kAppGuid));
86 }
87
88 // This is an invalid case and causes an assert. Always returns HKLM path.
89 TEST(AppRegistryUtilsTest, GetAppClientStateMediumKey_User) {
90 const TCHAR kAppGuid[] = _T("{F998D7E0-0CD3-434e-96B9-B8D3A295C3FB}");
91 ExpectAsserts expect_asserts;
92 EXPECT_STREQ(_T("HKLM\\Software\\") SHORT_COMPANY_NAME
93 _T("\\") PRODUCT_NAME _T("\\ClientStateMedium\\")
94 _T("{F998D7E0-0CD3-434e-96B9-B8D3A295C3FB}"),
95 GetAppClientStateMediumKey(false, kAppGuid));
96 }
97
98 TEST(AppRegistryUtilsTest, GetAppClientStateMediumKey_Machine) {
99 const TCHAR kAppGuid[] = _T("{F998D7E0-0CD3-434e-96B9-B8D3A295C3FB}");
100 EXPECT_STREQ(_T("HKLM\\Software\\") SHORT_COMPANY_NAME
101 _T("\\") PRODUCT_NAME _T("\\ClientStateMedium\\")
102 _T("{F998D7E0-0CD3-434e-96B9-B8D3A295C3FB}"),
103 GetAppClientStateMediumKey(true, kAppGuid));
104 }
105
106 // This is an invalid case and causes an assert.
107 TEST(AppRegistryUtilsTest, GetAppClientStateMediumKey_UserAndMachineAreSame) {
108 const TCHAR kAppGuid[] = _T("{F998D7E0-0CD3-434e-96B9-B8D3A295C3FB}");
109 ExpectAsserts expect_asserts;
110 EXPECT_STREQ(GetAppClientStateMediumKey(true, kAppGuid),
111 GetAppClientStateMediumKey(false, kAppGuid));
112 }
113
114 class AppRegistryUtilsRegistryProtectedTest : public testing::Test {
115 protected:
116 AppRegistryUtilsRegistryProtectedTest()
117 : hive_override_key_name_(kRegistryHiveOverrideRoot) {
118 }
119
120 CString hive_override_key_name_;
121
122 virtual void SetUp() {
123 RegKey::DeleteKey(hive_override_key_name_, true);
124 OverrideRegistryHives(hive_override_key_name_);
125 }
126
127 virtual void TearDown() {
128 RestoreRegistryHives();
129 ASSERT_SUCCEEDED(RegKey::DeleteKey(hive_override_key_name_, true));
130 }
131 };
132
133 TEST_F(AppRegistryUtilsRegistryProtectedTest,
134 IsAppEulaAccepted_Machine_NotExplicit_NoKey) {
135 EXPECT_TRUE(IsAppEulaAccepted(true, kAppGuid, false));
136 EXPECT_FALSE(
137 RegKey::HasValue(kAppMachineClientStatePath, _T("eulaaccepted")));
138 EXPECT_FALSE(
139 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
140 }
141
142 TEST_F(AppRegistryUtilsRegistryProtectedTest,
143 IsAppEulaAccepted_Machine_NotExplicit_ClientStateExists) {
144 EXPECT_SUCCEEDED(RegKey::CreateKey(kAppMachineClientStatePath));
145 EXPECT_TRUE(IsAppEulaAccepted(true, kAppGuid, false));
146 EXPECT_FALSE(
147 RegKey::HasValue(kAppMachineClientStatePath, _T("eulaaccepted")));
148 EXPECT_FALSE(
149 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
150 }
151
152 TEST_F(AppRegistryUtilsRegistryProtectedTest,
153 IsAppEulaAccepted_Machine_NotExplicit_ClientStateOne) {
154 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
155 _T("eulaaccepted"),
156 static_cast<DWORD>(1)));
157 EXPECT_TRUE(IsAppEulaAccepted(true, kAppGuid, false));
158 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
159 EXPECT_FALSE(
160 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
161 }
162
163 TEST_F(AppRegistryUtilsRegistryProtectedTest,
164 IsAppEulaAccepted_Machine_NotExplicit_ClientStateNegativeOne) {
165 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
166 _T("eulaaccepted"),
167 static_cast<DWORD>(-1)));
168 EXPECT_TRUE(IsAppEulaAccepted(true, kAppGuid, false));
169 EXPECT_EQ(-1, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
170 EXPECT_FALSE(
171 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
172 }
173
174 TEST_F(AppRegistryUtilsRegistryProtectedTest,
175 IsAppEulaAccepted_Machine_NotExplicit_ClientStateZero_MediumNotExist) {
176 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
177 _T("eulaaccepted"),
178 static_cast<DWORD>(0)));
179 EXPECT_FALSE(IsAppEulaAccepted(true, kAppGuid, false));
180 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
181 EXPECT_FALSE(
182 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
183 }
184
185 TEST_F(AppRegistryUtilsRegistryProtectedTest,
186 IsAppEulaAccepted_Machine_NotExplicit_ClientStateZero_MediumExists) {
187 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
188 _T("eulaaccepted"),
189 static_cast<DWORD>(0)));
190 EXPECT_SUCCEEDED(RegKey::CreateKey(kAppMachineClientStateMediumPath));
191 EXPECT_FALSE(IsAppEulaAccepted(true, kAppGuid, false));
192 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
193 EXPECT_FALSE(
194 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
195 }
196
197 TEST_F(AppRegistryUtilsRegistryProtectedTest,
198 IsAppEulaAccepted_Machine_NotExplicit_ClientStateZero_MediumOne) {
199 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
200 _T("eulaaccepted"),
201 static_cast<DWORD>(0)));
202 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
203 _T("eulaaccepted"),
204 static_cast<DWORD>(1)));
205 EXPECT_TRUE(IsAppEulaAccepted(true, kAppGuid, false));
206 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
207 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStateMediumPath,
208 _T("eulaaccepted")));
209 }
210
211 TEST_F(AppRegistryUtilsRegistryProtectedTest,
212 IsAppEulaAccepted_Machine_NotExplicit_ClientStateZero_MediumNegativeOne) {
213 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
214 _T("eulaaccepted"),
215 static_cast<DWORD>(0)));
216 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
217 _T("eulaaccepted"),
218 static_cast<DWORD>(-1)));
219 EXPECT_TRUE(IsAppEulaAccepted(true, kAppGuid, false));
220 EXPECT_EQ(-1, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
221 EXPECT_EQ(-1, GetDwordValue(kAppMachineClientStateMediumPath,
222 _T("eulaaccepted")));
223 }
224
225 // Also tests that user values are not used.
226 TEST_F(AppRegistryUtilsRegistryProtectedTest,
227 IsAppEulaAccepted_Machine_NotExplicit_ClientStateZero_MediumZero) {
228 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
229 _T("eulaaccepted"),
230 static_cast<DWORD>(0)));
231 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
232 _T("eulaaccepted"),
233 static_cast<DWORD>(0)));
234 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
235 _T("eulaaccepted"),
236 static_cast<DWORD>(1)));
237 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
238 _T("eulaaccepted"),
239 static_cast<DWORD>(1)));
240 EXPECT_FALSE(IsAppEulaAccepted(true, kAppGuid, false));
241 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
242 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStateMediumPath,
243 _T("eulaaccepted")));
244 EXPECT_EQ(1, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
245 EXPECT_EQ(1, GetDwordValue(kAppUserClientStateMediumPath,
246 _T("eulaaccepted")));
247 }
248
249 // ClientStateMedium does not override ClientState.
250 TEST_F(AppRegistryUtilsRegistryProtectedTest,
251 IsAppEulaAccepted_Machine_NotExplicit_ClientStateOne_MediumZero) {
252 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
253 _T("eulaaccepted"),
254 static_cast<DWORD>(1)));
255 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
256 _T("eulaaccepted"),
257 static_cast<DWORD>(0)));
258 EXPECT_TRUE(IsAppEulaAccepted(true, kAppGuid, false));
259 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
260 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStateMediumPath,
261 _T("eulaaccepted")));
262 }
263
264 // Implicitly accepted because of the absence of eualaccepted=0.
265 TEST_F(AppRegistryUtilsRegistryProtectedTest,
266 IsAppEulaAccepted_Machine_NotExplicit_ClientStateNotExist_MediumOne) {
267 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
268 _T("eulaaccepted"),
269 static_cast<DWORD>(1)));
270 EXPECT_TRUE(IsAppEulaAccepted(true, kAppGuid, false));
271 EXPECT_FALSE(
272 RegKey::HasValue(kAppMachineClientStatePath, _T("eulaaccepted")));
273 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStateMediumPath,
274 _T("eulaaccepted")));
275 }
276
277 // Implicitly accepted because of the absence of eualaccepted=0.
278 TEST_F(AppRegistryUtilsRegistryProtectedTest,
279 IsAppEulaAccepted_Machine_NotExplicit_ClientStateNotExist_MediumZero) {
280 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
281 _T("eulaaccepted"),
282 static_cast<DWORD>(0)));
283 EXPECT_TRUE(IsAppEulaAccepted(true, kAppGuid, false));
284 EXPECT_FALSE(
285 RegKey::HasValue(kAppMachineClientStatePath, _T("eulaaccepted")));
286 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStateMediumPath,
287 _T("eulaaccepted")));
288 }
289
290 TEST_F(AppRegistryUtilsRegistryProtectedTest,
291 IsAppEulaAccepted_Machine_Explicit_NoKey) {
292 EXPECT_FALSE(IsAppEulaAccepted(true, kAppGuid, true));
293 EXPECT_FALSE(
294 RegKey::HasValue(kAppMachineClientStatePath, _T("eulaaccepted")));
295 EXPECT_FALSE(
296 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
297 }
298
299 TEST_F(AppRegistryUtilsRegistryProtectedTest,
300 IsAppEulaAccepted_Machine_Explicit_ClientStateExists) {
301 EXPECT_SUCCEEDED(RegKey::CreateKey(kAppMachineClientStatePath));
302 EXPECT_FALSE(IsAppEulaAccepted(true, kAppGuid, true));
303 EXPECT_FALSE(
304 RegKey::HasValue(kAppMachineClientStatePath, _T("eulaaccepted")));
305 EXPECT_FALSE(
306 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
307 }
308
309 TEST_F(AppRegistryUtilsRegistryProtectedTest,
310 IsAppEulaAccepted_Machine_Explicit_ClientStateOne) {
311 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
312 _T("eulaaccepted"),
313 static_cast<DWORD>(1)));
314 EXPECT_TRUE(IsAppEulaAccepted(true, kAppGuid, true));
315 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
316 EXPECT_FALSE(
317 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
318 }
319
320 TEST_F(AppRegistryUtilsRegistryProtectedTest,
321 IsAppEulaAccepted_Machine_Explicit_ClientStateNegativeOne) {
322 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
323 _T("eulaaccepted"),
324 static_cast<DWORD>(-1)));
325 EXPECT_TRUE(IsAppEulaAccepted(true, kAppGuid, true));
326 EXPECT_EQ(-1, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
327 EXPECT_FALSE(
328 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
329 }
330
331 TEST_F(AppRegistryUtilsRegistryProtectedTest,
332 IsAppEulaAccepted_Machine_Explicit_ClientStateZero_MediumNotExist) {
333 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
334 _T("eulaaccepted"),
335 static_cast<DWORD>(0)));
336 EXPECT_FALSE(IsAppEulaAccepted(true, kAppGuid, true));
337 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
338 EXPECT_FALSE(
339 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
340 }
341
342 TEST_F(AppRegistryUtilsRegistryProtectedTest,
343 IsAppEulaAccepted_Machine_Explicit_ClientStateZero_MediumExists) {
344 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
345 _T("eulaaccepted"),
346 static_cast<DWORD>(0)));
347 EXPECT_SUCCEEDED(RegKey::CreateKey(kAppMachineClientStateMediumPath));
348 EXPECT_FALSE(IsAppEulaAccepted(true, kAppGuid, true));
349 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
350 EXPECT_FALSE(
351 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
352 }
353
354 TEST_F(AppRegistryUtilsRegistryProtectedTest,
355 IsAppEulaAccepted_Machine_Explicit_ClientStateZero_MediumOne) {
356 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
357 _T("eulaaccepted"),
358 static_cast<DWORD>(0)));
359 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
360 _T("eulaaccepted"),
361 static_cast<DWORD>(1)));
362 EXPECT_TRUE(IsAppEulaAccepted(true, kAppGuid, true));
363 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
364 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStateMediumPath,
365 _T("eulaaccepted")));
366 }
367
368 TEST_F(AppRegistryUtilsRegistryProtectedTest,
369 IsAppEulaAccepted_Machine_Explicit_ClientStateZero_MediumNegativeOne) {
370 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
371 _T("eulaaccepted"),
372 static_cast<DWORD>(0)));
373 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
374 _T("eulaaccepted"),
375 static_cast<DWORD>(-1)));
376 EXPECT_TRUE(IsAppEulaAccepted(true, kAppGuid, true));
377 EXPECT_EQ(-1, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
378 EXPECT_EQ(-1, GetDwordValue(kAppMachineClientStateMediumPath,
379 _T("eulaaccepted")));
380 }
381
382 // Also tests that user values are not used.
383 TEST_F(AppRegistryUtilsRegistryProtectedTest,
384 IsAppEulaAccepted_Machine_Explicit_ClientStateZero_MediumZero) {
385 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
386 _T("eulaaccepted"),
387 static_cast<DWORD>(0)));
388 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
389 _T("eulaaccepted"),
390 static_cast<DWORD>(0)));
391 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
392 _T("eulaaccepted"),
393 static_cast<DWORD>(1)));
394 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
395 _T("eulaaccepted"),
396 static_cast<DWORD>(1)));
397 EXPECT_FALSE(IsAppEulaAccepted(true, kAppGuid, true));
398 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
399 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStateMediumPath,
400 _T("eulaaccepted")));
401 EXPECT_EQ(1, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
402 EXPECT_EQ(1, GetDwordValue(kAppUserClientStateMediumPath,
403 _T("eulaaccepted")));
404 }
405
406 // ClientStateMedium does not override ClientState.
407 TEST_F(AppRegistryUtilsRegistryProtectedTest,
408 IsAppEulaAccepted_Machine_Explicit_ClientStateOne_MediumZero) {
409 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
410 _T("eulaaccepted"),
411 static_cast<DWORD>(1)));
412 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
413 _T("eulaaccepted"),
414 static_cast<DWORD>(0)));
415 EXPECT_TRUE(IsAppEulaAccepted(true, kAppGuid, true));
416 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
417 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStateMediumPath,
418 _T("eulaaccepted")));
419 }
420
421 TEST_F(AppRegistryUtilsRegistryProtectedTest,
422 IsAppEulaAccepted_Machine_Explicit_ClientStateNotExist_MediumOne) {
423 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
424 _T("eulaaccepted"),
425 static_cast<DWORD>(1)));
426 EXPECT_TRUE(IsAppEulaAccepted(true, kAppGuid, true));
427 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
428 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStateMediumPath,
429 _T("eulaaccepted")));
430 }
431
432 TEST_F(AppRegistryUtilsRegistryProtectedTest,
433 IsAppEulaAccepted_Machine_Explicit_ClientStateNotExist_MediumZero) {
434 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
435 _T("eulaaccepted"),
436 static_cast<DWORD>(0)));
437 EXPECT_FALSE(IsAppEulaAccepted(true, kAppGuid, true));
438 EXPECT_FALSE(
439 RegKey::HasValue(kAppMachineClientStatePath, _T("eulaaccepted")));
440 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStateMediumPath,
441 _T("eulaaccepted")));
442 }
443
444 // ClientStateMedium is not supported for user apps.
445
446 TEST_F(AppRegistryUtilsRegistryProtectedTest,
447 IsAppEulaAccepted_User_NotExplicit_NoKey) {
448 EXPECT_TRUE(IsAppEulaAccepted(false, kAppGuid, false));
449 EXPECT_FALSE(
450 RegKey::HasValue(kAppUserClientStatePath, _T("eulaaccepted")));
451 EXPECT_FALSE(
452 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
453 }
454
455 TEST_F(AppRegistryUtilsRegistryProtectedTest,
456 IsAppEulaAccepted_User_NotExplicit_ClientStateExists) {
457 EXPECT_SUCCEEDED(RegKey::CreateKey(kAppUserClientStatePath));
458 EXPECT_TRUE(IsAppEulaAccepted(false, kAppGuid, false));
459 EXPECT_FALSE(
460 RegKey::HasValue(kAppUserClientStatePath, _T("eulaaccepted")));
461 EXPECT_FALSE(
462 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
463 }
464
465 TEST_F(AppRegistryUtilsRegistryProtectedTest,
466 IsAppEulaAccepted_User_NotExplicit_ClientStateOne) {
467 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
468 _T("eulaaccepted"),
469 static_cast<DWORD>(1)));
470 EXPECT_TRUE(IsAppEulaAccepted(false, kAppGuid, false));
471 EXPECT_EQ(1, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
472 EXPECT_FALSE(
473 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
474 }
475
476 TEST_F(AppRegistryUtilsRegistryProtectedTest,
477 IsAppEulaAccepted_User_NotExplicit_ClientStateNegativeOne) {
478 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
479 _T("eulaaccepted"),
480 static_cast<DWORD>(-1)));
481 EXPECT_TRUE(IsAppEulaAccepted(false, kAppGuid, false));
482 EXPECT_EQ(-1, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
483 EXPECT_FALSE(
484 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
485 }
486
487 TEST_F(AppRegistryUtilsRegistryProtectedTest,
488 IsAppEulaAccepted_User_NotExplicit_ClientStateZero_MediumNotExist) {
489 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
490 _T("eulaaccepted"),
491 static_cast<DWORD>(0)));
492 EXPECT_FALSE(IsAppEulaAccepted(false, kAppGuid, false));
493 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
494 EXPECT_FALSE(
495 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
496 }
497
498 TEST_F(AppRegistryUtilsRegistryProtectedTest,
499 IsAppEulaAccepted_User_NotExplicit_ClientStateZero_MediumExists) {
500 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
501 _T("eulaaccepted"),
502 static_cast<DWORD>(0)));
503 EXPECT_SUCCEEDED(RegKey::CreateKey(kAppUserClientStateMediumPath));
504 EXPECT_FALSE(IsAppEulaAccepted(false, kAppGuid, false));
505 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
506 EXPECT_FALSE(
507 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
508 }
509
510 TEST_F(AppRegistryUtilsRegistryProtectedTest,
511 IsAppEulaAccepted_User_NotExplicit_ClientStateZero_MediumOne) {
512 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
513 _T("eulaaccepted"),
514 static_cast<DWORD>(0)));
515 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
516 _T("eulaaccepted"),
517 static_cast<DWORD>(1)));
518 EXPECT_FALSE(IsAppEulaAccepted(false, kAppGuid, false));
519 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
520 EXPECT_EQ(1, GetDwordValue(kAppUserClientStateMediumPath,
521 _T("eulaaccepted")));
522 }
523
524 TEST_F(AppRegistryUtilsRegistryProtectedTest,
525 IsAppEulaAccepted_User_NotExplicit_ClientStateZero_MediumNegativeOne) {
526 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
527 _T("eulaaccepted"),
528 static_cast<DWORD>(0)));
529 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
530 _T("eulaaccepted"),
531 static_cast<DWORD>(-1)));
532 EXPECT_FALSE(IsAppEulaAccepted(false, kAppGuid, false));
533 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
534 EXPECT_EQ(-1, GetDwordValue(kAppUserClientStateMediumPath,
535 _T("eulaaccepted")));
536 }
537
538 // Also tests that machine values are not used.
539 TEST_F(AppRegistryUtilsRegistryProtectedTest,
540 IsAppEulaAccepted_User_NotExplicit_ClientStateZero_MediumZero) {
541 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
542 _T("eulaaccepted"),
543 static_cast<DWORD>(0)));
544 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
545 _T("eulaaccepted"),
546 static_cast<DWORD>(0)));
547 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
548 _T("eulaaccepted"),
549 static_cast<DWORD>(1)));
550 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
551 _T("eulaaccepted"),
552 static_cast<DWORD>(1)));
553 EXPECT_FALSE(IsAppEulaAccepted(false, kAppGuid, false));
554 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
555 EXPECT_EQ(0, GetDwordValue(kAppUserClientStateMediumPath,
556 _T("eulaaccepted")));
557 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
558 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStateMediumPath,
559 _T("eulaaccepted")));
560 }
561
562 // ClientStateMedium is not used.
563 TEST_F(AppRegistryUtilsRegistryProtectedTest,
564 IsAppEulaAccepted_User_NotExplicit_ClientStateOne_MediumZero) {
565 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
566 _T("eulaaccepted"),
567 static_cast<DWORD>(1)));
568 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
569 _T("eulaaccepted"),
570 static_cast<DWORD>(0)));
571 EXPECT_TRUE(IsAppEulaAccepted(false, kAppGuid, false));
572 EXPECT_EQ(1, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
573 EXPECT_EQ(0, GetDwordValue(kAppUserClientStateMediumPath,
574 _T("eulaaccepted")));
575 }
576
577 // Implicitly accepted because of the absence of eualaccepted=0.
578 TEST_F(AppRegistryUtilsRegistryProtectedTest,
579 IsAppEulaAccepted_User_NotExplicit_ClientStateNotExist_MediumOne) {
580 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
581 _T("eulaaccepted"),
582 static_cast<DWORD>(1)));
583 EXPECT_TRUE(IsAppEulaAccepted(false, kAppGuid, false));
584 EXPECT_FALSE(
585 RegKey::HasValue(kAppUserClientStatePath, _T("eulaaccepted")));
586 EXPECT_EQ(1, GetDwordValue(kAppUserClientStateMediumPath,
587 _T("eulaaccepted")));
588 }
589
590 // Implicitly accepted because of the absence of eualaccepted=0.
591 TEST_F(AppRegistryUtilsRegistryProtectedTest,
592 IsAppEulaAccepted_User_NotExplicit_ClientStateNotExist_MediumZero) {
593 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
594 _T("eulaaccepted"),
595 static_cast<DWORD>(0)));
596 EXPECT_TRUE(IsAppEulaAccepted(false, kAppGuid, false));
597 EXPECT_FALSE(
598 RegKey::HasValue(kAppUserClientStatePath, _T("eulaaccepted")));
599 EXPECT_EQ(0, GetDwordValue(kAppUserClientStateMediumPath,
600 _T("eulaaccepted")));
601 }
602
603 TEST_F(AppRegistryUtilsRegistryProtectedTest,
604 IsAppEulaAccepted_User_Explicit_NoKey) {
605 EXPECT_FALSE(IsAppEulaAccepted(false, kAppGuid, true));
606 EXPECT_FALSE(
607 RegKey::HasValue(kAppUserClientStatePath, _T("eulaaccepted")));
608 EXPECT_FALSE(
609 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
610 }
611
612 TEST_F(AppRegistryUtilsRegistryProtectedTest,
613 IsAppEulaAccepted_User_Explicit_ClientStateExists) {
614 EXPECT_SUCCEEDED(RegKey::CreateKey(kAppUserClientStatePath));
615 EXPECT_FALSE(IsAppEulaAccepted(false, kAppGuid, true));
616 EXPECT_FALSE(
617 RegKey::HasValue(kAppUserClientStatePath, _T("eulaaccepted")));
618 EXPECT_FALSE(
619 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
620 }
621
622 TEST_F(AppRegistryUtilsRegistryProtectedTest,
623 IsAppEulaAccepted_User_Explicit_ClientStateOne) {
624 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
625 _T("eulaaccepted"),
626 static_cast<DWORD>(1)));
627 EXPECT_TRUE(IsAppEulaAccepted(false, kAppGuid, true));
628 EXPECT_EQ(1, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
629 EXPECT_FALSE(
630 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
631 }
632
633 TEST_F(AppRegistryUtilsRegistryProtectedTest,
634 IsAppEulaAccepted_User_Explicit_ClientStateNotExist_MediumOne) {
635 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
636 _T("eulaaccepted"),
637 static_cast<DWORD>(1)));
638 EXPECT_FALSE(IsAppEulaAccepted(false, kAppGuid, true));
639 EXPECT_FALSE(
640 RegKey::HasValue(kAppUserClientStatePath, _T("eulaaccepted")));
641 EXPECT_EQ(1, GetDwordValue(kAppUserClientStateMediumPath,
642 _T("eulaaccepted")));
643 }
644
645 TEST_F(AppRegistryUtilsRegistryProtectedTest,
646 IsAppEulaAccepted_User_Explicit_ClientStateNotExist_MediumZero) {
647 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
648 _T("eulaaccepted"),
649 static_cast<DWORD>(0)));
650 EXPECT_FALSE(IsAppEulaAccepted(false, kAppGuid, true));
651 EXPECT_FALSE(
652 RegKey::HasValue(kAppUserClientStatePath, _T("eulaaccepted")));
653 EXPECT_EQ(0, GetDwordValue(kAppUserClientStateMediumPath,
654 _T("eulaaccepted")));
655 }
656
657 TEST_F(AppRegistryUtilsRegistryProtectedTest,
658 SetAppEulaNotAccepted_Machine_NoKey) {
659 EXPECT_SUCCEEDED(SetAppEulaNotAccepted(true, kAppGuid));
660 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
661 EXPECT_FALSE(
662 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
663 }
664
665 TEST_F(AppRegistryUtilsRegistryProtectedTest,
666 SetAppEulaNotAccepted_Machine_ClientStateExists) {
667 EXPECT_SUCCEEDED(RegKey::CreateKey(kAppMachineClientStatePath));
668 EXPECT_SUCCEEDED(SetAppEulaNotAccepted(true, kAppGuid));
669 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
670 EXPECT_FALSE(
671 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
672 }
673
674 TEST_F(AppRegistryUtilsRegistryProtectedTest,
675 SetAppEulaNotAccepted_Machine_ClientStateOne) {
676 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
677 _T("eulaaccepted"),
678 static_cast<DWORD>(1)));
679 EXPECT_SUCCEEDED(SetAppEulaNotAccepted(true, kAppGuid));
680 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
681 EXPECT_FALSE(
682 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
683 }
684
685 TEST_F(AppRegistryUtilsRegistryProtectedTest,
686 SetAppEulaNotAccepted_Machine_ClientStateZero) {
687 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
688 _T("eulaaccepted"),
689 static_cast<DWORD>(0)));
690 EXPECT_SUCCEEDED(SetAppEulaNotAccepted(true, kAppGuid));
691 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
692 EXPECT_FALSE(
693 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
694 }
695
696 TEST_F(AppRegistryUtilsRegistryProtectedTest,
697 SetAppEulaNotAccepted_Machine_ClientStateZero_ClientStateMediumOne) {
698 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
699 _T("eulaaccepted"),
700 static_cast<DWORD>(0)));
701 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
702 _T("eulaaccepted"),
703 static_cast<DWORD>(1)));
704 EXPECT_SUCCEEDED(SetAppEulaNotAccepted(true, kAppGuid));
705 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
706 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStateMediumPath,
707 _T("eulaaccepted")));
708 }
709
710 // Also tests that user values are not affected.
711 TEST_F(AppRegistryUtilsRegistryProtectedTest,
712 SetAppEulaNotAccepted_Machine_ClientStateZero_ClientStateMediumZero) {
713 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
714 _T("eulaaccepted"),
715 static_cast<DWORD>(0)));
716 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
717 _T("eulaaccepted"),
718 static_cast<DWORD>(0)));
719 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
720 _T("eulaaccepted"),
721 static_cast<DWORD>(1)));
722 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
723 _T("eulaaccepted"),
724 static_cast<DWORD>(1)));
725 EXPECT_SUCCEEDED(SetAppEulaNotAccepted(true, kAppGuid));
726 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
727 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStateMediumPath,
728 _T("eulaaccepted")));
729 EXPECT_EQ(1, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
730 EXPECT_EQ(1, GetDwordValue(kAppUserClientStateMediumPath,
731 _T("eulaaccepted")));
732 }
733
734 TEST_F(AppRegistryUtilsRegistryProtectedTest,
735 SetAppEulaNotAccepted_User_NoKey) {
736 EXPECT_SUCCEEDED(SetAppEulaNotAccepted(false, kAppGuid));
737 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
738 EXPECT_FALSE(
739 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
740 }
741
742 TEST_F(AppRegistryUtilsRegistryProtectedTest,
743 SetAppEulaNotAccepted_User_ClientStateExists) {
744 EXPECT_SUCCEEDED(RegKey::CreateKey(kAppUserClientStatePath));
745 EXPECT_SUCCEEDED(SetAppEulaNotAccepted(false, kAppGuid));
746 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
747 EXPECT_FALSE(
748 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
749 }
750
751 TEST_F(AppRegistryUtilsRegistryProtectedTest,
752 SetAppEulaNotAccepted_User_ClientStateOne) {
753 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
754 _T("eulaaccepted"),
755 static_cast<DWORD>(1)));
756 EXPECT_SUCCEEDED(SetAppEulaNotAccepted(false, kAppGuid));
757 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
758 EXPECT_FALSE(
759 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
760 }
761
762 TEST_F(AppRegistryUtilsRegistryProtectedTest,
763 SetAppEulaNotAccepted_User_ClientStateZero) {
764 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
765 _T("eulaaccepted"),
766 static_cast<DWORD>(0)));
767 EXPECT_SUCCEEDED(SetAppEulaNotAccepted(false, kAppGuid));
768 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
769 EXPECT_FALSE(
770 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
771 }
772
773 TEST_F(AppRegistryUtilsRegistryProtectedTest,
774 SetAppEulaNotAccepted_User_ClientStateZero_ClientStateMediumOne) {
775 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
776 _T("eulaaccepted"),
777 static_cast<DWORD>(0)));
778 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
779 _T("eulaaccepted"),
780 static_cast<DWORD>(1)));
781 EXPECT_SUCCEEDED(SetAppEulaNotAccepted(false, kAppGuid));
782 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
783 EXPECT_EQ(1, GetDwordValue(kAppUserClientStateMediumPath,
784 _T("eulaaccepted")));
785 }
786
787 // Also tests that machine values are not affected.
788 TEST_F(AppRegistryUtilsRegistryProtectedTest,
789 SetAppEulaNotAccepted_User_ClientStateZero_ClientStateMediumZero) {
790 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
791 _T("eulaaccepted"),
792 static_cast<DWORD>(0)));
793 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
794 _T("eulaaccepted"),
795 static_cast<DWORD>(0)));
796 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
797 _T("eulaaccepted"),
798 static_cast<DWORD>(1)));
799 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
800 _T("eulaaccepted"),
801 static_cast<DWORD>(1)));
802 EXPECT_SUCCEEDED(SetAppEulaNotAccepted(false, kAppGuid));
803 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
804 EXPECT_EQ(0, GetDwordValue(kAppUserClientStateMediumPath,
805 _T("eulaaccepted")));
806 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
807 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStateMediumPath,
808 _T("eulaaccepted")));
809 }
810
811 TEST_F(AppRegistryUtilsRegistryProtectedTest,
812 ClearAppEulaNotAccepted_Machine_NoKey) {
813 EXPECT_SUCCEEDED(ClearAppEulaNotAccepted(true, kAppGuid));
814 EXPECT_FALSE(
815 RegKey::HasValue(kAppMachineClientStatePath, _T("eulaaccepted")));
816 EXPECT_FALSE(
817 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
818 }
819
820 TEST_F(AppRegistryUtilsRegistryProtectedTest,
821 ClearAppEulaNotAccepted_Machine_ClientStateExists) {
822 EXPECT_SUCCEEDED(RegKey::CreateKey(kAppMachineClientStatePath));
823 EXPECT_SUCCEEDED(ClearAppEulaNotAccepted(true, kAppGuid));
824 EXPECT_FALSE(
825 RegKey::HasValue(kAppMachineClientStatePath, _T("eulaaccepted")));
826 EXPECT_FALSE(
827 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
828 }
829
830 TEST_F(AppRegistryUtilsRegistryProtectedTest,
831 ClearAppEulaNotAccepted_Machine_ClientStateOne) {
832 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
833 _T("eulaaccepted"),
834 static_cast<DWORD>(1)));
835 EXPECT_SUCCEEDED(ClearAppEulaNotAccepted(true, kAppGuid));
836 EXPECT_FALSE(
837 RegKey::HasValue(kAppMachineClientStatePath, _T("eulaaccepted")));
838 EXPECT_FALSE(
839 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
840 }
841
842 TEST_F(AppRegistryUtilsRegistryProtectedTest,
843 ClearAppEulaNotAccepted_Machine_ClientStateZero) {
844 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
845 _T("eulaaccepted"),
846 static_cast<DWORD>(0)));
847 EXPECT_SUCCEEDED(ClearAppEulaNotAccepted(true, kAppGuid));
848 EXPECT_FALSE(
849 RegKey::HasValue(kAppMachineClientStatePath, _T("eulaaccepted")));
850 EXPECT_FALSE(
851 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
852 }
853
854 TEST_F(AppRegistryUtilsRegistryProtectedTest,
855 ClearAppEulaNotAccepted_Machine_ClientStateZero_ClientStateMediumZero) {
856 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
857 _T("eulaaccepted"),
858 static_cast<DWORD>(0)));
859 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
860 _T("eulaaccepted"),
861 static_cast<DWORD>(0)));
862 EXPECT_SUCCEEDED(ClearAppEulaNotAccepted(true, kAppGuid));
863 EXPECT_FALSE(
864 RegKey::HasValue(kAppMachineClientStatePath, _T("eulaaccepted")));
865 EXPECT_FALSE(
866 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
867 }
868
869 // Also tests that user values are not affected.
870 TEST_F(AppRegistryUtilsRegistryProtectedTest,
871 ClearAppEulaNotAccepted_Machine_ClientStateNone_ClientStateMediumZero) {
872 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
873 _T("eulaaccepted"),
874 static_cast<DWORD>(0)));
875 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
876 _T("eulaaccepted"),
877 static_cast<DWORD>(0)));
878 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
879 _T("eulaaccepted"),
880 static_cast<DWORD>(0)));
881 EXPECT_SUCCEEDED(ClearAppEulaNotAccepted(true, kAppGuid));
882 EXPECT_FALSE(
883 RegKey::HasValue(kAppMachineClientStatePath, _T("eulaaccepted")));
884 EXPECT_FALSE(
885 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("eulaaccepted")));
886 EXPECT_EQ(0,
887 GetDwordValue(kAppUserClientStatePath, _T("eulaaccepted")));
888 EXPECT_EQ(0,
889 GetDwordValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
890 }
891
892 TEST_F(AppRegistryUtilsRegistryProtectedTest,
893 ClearAppEulaNotAccepted_User_NoKey) {
894 EXPECT_SUCCEEDED(ClearAppEulaNotAccepted(false, kAppGuid));
895 EXPECT_FALSE(
896 RegKey::HasValue(kAppUserClientStatePath, _T("eulaaccepted")));
897 EXPECT_FALSE(
898 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
899 }
900
901 TEST_F(AppRegistryUtilsRegistryProtectedTest,
902 ClearAppEulaNotAccepted_User_ClientStateExists) {
903 EXPECT_SUCCEEDED(RegKey::CreateKey(kAppUserClientStatePath));
904 EXPECT_SUCCEEDED(ClearAppEulaNotAccepted(false, kAppGuid));
905 EXPECT_FALSE(
906 RegKey::HasValue(kAppUserClientStatePath, _T("eulaaccepted")));
907 EXPECT_FALSE(
908 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
909 }
910
911 TEST_F(AppRegistryUtilsRegistryProtectedTest,
912 ClearAppEulaNotAccepted_User_ClientStateOne) {
913 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
914 _T("eulaaccepted"),
915 static_cast<DWORD>(1)));
916 EXPECT_SUCCEEDED(ClearAppEulaNotAccepted(false, kAppGuid));
917 EXPECT_FALSE(
918 RegKey::HasValue(kAppUserClientStatePath, _T("eulaaccepted")));
919 EXPECT_FALSE(
920 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
921 }
922
923 TEST_F(AppRegistryUtilsRegistryProtectedTest,
924 ClearAppEulaNotAccepted_User_ClientStateZero) {
925 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
926 _T("eulaaccepted"),
927 static_cast<DWORD>(0)));
928 EXPECT_SUCCEEDED(ClearAppEulaNotAccepted(false, kAppGuid));
929 EXPECT_FALSE(
930 RegKey::HasValue(kAppUserClientStatePath, _T("eulaaccepted")));
931 EXPECT_FALSE(
932 RegKey::HasValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
933 }
934
935 TEST_F(AppRegistryUtilsRegistryProtectedTest,
936 ClearAppEulaNotAccepted_User_ClientStateZero_ClientStateMediumZero) {
937 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
938 _T("eulaaccepted"),
939 static_cast<DWORD>(0)));
940 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
941 _T("eulaaccepted"),
942 static_cast<DWORD>(0)));
943 EXPECT_SUCCEEDED(ClearAppEulaNotAccepted(false, kAppGuid));
944 EXPECT_FALSE(
945 RegKey::HasValue(kAppUserClientStatePath, _T("eulaaccepted")));
946 EXPECT_EQ(0,
947 GetDwordValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
948 }
949
950 // Also tests that machine values are not affected.
951 TEST_F(AppRegistryUtilsRegistryProtectedTest,
952 ClearAppEulaNotAccepted_User_ClientStateNone_ClientStateMediumZero) {
953 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
954 _T("eulaaccepted"),
955 static_cast<DWORD>(0)));
956 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
957 _T("eulaaccepted"),
958 static_cast<DWORD>(0)));
959 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
960 _T("eulaaccepted"),
961 static_cast<DWORD>(0)));
962 EXPECT_SUCCEEDED(ClearAppEulaNotAccepted(false, kAppGuid));
963 EXPECT_FALSE(
964 RegKey::HasValue(kAppUserClientStatePath, _T("eulaaccepted")));
965 EXPECT_EQ(0,
966 GetDwordValue(kAppUserClientStateMediumPath, _T("eulaaccepted")));
967 EXPECT_EQ(0,
968 GetDwordValue(kAppMachineClientStatePath, _T("eulaaccepted")));
969 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStateMediumPath,
970 _T("eulaaccepted")));
971 }
972
973 TEST_F(AppRegistryUtilsRegistryProtectedTest,
974 AreAppUsageStatsEnabled_Machine_NoKey) {
975 EXPECT_FALSE(AreAppUsageStatsEnabled(true, kAppGuid));
976 EXPECT_FALSE(
977 RegKey::HasValue(kAppMachineClientStatePath, _T("usagestats")));
978 EXPECT_FALSE(
979 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("usagestats")));
980 }
981
982 TEST_F(AppRegistryUtilsRegistryProtectedTest,
983 AreAppUsageStatsEnabled_Machine_ClientStateExists) {
984 EXPECT_SUCCEEDED(RegKey::CreateKey(kAppMachineClientStatePath));
985 EXPECT_FALSE(AreAppUsageStatsEnabled(true, kAppGuid));
986 EXPECT_FALSE(
987 RegKey::HasValue(kAppMachineClientStatePath, _T("usagestats")));
988 EXPECT_FALSE(
989 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("usagestats")));
990 }
991
992 TEST_F(AppRegistryUtilsRegistryProtectedTest,
993 AreAppUsageStatsEnabled_Machine_ClientStateOne) {
994 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
995 _T("usagestats"),
996 static_cast<DWORD>(1)));
997 EXPECT_TRUE(AreAppUsageStatsEnabled(true, kAppGuid));
998 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStatePath, _T("usagestats")));
999 EXPECT_FALSE(
1000 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("usagestats")));
1001 }
1002
1003 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1004 AreAppUsageStatsEnabled_Machine_ClientStateNegativeOne) {
1005 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1006 _T("usagestats"),
1007 static_cast<DWORD>(-1)));
1008 EXPECT_FALSE(AreAppUsageStatsEnabled(true, kAppGuid));
1009 EXPECT_EQ(-1, GetDwordValue(kAppMachineClientStatePath, _T("usagestats")));
1010 EXPECT_FALSE(
1011 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("usagestats")));
1012 }
1013
1014 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1015 AreAppUsageStatsEnabled_Machine_ClientStateZero_MediumNotExist) {
1016 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1017 _T("usagestats"),
1018 static_cast<DWORD>(0)));
1019 EXPECT_FALSE(AreAppUsageStatsEnabled(true, kAppGuid));
1020 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("usagestats")));
1021 EXPECT_FALSE(
1022 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("usagestats")));
1023 }
1024
1025 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1026 AreAppUsageStatsEnabled_Machine_ClientStateZero_MediumExists) {
1027 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1028 _T("usagestats"),
1029 static_cast<DWORD>(0)));
1030 EXPECT_SUCCEEDED(RegKey::CreateKey(kAppMachineClientStateMediumPath));
1031 EXPECT_FALSE(AreAppUsageStatsEnabled(true, kAppGuid));
1032 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("usagestats")));
1033 EXPECT_FALSE(
1034 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("usagestats")));
1035 }
1036
1037 // ClientStateMedium overrides ClientState.
1038 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1039 AreAppUsageStatsEnabled_Machine_ClientStateZero_MediumOne) {
1040 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1041 _T("usagestats"),
1042 static_cast<DWORD>(0)));
1043 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
1044 _T("usagestats"),
1045 static_cast<DWORD>(1)));
1046 EXPECT_TRUE(AreAppUsageStatsEnabled(true, kAppGuid));
1047 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("usagestats")));
1048 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStateMediumPath,
1049 _T("usagestats")));
1050 }
1051
1052 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1053 AreAppUsageStatsEnabled_Machine_ClientStateZero_MediumNegativeOne) {
1054 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1055 _T("usagestats"),
1056 static_cast<DWORD>(0)));
1057 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
1058 _T("usagestats"),
1059 static_cast<DWORD>(-1)));
1060 EXPECT_FALSE(AreAppUsageStatsEnabled(true, kAppGuid));
1061 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("usagestats")));
1062 EXPECT_EQ(-1, GetDwordValue(kAppMachineClientStateMediumPath,
1063 _T("usagestats")));
1064 }
1065
1066 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1067 AreAppUsageStatsEnabled_Machine_ClientStateZero_MediumZero) {
1068 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1069 _T("usagestats"),
1070 static_cast<DWORD>(0)));
1071 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
1072 _T("usagestats"),
1073 static_cast<DWORD>(0)));
1074 EXPECT_FALSE(AreAppUsageStatsEnabled(true, kAppGuid));
1075 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStatePath, _T("usagestats")));
1076 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStateMediumPath,
1077 _T("usagestats")));
1078 }
1079
1080 // ClientStateMedium overrides ClientState.
1081 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1082 AreAppUsageStatsEnabled_Machine_ClientStateOne_MediumZero) {
1083 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1084 _T("usagestats"),
1085 static_cast<DWORD>(1)));
1086 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
1087 _T("usagestats"),
1088 static_cast<DWORD>(0)));
1089 EXPECT_FALSE(AreAppUsageStatsEnabled(true, kAppGuid));
1090 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStatePath, _T("usagestats")));
1091 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStateMediumPath,
1092 _T("usagestats")));
1093 }
1094
1095 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1096 AreAppUsageStatsEnabled_Machine_ClientStateNotExist_MediumOne) {
1097 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
1098 _T("usagestats"),
1099 static_cast<DWORD>(1)));
1100 EXPECT_TRUE(AreAppUsageStatsEnabled(true, kAppGuid));
1101 EXPECT_FALSE(
1102 RegKey::HasValue(kAppMachineClientStatePath, _T("usagestats")));
1103 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStateMediumPath,
1104 _T("usagestats")));
1105 }
1106
1107 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1108 AreAppUsageStatsEnabled_Machine_ClientStateNotExist_MediumZero) {
1109 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
1110 _T("usagestats"),
1111 static_cast<DWORD>(0)));
1112 EXPECT_FALSE(AreAppUsageStatsEnabled(true, kAppGuid));
1113 EXPECT_FALSE(
1114 RegKey::HasValue(kAppMachineClientStatePath, _T("usagestats")));
1115 EXPECT_EQ(0, GetDwordValue(kAppMachineClientStateMediumPath,
1116 _T("usagestats")));
1117 }
1118
1119 // User does not affect machine.
1120 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1121 AreAppUsageStatsEnabled_Machine_UserOne) {
1122 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
1123 _T("usagestats"),
1124 static_cast<DWORD>(1)));
1125 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
1126 _T("usagestats"),
1127 static_cast<DWORD>(1)));
1128 EXPECT_FALSE(AreAppUsageStatsEnabled(true, kAppGuid));
1129 EXPECT_FALSE(
1130 RegKey::HasValue(kAppMachineClientStatePath, _T("usagestats")));
1131 EXPECT_FALSE(
1132 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("usagestats")));
1133 EXPECT_EQ(1, GetDwordValue(kAppUserClientStatePath, _T("usagestats")));
1134 EXPECT_EQ(1, GetDwordValue(kAppUserClientStateMediumPath,
1135 _T("usagestats")));
1136 }
1137
1138 // ClientStateMedium is not supported for user apps.
1139
1140 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1141 AreAppUsageStatsEnabled_User_NoKey) {
1142 EXPECT_FALSE(AreAppUsageStatsEnabled(false, kAppGuid));
1143 EXPECT_FALSE(
1144 RegKey::HasValue(kAppUserClientStatePath, _T("usagestats")));
1145 EXPECT_FALSE(
1146 RegKey::HasValue(kAppUserClientStateMediumPath, _T("usagestats")));
1147 }
1148
1149 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1150 AreAppUsageStatsEnabled_User_ClientStateExists) {
1151 EXPECT_SUCCEEDED(RegKey::CreateKey(kAppUserClientStatePath));
1152 EXPECT_FALSE(AreAppUsageStatsEnabled(false, kAppGuid));
1153 EXPECT_FALSE(
1154 RegKey::HasValue(kAppUserClientStatePath, _T("usagestats")));
1155 EXPECT_FALSE(
1156 RegKey::HasValue(kAppUserClientStateMediumPath, _T("usagestats")));
1157 }
1158
1159 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1160 AreAppUsageStatsEnabled_User_ClientStateOne) {
1161 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
1162 _T("usagestats"),
1163 static_cast<DWORD>(1)));
1164 EXPECT_TRUE(AreAppUsageStatsEnabled(false, kAppGuid));
1165 EXPECT_EQ(1, GetDwordValue(kAppUserClientStatePath, _T("usagestats")));
1166 EXPECT_FALSE(
1167 RegKey::HasValue(kAppUserClientStateMediumPath, _T("usagestats")));
1168 }
1169
1170 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1171 AreAppUsageStatsEnabled_User_ClientStateNegativeOne) {
1172 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
1173 _T("usagestats"),
1174 static_cast<DWORD>(-1)));
1175 EXPECT_FALSE(AreAppUsageStatsEnabled(false, kAppGuid));
1176 EXPECT_EQ(-1, GetDwordValue(kAppUserClientStatePath, _T("usagestats")));
1177 EXPECT_FALSE(
1178 RegKey::HasValue(kAppUserClientStateMediumPath, _T("usagestats")));
1179 }
1180
1181 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1182 AreAppUsageStatsEnabled_User_ClientStateZero_MediumNotExist) {
1183 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
1184 _T("usagestats"),
1185 static_cast<DWORD>(0)));
1186 EXPECT_FALSE(AreAppUsageStatsEnabled(false, kAppGuid));
1187 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("usagestats")));
1188 EXPECT_FALSE(
1189 RegKey::HasValue(kAppUserClientStateMediumPath, _T("usagestats")));
1190 }
1191
1192 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1193 AreAppUsageStatsEnabled_User_ClientStateZero_MediumExists) {
1194 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
1195 _T("usagestats"),
1196 static_cast<DWORD>(0)));
1197 EXPECT_SUCCEEDED(RegKey::CreateKey(kAppUserClientStateMediumPath));
1198 EXPECT_FALSE(AreAppUsageStatsEnabled(false, kAppGuid));
1199 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("usagestats")));
1200 EXPECT_FALSE(
1201 RegKey::HasValue(kAppUserClientStateMediumPath, _T("usagestats")));
1202 }
1203
1204 // ClientStateMedium is not used.
1205 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1206 AreAppUsageStatsEnabled_User_ClientStateZero_MediumOne) {
1207 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
1208 _T("usagestats"),
1209 static_cast<DWORD>(0)));
1210 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
1211 _T("usagestats"),
1212 static_cast<DWORD>(1)));
1213 EXPECT_FALSE(AreAppUsageStatsEnabled(false, kAppGuid));
1214 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("usagestats")));
1215 EXPECT_EQ(1, GetDwordValue(kAppUserClientStateMediumPath,
1216 _T("usagestats")));
1217 }
1218
1219 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1220 AreAppUsageStatsEnabled_User_ClientStateZero_MediumNegativeOne) {
1221 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
1222 _T("usagestats"),
1223 static_cast<DWORD>(0)));
1224 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
1225 _T("usagestats"),
1226 static_cast<DWORD>(-1)));
1227 EXPECT_FALSE(AreAppUsageStatsEnabled(false, kAppGuid));
1228 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("usagestats")));
1229 EXPECT_EQ(-1, GetDwordValue(kAppUserClientStateMediumPath,
1230 _T("usagestats")));
1231 }
1232
1233 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1234 AreAppUsageStatsEnabled_User_ClientStateZero_MediumZero) {
1235 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
1236 _T("usagestats"),
1237 static_cast<DWORD>(0)));
1238 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
1239 _T("usagestats"),
1240 static_cast<DWORD>(0)));
1241 EXPECT_FALSE(AreAppUsageStatsEnabled(false, kAppGuid));
1242 EXPECT_EQ(0, GetDwordValue(kAppUserClientStatePath, _T("usagestats")));
1243 EXPECT_EQ(0, GetDwordValue(kAppUserClientStateMediumPath,
1244 _T("usagestats")));
1245 }
1246
1247 // ClientStateMedium is not used.
1248 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1249 AreAppUsageStatsEnabled_User_ClientStateOne_MediumZero) {
1250 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
1251 _T("usagestats"),
1252 static_cast<DWORD>(1)));
1253 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
1254 _T("usagestats"),
1255 static_cast<DWORD>(0)));
1256 EXPECT_TRUE(AreAppUsageStatsEnabled(false, kAppGuid));
1257 EXPECT_EQ(1, GetDwordValue(kAppUserClientStatePath, _T("usagestats")));
1258 EXPECT_EQ(0, GetDwordValue(kAppUserClientStateMediumPath,
1259 _T("usagestats")));
1260 }
1261
1262 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1263 AreAppUsageStatsEnabled_User_ClientStateNotExist_MediumOne) {
1264 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
1265 _T("usagestats"),
1266 static_cast<DWORD>(1)));
1267 EXPECT_FALSE(AreAppUsageStatsEnabled(false, kAppGuid));
1268 EXPECT_FALSE(
1269 RegKey::HasValue(kAppUserClientStatePath, _T("usagestats")));
1270 EXPECT_EQ(1, GetDwordValue(kAppUserClientStateMediumPath,
1271 _T("usagestats")));
1272 }
1273
1274 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1275 AreAppUsageStatsEnabled_User_ClientStateNotExist_MediumZero) {
1276 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
1277 _T("usagestats"),
1278 static_cast<DWORD>(0)));
1279 EXPECT_FALSE(AreAppUsageStatsEnabled(false, kAppGuid));
1280 EXPECT_FALSE(
1281 RegKey::HasValue(kAppUserClientStatePath, _T("usagestats")));
1282 EXPECT_EQ(0, GetDwordValue(kAppUserClientStateMediumPath,
1283 _T("usagestats")));
1284 }
1285
1286 // Machine does not affect user.
1287 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1288 AreAppUsageStatsEnabled_User_MachineOne) {
1289 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1290 _T("usagestats"),
1291 static_cast<DWORD>(1)));
1292 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
1293 _T("usagestats"),
1294 static_cast<DWORD>(1)));
1295 EXPECT_FALSE(AreAppUsageStatsEnabled(false, kAppGuid));
1296 EXPECT_FALSE(
1297 RegKey::HasValue(kAppUserClientStatePath, _T("usagestats")));
1298 EXPECT_FALSE(
1299 RegKey::HasValue(kAppUserClientStateMediumPath, _T("usagestats")));
1300 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStatePath, _T("usagestats")));
1301 EXPECT_EQ(1, GetDwordValue(kAppMachineClientStateMediumPath,
1302 _T("usagestats")));
1303 }
1304
1305 TEST_F(AppRegistryUtilsRegistryProtectedTest, SetUsageStatsEnable_Machine_Off) {
1306 EXPECT_SUCCEEDED(SetUsageStatsEnable(true, kAppGuid, TRISTATE_FALSE));
1307
1308 ASSERT_TRUE(RegKey::HasKey(kAppMachineClientStatePath));
1309 ASSERT_TRUE(RegKey::HasValue(kAppMachineClientStatePath,
1310 _T("usagestats")));
1311 ASSERT_FALSE(RegKey::HasKey(kAppUserClientStatePath));
1312
1313 DWORD enable_value = 1;
1314 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1315 _T("usagestats"),
1316 &enable_value));
1317 EXPECT_EQ(0, enable_value);
1318 }
1319
1320 TEST_F(AppRegistryUtilsRegistryProtectedTest, SetUsageStatsEnable_User_Off) {
1321 EXPECT_SUCCEEDED(SetUsageStatsEnable(false, kAppGuid, TRISTATE_FALSE));
1322
1323 ASSERT_TRUE(RegKey::HasKey(kAppUserClientStatePath));
1324 ASSERT_TRUE(RegKey::HasValue(kAppUserClientStatePath,
1325 _T("usagestats")));
1326 ASSERT_FALSE(RegKey::HasKey(kAppMachineClientStatePath));
1327
1328 DWORD enable_value = 1;
1329 EXPECT_SUCCEEDED(RegKey::GetValue(kAppUserClientStatePath,
1330 _T("usagestats"),
1331 &enable_value));
1332 EXPECT_EQ(0, enable_value);
1333 }
1334
1335 TEST_F(AppRegistryUtilsRegistryProtectedTest, SetUsageStatsEnable_Machine_On) {
1336 EXPECT_SUCCEEDED(SetUsageStatsEnable(true, kAppGuid, TRISTATE_TRUE));
1337
1338 ASSERT_TRUE(RegKey::HasKey(kAppMachineClientStatePath));
1339 ASSERT_TRUE(RegKey::HasValue(kAppMachineClientStatePath,
1340 _T("usagestats")));
1341 ASSERT_FALSE(RegKey::HasKey(kAppUserClientStatePath));
1342
1343 DWORD enable_value = 0;
1344 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1345 _T("usagestats"),
1346 &enable_value));
1347 EXPECT_EQ(1, enable_value);
1348 }
1349
1350 TEST_F(AppRegistryUtilsRegistryProtectedTest, SetUsageStatsEnable_User_On) {
1351 EXPECT_SUCCEEDED(SetUsageStatsEnable(false, kAppGuid, TRISTATE_TRUE));
1352
1353 ASSERT_TRUE(RegKey::HasKey(kAppUserClientStatePath));
1354 ASSERT_TRUE(RegKey::HasValue(kAppUserClientStatePath,
1355 _T("usagestats")));
1356 ASSERT_FALSE(RegKey::HasKey(kAppMachineClientStatePath));
1357
1358 DWORD enable_value = 0;
1359 EXPECT_SUCCEEDED(RegKey::GetValue(kAppUserClientStatePath,
1360 _T("usagestats"),
1361 &enable_value));
1362 EXPECT_EQ(1, enable_value);
1363 }
1364
1365
1366 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1367 SetUsageStatsEnable_Machine_None) {
1368 EXPECT_SUCCEEDED(SetUsageStatsEnable(true, kAppGuid, TRISTATE_NONE));
1369 ASSERT_FALSE(RegKey::HasKey(MACHINE_REG_UPDATE));
1370 ASSERT_FALSE(RegKey::HasKey(USER_REG_UPDATE));
1371
1372 EXPECT_SUCCEEDED(SetUsageStatsEnable(false, kAppGuid, TRISTATE_NONE));
1373 ASSERT_FALSE(RegKey::HasKey(USER_REG_UPDATE));
1374 ASSERT_FALSE(RegKey::HasKey(MACHINE_REG_UPDATE));
1375 }
1376
1377 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1378 SetUsageStatsEnable_Machine_Overwrite) {
1379 EXPECT_SUCCEEDED(SetUsageStatsEnable(true, kAppGuid, TRISTATE_FALSE));
1380
1381 ASSERT_TRUE(RegKey::HasKey(kAppMachineClientStatePath));
1382 ASSERT_TRUE(RegKey::HasValue(kAppMachineClientStatePath,
1383 _T("usagestats")));
1384 ASSERT_FALSE(RegKey::HasKey(kAppUserClientStatePath));
1385
1386 DWORD enable_value = 1;
1387 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1388 _T("usagestats"),
1389 &enable_value));
1390 EXPECT_EQ(0, enable_value);
1391
1392 EXPECT_SUCCEEDED(SetUsageStatsEnable(true, kAppGuid, TRISTATE_TRUE));
1393
1394 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1395 _T("usagestats"),
1396 &enable_value));
1397 EXPECT_EQ(1, enable_value);
1398
1399 EXPECT_SUCCEEDED(SetUsageStatsEnable(true, kAppGuid, TRISTATE_FALSE));
1400
1401 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1402 _T("usagestats"),
1403 &enable_value));
1404 EXPECT_EQ(0, enable_value);
1405 }
1406
1407 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1408 SetUsageStatsEnable_Machine_NoneDoesNotOverwrite) {
1409 EXPECT_SUCCEEDED(SetUsageStatsEnable(true, kAppGuid, TRISTATE_FALSE));
1410
1411 ASSERT_TRUE(RegKey::HasKey(kAppMachineClientStatePath));
1412 ASSERT_TRUE(RegKey::HasValue(kAppMachineClientStatePath,
1413 _T("usagestats")));
1414 ASSERT_FALSE(RegKey::HasKey(kAppUserClientStatePath));
1415
1416 DWORD enable_value = 1;
1417 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1418 _T("usagestats"),
1419 &enable_value));
1420 EXPECT_EQ(0, enable_value);
1421
1422 EXPECT_SUCCEEDED(SetUsageStatsEnable(true, kAppGuid, TRISTATE_NONE));
1423
1424 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1425 _T("usagestats"),
1426 &enable_value));
1427 EXPECT_EQ(0, enable_value);
1428
1429 EXPECT_SUCCEEDED(SetUsageStatsEnable(true, kAppGuid, TRISTATE_TRUE));
1430
1431 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1432 _T("usagestats"),
1433 &enable_value));
1434 EXPECT_EQ(1, enable_value);
1435
1436 EXPECT_SUCCEEDED(SetUsageStatsEnable(true, kAppGuid, TRISTATE_NONE));
1437
1438 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1439 _T("usagestats"),
1440 &enable_value));
1441 EXPECT_EQ(1, enable_value);
1442 }
1443
1444 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1445 SetUsageStatsEnable_Machine_ClientStateMediumCleared) {
1446 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
1447 _T("usagestats"),
1448 static_cast<DWORD>(0)));
1449
1450 EXPECT_SUCCEEDED(SetUsageStatsEnable(true, kAppGuid, TRISTATE_TRUE));
1451 EXPECT_FALSE(
1452 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("usagestats")));
1453
1454 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
1455 _T("usagestats"),
1456 static_cast<DWORD>(1)));
1457 EXPECT_SUCCEEDED(SetUsageStatsEnable(true, kAppGuid, TRISTATE_FALSE));
1458 EXPECT_FALSE(
1459 RegKey::HasValue(kAppMachineClientStateMediumPath, _T("usagestats")));
1460 }
1461
1462 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1463 SetUsageStatsEnable_Machine_NoneDoesNotClearClientStateMedium) {
1464 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
1465 _T("usagestats"),
1466 static_cast<DWORD>(1)));
1467
1468 EXPECT_SUCCEEDED(SetUsageStatsEnable(true, kAppGuid, TRISTATE_NONE));
1469
1470 DWORD enable_value = 0;
1471 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStateMediumPath,
1472 _T("usagestats"),
1473 &enable_value));
1474 EXPECT_EQ(1, enable_value);
1475 }
1476
1477 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1478 SetUsageStatsEnable_User_ClientStateMediumNotCleared) {
1479 // User and machine values should not be cleared.
1480 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
1481 _T("usagestats"),
1482 static_cast<DWORD>(0)));
1483 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
1484 _T("usagestats"),
1485 static_cast<DWORD>(0)));
1486
1487 // True does not clear them.
1488 EXPECT_SUCCEEDED(SetUsageStatsEnable(false, kAppGuid, TRISTATE_TRUE));
1489 DWORD enable_value = 1;
1490 EXPECT_SUCCEEDED(RegKey::GetValue(kAppUserClientStateMediumPath,
1491 _T("usagestats"),
1492 &enable_value));
1493 EXPECT_EQ(0, enable_value);
1494 enable_value = 1;
1495 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStateMediumPath,
1496 _T("usagestats"),
1497 &enable_value));
1498 EXPECT_EQ(0, enable_value);
1499
1500 // False does not clear them.
1501 EXPECT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
1502 _T("usagestats"),
1503 static_cast<DWORD>(1)));
1504 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
1505 _T("usagestats"),
1506 static_cast<DWORD>(1)));
1507 EXPECT_SUCCEEDED(SetUsageStatsEnable(false, kAppGuid, TRISTATE_FALSE));
1508 enable_value = 0;
1509 EXPECT_SUCCEEDED(RegKey::GetValue(kAppUserClientStateMediumPath,
1510 _T("usagestats"),
1511 &enable_value));
1512 EXPECT_EQ(1, enable_value);
1513 enable_value = 0;
1514 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStateMediumPath,
1515 _T("usagestats"),
1516 &enable_value));
1517 EXPECT_EQ(1, enable_value);
1518 }
1519
1520 TEST_F(AppRegistryUtilsRegistryProtectedTest, GetNumClients) {
1521 size_t num_clients(0);
1522
1523 // Fails when no "Clients" key.
1524 EXPECT_HRESULT_FAILED(GetNumClients(true, &num_clients));
1525 EXPECT_HRESULT_FAILED(GetNumClients(false, &num_clients));
1526
1527 // Tests no subkeys.
1528 const TCHAR* keys_to_create[] = { MACHINE_REG_CLIENTS, USER_REG_CLIENTS };
1529 EXPECT_HRESULT_SUCCEEDED(RegKey::CreateKeys(keys_to_create,
1530 arraysize(keys_to_create)));
1531 EXPECT_HRESULT_SUCCEEDED(GetNumClients(true, &num_clients));
1532 EXPECT_EQ(0, num_clients);
1533 EXPECT_HRESULT_SUCCEEDED(GetNumClients(false, &num_clients));
1534 EXPECT_EQ(0, num_clients);
1535
1536 // Subkeys should be counted. Values should not be counted.
1537 RegKey machine_key;
1538 EXPECT_HRESULT_SUCCEEDED(machine_key.Open(HKEY_LOCAL_MACHINE,
1539 GOOPDATE_REG_RELATIVE_CLIENTS));
1540 EXPECT_HRESULT_SUCCEEDED(machine_key.SetValue(_T("name"), _T("value")));
1541 EXPECT_HRESULT_SUCCEEDED(GetNumClients(true, &num_clients));
1542 EXPECT_EQ(0, num_clients);
1543
1544 const TCHAR* app_id = _T("{AA5523E3-40C0-4b85-B074-4BBA09559CCD}");
1545 EXPECT_HRESULT_SUCCEEDED(machine_key.Create(machine_key.Key(), app_id));
1546 EXPECT_HRESULT_SUCCEEDED(GetNumClients(true, &num_clients));
1547 EXPECT_EQ(1, num_clients);
1548
1549 // Tests user scenario.
1550 RegKey user_key;
1551 EXPECT_HRESULT_SUCCEEDED(user_key.Open(HKEY_CURRENT_USER,
1552 GOOPDATE_REG_RELATIVE_CLIENTS));
1553 EXPECT_HRESULT_SUCCEEDED(user_key.SetValue(_T("name"), _T("value")));
1554 EXPECT_HRESULT_SUCCEEDED(GetNumClients(false, &num_clients));
1555 EXPECT_EQ(0, num_clients);
1556
1557 EXPECT_HRESULT_SUCCEEDED(user_key.Create(user_key.Key(), app_id));
1558 EXPECT_HRESULT_SUCCEEDED(GetNumClients(false, &num_clients));
1559 EXPECT_EQ(1, num_clients);
1560 }
1561
1562 // This test verifies that InstallTime is created afresh for Omaha if it does
1563 // not exist, and even if the brand code is already set.
1564 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1565 SetGoogleUpdateBranding_BrandAlreadyExistsAllEmpty) {
1566 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1567 kRegValueBrandCode,
1568 _T("EFGH")));
1569
1570 EXPECT_SUCCEEDED(SetGoogleUpdateBranding(kAppMachineClientStatePath,
1571 _T(""),
1572 _T("")));
1573
1574 const uint32 now = Time64ToInt32(GetCurrent100NSTime());
1575
1576 CString value;
1577 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1578 kRegValueBrandCode,
1579 &value));
1580 EXPECT_STREQ(_T("EFGH"), value);
1581 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1582 RegKey::GetValue(kAppMachineClientStatePath,
1583 kRegValueClientId,
1584 &value));
1585 DWORD install_time = 0;
1586 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1587 kRegValueInstallTimeSec,
1588 &install_time));
1589 EXPECT_GE(now, install_time);
1590 EXPECT_GE(static_cast<uint32>(200), now - install_time);
1591 }
1592
1593 // This test verifies that InstallTime remains unchanged for Omaha if it already
1594 // exists and the brand code is already set.
1595 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1596 SetGoogleUpdateBranding_AllAlreadyExistAllEmpty) {
1597 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1598 kRegValueBrandCode,
1599 _T("EFGH")));
1600 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1601 kRegValueClientId,
1602 _T("existing_partner")));
1603 const DWORD kInstallTime = 1234567890;
1604 EXPECT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1605 kRegValueInstallTimeSec,
1606 kInstallTime));
1607
1608 EXPECT_SUCCEEDED(SetGoogleUpdateBranding(kAppMachineClientStatePath,
1609 _T(""),
1610 _T("")));
1611
1612 CString value;
1613 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1614 kRegValueBrandCode,
1615 &value));
1616 EXPECT_STREQ(_T("EFGH"), value);
1617 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1618 kRegValueClientId,
1619 &value));
1620 EXPECT_STREQ(_T("existing_partner"), value);
1621 EXPECT_EQ(kInstallTime,
1622 GetDwordValue(kAppMachineClientStatePath, kRegValueInstallTimeSec));
1623 }
1624
1625 TEST_F(AppRegistryUtilsRegistryProtectedTest, SetAppBranding_KeyDoesNotExist) {
1626 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
1627 _T("ABCD"),
1628 _T("some_partner"),
1629 _T("referrer")));
1630 }
1631
1632 TEST_F(AppRegistryUtilsRegistryProtectedTest, SetAppBranding_AllEmpty) {
1633 ASSERT_SUCCEEDED(RegKey::CreateKey(kAppMachineClientStatePath));
1634
1635 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
1636 _T(""),
1637 _T(""),
1638 _T("")));
1639 const uint32 now = Time64ToInt32(GetCurrent100NSTime());
1640
1641 CString value;
1642 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1643 kRegValueBrandCode,
1644 &value));
1645 EXPECT_STREQ(_T("GGLS"), value);
1646 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1647 RegKey::GetValue(kAppMachineClientStatePath,
1648 kRegValueClientId,
1649 &value));
1650 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1651 RegKey::GetValue(kAppMachineClientStatePath,
1652 kRegValueReferralId,
1653 &value));
1654 DWORD install_time = 0;
1655 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1656 kRegValueInstallTimeSec,
1657 &install_time));
1658 EXPECT_GE(now, install_time);
1659 EXPECT_GE(static_cast<uint32>(200), now - install_time);
1660 }
1661
1662 TEST_F(AppRegistryUtilsRegistryProtectedTest, SetAppBranding_BrandCodeOnly) {
1663 ASSERT_SUCCEEDED(RegKey::CreateKey(kAppMachineClientStatePath));
1664
1665 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
1666 _T("ABCD"),
1667 _T(""),
1668 _T("")));
1669 const uint32 now = Time64ToInt32(GetCurrent100NSTime());
1670
1671 CString value;
1672 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1673 kRegValueBrandCode,
1674 &value));
1675 EXPECT_STREQ(_T("ABCD"), value);
1676 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1677 RegKey::GetValue(kAppMachineClientStatePath,
1678 kRegValueClientId,
1679 &value));
1680 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1681 RegKey::GetValue(kAppMachineClientStatePath,
1682 kRegValueReferralId,
1683 &value));
1684 DWORD install_time = 0;
1685 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1686 kRegValueInstallTimeSec,
1687 &install_time));
1688 EXPECT_GE(now, install_time);
1689 EXPECT_GE(static_cast<uint32>(200), now - install_time);
1690 }
1691
1692 TEST_F(AppRegistryUtilsRegistryProtectedTest, SetAppBranding_BrandCodeTooLong) {
1693 EXPECT_EQ(E_INVALIDARG, SetAppBranding(kAppMachineClientStatePath,
1694 _T("CHMGon.href)}"),
1695 _T(""),
1696 _T("")));
1697 }
1698
1699 TEST_F(AppRegistryUtilsRegistryProtectedTest, SetAppBranding_ClientIdOnly) {
1700 ASSERT_SUCCEEDED(RegKey::CreateKey(kAppMachineClientStatePath));
1701
1702 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
1703 _T(""),
1704 _T("some_partner"),
1705 _T("")));
1706 const uint32 now = Time64ToInt32(GetCurrent100NSTime());
1707
1708 CString value;
1709 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1710 kRegValueBrandCode,
1711 &value));
1712 EXPECT_STREQ(_T("GGLS"), value);
1713 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1714 kRegValueClientId,
1715 &value));
1716 EXPECT_STREQ(_T("some_partner"), value);
1717 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1718 RegKey::GetValue(kAppMachineClientStatePath,
1719 kRegValueReferralId,
1720 &value));
1721 DWORD install_time = 0;
1722 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1723 kRegValueInstallTimeSec,
1724 &install_time));
1725 EXPECT_GE(now, install_time);
1726 EXPECT_GE(static_cast<uint32>(200), now - install_time);
1727 }
1728
1729 TEST_F(AppRegistryUtilsRegistryProtectedTest, SetAppBranding_AllValid) {
1730 ASSERT_SUCCEEDED(RegKey::CreateKey(kAppMachineClientStatePath));
1731
1732 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
1733 _T("ABCD"),
1734 _T("some_partner"),
1735 _T("referrer")));
1736 const uint32 now = Time64ToInt32(GetCurrent100NSTime());
1737
1738 CString value;
1739 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1740 kRegValueBrandCode,
1741 &value));
1742 EXPECT_STREQ(_T("ABCD"), value);
1743 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1744 kRegValueClientId,
1745 &value));
1746 EXPECT_STREQ(_T("some_partner"), value);
1747 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1748 kRegValueReferralId,
1749 &value));
1750 EXPECT_STREQ(_T("referrer"), value);
1751 DWORD install_time(0);
1752 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1753 kRegValueInstallTimeSec,
1754 &install_time));
1755 EXPECT_GE(now, install_time);
1756 EXPECT_GE(static_cast<uint32>(200), now - install_time);
1757 }
1758
1759 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1760 SetAppBranding_BrandAlreadyExistsAllEmpty) {
1761 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1762 kRegValueBrandCode,
1763 _T("EFGH")));
1764
1765 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
1766 _T(""),
1767 _T(""),
1768 _T("")));
1769
1770 CString value;
1771 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1772 kRegValueBrandCode,
1773 &value));
1774 EXPECT_STREQ(_T("EFGH"), value);
1775 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1776 RegKey::GetValue(kAppMachineClientStatePath,
1777 kRegValueClientId,
1778 &value));
1779 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1780 RegKey::GetValue(kAppMachineClientStatePath,
1781 kRegValueReferralId,
1782 &value));
1783 DWORD dword_value(0);
1784 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1785 RegKey::GetValue(kAppMachineClientStatePath,
1786 kRegValueInstallTimeSec,
1787 &dword_value));
1788 }
1789
1790 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1791 SetAppBranding_BrandAlreadyExistsBrandCodeOnly) {
1792 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1793 kRegValueBrandCode,
1794 _T("EFGH")));
1795
1796 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
1797 _T("ABCD"),
1798 _T(""),
1799 _T("")));
1800
1801 CString value;
1802 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1803 kRegValueBrandCode,
1804 &value));
1805 EXPECT_STREQ(_T("EFGH"), value);
1806 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1807 RegKey::GetValue(kAppMachineClientStatePath,
1808 kRegValueClientId,
1809 &value));
1810 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1811 RegKey::GetValue(kAppMachineClientStatePath,
1812 kRegValueReferralId,
1813 &value));
1814 DWORD dword_value(0);
1815 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1816 RegKey::GetValue(kAppMachineClientStatePath,
1817 kRegValueInstallTimeSec,
1818 &dword_value));
1819 }
1820
1821 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1822 SetAppBranding_ExistingBrandTooLong) {
1823 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1824 kRegValueBrandCode,
1825 _T("CHMG4CUTNt")));
1826
1827 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
1828 _T("ABCD"),
1829 _T(""),
1830 _T("")));
1831
1832 CString value;
1833 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1834 kRegValueBrandCode,
1835 &value));
1836 EXPECT_STREQ(_T("CHMG"), value);
1837 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1838 RegKey::GetValue(kAppMachineClientStatePath,
1839 kRegValueClientId,
1840 &value));
1841 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1842 RegKey::GetValue(kAppMachineClientStatePath,
1843 kRegValueReferralId,
1844 &value));
1845 DWORD dword_value(0);
1846 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1847 RegKey::GetValue(kAppMachineClientStatePath,
1848 kRegValueInstallTimeSec,
1849 &dword_value));
1850 }
1851
1852 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1853 SetAppBranding_BrandAlreadyExistsCliendIdOnly) {
1854 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1855 kRegValueBrandCode,
1856 _T("EFGH")));
1857
1858 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
1859 _T(""),
1860 _T("some_partner"),
1861 _T("")));
1862
1863 CString value;
1864 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1865 kRegValueBrandCode,
1866 &value));
1867 EXPECT_STREQ(_T("EFGH"), value);
1868 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1869 RegKey::GetValue(kAppMachineClientStatePath,
1870 kRegValueClientId,
1871 &value));
1872 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1873 RegKey::GetValue(kAppMachineClientStatePath,
1874 kRegValueReferralId,
1875 &value));
1876 DWORD dword_value(0);
1877 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1878 RegKey::GetValue(kAppMachineClientStatePath,
1879 kRegValueInstallTimeSec,
1880 &dword_value));
1881 }
1882
1883 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1884 SetAppBranding_BrandAlreadyExistsBothValid) {
1885 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1886 kRegValueBrandCode,
1887 _T("EFGH")));
1888
1889 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
1890 _T("ABCD"),
1891 _T("some_partner"),
1892 _T("")));
1893
1894 CString value;
1895 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1896 kRegValueBrandCode,
1897 &value));
1898 EXPECT_STREQ(_T("EFGH"), value);
1899 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1900 RegKey::GetValue(kAppMachineClientStatePath,
1901 kRegValueClientId,
1902 &value));
1903 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1904 RegKey::GetValue(kAppMachineClientStatePath,
1905 kRegValueReferralId,
1906 &value));
1907 DWORD dword_value(0);
1908 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1909 RegKey::GetValue(kAppMachineClientStatePath,
1910 kRegValueInstallTimeSec,
1911 &dword_value));
1912 }
1913
1914 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1915 SetAppBranding_ClientIdAlreadyExistsAllEmtpy) {
1916 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1917 kRegValueClientId,
1918 _T("existing_partner")));
1919
1920 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
1921 _T(""),
1922 _T(""),
1923 _T("")));
1924 const uint32 now = Time64ToInt32(GetCurrent100NSTime());
1925
1926 CString value;
1927 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1928 kRegValueBrandCode,
1929 &value));
1930 EXPECT_STREQ(_T("GGLS"), value);
1931 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1932 kRegValueClientId,
1933 &value));
1934 EXPECT_STREQ(_T("existing_partner"), value);
1935 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1936 RegKey::GetValue(kAppMachineClientStatePath,
1937 kRegValueReferralId,
1938 &value));
1939 DWORD install_time = 0;
1940 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1941 kRegValueInstallTimeSec,
1942 &install_time));
1943 EXPECT_GE(now, install_time);
1944 EXPECT_GE(static_cast<uint32>(200), now - install_time);
1945 }
1946
1947 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1948 SetAppBranding_ClientIdAlreadyExistsBrandCodeOnly) {
1949 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1950 kRegValueClientId,
1951 _T("existing_partner")));
1952
1953 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
1954 _T("ABCE"),
1955 _T(""),
1956 _T("")));
1957 const uint32 now = Time64ToInt32(GetCurrent100NSTime());
1958
1959 CString value;
1960 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1961 kRegValueBrandCode,
1962 &value));
1963 EXPECT_STREQ(_T("ABCE"), value);
1964 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1965 kRegValueClientId,
1966 &value));
1967 EXPECT_STREQ(_T("existing_partner"), value);
1968 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
1969 RegKey::GetValue(kAppMachineClientStatePath,
1970 kRegValueReferralId,
1971 &value));
1972 DWORD install_time = 0;
1973 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1974 kRegValueInstallTimeSec,
1975 &install_time));
1976 EXPECT_GE(now, install_time);
1977 EXPECT_GE(static_cast<uint32>(200), now - install_time);
1978 }
1979
1980 TEST_F(AppRegistryUtilsRegistryProtectedTest,
1981 SetAppBranding_ClientIdAlreadyExistsCliendIdOnly) {
1982 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
1983 kRegValueClientId,
1984 _T("existing_partner")));
1985
1986 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
1987 _T(""),
1988 _T("some_partner"),
1989 _T("")));
1990 const uint32 now = Time64ToInt32(GetCurrent100NSTime());
1991
1992 CString value;
1993 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1994 kRegValueBrandCode,
1995 &value));
1996 EXPECT_STREQ(_T("GGLS"), value);
1997 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
1998 kRegValueClientId,
1999 &value));
2000 EXPECT_STREQ(_T("some_partner"), value);
2001 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
2002 RegKey::GetValue(kAppMachineClientStatePath,
2003 kRegValueReferralId,
2004 &value));
2005 DWORD install_time = 0;
2006 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2007 kRegValueInstallTimeSec,
2008 &install_time));
2009 EXPECT_GE(now, install_time);
2010 EXPECT_GE(static_cast<uint32>(200), now - install_time);
2011 }
2012
2013 TEST_F(AppRegistryUtilsRegistryProtectedTest,
2014 SetAppBranding_ClientIdAlreadyExistsBothValid) {
2015 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2016 kRegValueClientId,
2017 _T("existing_partner")));
2018
2019 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
2020 _T("ABCD"),
2021 _T("some_partner"),
2022 _T("")));
2023 const uint32 now = Time64ToInt32(GetCurrent100NSTime());
2024
2025 CString value;
2026 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2027 kRegValueBrandCode,
2028 &value));
2029 EXPECT_STREQ(_T("ABCD"), value);
2030 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2031 kRegValueClientId,
2032 &value));
2033 EXPECT_STREQ(_T("some_partner"), value);
2034 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
2035 RegKey::GetValue(kAppMachineClientStatePath,
2036 kRegValueReferralId,
2037 &value));
2038 DWORD install_time = 0;
2039 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2040 kRegValueInstallTimeSec,
2041 &install_time));
2042 EXPECT_GE(now, install_time);
2043 EXPECT_GE(static_cast<uint32>(200), now - install_time);
2044 }
2045
2046 TEST_F(AppRegistryUtilsRegistryProtectedTest,
2047 SetAppBranding_AllAlreadyExistAllEmpty) {
2048 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2049 kRegValueBrandCode,
2050 _T("EFGH")));
2051 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2052 kRegValueClientId,
2053 _T("existing_partner")));
2054 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2055 kRegValueReferralId,
2056 __T("existingreferrerid")));
2057 const DWORD kInstallTime = 1234567890;
2058 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2059 kRegValueInstallTimeSec,
2060 kInstallTime));
2061
2062 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
2063 _T(""),
2064 _T(""),
2065 _T("")));
2066
2067 CString value;
2068 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2069 kRegValueBrandCode,
2070 &value));
2071 EXPECT_STREQ(_T("EFGH"), value);
2072 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2073 kRegValueClientId,
2074 &value));
2075 EXPECT_STREQ(_T("existing_partner"), value);
2076 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2077 kRegValueReferralId,
2078 &value));
2079 EXPECT_STREQ(__T("existingreferrerid"), value);
2080 EXPECT_EQ(kInstallTime,
2081 GetDwordValue(kAppMachineClientStatePath, kRegValueInstallTimeSec));
2082 }
2083
2084 TEST_F(AppRegistryUtilsRegistryProtectedTest,
2085 SetAppBranding_AllAlreadyExistBrandCodeOnly) {
2086 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2087 kRegValueBrandCode,
2088 _T("EFGH")));
2089 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2090 kRegValueClientId,
2091 _T("existing_partner")));
2092 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2093 kRegValueReferralId,
2094 __T("existingreferrerid")));
2095 const DWORD kInstallTime = 1234567890;
2096 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2097 kRegValueInstallTimeSec,
2098 kInstallTime));
2099
2100 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
2101 _T("ABCD"),
2102 _T(""),
2103 _T("")));
2104
2105 CString value;
2106 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2107 kRegValueBrandCode,
2108 &value));
2109 EXPECT_STREQ(_T("EFGH"), value);
2110 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2111 kRegValueClientId,
2112 &value));
2113 EXPECT_STREQ(_T("existing_partner"), value);
2114 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2115 kRegValueReferralId,
2116 &value));
2117 EXPECT_STREQ(__T("existingreferrerid"), value);
2118 EXPECT_EQ(kInstallTime,
2119 GetDwordValue(kAppMachineClientStatePath, kRegValueInstallTimeSec));
2120 }
2121
2122 TEST_F(AppRegistryUtilsRegistryProtectedTest,
2123 SetAppBranding_BothAlreadyExistCliendIdOnly) {
2124 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2125 kRegValueBrandCode,
2126 _T("EFGH")));
2127 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2128 kRegValueClientId,
2129 _T("existing_partner")));
2130 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2131 kRegValueReferralId,
2132 __T("existingreferrerid")));
2133
2134 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
2135 _T(""),
2136 _T("some_partner"),
2137 _T("")));
2138
2139 CString value;
2140 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2141 kRegValueBrandCode,
2142 &value));
2143 EXPECT_STREQ(_T("EFGH"), value);
2144 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2145 kRegValueClientId,
2146 &value));
2147 EXPECT_STREQ(_T("existing_partner"), value);
2148 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2149 kRegValueReferralId,
2150 &value));
2151 EXPECT_STREQ(__T("existingreferrerid"), value);
2152 DWORD dword_value(0);
2153 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
2154 RegKey::GetValue(kAppMachineClientStatePath,
2155 kRegValueInstallTimeSec,
2156 &dword_value));
2157 }
2158
2159 TEST_F(AppRegistryUtilsRegistryProtectedTest,
2160 SetAppBranding_BothAlreadyExistBothValid) {
2161 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2162 kRegValueBrandCode,
2163 _T("EFGH")));
2164 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2165 kRegValueClientId,
2166 _T("existing_partner")));
2167 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2168 kRegValueReferralId,
2169 _T("existingreferrerid")));
2170
2171 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
2172 _T("ABCD"),
2173 _T("some_partner"),
2174 _T("")));
2175
2176 CString value;
2177 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2178 kRegValueBrandCode,
2179 &value));
2180 EXPECT_STREQ(_T("EFGH"), value);
2181 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2182 kRegValueClientId,
2183 &value));
2184 EXPECT_STREQ(_T("existing_partner"), value);
2185 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2186 kRegValueReferralId,
2187 &value));
2188 EXPECT_STREQ(_T("existingreferrerid"), value);
2189 DWORD dword_value(0);
2190 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
2191 RegKey::GetValue(kAppMachineClientStatePath,
2192 kRegValueInstallTimeSec,
2193 &dword_value));
2194 }
2195
2196 TEST_F(AppRegistryUtilsRegistryProtectedTest,
2197 SetAppBranding_InstallTimeAlreadyExistsBrandCodeOnly) {
2198 const DWORD kExistingInstallTime = 1234567890;
2199 ASSERT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2200 kRegValueInstallTimeSec,
2201 kExistingInstallTime));
2202
2203 EXPECT_SUCCEEDED(SetAppBranding(kAppMachineClientStatePath,
2204 _T("ABCE"),
2205 _T(""),
2206 _T("")));
2207 const uint32 now = Time64ToInt32(GetCurrent100NSTime());
2208
2209 CString value;
2210 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2211 kRegValueBrandCode,
2212 &value));
2213 EXPECT_STREQ(_T("ABCE"), value);
2214 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
2215 RegKey::GetValue(kAppMachineClientStatePath,
2216 kRegValueClientId,
2217 &value));
2218 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
2219 RegKey::GetValue(kAppMachineClientStatePath,
2220 kRegValueReferralId,
2221 &value));
2222 DWORD install_time = 0;
2223 EXPECT_SUCCEEDED(RegKey::GetValue(kAppMachineClientStatePath,
2224 kRegValueInstallTimeSec,
2225 &install_time));
2226 EXPECT_NE(kExistingInstallTime, install_time);
2227 EXPECT_GE(now, install_time);
2228 EXPECT_GE(static_cast<uint32>(200), now - install_time);
2229 }
2230
2231 TEST_F(AppRegistryUtilsRegistryProtectedTest, GetAppVersion_User) {
2232 const CString expected_pv = _T("1.0");
2233
2234 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaUserClientsPath,
2235 kRegValueProductVersion,
2236 expected_pv));
2237
2238 CString actual_pv;
2239 GetAppVersion(false, kGoogleUpdateAppId, &actual_pv);
2240 EXPECT_STREQ(expected_pv, actual_pv);
2241 }
2242
2243 TEST_F(AppRegistryUtilsRegistryProtectedTest, GetAppVersion_Machine) {
2244 const CString expected_pv = _T("1.0");
2245
2246 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaMachineClientsPath,
2247 kRegValueProductVersion,
2248 expected_pv));
2249
2250 CString actual_pv;
2251 GetAppVersion(true, kGoogleUpdateAppId, &actual_pv);
2252 EXPECT_STREQ(expected_pv, actual_pv);
2253 }
2254
2255 TEST_F(AppRegistryUtilsRegistryProtectedTest,
2256 GetClientStateData_User) {
2257 const CString expected_pv = _T("1.0");
2258 const CString expected_ap = _T("additional parameters");
2259 const CString expected_lang = _T("some lang");
2260 const CString expected_brand_code = _T("some brand");
2261 const CString expected_client_id = _T("some client id");
2262 const CString expected_iid =
2263 _T("{7C0B6E56-B24B-436b-A960-A6EA201E886F}");
2264 const CString expected_experiment_label =
2265 _T("some_experiment=a|Fri, 14 Aug 2015 16:13:03 GMT");
2266
2267 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaUserClientStatePath,
2268 kRegValueProductVersion,
2269 expected_pv));
2270 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaUserClientStatePath,
2271 kRegValueAdditionalParams,
2272 expected_ap));
2273 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaUserClientStatePath,
2274 kRegValueLanguage,
2275 expected_lang));
2276 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaUserClientStatePath,
2277 kRegValueBrandCode,
2278 expected_brand_code));
2279 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaUserClientStatePath,
2280 kRegValueClientId,
2281 expected_client_id));
2282 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaUserClientStatePath,
2283 kRegValueInstallationId,
2284 expected_iid));
2285 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaUserClientStatePath,
2286 kRegValueExperimentLabels,
2287 expected_experiment_label));
2288
2289 CString actual_pv, actual_ap, actual_lang, actual_brand_code,
2290 actual_client_id, actual_experiment_label, actual_iid;
2291
2292 GetClientStateData(false,
2293 kGoogleUpdateAppId,
2294 &actual_pv,
2295 &actual_ap,
2296 &actual_lang,
2297 &actual_brand_code,
2298 &actual_client_id,
2299 &actual_iid,
2300 &actual_experiment_label);
2301
2302 EXPECT_STREQ(expected_pv, actual_pv);
2303 EXPECT_STREQ(expected_ap, actual_ap);
2304 EXPECT_STREQ(expected_lang, actual_lang);
2305 EXPECT_STREQ(expected_brand_code, actual_brand_code);
2306 EXPECT_STREQ(expected_client_id, actual_client_id);
2307 EXPECT_STREQ(expected_iid, actual_iid);
2308 EXPECT_STREQ(expected_experiment_label, actual_experiment_label);
2309 }
2310
2311 TEST_F(AppRegistryUtilsRegistryProtectedTest,
2312 GetGoogleUpdatePersistentData_Machine) {
2313 const CString expected_pv = _T("1.0");
2314 const CString expected_ap = _T("additional parameters");
2315 const CString expected_lang = _T("some lang");
2316 const CString expected_brand_code = _T("some brand");
2317 const CString expected_client_id = _T("some client id");
2318 const CString expected_iid =
2319 _T("{7C0B6E56-B24B-436b-A960-A6EA201E886F}");
2320 const CString expected_experiment_label =
2321 _T("some_experiment=a|Fri, 14 Aug 2015 16:13:03 GMT");
2322
2323 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaMachineClientStatePath,
2324 kRegValueProductVersion,
2325 expected_pv));
2326 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaMachineClientStatePath,
2327 kRegValueAdditionalParams,
2328 expected_ap));
2329 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaMachineClientStatePath,
2330 kRegValueLanguage,
2331 expected_lang));
2332 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaMachineClientStatePath,
2333 kRegValueBrandCode,
2334 expected_brand_code));
2335 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaMachineClientStatePath,
2336 kRegValueClientId,
2337 expected_client_id));
2338 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaMachineClientStatePath,
2339 kRegValueInstallationId,
2340 expected_iid));
2341 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaMachineClientStatePath,
2342 kRegValueExperimentLabels,
2343 expected_experiment_label));
2344
2345 CString actual_pv, actual_ap, actual_lang, actual_brand_code,
2346 actual_client_id, actual_experiment_label, actual_iid;
2347
2348 GetClientStateData(true,
2349 kGoogleUpdateAppId,
2350 &actual_pv,
2351 &actual_ap,
2352 &actual_lang,
2353 &actual_brand_code,
2354 &actual_client_id,
2355 &actual_iid,
2356 &actual_experiment_label);
2357
2358 EXPECT_STREQ(expected_pv, actual_pv);
2359 EXPECT_STREQ(expected_ap, actual_ap);
2360 EXPECT_STREQ(expected_lang, actual_lang);
2361 EXPECT_STREQ(expected_brand_code, actual_brand_code);
2362 EXPECT_STREQ(expected_client_id, actual_client_id);
2363 EXPECT_STREQ(expected_iid, actual_iid);
2364 EXPECT_STREQ(expected_experiment_label, actual_experiment_label);
2365 }
2366
2367 TEST_F(AppRegistryUtilsRegistryProtectedTest, RemoveClientState_Machine) {
2368 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2369 kRegValueProductVersion,
2370 _T("1.1")));
2371 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStateMediumPath,
2372 kRegValueProductVersion,
2373 _T("1.1")));
2374 RemoveClientState(true, GOOPDATE_APP_ID);
2375 EXPECT_TRUE(RegKey::HasValue(kAppMachineClientStatePath,
2376 kRegValueProductVersion));
2377 EXPECT_TRUE(RegKey::HasValue(kAppMachineClientStateMediumPath,
2378 kRegValueProductVersion));
2379 EXPECT_HRESULT_SUCCEEDED(RemoveClientState(true, kAppGuid));
2380 EXPECT_FALSE(RegKey::HasValue(kAppMachineClientStatePath,
2381 kRegValueProductVersion));
2382 EXPECT_FALSE(RegKey::HasValue(kAppMachineClientStateMediumPath,
2383 kRegValueProductVersion));
2384 }
2385
2386 TEST_F(AppRegistryUtilsRegistryProtectedTest, RemoveClientState_User) {
2387 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
2388 kRegValueProductVersion,
2389 _T("1.1")));
2390 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kAppUserClientStateMediumPath,
2391 kRegValueProductVersion,
2392 _T("1.1")));
2393 RemoveClientState(false, GOOPDATE_APP_ID);
2394 EXPECT_TRUE(RegKey::HasValue(kAppUserClientStatePath,
2395 kRegValueProductVersion));
2396 EXPECT_HRESULT_SUCCEEDED(RemoveClientState(false, kAppGuid));
2397 EXPECT_FALSE(RegKey::HasValue(kAppUserClientStatePath,
2398 kRegValueProductVersion));
2399
2400 // For user case, StateMedium key is not deleted.
2401 EXPECT_TRUE(RegKey::HasValue(kAppUserClientStateMediumPath,
2402 kRegValueProductVersion));
2403 }
2404
2405 TEST_F(AppRegistryUtilsRegistryProtectedTest, GetUninstalledApps_Machine) {
2406 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaMachineClientsPath,
2407 kRegValueProductVersion,
2408 _T("1.0")));
2409 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaMachineClientStatePath,
2410 kRegValueProductVersion,
2411 _T("1.0")));
2412 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kAppMachineClientStatePath,
2413 kRegValueProductVersion,
2414 _T("1.1")));
2415
2416 std::vector<CString> uninstalled_apps;
2417 GetUninstalledApps(true, &uninstalled_apps);
2418 EXPECT_EQ(1, uninstalled_apps.size());
2419 EXPECT_STREQ(kAppGuid, uninstalled_apps[0]);
2420
2421 RemoveClientStateForApps(true, uninstalled_apps);
2422 uninstalled_apps.clear();
2423 GetUninstalledApps(true, &uninstalled_apps);
2424 EXPECT_EQ(0, uninstalled_apps.size());
2425 }
2426
2427 TEST_F(AppRegistryUtilsRegistryProtectedTest, GetUninstalledApps_User) {
2428 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaUserClientsPath,
2429 kRegValueProductVersion,
2430 _T("1.0")));
2431 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kOmahaUserClientStatePath,
2432 kRegValueProductVersion,
2433 _T("1.0")));
2434 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue(kAppUserClientStatePath,
2435 kRegValueProductVersion,
2436 _T("1.1")));
2437
2438 std::vector<CString> uninstalled_apps;
2439 GetUninstalledApps(false, &uninstalled_apps);
2440 EXPECT_EQ(1, uninstalled_apps.size());
2441 EXPECT_STREQ(kAppGuid, uninstalled_apps[0]);
2442
2443 RemoveClientStateForApps(false, uninstalled_apps);
2444 uninstalled_apps.clear();
2445 GetUninstalledApps(false, &uninstalled_apps);
2446 EXPECT_EQ(0, uninstalled_apps.size());
2447 }
2448
2449 } // namespace app_registry_utils
2450
2451 } // namespace omaha
OLDNEW
« no previous file with comments | « common/app_registry_utils.cc ('k') | common/build.scons » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698