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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: common/oem_install_utils_test.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/oem_install_utils.cc ('k') | common/omaha_customization_unittest.cc » ('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/error.h"
17 #include "omaha/base/file.h"
18 #include "omaha/base/reg_key.h"
19 #include "omaha/base/string.h"
20 #include "omaha/base/time.h"
21 #include "omaha/base/vistautil.h"
22 #include "omaha/common/config_manager.h"
23 #include "omaha/common/const_goopdate.h"
24 #include "omaha/common/oem_install_utils.h"
25 #include "omaha/testing/unit_test.h"
26
27 namespace omaha {
28
29 namespace {
30
31 const TCHAR* const kVistaSetupStateKey =
32 _T("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\State");
33 const TCHAR* const kXpSystemSetupKey = _T("HKLM\\System\\Setup");
34
35 } // namespace
36
37 class OemInstallTest : public testing::Test {
38 protected:
39 OemInstallTest() : cm_(ConfigManager::Instance()) {
40 }
41
42 virtual void SetUp() {
43 RegKey::DeleteKey(kRegistryHiveOverrideRoot, true);
44 OverrideRegistryHives(kRegistryHiveOverrideRoot);
45 }
46
47 virtual void TearDown() {
48 RestoreRegistryHives();
49 EXPECT_SUCCEEDED(RegKey::DeleteKey(kRegistryHiveOverrideRoot, true));
50 }
51
52 ConfigManager* cm_;
53 };
54
55 class AuditModeTest : public OemInstallTest {
56 protected:
57 virtual void SetUp() {
58 OemInstallTest::SetUp();
59
60 if (vista_util::IsVistaOrLater()) {
61 EXPECT_SUCCEEDED(RegKey::SetValue(kVistaSetupStateKey,
62 _T("ImageState"),
63 _T("IMAGE_STATE_UNDEPLOYABLE")));
64 } else {
65 EXPECT_SUCCEEDED(RegKey::SetValue(kXpSystemSetupKey,
66 _T("AuditInProgress"),
67 static_cast<DWORD>(1)));
68 }
69
70 EXPECT_TRUE(ConfigManager::Instance()->IsWindowsInstalling());
71 }
72 };
73
74 TEST_F(OemInstallTest, SetOemInstallState_User) {
75 EXPECT_EQ(GOOPDATE_E_OEM_NOT_MACHINE_AND_PRIVILEGED_AND_AUDIT_MODE,
76 oem_install_utils::SetOemInstallState(false));
77 EXPECT_FALSE(RegKey::HasValue(USER_REG_UPDATE, kRegValueOemInstallTimeSec));
78 EXPECT_FALSE(
79 RegKey::HasValue(MACHINE_REG_UPDATE, kRegValueOemInstallTimeSec));
80 }
81
82 TEST_F(AuditModeTest, SetOemInstallState_User) {
83 EXPECT_EQ(GOOPDATE_E_OEM_NOT_MACHINE_AND_PRIVILEGED_AND_AUDIT_MODE,
84 oem_install_utils::SetOemInstallState(false));
85 EXPECT_FALSE(RegKey::HasValue(USER_REG_UPDATE, kRegValueOemInstallTimeSec));
86 EXPECT_FALSE(
87 RegKey::HasValue(MACHINE_REG_UPDATE, kRegValueOemInstallTimeSec));
88 }
89
90 TEST_F(OemInstallTest, SetOemInstallState_Machine) {
91 if (!vista_util::IsUserAdmin()) {
92 std::wcout << _T("\tTest did not cover expected path because not an admin.")
93 << std::endl;
94 }
95 EXPECT_EQ(GOOPDATE_E_OEM_NOT_MACHINE_AND_PRIVILEGED_AND_AUDIT_MODE,
96 oem_install_utils::SetOemInstallState(true));
97 EXPECT_FALSE(
98 RegKey::HasValue(MACHINE_REG_UPDATE, kRegValueOemInstallTimeSec));
99 }
100
101 TEST_F(AuditModeTest, SetOemInstallState_Machine) {
102 if (!vista_util::IsUserAdmin()) {
103 std::wcout << _T("\tTest did not run because the user is not an admin.")
104 << std::endl;
105 return;
106 }
107 EXPECT_SUCCEEDED(oem_install_utils::SetOemInstallState(true));
108 const uint32 now = Time64ToInt32(GetCurrent100NSTime());
109
110 EXPECT_TRUE(RegKey::HasValue(MACHINE_REG_UPDATE, kRegValueOemInstallTimeSec));
111 const uint32 install_time = GetDwordValue(MACHINE_REG_UPDATE,
112 kRegValueOemInstallTimeSec);
113 EXPECT_GE(now, install_time);
114 EXPECT_GE(static_cast<uint32>(200), now - install_time);
115
116 EXPECT_TRUE(oem_install_utils::IsOemInstalling(true));
117 EXPECT_SUCCEEDED(oem_install_utils::ResetOemInstallState(true));
118 EXPECT_FALSE(RegKey::HasValue(MACHINE_REG_UPDATE,
119 kRegValueOemInstallTimeSec));
120 EXPECT_FALSE(oem_install_utils::IsOemInstalling(true));
121 }
122
123 TEST_F(AuditModeTest, SetOemInstallState_Machine_NeedsElevation) {
124 if (vista_util::IsUserAdmin()) {
125 std::wcout << _T("\tTest did not run because the user IS an admin.")
126 << std::endl;
127 return;
128 }
129
130 EXPECT_EQ(GOOPDATE_E_OEM_NOT_MACHINE_AND_PRIVILEGED_AND_AUDIT_MODE,
131 oem_install_utils::SetOemInstallState(true));
132 EXPECT_FALSE(
133 RegKey::HasValue(MACHINE_REG_UPDATE, kRegValueOemInstallTimeSec));
134 }
135
136 //
137 // IsOemInstalling tests.
138 //
139
140 TEST_F(OemInstallTest, IsOemInstalling_Machine_Normal) {
141 EXPECT_FALSE(oem_install_utils::IsOemInstalling(true));
142 }
143
144 TEST_F(OemInstallTest, IsOemInstalling_User_Normal) {
145 EXPECT_FALSE(oem_install_utils::IsOemInstalling(false));
146 }
147
148 TEST_F(OemInstallTest,
149 IsOemInstalling_Machine_OemInstallTimeNow_NotAuditMode) {
150 const DWORD now_seconds = Time64ToInt32(GetCurrent100NSTime());
151 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
152 _T("OemInstallTime"),
153 now_seconds));
154
155 EXPECT_TRUE(oem_install_utils::IsOemInstalling(true));
156 }
157
158 TEST_F(OemInstallTest, IsOemInstalling_Machine_OemInstallTimeNow_AuditMode) {
159 const DWORD now_seconds = Time64ToInt32(GetCurrent100NSTime());
160 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
161 _T("OemInstallTime"),
162 now_seconds));
163
164 if (vista_util::IsVistaOrLater()) {
165 EXPECT_SUCCEEDED(RegKey::SetValue(
166 _T("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\State"),
167 _T("ImageState"),
168 _T("IMAGE_STATE_UNDEPLOYABLE")));
169 } else {
170 EXPECT_SUCCEEDED(RegKey::SetValue(_T("HKLM\\System\\Setup"),
171 _T("AuditInProgress"),
172 static_cast<DWORD>(1)));
173 }
174 EXPECT_TRUE(cm_->IsWindowsInstalling());
175
176 EXPECT_TRUE(oem_install_utils::IsOemInstalling(true));
177 }
178
179 TEST_F(OemInstallTest,
180 IsOemInstalling_Machine_OemInstallTime71HoursAgo_NotAuditMode) {
181 const DWORD kDesiredDifferenceSeconds = 71 * 60 * 60; // 71 hours.
182 const DWORD now_seconds = Time64ToInt32(GetCurrent100NSTime());
183 EXPECT_GT(now_seconds, kDesiredDifferenceSeconds);
184 const DWORD install_time_seconds = now_seconds - kDesiredDifferenceSeconds;
185 EXPECT_LT(install_time_seconds, now_seconds);
186
187 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
188 _T("OemInstallTime"),
189 install_time_seconds));
190
191 EXPECT_TRUE(oem_install_utils::IsOemInstalling(true));
192 }
193
194 TEST_F(OemInstallTest,
195 IsOemInstalling_Machine_OemInstallTime71HoursAgo_AuditMode) {
196 const DWORD kDesiredDifferenceSeconds = 71 * 60 * 60; // 71 hours.
197 const DWORD now_seconds = Time64ToInt32(GetCurrent100NSTime());
198 EXPECT_GT(now_seconds, kDesiredDifferenceSeconds);
199 const DWORD install_time_seconds = now_seconds - kDesiredDifferenceSeconds;
200 EXPECT_LT(install_time_seconds, now_seconds);
201
202 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
203 _T("OemInstallTime"),
204 install_time_seconds));
205
206 if (vista_util::IsVistaOrLater()) {
207 EXPECT_SUCCEEDED(RegKey::SetValue(
208 _T("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\State"),
209 _T("ImageState"),
210 _T("IMAGE_STATE_UNDEPLOYABLE")));
211 } else {
212 EXPECT_SUCCEEDED(RegKey::SetValue(_T("HKLM\\System\\Setup"),
213 _T("AuditInProgress"),
214 static_cast<DWORD>(1)));
215 }
216 EXPECT_TRUE(cm_->IsWindowsInstalling());
217
218 EXPECT_TRUE(oem_install_utils::IsOemInstalling(true));
219 }
220
221 TEST_F(OemInstallTest,
222 IsOemInstalling_Machine_OemInstallTime73HoursAgo_NotAuditMode) {
223 const DWORD kDesiredDifferenceSeconds = 73 * 60 * 60; // 73 hours.
224 const DWORD now_seconds = Time64ToInt32(GetCurrent100NSTime());
225 EXPECT_GT(now_seconds, kDesiredDifferenceSeconds);
226 const DWORD install_time_seconds = now_seconds - kDesiredDifferenceSeconds;
227 EXPECT_LT(install_time_seconds, now_seconds);
228
229 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
230 _T("OemInstallTime"),
231 install_time_seconds));
232
233 EXPECT_FALSE(oem_install_utils::IsOemInstalling(true));
234 }
235
236 TEST_F(OemInstallTest,
237 IsOemInstalling_Machine_OemInstallTime73HoursAgo_AuditMode) {
238 const DWORD kDesiredDifferenceSeconds = 73 * 60 * 60; // 73 hours.
239 const DWORD now_seconds = Time64ToInt32(GetCurrent100NSTime());
240 EXPECT_GT(now_seconds, kDesiredDifferenceSeconds);
241 const DWORD install_time_seconds = now_seconds - kDesiredDifferenceSeconds;
242 EXPECT_LT(install_time_seconds, now_seconds);
243
244 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
245 _T("OemInstallTime"),
246 install_time_seconds));
247
248 if (vista_util::IsVistaOrLater()) {
249 EXPECT_SUCCEEDED(RegKey::SetValue(
250 _T("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\State"),
251 _T("ImageState"),
252 _T("IMAGE_STATE_UNDEPLOYABLE")));
253 } else {
254 EXPECT_SUCCEEDED(RegKey::SetValue(_T("HKLM\\System\\Setup"),
255 _T("AuditInProgress"),
256 static_cast<DWORD>(1)));
257 }
258 EXPECT_TRUE(cm_->IsWindowsInstalling());
259
260 EXPECT_FALSE(oem_install_utils::IsOemInstalling(true));
261 }
262
263 TEST_F(OemInstallTest,
264 IsOemInstalling_Machine_OemInstallTime71HoursInFuture_NotAuditMode) {
265 const DWORD kDesiredDifferenceSeconds = 71 * 60 * 60; // 71 hours.
266 const DWORD now_seconds = Time64ToInt32(GetCurrent100NSTime());
267 const DWORD install_time_seconds = now_seconds + kDesiredDifferenceSeconds;
268 EXPECT_GT(install_time_seconds, now_seconds);
269
270 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
271 _T("OemInstallTime"),
272 install_time_seconds));
273
274 EXPECT_TRUE(oem_install_utils::IsOemInstalling(true));
275 }
276
277 TEST_F(OemInstallTest,
278 IsOemInstalling_Machine_OemInstallTime71HoursInFuture_AuditMode) {
279 const DWORD kDesiredDifferenceSeconds = 71 * 60 * 60; // 71 hours.
280 const DWORD now_seconds = Time64ToInt32(GetCurrent100NSTime());
281 const DWORD install_time_seconds = now_seconds + kDesiredDifferenceSeconds;
282 EXPECT_GT(install_time_seconds, now_seconds);
283
284 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
285 _T("OemInstallTime"),
286 install_time_seconds));
287
288 if (vista_util::IsVistaOrLater()) {
289 EXPECT_SUCCEEDED(RegKey::SetValue(
290 _T("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\State"),
291 _T("ImageState"),
292 _T("IMAGE_STATE_UNDEPLOYABLE")));
293 } else {
294 EXPECT_SUCCEEDED(RegKey::SetValue(_T("HKLM\\System\\Setup"),
295 _T("AuditInProgress"),
296 static_cast<DWORD>(1)));
297 }
298 EXPECT_TRUE(cm_->IsWindowsInstalling());
299
300 EXPECT_TRUE(oem_install_utils::IsOemInstalling(true));
301 }
302
303 TEST_F(OemInstallTest,
304 IsOemInstalling_Machine_OemInstallTime73HoursInFuture_NotAuditMode) {
305 const DWORD kDesiredDifferenceSeconds = 73 * 60 * 60; // 73 hours.
306 const DWORD now_seconds = Time64ToInt32(GetCurrent100NSTime());
307 const DWORD install_time_seconds = now_seconds + kDesiredDifferenceSeconds;
308 EXPECT_GT(install_time_seconds, now_seconds);
309
310 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
311 _T("OemInstallTime"),
312 install_time_seconds));
313
314 EXPECT_FALSE(oem_install_utils::IsOemInstalling(true));
315 }
316
317 TEST_F(OemInstallTest,
318 IsOemInstalling_Machine_OemInstallTime73HoursInFuture_AuditMode) {
319 const DWORD kDesiredDifferenceSeconds = 73 * 60 * 60; // 73 hours.
320 const DWORD now_seconds = Time64ToInt32(GetCurrent100NSTime());
321 const DWORD install_time_seconds = now_seconds + kDesiredDifferenceSeconds;
322 EXPECT_GT(install_time_seconds, now_seconds);
323
324 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
325 _T("OemInstallTime"),
326 install_time_seconds));
327
328 if (vista_util::IsVistaOrLater()) {
329 EXPECT_SUCCEEDED(RegKey::SetValue(
330 _T("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\State"),
331 _T("ImageState"),
332 _T("IMAGE_STATE_UNDEPLOYABLE")));
333 } else {
334 EXPECT_SUCCEEDED(RegKey::SetValue(_T("HKLM\\System\\Setup"),
335 _T("AuditInProgress"),
336 static_cast<DWORD>(1)));
337 }
338 EXPECT_TRUE(cm_->IsWindowsInstalling());
339
340 EXPECT_FALSE(oem_install_utils::IsOemInstalling(true));
341 }
342
343 TEST_F(OemInstallTest,
344 IsOemInstalling_Machine_OemInstallTimeZero_NotAuditMode) {
345 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
346 _T("OemInstallTime"),
347 static_cast<DWORD>(0)));
348
349 EXPECT_FALSE(oem_install_utils::IsOemInstalling(true));
350 }
351
352 TEST_F(OemInstallTest,
353 IsOemInstalling_Machine_OemInstallTimeZero_AuditMode) {
354 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
355 _T("OemInstallTime"),
356 static_cast<DWORD>(0)));
357
358 if (vista_util::IsVistaOrLater()) {
359 EXPECT_SUCCEEDED(RegKey::SetValue(
360 _T("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\State"),
361 _T("ImageState"),
362 _T("IMAGE_STATE_UNDEPLOYABLE")));
363 } else {
364 EXPECT_SUCCEEDED(RegKey::SetValue(_T("HKLM\\System\\Setup"),
365 _T("AuditInProgress"),
366 static_cast<DWORD>(1)));
367 }
368 EXPECT_TRUE(cm_->IsWindowsInstalling());
369
370 EXPECT_FALSE(oem_install_utils::IsOemInstalling(true));
371 }
372
373 TEST_F(OemInstallTest,
374 IsOemInstalling_Machine_OemInstallTimeWrongType_NotAuditMode) {
375 const uint32 now_seconds = Time64ToInt32(GetCurrent100NSTime());
376 const CString now_string = itostr(now_seconds);
377 EXPECT_FALSE(now_string.IsEmpty());
378
379 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
380 _T("OemInstallTime"),
381 now_string));
382
383 EXPECT_FALSE(oem_install_utils::IsOemInstalling(true));
384 }
385
386 TEST_F(OemInstallTest,
387 IsOemInstalling_Machine_OemInstallTimeWrongType_AuditMode) {
388 const uint32 now_seconds = Time64ToInt32(GetCurrent100NSTime());
389 const CString now_string = itostr(now_seconds);
390 EXPECT_FALSE(now_string.IsEmpty());
391
392 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
393 _T("OemInstallTime"),
394 now_string));
395
396 if (vista_util::IsVistaOrLater()) {
397 EXPECT_SUCCEEDED(RegKey::SetValue(
398 _T("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\State"),
399 _T("ImageState"),
400 _T("IMAGE_STATE_UNDEPLOYABLE")));
401 } else {
402 EXPECT_SUCCEEDED(RegKey::SetValue(_T("HKLM\\System\\Setup"),
403 _T("AuditInProgress"),
404 static_cast<DWORD>(1)));
405 }
406 EXPECT_TRUE(cm_->IsWindowsInstalling());
407
408 EXPECT_FALSE(oem_install_utils::IsOemInstalling(true));
409 }
410
411 TEST_F(OemInstallTest, IsOemInstalling_Machine_NoOemInstallTime_AuditMode) {
412 if (vista_util::IsVistaOrLater()) {
413 EXPECT_SUCCEEDED(RegKey::SetValue(
414 _T("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\State"),
415 _T("ImageState"),
416 _T("IMAGE_STATE_UNDEPLOYABLE")));
417 } else {
418 EXPECT_SUCCEEDED(RegKey::SetValue(_T("HKLM\\System\\Setup"),
419 _T("AuditInProgress"),
420 static_cast<DWORD>(1)));
421 }
422 EXPECT_TRUE(cm_->IsWindowsInstalling());
423
424 EXPECT_FALSE(oem_install_utils::IsOemInstalling(true));
425 }
426
427 TEST_F(OemInstallTest,
428 IsOemInstalling_User_OemInstallTimeNow_NotAuditMode) {
429 const DWORD now_seconds = Time64ToInt32(GetCurrent100NSTime());
430 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
431 _T("OemInstallTime"),
432 now_seconds));
433
434 EXPECT_FALSE(oem_install_utils::IsOemInstalling(false));
435 }
436
437 TEST_F(OemInstallTest, IsOemInstalling_User_OemInstallTimeNow_AuditMode) {
438 const DWORD now_seconds = Time64ToInt32(GetCurrent100NSTime());
439 EXPECT_SUCCEEDED(RegKey::SetValue(MACHINE_REG_UPDATE,
440 _T("OemInstallTime"),
441 now_seconds));
442
443 if (vista_util::IsVistaOrLater()) {
444 EXPECT_SUCCEEDED(RegKey::SetValue(
445 _T("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\State"),
446 _T("ImageState"),
447 _T("IMAGE_STATE_UNDEPLOYABLE")));
448 } else {
449 EXPECT_SUCCEEDED(RegKey::SetValue(_T("HKLM\\System\\Setup"),
450 _T("AuditInProgress"),
451 static_cast<DWORD>(1)));
452 }
453 EXPECT_TRUE(cm_->IsWindowsInstalling());
454
455 EXPECT_FALSE(oem_install_utils::IsOemInstalling(false));
456 }
457
458 } // namespace omaha
OLDNEW
« no previous file with comments | « common/oem_install_utils.cc ('k') | common/omaha_customization_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698