@joebigelow / wix
Code Commits Issues Pulls Sessions CI/CD
main
main
cpp 3,842 lines 222 KB
Raw
1 // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
2
3 #include "precomp.h"
4
5 static HRESULT WINAPI PlanTestBAProc(
6 __in BOOTSTRAPPER_APPLICATION_MESSAGE message,
7 __in const LPVOID pvArgs,
8 __inout LPVOID pvResults,
9 __in_opt LPVOID pvContext
10 );
11
12 static LPCWSTR wzArpEntryExeManifestFileName = L"ExePackage_PerUserArpEntry_manifest.xml";
13 static LPCWSTR wzMsiTransactionManifestFileName = L"MsiTransaction_BundleAv1_manifest.xml";
14 static LPCWSTR wzMultipleBundlePackageManifestFileName = L"BundlePackage_Multiple_manifest.xml";
15 static LPCWSTR wzSingleExeManifestFileName = L"Failure_BundleD_manifest.xml";
16 static LPCWSTR wzSingleMsiManifestFileName = L"BasicFunctionality_BundleA_manifest.xml";
17 static LPCWSTR wzSingleMsuManifestFileName = L"MsuPackageFixture_manifest.xml";
18 static LPCWSTR wzSlipstreamManifestFileName = L"Slipstream_BundleA_manifest.xml";
19 static LPCWSTR wzSlipstreamModifiedManifestFileName = L"Slipstream_BundleA_modified_manifest.xml";
20
21 static BOOL vfUsePackageRequestState = FALSE;
22 static BOOTSTRAPPER_REQUEST_STATE vPackageRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
23 static BOOL vfUseRelatedBundleRequestState = FALSE;
24 static BOOTSTRAPPER_REQUEST_STATE vRelatedBundleRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
25 static BOOL vfUseRelatedBundlePlanType = FALSE;
26 static BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE vRelatedBundlePlanType = BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_NONE;
27
28 static BURN_DEPENDENCY_ACTION registerActions1[] = { BURN_DEPENDENCY_ACTION_REGISTER };
29 static BURN_DEPENDENCY_ACTION unregisterActions1[] = { BURN_DEPENDENCY_ACTION_UNREGISTER };
30
31 namespace Microsoft
32 {
33 namespace Tools
34 {
35 namespace WindowsInstallerXml
36 {
37 namespace Test
38 {
39 namespace Bootstrapper
40 {
41 using namespace System;
42 using namespace Xunit;
43
44 public ref class PlanTest : BurnUnitTest
45 {
46 public:
47 PlanTest(BurnTestFixture^ fixture) : BurnUnitTest(fixture)
48 {
49 }
50
51 [Fact]
52 void ArpEntryExeInstallTest()
53 {
54 HRESULT hr = S_OK;
55 BURN_ENGINE_STATE engineState = { };
56 BURN_ENGINE_STATE* pEngineState = &engineState;
57 BURN_PLAN* pPlan = &engineState.plan;
58
59 InitializeEngineStateForCorePlan(wzArpEntryExeManifestFileName, pEngineState);
60 DetectAttachedContainerAsAttached(pEngineState);
61 DetectPermanentPackagesAsPresentAndCached(pEngineState);
62
63 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
64 NativeAssert::Succeeded(hr, "CorePlan failed");
65
66 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
67 NativeAssert::StringEqual(L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}", pPlan->wzBundleId);
68 NativeAssert::StringEqual(L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}", pPlan->wzBundleProviderKey);
69 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
70 Assert::Equal<BOOL>(FALSE, pPlan->fPerMachine);
71 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
72 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
73 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
74 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
75 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
76
77 BOOL fRollback = FALSE;
78 DWORD dwIndex = 0;
79 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}", L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}");
80 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
81
82 fRollback = TRUE;
83 dwIndex = 0;
84 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}", L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}");
85 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
86
87 fRollback = FALSE;
88 dwIndex = 0;
89 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
90 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"TestExe", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
91 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"TestExe");
92 Assert::Equal(dwIndex, pPlan->cCacheActions);
93
94 fRollback = TRUE;
95 dwIndex = 0;
96 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
97
98 Assert::Equal(119695ull, pPlan->qwCacheSizeTotal);
99
100 fRollback = FALSE;
101 dwIndex = 0;
102 DWORD dwExecuteCheckpointId = 2;
103 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
104 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
105 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"TestExe");
106 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
107 ValidateExecuteExePackage(pPlan, fRollback, dwIndex++, L"TestExe", BOOTSTRAPPER_ACTION_STATE_INSTALL);
108 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
109 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
110 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
111 Assert::Equal(dwIndex, pPlan->cExecuteActions);
112
113 fRollback = TRUE;
114 dwIndex = 0;
115 dwExecuteCheckpointId = 2;
116 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
117 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
118 ValidateExecuteExePackage(pPlan, fRollback, dwIndex++, L"TestExe", BOOTSTRAPPER_ACTION_STATE_UNINSTALL);
119 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
120 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
121 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
122 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
123 Assert::Equal(dwIndex, pPlan->cRollbackActions);
124
125 Assert::Equal(1ul, pPlan->cExecutePackagesTotal);
126 Assert::Equal(2ul, pPlan->cOverallProgressTicksTotal);
127
128 dwIndex = 0;
129 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
130
131 dwIndex = 0;
132 ValidateCleanAction(pPlan, dwIndex++, L"NetFx48Web");
133 Assert::Equal(dwIndex, pPlan->cCleanActions);
134
135 UINT uIndex = 0;
136 ValidatePlannedProvider(pPlan, uIndex++, L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}", NULL);
137 Assert::Equal(uIndex, pPlan->cPlannedProviders);
138
139 Assert::Equal(2ul, pEngineState->packages.cPackages);
140 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"TestExe", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
141 }
142
143 [Fact]
144 void ArpEntryExeInstallObsoleteTest()
145 {
146 HRESULT hr = S_OK;
147 BURN_ENGINE_STATE engineState = { };
148 BURN_ENGINE_STATE* pEngineState = &engineState;
149 BURN_PLAN* pPlan = &engineState.plan;
150
151 InitializeEngineStateForCorePlan(wzArpEntryExeManifestFileName, pEngineState);
152 DetectAttachedContainerAsAttached(pEngineState);
153 DetectPermanentPackagesAsPresentAndCached(pEngineState);
154
155 pEngineState->packages.rgPackages[1].currentState = BOOTSTRAPPER_PACKAGE_STATE_OBSOLETE;
156
157 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
158 NativeAssert::Succeeded(hr, "CorePlan failed");
159
160 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
161 NativeAssert::StringEqual(L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}", pPlan->wzBundleId);
162 NativeAssert::StringEqual(L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}", pPlan->wzBundleProviderKey);
163 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
164 Assert::Equal<BOOL>(FALSE, pPlan->fPerMachine);
165 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
166 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
167 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
168 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
169 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
170
171 BOOL fRollback = FALSE;
172 DWORD dwIndex = 0;
173 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}", L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}");
174 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
175
176 fRollback = TRUE;
177 dwIndex = 0;
178 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}", L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}");
179 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
180
181 fRollback = FALSE;
182 dwIndex = 0;
183 Assert::Equal(dwIndex, pPlan->cCacheActions);
184
185 fRollback = TRUE;
186 dwIndex = 0;
187 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
188
189 Assert::Equal(0ull, pPlan->qwCacheSizeTotal);
190
191 fRollback = FALSE;
192 dwIndex = 0;
193 DWORD dwExecuteCheckpointId = 1;
194 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
195 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
196 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
197 Assert::Equal(dwIndex, pPlan->cExecuteActions);
198
199 fRollback = TRUE;
200 dwIndex = 0;
201 dwExecuteCheckpointId = 1;
202 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
203 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
204 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
205 Assert::Equal(dwIndex, pPlan->cRollbackActions);
206
207 Assert::Equal(0ul, pPlan->cExecutePackagesTotal);
208 Assert::Equal(0ul, pPlan->cOverallProgressTicksTotal);
209
210 dwIndex = 0;
211 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
212
213 dwIndex = 0;
214 ValidateCleanAction(pPlan, dwIndex++, L"NetFx48Web");
215 Assert::Equal(dwIndex, pPlan->cCleanActions);
216
217 UINT uIndex = 0;
218 ValidatePlannedProvider(pPlan, uIndex++, L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}", NULL);
219 Assert::Equal(uIndex, pPlan->cPlannedProviders);
220
221 Assert::Equal(2ul, pEngineState->packages.cPackages);
222 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"TestExe", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
223 }
224
225 [Fact]
226 void ArpEntryExeUninstallTest()
227 {
228 HRESULT hr = S_OK;
229 BURN_ENGINE_STATE engineState = { };
230 BURN_ENGINE_STATE* pEngineState = &engineState;
231 BURN_PLAN* pPlan = &engineState.plan;
232
233 InitializeEngineStateForCorePlan(wzArpEntryExeManifestFileName, pEngineState);
234 DetectPackagesAsPresentAndCached(pEngineState);
235
236 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNINSTALL);
237 NativeAssert::Succeeded(hr, "CorePlan failed");
238
239 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNINSTALL, pPlan->action);
240 NativeAssert::StringEqual(L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}", pPlan->wzBundleId);
241 NativeAssert::StringEqual(L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}", pPlan->wzBundleProviderKey);
242 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
243 Assert::Equal<BOOL>(FALSE, pPlan->fPerMachine);
244 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
245 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
246 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
247 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
248 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
249
250 BOOL fRollback = FALSE;
251 DWORD dwIndex = 0;
252 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}", L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}");
253 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
254
255 fRollback = TRUE;
256 dwIndex = 0;
257 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}", L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}");
258 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
259
260 fRollback = FALSE;
261 dwIndex = 0;
262 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
263 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"TestExe", FALSE, BURN_CACHE_PACKAGE_TYPE_NONE, BURN_CACHE_PACKAGE_TYPE_REQUIRED);
264 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"TestExe");
265 Assert::Equal(dwIndex, pPlan->cCacheActions);
266
267 fRollback = TRUE;
268 dwIndex = 0;
269 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
270
271 Assert::Equal(143724ull, pPlan->qwCacheSizeTotal);
272
273 fRollback = FALSE;
274 dwIndex = 0;
275 DWORD dwExecuteCheckpointId = 2;
276 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
277 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
278 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"TestExe");
279 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
280 ValidateExecuteExePackage(pPlan, fRollback, dwIndex++, L"TestExe", BOOTSTRAPPER_ACTION_STATE_UNINSTALL);
281 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
282 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
283 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
284 Assert::Equal(dwIndex, pPlan->cExecuteActions);
285
286 fRollback = TRUE;
287 dwIndex = 0;
288 dwExecuteCheckpointId = 2;
289 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
290 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
291 ValidateExecuteExePackage(pPlan, fRollback, dwIndex++, L"TestExe", BOOTSTRAPPER_ACTION_STATE_INSTALL);
292 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
293 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
294 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
295 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
296 Assert::Equal(dwIndex, pPlan->cRollbackActions);
297
298 Assert::Equal(1ul, pPlan->cExecutePackagesTotal);
299 Assert::Equal(2ul, pPlan->cOverallProgressTicksTotal);
300
301 dwIndex = 0;
302 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
303
304 dwIndex = 0;
305 ValidateCleanAction(pPlan, dwIndex++, L"TestExe");
306 ValidateCleanAction(pPlan, dwIndex++, L"NetFx48Web");
307 Assert::Equal(dwIndex, pPlan->cCleanActions);
308
309 UINT uIndex = 0;
310 ValidatePlannedProvider(pPlan, uIndex++, L"{9C459DAD-0E64-40C8-8C9F-4F68E46AB223}", NULL);
311 Assert::Equal(uIndex, pPlan->cPlannedProviders);
312
313 Assert::Equal(2ul, pEngineState->packages.cPackages);
314 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"TestExe", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
315 }
316
317 [Fact]
318 void MsiTransactionInstallTest()
319 {
320 HRESULT hr = S_OK;
321 BURN_ENGINE_STATE engineState = { };
322 BURN_ENGINE_STATE* pEngineState = &engineState;
323 BURN_PLAN* pPlan = &engineState.plan;
324
325 InitializeEngineStateForCorePlan(wzMsiTransactionManifestFileName, pEngineState);
326 DetectPackagesAsAbsent(pEngineState);
327 DetectRelatedBundle(pEngineState, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", L"1.0.0.0", BOOTSTRAPPER_RELATION_UPGRADE);
328
329 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
330 NativeAssert::Succeeded(hr, "CorePlan failed");
331
332 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
333 NativeAssert::StringEqual(L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", pPlan->wzBundleId);
334 NativeAssert::StringEqual(L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", pPlan->wzBundleProviderKey);
335 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
336 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
337 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
338 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
339 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
340 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
341 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
342
343 BOOL fRollback = FALSE;
344 DWORD dwIndex = 0;
345 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}");
346 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
347
348 fRollback = TRUE;
349 dwIndex = 0;
350 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}");
351 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
352
353 fRollback = FALSE;
354 dwIndex = 0;
355 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
356 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
357 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageA");
358 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 9);
359 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageB", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
360 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageB");
361 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 14);
362 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageC", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
363 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageC");
364 Assert::Equal(dwIndex, pPlan->cCacheActions);
365
366 fRollback = TRUE;
367 dwIndex = 0;
368 ValidateCacheRollbackPackage(pPlan, fRollback, dwIndex++, L"PackageA");
369 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
370 ValidateCacheRollbackPackage(pPlan, fRollback, dwIndex++, L"PackageB");
371 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 9);
372 ValidateCacheRollbackPackage(pPlan, fRollback, dwIndex++, L"PackageC");
373 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 14);
374 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
375
376 Assert::Equal(522548ull, pPlan->qwCacheSizeTotal);
377
378 fRollback = FALSE;
379 dwIndex = 0;
380 DWORD dwExecuteCheckpointId = 2;
381 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
382 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
383 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
384 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
385 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", registerActions1, 1);
386 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
387 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
388 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
389 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", registerActions1, 1);
390 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
391 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
392 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
393 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ", TRUE, TRUE);
394 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
395 ValidateExecuteBeginMsiTransaction(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ");
396 dwExecuteCheckpointId += 1; // cache checkpoints
397 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
398 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageB");
399 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
400 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageB", registerActions1, 1);
401 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageB", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
402 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
403 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageB", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", registerActions1, 1);
404 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
405 dwExecuteCheckpointId += 1; // cache checkpoints
406 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
407 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageC");
408 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
409 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageC", registerActions1, 1);
410 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageC", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
411 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
412 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageC", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", registerActions1, 1);
413 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
414 ValidateExecuteCommitMsiTransaction(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ");
415 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
416 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
417 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, NULL);
418 Assert::Equal(dwIndex, pPlan->cExecuteActions);
419
420 fRollback = TRUE;
421 dwIndex = 0;
422 dwExecuteCheckpointId = 2;
423 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
424 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
425 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
426 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", unregisterActions1, 1);
427 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
428 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
429 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
430 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", unregisterActions1, 1);
431 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
432 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
433 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
434 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
435 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ", TRUE, TRUE);
436 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
437 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PackageB");
438 dwExecuteCheckpointId += 1; // cache checkpoints
439 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
440 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageB", unregisterActions1, 1);
441 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
442 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageB", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", unregisterActions1, 1);
443 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
444 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
445 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PackageC");
446 dwExecuteCheckpointId += 1; // cache checkpoints
447 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
448 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageC", unregisterActions1, 1);
449 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
450 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageC", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", unregisterActions1, 1);
451 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
452 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
453 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
454 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
455 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
456 Assert::Equal(dwIndex, pPlan->cRollbackActions);
457
458 Assert::Equal(4ul, pPlan->cExecutePackagesTotal);
459 Assert::Equal(7ul, pPlan->cOverallProgressTicksTotal);
460
461 dwIndex = 0;
462 ValidateRestoreRelatedBundle(pPlan, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
463 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
464
465 dwIndex = 0;
466 Assert::Equal(dwIndex, pPlan->cCleanActions);
467
468 UINT uIndex = 0;
469 ValidatePlannedProvider(pPlan, uIndex++, L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", NULL);
470 Assert::Equal(uIndex, pPlan->cPlannedProviders);
471
472 Assert::Equal(3ul, pEngineState->packages.cPackages);
473 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
474 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"PackageB", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
475 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[2], L"PackageC", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
476 }
477
478 [Fact]
479 void MsiTransactionUninstallTest()
480 {
481 HRESULT hr = S_OK;
482 BURN_ENGINE_STATE engineState = { };
483 BURN_ENGINE_STATE* pEngineState = &engineState;
484 BURN_PLAN* pPlan = &engineState.plan;
485
486 InitializeEngineStateForCorePlan(wzMsiTransactionManifestFileName, pEngineState);
487 DetectPackagesAsPresentAndCached(pEngineState);
488
489 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNINSTALL);
490 NativeAssert::Succeeded(hr, "CorePlan failed");
491
492 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNINSTALL, pPlan->action);
493 NativeAssert::StringEqual(L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", pPlan->wzBundleId);
494 NativeAssert::StringEqual(L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", pPlan->wzBundleProviderKey);
495 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
496 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
497 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
498 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
499 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
500 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
501 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
502
503 BOOL fRollback = FALSE;
504 DWORD dwIndex = 0;
505 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}");
506 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
507
508 fRollback = TRUE;
509 dwIndex = 0;
510 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}");
511 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
512
513 fRollback = FALSE;
514 dwIndex = 0;
515 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 9);
516 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA", FALSE, BURN_CACHE_PACKAGE_TYPE_NONE, BURN_CACHE_PACKAGE_TYPE_REQUIRED);
517 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageA");
518 Assert::Equal(dwIndex, pPlan->cCacheActions);
519
520 fRollback = TRUE;
521 dwIndex = 0;
522 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
523
524 Assert::Equal(185118ull, pPlan->qwCacheSizeTotal);
525
526 fRollback = FALSE;
527 dwIndex = 0;
528 DWORD dwExecuteCheckpointId = 1;
529 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ", TRUE, TRUE);
530 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
531 ValidateExecuteBeginMsiTransaction(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ");
532 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
533 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageC", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", unregisterActions1, 1);
534 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
535 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageC", unregisterActions1, 1);
536 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageC", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
537 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
538 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
539 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageB", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", unregisterActions1, 1);
540 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
541 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageB", unregisterActions1, 1);
542 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageB", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
543 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
544 ValidateExecuteCommitMsiTransaction(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ");
545 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
546 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
547 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
548 dwExecuteCheckpointId += 1; // cache checkpoints
549 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
550 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
551 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
552 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", unregisterActions1, 1);
553 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
554 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", unregisterActions1, 1);
555 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
556 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
557 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
558 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
559 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
560 Assert::Equal(dwIndex, pPlan->cExecuteActions);
561
562 fRollback = TRUE;
563 dwIndex = 0;
564 dwExecuteCheckpointId = 1;
565 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ", TRUE, TRUE);
566 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
567 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageC", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", registerActions1, 1);
568 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
569 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageC", registerActions1, 1);
570 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
571 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
572 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageB", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", registerActions1, 1);
573 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
574 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageB", registerActions1, 1);
575 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
576 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
577 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
578 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
579 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
580 dwExecuteCheckpointId += 1; // cache checkpoints
581 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
582 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", registerActions1, 1);
583 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
584 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", registerActions1, 1);
585 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
586 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
587 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
588 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
589 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
590 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
591 Assert::Equal(dwIndex, pPlan->cRollbackActions);
592
593 Assert::Equal(3ul, pPlan->cExecutePackagesTotal);
594 Assert::Equal(4ul, pPlan->cOverallProgressTicksTotal);
595
596 dwIndex = 0;
597 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
598
599 dwIndex = 0;
600 ValidateCleanAction(pPlan, dwIndex++, L"PackageC");
601 ValidateCleanAction(pPlan, dwIndex++, L"PackageB");
602 ValidateCleanAction(pPlan, dwIndex++, L"PackageA");
603 Assert::Equal(dwIndex, pPlan->cCleanActions);
604
605 UINT uIndex = 0;
606 ValidatePlannedProvider(pPlan, uIndex++, L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", NULL);
607 ValidatePlannedProvider(pPlan, uIndex++, L"{A497C5E5-C78B-4F0B-BF72-B33E1DB1C4B8}", NULL);
608 ValidatePlannedProvider(pPlan, uIndex++, L"{D1D01094-23CE-4AF0-84B6-4A1A133F21D3}", NULL);
609 ValidatePlannedProvider(pPlan, uIndex++, L"{01E6B748-7B95-4BA9-976D-B6F35076CEF4}", NULL);
610 Assert::Equal(uIndex, pPlan->cPlannedProviders);
611
612 Assert::Equal(3ul, pEngineState->packages.cPackages);
613 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
614 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"PackageB", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
615 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[2], L"PackageC", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
616 }
617
618 [Fact]
619 void MultipleBundlePackageInstallTest()
620 {
621 HRESULT hr = S_OK;
622 BURN_ENGINE_STATE engineState = { };
623 BURN_ENGINE_STATE* pEngineState = &engineState;
624 BURN_PLAN* pPlan = &engineState.plan;
625
626 InitializeEngineStateForCorePlan(wzMultipleBundlePackageManifestFileName, pEngineState);
627 DetectAttachedContainerAsAttached(pEngineState);
628 DetectPermanentPackagesAsPresentAndCached(pEngineState);
629
630 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
631 NativeAssert::Succeeded(hr, "CorePlan failed");
632
633 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
634 NativeAssert::StringEqual(L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", pPlan->wzBundleId);
635 NativeAssert::StringEqual(L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", pPlan->wzBundleProviderKey);
636 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
637 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
638 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
639 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
640 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
641 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
642 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
643
644 BOOL fRollback = FALSE;
645 DWORD dwIndex = 0;
646 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}");
647 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
648
649 fRollback = TRUE;
650 dwIndex = 0;
651 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}");
652 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
653
654 fRollback = FALSE;
655 dwIndex = 0;
656 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
657 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_OPTIONAL);
658 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageA");
659 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 6);
660 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageB", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_OPTIONAL);
661 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageB");
662 Assert::Equal(dwIndex, pPlan->cCacheActions);
663
664 fRollback = TRUE;
665 dwIndex = 0;
666 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
667
668 Assert::Equal(78462280ull, pPlan->qwCacheSizeTotal);
669
670 fRollback = FALSE;
671 dwIndex = 0;
672 DWORD dwExecuteCheckpointId = 2;
673 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
674 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
675 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
676 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
677 ValidateExecuteBundlePackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}");
678 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
679 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", registerActions1, 1);
680 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
681 dwExecuteCheckpointId += 1; // cache checkpoints
682 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
683 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageB");
684 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
685 ValidateExecuteBundlePackage(pPlan, fRollback, dwIndex++, L"PackageB", BOOTSTRAPPER_ACTION_STATE_INSTALL, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}");
686 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
687 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageB", L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", registerActions1, 1);
688 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
689 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
690 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
691 Assert::Equal(dwIndex, pPlan->cExecuteActions);
692
693 fRollback = TRUE;
694 dwIndex = 0;
695 dwExecuteCheckpointId = 2;
696 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
697 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
698 ValidateExecuteBundlePackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}");
699 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
700 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", unregisterActions1, 1);
701 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
702 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
703 dwExecuteCheckpointId += 1; // cache checkpoints
704 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
705 ValidateExecuteBundlePackage(pPlan, fRollback, dwIndex++, L"PackageB", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}");
706 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
707 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageB", L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", unregisterActions1, 1);
708 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
709 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
710 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
711 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
712 Assert::Equal(dwIndex, pPlan->cRollbackActions);
713
714 Assert::Equal(2ul, pPlan->cExecutePackagesTotal);
715 Assert::Equal(4ul, pPlan->cOverallProgressTicksTotal);
716
717 dwIndex = 0;
718 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
719
720 dwIndex = 0;
721 ValidateCleanAction(pPlan, dwIndex++, L"NetFx48Web");
722 Assert::Equal(dwIndex, pPlan->cCleanActions);
723
724 UINT uIndex = 0;
725 ValidatePlannedProvider(pPlan, uIndex++, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", NULL);
726 Assert::Equal(uIndex, pPlan->cPlannedProviders);
727
728 Assert::Equal(3ul, pEngineState->packages.cPackages);
729 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
730 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[2], L"PackageB", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
731 }
732
733 [Fact]
734 void MultipleBundlePackageRepairTest()
735 {
736 HRESULT hr = S_OK;
737 BURN_ENGINE_STATE engineState = { };
738 BURN_ENGINE_STATE* pEngineState = &engineState;
739 BURN_PLAN* pPlan = &engineState.plan;
740
741 InitializeEngineStateForCorePlan(wzMultipleBundlePackageManifestFileName, pEngineState);
742 DetectAttachedContainerAsAttached(pEngineState);
743 DetectPackagesAsPresentAndCached(pEngineState);
744
745 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_REPAIR);
746 NativeAssert::Succeeded(hr, "CorePlan failed");
747
748 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_REPAIR, pPlan->action);
749 NativeAssert::StringEqual(L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", pPlan->wzBundleId);
750 NativeAssert::StringEqual(L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", pPlan->wzBundleProviderKey);
751 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
752 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
753 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
754 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
755 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
756 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
757 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
758
759 BOOL fRollback = FALSE;
760 DWORD dwIndex = 0;
761 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
762
763 fRollback = TRUE;
764 dwIndex = 0;
765 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
766
767 fRollback = FALSE;
768 dwIndex = 0;
769 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 2);
770 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageB", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
771 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageB");
772 Assert::Equal(dwIndex, pPlan->cCacheActions);
773
774 fRollback = TRUE;
775 dwIndex = 0;
776 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
777
778 Assert::Equal(52254105ull, pPlan->qwCacheSizeTotal);
779
780 fRollback = FALSE;
781 dwIndex = 0;
782 DWORD dwExecuteCheckpointId = 1;
783 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
784 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", registerActions1, 1);
785 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
786 dwExecuteCheckpointId += 1; // cache checkpoints
787 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
788 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageB");
789 ValidateExecuteBundlePackage(pPlan, fRollback, dwIndex++, L"PackageB", BOOTSTRAPPER_ACTION_STATE_REPAIR, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}");
790 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageB", L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", registerActions1, 1);
791 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
792 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
793 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
794 Assert::Equal(dwIndex, pPlan->cExecuteActions);
795
796 fRollback = TRUE;
797 dwIndex = 0;
798 dwExecuteCheckpointId = 1;
799 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
800 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
801 dwExecuteCheckpointId += 1; // cache checkpoints
802 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
803 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
804 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
805 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
806 Assert::Equal(dwIndex, pPlan->cRollbackActions);
807
808 Assert::Equal(1ul, pPlan->cExecutePackagesTotal);
809 Assert::Equal(2ul, pPlan->cOverallProgressTicksTotal);
810
811 dwIndex = 0;
812 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
813
814 dwIndex = 0;
815 ValidateCleanAction(pPlan, dwIndex++, L"NetFx48Web");
816 Assert::Equal(dwIndex, pPlan->cCleanActions);
817
818 UINT uIndex = 0;
819 ValidatePlannedProvider(pPlan, uIndex++, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", NULL);
820 Assert::Equal(uIndex, pPlan->cPlannedProviders);
821
822 Assert::Equal(3ul, pEngineState->packages.cPackages);
823 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
824 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[2], L"PackageB", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
825 }
826
827 [Fact]
828 void MultipleBundlePackageUninstallTest()
829 {
830 HRESULT hr = S_OK;
831 BURN_ENGINE_STATE engineState = { };
832 BURN_ENGINE_STATE* pEngineState = &engineState;
833 BURN_PLAN* pPlan = &engineState.plan;
834
835 InitializeEngineStateForCorePlan(wzMultipleBundlePackageManifestFileName, pEngineState);
836 DetectAttachedContainerAsAttached(pEngineState);
837 DetectPackagesAsPresentAndCached(pEngineState);
838
839 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNINSTALL);
840 NativeAssert::Succeeded(hr, "CorePlan failed");
841
842 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNINSTALL, pPlan->action);
843 NativeAssert::StringEqual(L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", pPlan->wzBundleId);
844 NativeAssert::StringEqual(L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", pPlan->wzBundleProviderKey);
845 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
846 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
847 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
848 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
849 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
850 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
851 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
852
853 BOOL fRollback = FALSE;
854 DWORD dwIndex = 0;
855 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}");
856 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
857
858 fRollback = TRUE;
859 dwIndex = 0;
860 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}");
861 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
862
863 fRollback = FALSE;
864 dwIndex = 0;
865 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
866 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageB", FALSE, BURN_CACHE_PACKAGE_TYPE_OPTIONAL, BURN_CACHE_PACKAGE_TYPE_REQUIRED);
867 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageB");
868 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 6);
869 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA", FALSE, BURN_CACHE_PACKAGE_TYPE_OPTIONAL, BURN_CACHE_PACKAGE_TYPE_REQUIRED);
870 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageA");
871 Assert::Equal(dwIndex, pPlan->cCacheActions);
872
873 fRollback = TRUE;
874 dwIndex = 0;
875 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
876
877 Assert::Equal(78462280ull, pPlan->qwCacheSizeTotal);
878
879 fRollback = FALSE;
880 dwIndex = 0;
881 DWORD dwExecuteCheckpointId = 2;
882 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
883 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
884 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageB");
885 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
886 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageB", L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", unregisterActions1, 1);
887 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
888 ValidateExecuteBundlePackage(pPlan, fRollback, dwIndex++, L"PackageB", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}");
889 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
890 dwExecuteCheckpointId += 1; // cache checkpoints
891 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
892 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
893 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
894 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", unregisterActions1, 1);
895 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
896 ValidateExecuteBundlePackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}");
897 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
898 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
899 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
900 Assert::Equal(dwIndex, pPlan->cExecuteActions);
901
902 fRollback = TRUE;
903 dwIndex = 0;
904 dwExecuteCheckpointId = 2;
905 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
906 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
907 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageB", L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", registerActions1, 1);
908 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
909 ValidateExecuteBundlePackage(pPlan, fRollback, dwIndex++, L"PackageB", BOOTSTRAPPER_ACTION_STATE_INSTALL, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}");
910 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
911 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
912 dwExecuteCheckpointId += 1; // cache checkpoints
913 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
914 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", registerActions1, 1);
915 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
916 ValidateExecuteBundlePackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}");
917 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
918 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
919 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
920 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
921 Assert::Equal(dwIndex, pPlan->cRollbackActions);
922
923 Assert::Equal(2ul, pPlan->cExecutePackagesTotal);
924 Assert::Equal(4ul, pPlan->cOverallProgressTicksTotal);
925
926 dwIndex = 0;
927 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
928
929 dwIndex = 0;
930 ValidateCleanAction(pPlan, dwIndex++, L"PackageB");
931 ValidateCleanAction(pPlan, dwIndex++, L"PackageA");
932 ValidateCleanAction(pPlan, dwIndex++, L"NetFx48Web");
933 Assert::Equal(dwIndex, pPlan->cCleanActions);
934
935 UINT uIndex = 0;
936 ValidatePlannedProvider(pPlan, uIndex++, L"{35192ED0-C70A-49B2-9D12-3B1FA39B5E6F}", NULL);
937 ValidatePlannedProvider(pPlan, uIndex++, L"{7506235A-7C59-4750-82C7-EB460A87ED3A}", NULL);
938 ValidatePlannedProvider(pPlan, uIndex++, L"{B39CEE4D-CCD7-4797-BE3A-6613BD1DC4BE}", NULL);
939 Assert::Equal(uIndex, pPlan->cPlannedProviders);
940
941 Assert::Equal(3ul, pEngineState->packages.cPackages);
942 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
943 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[2], L"PackageB", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
944 }
945
946 [Fact]
947 void OrphanCompatiblePackageTest()
948 {
949 HRESULT hr = S_OK;
950 BURN_ENGINE_STATE engineState = { };
951 BURN_ENGINE_STATE* pEngineState = &engineState;
952 BURN_PLAN* pPlan = &engineState.plan;
953
954 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
955 DetectPackagesAsAbsent(pEngineState);
956 DetectCompatibleMsiPackage(pEngineState, pEngineState->packages.rgPackages, L"{C24F3903-38E7-4D44-8037-D9856B3C5046}", L"2.0.0.0");
957
958 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNINSTALL);
959 NativeAssert::Succeeded(hr, "CorePlan failed");
960
961 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNINSTALL, pPlan->action);
962 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleId);
963 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleProviderKey);
964 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
965 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
966 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
967 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
968 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
969 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
970 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
971
972 BOOL fRollback = FALSE;
973 DWORD dwIndex = 0;
974 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
975
976 fRollback = TRUE;
977 dwIndex = 0;
978 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
979
980 fRollback = FALSE;
981 dwIndex = 0;
982 Assert::Equal(dwIndex, pPlan->cCacheActions);
983
984 fRollback = TRUE;
985 dwIndex = 0;
986 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
987
988 Assert::Equal(0ull, pPlan->qwCacheSizeTotal);
989
990 fRollback = FALSE;
991 dwIndex = 0;
992 DWORD dwExecuteCheckpointId = 1;
993 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
994 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", unregisterActions1, 1);
995 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", unregisterActions1, 1);
996 ValidateUninstallMsiCompatiblePackage(pPlan, fRollback, dwIndex++, L"PackageA", 0);
997 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
998 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
999 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1000 Assert::Equal(dwIndex, pPlan->cExecuteActions);
1001
1002 fRollback = TRUE;
1003 dwIndex = 0;
1004 dwExecuteCheckpointId = 1;
1005 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1006 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1007 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1008 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1009 Assert::Equal(dwIndex, pPlan->cRollbackActions);
1010
1011 Assert::Equal(1ul, pPlan->cExecutePackagesTotal);
1012 Assert::Equal(1ul, pPlan->cOverallProgressTicksTotal);
1013
1014 dwIndex = 0;
1015 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
1016
1017 dwIndex = 0;
1018 ValidateCleanAction(pPlan, dwIndex++, L"PackageA");
1019 ValidateCleanCompatibleAction(pPlan, dwIndex++, L"PackageA");
1020 Assert::Equal(dwIndex, pPlan->cCleanActions);
1021
1022 UINT uIndex = 0;
1023 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
1024 ValidatePlannedProvider(pPlan, uIndex++, L"{64633047-D172-4BBB-B202-64337D15C952}", NULL);
1025 Assert::Equal(uIndex, pPlan->cPlannedProviders);
1026
1027 Assert::Equal(1ul, pEngineState->packages.cPackages);
1028 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
1029 }
1030
1031 [Fact(Skip = "Need to reimplement PlanTestBAProc() using a fake out of proc BA")]
1032 void RelatedBundlesAreSortedByPlanType()
1033 {
1034 HRESULT hr = S_OK;
1035 BURN_ENGINE_STATE engineState = { };
1036 BURN_ENGINE_STATE* pEngineState = &engineState;
1037 BURN_PLAN* pPlan = &engineState.plan;
1038
1039 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
1040 DetectAttachedContainerAsAttached(pEngineState);
1041 DetectPackagesAsAbsent(pEngineState);
1042 DetectRelatedBundle(pEngineState, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", L"0.9.0.0", BOOTSTRAPPER_RELATION_UPGRADE);
1043 DetectRelatedBundle(pEngineState, L"{6B2D8401-C0C2-4060-BFEF-5DDFD04BD586}", L"0.2.0.0", BOOTSTRAPPER_RELATION_PATCH);
1044 DetectRelatedBundle(pEngineState, L"{5C80A327-61B9-44CF-A6D4-64C45F4F90A9}", L"0.4.0.0", BOOTSTRAPPER_RELATION_ADDON);
1045 DetectRelatedBundle(pEngineState, L"{33A8757F-32EA-4974-888E-D15547259B3C}", L"0.3.0.0", BOOTSTRAPPER_RELATION_DEPENDENT_PATCH);
1046 DetectRelatedBundle(pEngineState, L"{59CD5A25-0398-41CA-AD53-AD8C061E2A1A}", L"0.7.0.0", BOOTSTRAPPER_RELATION_DEPENDENT_ADDON);
1047
1048 RelatedBundlesSortDetect(&pEngineState->registration.relatedBundles);
1049 NativeAssert::StringEqual(L"{5C80A327-61B9-44CF-A6D4-64C45F4F90A9}", pEngineState->registration.relatedBundles.rgRelatedBundles[0].package.sczId);
1050 NativeAssert::StringEqual(L"{6B2D8401-C0C2-4060-BFEF-5DDFD04BD586}", pEngineState->registration.relatedBundles.rgRelatedBundles[1].package.sczId);
1051 NativeAssert::StringEqual(L"{59CD5A25-0398-41CA-AD53-AD8C061E2A1A}", pEngineState->registration.relatedBundles.rgRelatedBundles[2].package.sczId);
1052 NativeAssert::StringEqual(L"{33A8757F-32EA-4974-888E-D15547259B3C}", pEngineState->registration.relatedBundles.rgRelatedBundles[3].package.sczId);
1053 NativeAssert::StringEqual(L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", pEngineState->registration.relatedBundles.rgRelatedBundles[4].package.sczId);
1054
1055 vfUseRelatedBundlePlanType = TRUE;
1056 vRelatedBundlePlanType = BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_UPGRADE;
1057
1058 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
1059 NativeAssert::Succeeded(hr, "CorePlan failed");
1060
1061 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
1062 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleId);
1063 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleProviderKey);
1064 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
1065 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
1066 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
1067 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
1068 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
1069 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
1070 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
1071
1072 BOOL fRollback = FALSE;
1073 DWORD dwIndex = 0;
1074 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
1075 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
1076
1077 fRollback = TRUE;
1078 dwIndex = 0;
1079 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
1080 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
1081
1082 fRollback = FALSE;
1083 dwIndex = 0;
1084 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
1085 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
1086 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageA");
1087 Assert::Equal(dwIndex, pPlan->cCacheActions);
1088
1089 fRollback = TRUE;
1090 dwIndex = 0;
1091 ValidateCacheRollbackPackage(pPlan, fRollback, dwIndex++, L"PackageA");
1092 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
1093 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
1094
1095 Assert::Equal(168715ull, pPlan->qwCacheSizeTotal);
1096
1097 fRollback = FALSE;
1098 dwIndex = 0;
1099 DWORD dwExecuteCheckpointId = 2;
1100 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1101 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1102 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
1103 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1104 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", registerActions1, 1);
1105 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1106 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
1107 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1108 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", registerActions1, 1);
1109 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1110 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1111 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1112 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{6B2D8401-C0C2-4060-BFEF-5DDFD04BD586}", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, NULL);
1113 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{33A8757F-32EA-4974-888E-D15547259B3C}", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, NULL);
1114 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{5C80A327-61B9-44CF-A6D4-64C45F4F90A9}", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, NULL);
1115 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{59CD5A25-0398-41CA-AD53-AD8C061E2A1A}", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, NULL);
1116 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, NULL);
1117 Assert::Equal(dwIndex, pPlan->cExecuteActions);
1118
1119 fRollback = TRUE;
1120 dwIndex = 0;
1121 dwExecuteCheckpointId = 2;
1122 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1123 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
1124 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1125 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", unregisterActions1, 1);
1126 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1127 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
1128 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1129 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", unregisterActions1, 1);
1130 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1131 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1132 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1133 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1134 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{6B2D8401-C0C2-4060-BFEF-5DDFD04BD586}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
1135 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{33A8757F-32EA-4974-888E-D15547259B3C}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
1136 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{5C80A327-61B9-44CF-A6D4-64C45F4F90A9}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
1137 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{59CD5A25-0398-41CA-AD53-AD8C061E2A1A}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
1138 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
1139 Assert::Equal(dwIndex, pPlan->cRollbackActions);
1140
1141 Assert::Equal(6ul, pPlan->cExecutePackagesTotal);
1142 Assert::Equal(7ul, pPlan->cOverallProgressTicksTotal);
1143
1144 dwIndex = 0;
1145 ValidateRestoreRelatedBundle(pPlan, dwIndex++, L"{6B2D8401-C0C2-4060-BFEF-5DDFD04BD586}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
1146 ValidateRestoreRelatedBundle(pPlan, dwIndex++, L"{33A8757F-32EA-4974-888E-D15547259B3C}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
1147 ValidateRestoreRelatedBundle(pPlan, dwIndex++, L"{5C80A327-61B9-44CF-A6D4-64C45F4F90A9}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
1148 ValidateRestoreRelatedBundle(pPlan, dwIndex++, L"{59CD5A25-0398-41CA-AD53-AD8C061E2A1A}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
1149 ValidateRestoreRelatedBundle(pPlan, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
1150 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
1151
1152 dwIndex = 0;
1153 Assert::Equal(dwIndex, pPlan->cCleanActions);
1154
1155 UINT uIndex = 0;
1156 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
1157 Assert::Equal(uIndex, pPlan->cPlannedProviders);
1158
1159 Assert::Equal(1ul, pEngineState->packages.cPackages);
1160 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
1161 }
1162
1163 [Fact]
1164 void RelatedBundleMissingFromCacheTest()
1165 {
1166 HRESULT hr = S_OK;
1167 BURN_ENGINE_STATE engineState = { };
1168 BURN_ENGINE_STATE* pEngineState = &engineState;
1169 BURN_PLAN* pPlan = &engineState.plan;
1170
1171 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
1172 DetectAttachedContainerAsAttached(pEngineState);
1173 DetectPackagesAsAbsent(pEngineState);
1174 BURN_RELATED_BUNDLE* pRelatedBundle = DetectRelatedBundle(pEngineState, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", L"0.9.0.0", BOOTSTRAPPER_RELATION_UPGRADE);
1175 pRelatedBundle->fPlannable = FALSE;
1176
1177 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
1178 NativeAssert::Succeeded(hr, "CorePlan failed");
1179
1180 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
1181 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleId);
1182 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleProviderKey);
1183 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
1184 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
1185 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
1186 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
1187 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
1188 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
1189 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
1190
1191 BOOL fRollback = FALSE;
1192 DWORD dwIndex = 0;
1193 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
1194 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
1195
1196 fRollback = TRUE;
1197 dwIndex = 0;
1198 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
1199 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
1200
1201 fRollback = FALSE;
1202 dwIndex = 0;
1203 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
1204 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
1205 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageA");
1206 Assert::Equal(dwIndex, pPlan->cCacheActions);
1207
1208 fRollback = TRUE;
1209 dwIndex = 0;
1210 ValidateCacheRollbackPackage(pPlan, fRollback, dwIndex++, L"PackageA");
1211 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
1212 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
1213
1214 Assert::Equal(168715ull, pPlan->qwCacheSizeTotal);
1215
1216 fRollback = FALSE;
1217 dwIndex = 0;
1218 DWORD dwExecuteCheckpointId = 2;
1219 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1220 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1221 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
1222 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1223 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", registerActions1, 1);
1224 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1225 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
1226 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1227 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", registerActions1, 1);
1228 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1229 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1230 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1231 Assert::Equal(dwIndex, pPlan->cExecuteActions);
1232
1233 fRollback = TRUE;
1234 dwIndex = 0;
1235 dwExecuteCheckpointId = 2;
1236 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1237 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
1238 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1239 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", unregisterActions1, 1);
1240 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1241 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
1242 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1243 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", unregisterActions1, 1);
1244 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1245 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1246 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1247 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1248 Assert::Equal(dwIndex, pPlan->cRollbackActions);
1249
1250 Assert::Equal(1ul, pPlan->cExecutePackagesTotal);
1251 Assert::Equal(2ul, pPlan->cOverallProgressTicksTotal);
1252
1253 dwIndex = 0;
1254 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
1255
1256 dwIndex = 0;
1257 Assert::Equal(dwIndex, pPlan->cCleanActions);
1258
1259 UINT uIndex = 0;
1260 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
1261 Assert::Equal(uIndex, pPlan->cPlannedProviders);
1262
1263 Assert::Equal(1ul, pEngineState->packages.cPackages);
1264 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
1265 }
1266
1267 [Fact]
1268 void SingleExeInstallTest()
1269 {
1270 HRESULT hr = S_OK;
1271 BURN_ENGINE_STATE engineState = { };
1272 BURN_ENGINE_STATE* pEngineState = &engineState;
1273 BURN_PLAN* pPlan = &engineState.plan;
1274
1275 InitializeEngineStateForCorePlan(wzSingleExeManifestFileName, pEngineState);
1276 DetectAttachedContainerAsAttached(pEngineState);
1277 DetectPermanentPackagesAsPresentAndCached(pEngineState);
1278
1279 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
1280 NativeAssert::Succeeded(hr, "CorePlan failed");
1281
1282 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
1283 NativeAssert::StringEqual(L"{9C184683-04FB-49AD-9D79-65101BDC3EE3}", pPlan->wzBundleId);
1284 NativeAssert::StringEqual(L"{9C184683-04FB-49AD-9D79-65101BDC3EE3}", pPlan->wzBundleProviderKey);
1285 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
1286 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
1287 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
1288 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
1289 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
1290 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
1291 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
1292
1293 BOOL fRollback = FALSE;
1294 DWORD dwIndex = 0;
1295 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{9C184683-04FB-49AD-9D79-65101BDC3EE3}", L"{9C184683-04FB-49AD-9D79-65101BDC3EE3}");
1296 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
1297
1298 fRollback = TRUE;
1299 dwIndex = 0;
1300 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{9C184683-04FB-49AD-9D79-65101BDC3EE3}", L"{9C184683-04FB-49AD-9D79-65101BDC3EE3}");
1301 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
1302
1303 fRollback = FALSE;
1304 dwIndex = 0;
1305 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
1306 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"ExeA", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_REQUIRED);
1307 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"ExeA");
1308 Assert::Equal(dwIndex, pPlan->cCacheActions);
1309
1310 fRollback = TRUE;
1311 dwIndex = 0;
1312 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
1313
1314 Assert::Equal(119695ull, pPlan->qwCacheSizeTotal);
1315
1316 fRollback = FALSE;
1317 dwIndex = 0;
1318 DWORD dwExecuteCheckpointId = 2;
1319 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1320 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1321 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"ExeA");
1322 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1323 ValidateExecuteExePackage(pPlan, fRollback, dwIndex++, L"ExeA", BOOTSTRAPPER_ACTION_STATE_INSTALL);
1324 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1325 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1326 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1327 Assert::Equal(dwIndex, pPlan->cExecuteActions);
1328
1329 fRollback = TRUE;
1330 dwIndex = 0;
1331 dwExecuteCheckpointId = 2;
1332 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1333 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1334 ValidateExecuteExePackage(pPlan, fRollback, dwIndex++, L"ExeA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL);
1335 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1336 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1337 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1338 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1339 Assert::Equal(dwIndex, pPlan->cRollbackActions);
1340
1341 Assert::Equal(1ul, pPlan->cExecutePackagesTotal);
1342 Assert::Equal(2ul, pPlan->cOverallProgressTicksTotal);
1343
1344 dwIndex = 0;
1345 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
1346
1347 dwIndex = 0;
1348 ValidateCleanAction(pPlan, dwIndex++, L"NetFx48Web");
1349 ValidateCleanAction(pPlan, dwIndex++, L"ExeA");
1350 Assert::Equal(dwIndex, pPlan->cCleanActions);
1351
1352 UINT uIndex = 0;
1353 ValidatePlannedProvider(pPlan, uIndex++, L"{9C184683-04FB-49AD-9D79-65101BDC3EE3}", NULL);
1354 Assert::Equal(uIndex, pPlan->cPlannedProviders);
1355
1356 Assert::Equal(2ul, pEngineState->packages.cPackages);
1357 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"ExeA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
1358 }
1359
1360 [Fact]
1361 void SingleExeLayoutTest()
1362 {
1363 HRESULT hr = S_OK;
1364 BURN_ENGINE_STATE engineState = { };
1365 BURN_ENGINE_STATE* pEngineState = &engineState;
1366 BURN_PLAN* pPlan = &engineState.plan;
1367
1368 InitializeEngineStateForCorePlan(wzSingleExeManifestFileName, pEngineState);
1369 DetectAttachedContainerAsAttached(pEngineState);
1370 DetectPermanentPackagesAsPresentAndCached(pEngineState);
1371
1372 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_LAYOUT);
1373 NativeAssert::Succeeded(hr, "CorePlan failed");
1374
1375 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_LAYOUT, pPlan->action);
1376 NativeAssert::StringEqual(L"{9C184683-04FB-49AD-9D79-65101BDC3EE3}", pPlan->wzBundleId);
1377 NativeAssert::StringEqual(L"{9C184683-04FB-49AD-9D79-65101BDC3EE3}", pPlan->wzBundleProviderKey);
1378 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
1379 Assert::Equal<BOOL>(FALSE, pPlan->fPerMachine);
1380 Assert::Equal<BOOL>(FALSE, pPlan->fCanAffectMachineState);
1381 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
1382 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
1383 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
1384 Assert::Equal<DWORD>(0, pPlan->dwRegistrationOperations);
1385 Assert::True(0 != pPlan->sczLayoutDirectory);
1386 Assert::NotEqual<WCHAR>(0, *pPlan->sczLayoutDirectory);
1387
1388 BOOL fRollback = FALSE;
1389 DWORD dwIndex = 0;
1390 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
1391
1392 fRollback = TRUE;
1393 dwIndex = 0;
1394 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
1395
1396 fRollback = FALSE;
1397 dwIndex = 0;
1398 ValidateCacheLayoutBundle(pPlan, fRollback, dwIndex++);
1399 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"NetFx48Web", TRUE, BURN_CACHE_PACKAGE_TYPE_NONE, BURN_CACHE_PACKAGE_TYPE_NONE);
1400 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"ExeA", TRUE, BURN_CACHE_PACKAGE_TYPE_NONE, BURN_CACHE_PACKAGE_TYPE_NONE);
1401 Assert::Equal(dwIndex, pPlan->cCacheActions);
1402
1403 fRollback = TRUE;
1404 dwIndex = 0;
1405 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
1406
1407 Assert::Equal(4321686ull, pPlan->qwCacheSizeTotal);
1408
1409 fRollback = FALSE;
1410 dwIndex = 0;
1411 DWORD dwExecuteCheckpointId = 1;
1412 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1413 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1414 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1415 Assert::Equal(dwIndex, pPlan->cExecuteActions);
1416
1417 fRollback = TRUE;
1418 dwIndex = 0;
1419 dwExecuteCheckpointId = 1;
1420 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1421 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1422 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1423 Assert::Equal(dwIndex, pPlan->cRollbackActions);
1424
1425 Assert::Equal(0ul, pPlan->cExecutePackagesTotal);
1426 Assert::Equal(3ul, pPlan->cOverallProgressTicksTotal);
1427
1428 dwIndex = 0;
1429 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
1430
1431 dwIndex = 0;
1432 Assert::Equal(dwIndex, pPlan->cCleanActions);
1433
1434 UINT uIndex = 0;
1435 ValidatePlannedProvider(pPlan, uIndex++, L"{9C184683-04FB-49AD-9D79-65101BDC3EE3}", NULL);
1436 Assert::Equal(uIndex, pPlan->cPlannedProviders);
1437
1438 Assert::Equal(2ul, pEngineState->packages.cPackages);
1439 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"ExeA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
1440 }
1441
1442 [Fact]
1443 void SingleMsiCacheTest()
1444 {
1445 HRESULT hr = S_OK;
1446 BURN_ENGINE_STATE engineState = { };
1447 BURN_ENGINE_STATE* pEngineState = &engineState;
1448 BURN_PLAN* pPlan = &engineState.plan;
1449
1450 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
1451 DetectAttachedContainerAsAttached(pEngineState);
1452 DetectPackagesAsAbsent(pEngineState);
1453 DetectRelatedBundle(pEngineState, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", L"0.9.0.0", BOOTSTRAPPER_RELATION_UPGRADE);
1454
1455 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_CACHE);
1456 NativeAssert::Succeeded(hr, "CorePlan failed");
1457
1458 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_CACHE, pPlan->action);
1459 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleId);
1460 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleProviderKey);
1461 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
1462 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
1463 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
1464 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
1465 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
1466 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
1467 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
1468
1469 BOOL fRollback = FALSE;
1470 DWORD dwIndex = 0;
1471 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
1472 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
1473
1474 fRollback = TRUE;
1475 dwIndex = 0;
1476 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
1477 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
1478
1479 fRollback = FALSE;
1480 dwIndex = 0;
1481 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
1482 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
1483 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageA");
1484 Assert::Equal(dwIndex, pPlan->cCacheActions);
1485
1486 fRollback = TRUE;
1487 dwIndex = 0;
1488 ValidateCacheRollbackPackage(pPlan, fRollback, dwIndex++, L"PackageA");
1489 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
1490 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
1491
1492 Assert::Equal(168715ull, pPlan->qwCacheSizeTotal);
1493
1494 fRollback = FALSE;
1495 dwIndex = 0;
1496 DWORD dwExecuteCheckpointId = 2;
1497 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1498 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1499 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
1500 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1501 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1502 Assert::Equal(dwIndex, pPlan->cExecuteActions);
1503
1504 fRollback = TRUE;
1505 dwIndex = 0;
1506 dwExecuteCheckpointId = 2;
1507 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1508 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
1509 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1510 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1511 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1512 Assert::Equal(dwIndex, pPlan->cRollbackActions);
1513
1514 Assert::Equal(0ul, pPlan->cExecutePackagesTotal);
1515 Assert::Equal(1ul, pPlan->cOverallProgressTicksTotal);
1516
1517 dwIndex = 0;
1518 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
1519
1520 dwIndex = 0;
1521 Assert::Equal(dwIndex, pPlan->cCleanActions);
1522
1523 UINT uIndex = 0;
1524 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
1525 Assert::Equal(uIndex, pPlan->cPlannedProviders);
1526
1527 Assert::Equal(1ul, pEngineState->packages.cPackages);
1528 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
1529 }
1530
1531 [Fact]
1532 void SingleMsiDowngradeTest()
1533 {
1534 HRESULT hr = S_OK;
1535 BURN_ENGINE_STATE engineState = { };
1536 BURN_ENGINE_STATE* pEngineState = &engineState;
1537 BURN_PLAN* pPlan = &engineState.plan;
1538
1539 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
1540 DetectAttachedContainerAsAttached(pEngineState);
1541 DetectPackagesAsAbsent(pEngineState);
1542 DetectRelatedBundle(pEngineState, L"{AF8355C9-CCDD-4D61-BF5F-EA5F948D8F01}", L"1.1.0.0", BOOTSTRAPPER_RELATION_UPGRADE);
1543
1544 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
1545 NativeAssert::Succeeded(hr, "CorePlan failed");
1546
1547 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
1548 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleId);
1549 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleProviderKey);
1550 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
1551 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
1552 Assert::Equal<BOOL>(FALSE, pPlan->fCanAffectMachineState);
1553 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
1554 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
1555 Assert::Equal<BOOL>(TRUE, pPlan->fDowngrade);
1556 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_NONE, pPlan->dwRegistrationOperations);
1557
1558 BOOL fRollback = FALSE;
1559 DWORD dwIndex = 0;
1560 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
1561
1562 fRollback = TRUE;
1563 dwIndex = 0;
1564 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
1565
1566 fRollback = FALSE;
1567 dwIndex = 0;
1568 Assert::Equal(dwIndex, pPlan->cCacheActions);
1569
1570 fRollback = TRUE;
1571 dwIndex = 0;
1572 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
1573
1574 Assert::Equal(0ull, pPlan->qwCacheSizeTotal);
1575
1576 fRollback = FALSE;
1577 dwIndex = 0;
1578 Assert::Equal(dwIndex, pPlan->cExecuteActions);
1579
1580 fRollback = TRUE;
1581 dwIndex = 0;
1582 Assert::Equal(dwIndex, pPlan->cRollbackActions);
1583
1584 Assert::Equal(0ul, pPlan->cExecutePackagesTotal);
1585 Assert::Equal(0ul, pPlan->cOverallProgressTicksTotal);
1586
1587 dwIndex = 0;
1588 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
1589
1590 dwIndex = 0;
1591 Assert::Equal(dwIndex, pPlan->cCleanActions);
1592
1593 UINT uIndex = 0;
1594 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
1595 Assert::Equal(uIndex, pPlan->cPlannedProviders);
1596
1597 Assert::Equal(1ul, pEngineState->packages.cPackages);
1598 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_UNKNOWN, BURN_PACKAGE_REGISTRATION_STATE_UNKNOWN);
1599 }
1600
1601 [Fact(Skip = "Need to reimplement PlanTestBAProc() using a fake out of proc BA")]
1602 void SingleMsiForceAbsentTest()
1603 {
1604 HRESULT hr = S_OK;
1605 BURN_ENGINE_STATE engineState = { };
1606 BURN_ENGINE_STATE* pEngineState = &engineState;
1607 BURN_PLAN* pPlan = &engineState.plan;
1608
1609 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
1610 DetectAttachedContainerAsAttached(pEngineState);
1611 DetectPackagesAsAbsent(pEngineState);
1612 DetectRelatedBundle(pEngineState, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", L"0.9.0.0", BOOTSTRAPPER_RELATION_UPGRADE);
1613
1614 vfUsePackageRequestState = TRUE;
1615 vPackageRequestState = BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT;
1616 vfUseRelatedBundleRequestState = TRUE;
1617 vRelatedBundleRequestState = BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT;
1618
1619 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNINSTALL);
1620 NativeAssert::Succeeded(hr, "CorePlan failed");
1621
1622 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNINSTALL, pPlan->action);
1623 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleId);
1624 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleProviderKey);
1625 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
1626 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
1627 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
1628 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
1629 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
1630 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
1631 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
1632
1633 BOOL fRollback = FALSE;
1634 DWORD dwIndex = 0;
1635 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
1636
1637 fRollback = TRUE;
1638 dwIndex = 0;
1639 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
1640
1641 fRollback = FALSE;
1642 dwIndex = 0;
1643 Assert::Equal(dwIndex, pPlan->cCacheActions);
1644
1645 fRollback = TRUE;
1646 dwIndex = 0;
1647 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
1648
1649 Assert::Equal(0ull, pPlan->qwCacheSizeTotal);
1650
1651 fRollback = FALSE;
1652 dwIndex = 0;
1653 DWORD dwExecuteCheckpointId = 1;
1654 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1655 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
1656 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1657 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1658 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1659 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, NULL);
1660 Assert::Equal(dwIndex, pPlan->cExecuteActions);
1661
1662 fRollback = TRUE;
1663 dwIndex = 0;
1664 dwExecuteCheckpointId = 1;
1665 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1666 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1667 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1668 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1669 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
1670 Assert::Equal(dwIndex, pPlan->cRollbackActions);
1671
1672 Assert::Equal(2ul, pPlan->cExecutePackagesTotal);
1673 Assert::Equal(2ul, pPlan->cOverallProgressTicksTotal);
1674
1675 dwIndex = 0;
1676 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
1677
1678 dwIndex = 0;
1679 ValidateCleanAction(pPlan, dwIndex++, L"PackageA");
1680 Assert::Equal(dwIndex, pPlan->cCleanActions);
1681
1682 UINT uIndex = 0;
1683 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
1684 ValidatePlannedProvider(pPlan, uIndex++, L"{64633047-D172-4BBB-B202-64337D15C952}", NULL);
1685 Assert::Equal(uIndex, pPlan->cPlannedProviders);
1686
1687 Assert::Equal(1ul, pEngineState->packages.cPackages);
1688 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
1689 }
1690
1691 [Fact(Skip = "Need to reimplement PlanTestBAProc() using a fake out of proc BA")]
1692 void SingleMsiForcePresentTest()
1693 {
1694 HRESULT hr = S_OK;
1695 BURN_ENGINE_STATE engineState = { };
1696 BURN_ENGINE_STATE* pEngineState = &engineState;
1697 BURN_PLAN* pPlan = &engineState.plan;
1698
1699 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
1700 DetectPackagesAsPresentAndCached(pEngineState);
1701 DetectRelatedBundle(pEngineState, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", L"0.9.0.0", BOOTSTRAPPER_RELATION_UPGRADE);
1702
1703 vfUsePackageRequestState = TRUE;
1704 vPackageRequestState = BOOTSTRAPPER_REQUEST_STATE_FORCE_PRESENT;
1705 vfUseRelatedBundleRequestState = TRUE;
1706 vRelatedBundleRequestState = BOOTSTRAPPER_REQUEST_STATE_FORCE_PRESENT;
1707
1708 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
1709 NativeAssert::Succeeded(hr, "CorePlan failed");
1710
1711 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
1712 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleId);
1713 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleProviderKey);
1714 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
1715 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
1716 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
1717 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
1718 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
1719 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
1720 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
1721
1722 BOOL fRollback = FALSE;
1723 DWORD dwIndex = 0;
1724 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
1725
1726 fRollback = TRUE;
1727 dwIndex = 0;
1728 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
1729
1730 fRollback = FALSE;
1731 dwIndex = 0;
1732 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
1733 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
1734 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageA");
1735 Assert::Equal(dwIndex, pPlan->cCacheActions);
1736
1737 fRollback = TRUE;
1738 dwIndex = 0;
1739 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
1740
1741 Assert::Equal(175674ull, pPlan->qwCacheSizeTotal);
1742
1743 fRollback = FALSE;
1744 dwIndex = 0;
1745 DWORD dwExecuteCheckpointId = 2;
1746 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1747 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1748 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
1749 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", registerActions1, 1);
1750 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
1751 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", registerActions1, 1);
1752 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1753 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1754 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1755 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
1756 Assert::Equal(dwIndex, pPlan->cExecuteActions);
1757
1758 fRollback = TRUE;
1759 dwIndex = 0;
1760 dwExecuteCheckpointId = 2;
1761 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1762 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1763 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1764 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1765 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1766 Assert::Equal(dwIndex, pPlan->cRollbackActions);
1767
1768 Assert::Equal(2ul, pPlan->cExecutePackagesTotal);
1769 Assert::Equal(3ul, pPlan->cOverallProgressTicksTotal);
1770
1771 dwIndex = 0;
1772 ValidateRestoreRelatedBundle(pPlan, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
1773 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
1774
1775 dwIndex = 0;
1776 Assert::Equal(dwIndex, pPlan->cCleanActions);
1777
1778 UINT uIndex = 0;
1779 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
1780 Assert::Equal(uIndex, pPlan->cPlannedProviders);
1781
1782 Assert::Equal(1ul, pEngineState->packages.cPackages);
1783 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
1784 }
1785
1786 [Fact]
1787 void SingleMsiInstallTest()
1788 {
1789 HRESULT hr = S_OK;
1790 BURN_ENGINE_STATE engineState = { };
1791 BURN_ENGINE_STATE* pEngineState = &engineState;
1792 BURN_PLAN* pPlan = &engineState.plan;
1793
1794 pEngineState->internalCommand.fArpSystemComponent = TRUE;
1795
1796 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
1797 DetectAttachedContainerAsAttached(pEngineState);
1798 DetectPackagesAsAbsent(pEngineState);
1799 DetectRelatedBundle(pEngineState, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", L"0.9.0.0", BOOTSTRAPPER_RELATION_UPGRADE);
1800
1801 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
1802 NativeAssert::Succeeded(hr, "CorePlan failed");
1803
1804 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
1805 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleId);
1806 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleProviderKey);
1807 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
1808 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
1809 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
1810 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
1811 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
1812 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
1813 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY | BURN_REGISTRATION_ACTION_OPERATIONS_ARP_SYSTEM_COMPONENT, pPlan->dwRegistrationOperations);
1814
1815 BOOL fRollback = FALSE;
1816 DWORD dwIndex = 0;
1817 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
1818 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
1819
1820 fRollback = TRUE;
1821 dwIndex = 0;
1822 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
1823 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
1824
1825 fRollback = FALSE;
1826 dwIndex = 0;
1827 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
1828 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
1829 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageA");
1830 Assert::Equal(dwIndex, pPlan->cCacheActions);
1831
1832 fRollback = TRUE;
1833 dwIndex = 0;
1834 ValidateCacheRollbackPackage(pPlan, fRollback, dwIndex++, L"PackageA");
1835 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
1836 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
1837
1838 Assert::Equal(168715ull, pPlan->qwCacheSizeTotal);
1839
1840 fRollback = FALSE;
1841 dwIndex = 0;
1842 DWORD dwExecuteCheckpointId = 2;
1843 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1844 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1845 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
1846 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1847 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", registerActions1, 1);
1848 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1849 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
1850 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1851 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", registerActions1, 1);
1852 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1853 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1854 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1855 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, NULL);
1856 Assert::Equal(dwIndex, pPlan->cExecuteActions);
1857
1858 fRollback = TRUE;
1859 dwIndex = 0;
1860 dwExecuteCheckpointId = 2;
1861 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1862 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
1863 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1864 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", unregisterActions1, 1);
1865 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1866 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
1867 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1868 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", unregisterActions1, 1);
1869 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1870 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1871 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1872 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1873 ValidateExecuteRelatedBundle(pPlan, fRollback, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
1874 Assert::Equal(dwIndex, pPlan->cRollbackActions);
1875
1876 Assert::Equal(2ul, pPlan->cExecutePackagesTotal);
1877 Assert::Equal(3ul, pPlan->cOverallProgressTicksTotal);
1878
1879 dwIndex = 0;
1880 ValidateRestoreRelatedBundle(pPlan, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
1881 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
1882
1883 dwIndex = 0;
1884 Assert::Equal(dwIndex, pPlan->cCleanActions);
1885
1886 UINT uIndex = 0;
1887 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
1888 Assert::Equal(uIndex, pPlan->cPlannedProviders);
1889
1890 Assert::Equal(1ul, pEngineState->packages.cPackages);
1891 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
1892 }
1893
1894 [Fact]
1895 void SingleMsiInstalledWithNoInstalledPackagesModifyTest()
1896 {
1897 HRESULT hr = S_OK;
1898 BURN_ENGINE_STATE engineState = { };
1899 BURN_ENGINE_STATE* pEngineState = &engineState;
1900 BURN_PLAN* pPlan = &engineState.plan;
1901
1902 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
1903 DetectPackagesAsAbsent(pEngineState);
1904
1905 pEngineState->registration.detectedRegistrationType = BOOTSTRAPPER_REGISTRATION_TYPE_FULL;
1906
1907 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_MODIFY);
1908 NativeAssert::Succeeded(hr, "CorePlan failed");
1909
1910 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_MODIFY, pPlan->action);
1911 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleId);
1912 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleProviderKey);
1913 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
1914 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
1915 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
1916 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
1917 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
1918 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
1919 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
1920
1921 BOOL fRollback = FALSE;
1922 DWORD dwIndex = 0;
1923 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
1924 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
1925
1926 fRollback = TRUE;
1927 dwIndex = 0;
1928 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
1929 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
1930
1931 fRollback = FALSE;
1932 dwIndex = 0;
1933 Assert::Equal(dwIndex, pPlan->cCacheActions);
1934
1935 fRollback = TRUE;
1936 dwIndex = 0;
1937 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
1938
1939 Assert::Equal(0ull, pPlan->qwCacheSizeTotal);
1940
1941 fRollback = FALSE;
1942 dwIndex = 0;
1943 DWORD dwExecuteCheckpointId = 1;
1944 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1945 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1946 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1947 Assert::Equal(dwIndex, pPlan->cExecuteActions);
1948
1949 fRollback = TRUE;
1950 dwIndex = 0;
1951 dwExecuteCheckpointId = 1;
1952 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
1953 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
1954 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
1955 Assert::Equal(dwIndex, pPlan->cRollbackActions);
1956
1957 Assert::Equal(0ul, pPlan->cExecutePackagesTotal);
1958 Assert::Equal(0ul, pPlan->cOverallProgressTicksTotal);
1959
1960 dwIndex = 0;
1961 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
1962
1963 dwIndex = 0;
1964 ValidateCleanAction(pPlan, dwIndex++, L"PackageA");
1965 Assert::Equal(dwIndex, pPlan->cCleanActions);
1966
1967 UINT uIndex = 0;
1968 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
1969 Assert::Equal(uIndex, pPlan->cPlannedProviders);
1970
1971 Assert::Equal(1ul, pEngineState->packages.cPackages);
1972 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
1973 }
1974
1975 [Fact]
1976 void SingleMsiUninstallTest()
1977 {
1978 HRESULT hr = S_OK;
1979 BURN_ENGINE_STATE engineState = { };
1980 BURN_ENGINE_STATE* pEngineState = &engineState;
1981 BURN_PLAN* pPlan = &engineState.plan;
1982
1983 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
1984 DetectPackagesAsPresentAndCached(pEngineState);
1985
1986 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNINSTALL);
1987 NativeAssert::Succeeded(hr, "CorePlan failed");
1988
1989 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNINSTALL, pPlan->action);
1990 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleId);
1991 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleProviderKey);
1992 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
1993 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
1994 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
1995 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
1996 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
1997 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
1998 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
1999
2000 BOOL fRollback = FALSE;
2001 DWORD dwIndex = 0;
2002 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
2003 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
2004
2005 fRollback = TRUE;
2006 dwIndex = 0;
2007 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
2008 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
2009
2010 fRollback = FALSE;
2011 dwIndex = 0;
2012 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
2013 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA", FALSE, BURN_CACHE_PACKAGE_TYPE_NONE, BURN_CACHE_PACKAGE_TYPE_REQUIRED);
2014 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageA");
2015 Assert::Equal(dwIndex, pPlan->cCacheActions);
2016
2017 fRollback = TRUE;
2018 dwIndex = 0;
2019 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
2020
2021 Assert::Equal(175674ull, pPlan->qwCacheSizeTotal);
2022
2023 fRollback = FALSE;
2024 dwIndex = 0;
2025 DWORD dwExecuteCheckpointId = 2;
2026 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2027 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2028 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
2029 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2030 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", unregisterActions1, 1);
2031 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2032 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", unregisterActions1, 1);
2033 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2034 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
2035 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2036 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2037 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2038 Assert::Equal(dwIndex, pPlan->cExecuteActions);
2039
2040 fRollback = TRUE;
2041 dwIndex = 0;
2042 dwExecuteCheckpointId = 2;
2043 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2044 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2045 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", registerActions1, 1);
2046 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2047 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", registerActions1, 1);
2048 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2049 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
2050 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2051 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2052 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2053 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2054 Assert::Equal(dwIndex, pPlan->cRollbackActions);
2055
2056 Assert::Equal(1ul, pPlan->cExecutePackagesTotal);
2057 Assert::Equal(2ul, pPlan->cOverallProgressTicksTotal);
2058
2059 dwIndex = 0;
2060 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
2061
2062 dwIndex = 0;
2063 ValidateCleanAction(pPlan, dwIndex++, L"PackageA");
2064 Assert::Equal(dwIndex, pPlan->cCleanActions);
2065
2066 UINT uIndex = 0;
2067 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
2068 ValidatePlannedProvider(pPlan, uIndex++, L"{64633047-D172-4BBB-B202-64337D15C952}", NULL);
2069 Assert::Equal(uIndex, pPlan->cPlannedProviders);
2070
2071 Assert::Equal(1ul, pEngineState->packages.cPackages);
2072 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
2073 }
2074
2075 [Fact]
2076 void SingleMsiUninstallWithDependentTest()
2077 {
2078 HRESULT hr = S_OK;
2079 BURN_ENGINE_STATE engineState = { };
2080 BURN_ENGINE_STATE* pEngineState = &engineState;
2081 BURN_PLAN* pPlan = &engineState.plan;
2082
2083 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
2084 DetectPackagesAsPresentAndCached(pEngineState);
2085 DetectBundleDependent(pEngineState, L"{29855EB1-724D-4285-A89C-5D37D8549DCD}");
2086
2087 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNINSTALL);
2088 NativeAssert::Succeeded(hr, "CorePlan failed");
2089
2090 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNINSTALL, pPlan->action);
2091 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleId);
2092 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleProviderKey);
2093 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
2094 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
2095 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
2096 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
2097 Assert::Equal<BOOL>(TRUE, pPlan->fDisallowRemoval);
2098 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
2099 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
2100
2101 BOOL fRollback = FALSE;
2102 DWORD dwIndex = 0;
2103 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
2104 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
2105
2106 fRollback = TRUE;
2107 dwIndex = 0;
2108 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
2109 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
2110
2111 fRollback = FALSE;
2112 dwIndex = 0;
2113 Assert::Equal(dwIndex, pPlan->cCacheActions);
2114
2115 fRollback = TRUE;
2116 dwIndex = 0;
2117 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
2118
2119 Assert::Equal(0ull, pPlan->qwCacheSizeTotal);
2120
2121 fRollback = FALSE;
2122 dwIndex = 0;
2123 Assert::Equal(dwIndex, pPlan->cExecuteActions);
2124
2125 fRollback = TRUE;
2126 dwIndex = 0;
2127 Assert::Equal(dwIndex, pPlan->cRollbackActions);
2128
2129 Assert::Equal(0ul, pPlan->cExecutePackagesTotal);
2130 Assert::Equal(0ul, pPlan->cOverallProgressTicksTotal);
2131
2132 dwIndex = 0;
2133 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
2134
2135 dwIndex = 0;
2136 Assert::Equal(dwIndex, pPlan->cCleanActions);
2137
2138 UINT uIndex = 0;
2139 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
2140 Assert::Equal(uIndex, pPlan->cPlannedProviders);
2141
2142 Assert::Equal(1ul, pEngineState->packages.cPackages);
2143 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_UNKNOWN, BURN_PACKAGE_REGISTRATION_STATE_UNKNOWN);
2144 }
2145
2146 [Fact]
2147 void SingleMsiUninstallTestFromUpgradeBundleWithSameExactPackage()
2148 {
2149 HRESULT hr = S_OK;
2150 BURN_ENGINE_STATE engineState = { };
2151 BURN_ENGINE_STATE* pEngineState = &engineState;
2152 BURN_PLAN* pPlan = &engineState.plan;
2153
2154 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
2155 DetectAsRelatedUpgradeBundle(&engineState, L"{02940F3E-C83E-452D-BFCF-C943777ACEAE}", L"2.0.0.0");
2156
2157 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNINSTALL);
2158 NativeAssert::Succeeded(hr, "CorePlan failed");
2159
2160 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNINSTALL, pPlan->action);
2161 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleId);
2162 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleProviderKey);
2163 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
2164 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
2165 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
2166 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
2167 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
2168 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
2169 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
2170
2171 BOOL fRollback = FALSE;
2172 DWORD dwIndex = 0;
2173 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
2174 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
2175
2176 fRollback = TRUE;
2177 dwIndex = 0;
2178 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
2179 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
2180
2181 fRollback = FALSE;
2182 dwIndex = 0;
2183 Assert::Equal(dwIndex, pPlan->cCacheActions);
2184
2185 fRollback = TRUE;
2186 dwIndex = 0;
2187 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
2188
2189 Assert::Equal(0ull, pPlan->qwCacheSizeTotal);
2190
2191 fRollback = FALSE;
2192 dwIndex = 0;
2193 DWORD dwExecuteCheckpointId = 1;
2194 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2195 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2196 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", unregisterActions1, 1);
2197 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2198 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2199 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2200 Assert::Equal(dwIndex, pPlan->cExecuteActions);
2201
2202 fRollback = TRUE;
2203 dwIndex = 0;
2204 dwExecuteCheckpointId = 1;
2205 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2206 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", registerActions1, 1);
2207 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2208 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2209 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2210 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2211 Assert::Equal(dwIndex, pPlan->cRollbackActions);
2212
2213 Assert::Equal(0ul, pPlan->cExecutePackagesTotal);
2214 Assert::Equal(0ul, pPlan->cOverallProgressTicksTotal);
2215
2216 dwIndex = 0;
2217 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
2218
2219 dwIndex = 0;
2220 Assert::Equal(dwIndex, pPlan->cCleanActions);
2221
2222 UINT uIndex = 0;
2223 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
2224 Assert::Equal(uIndex, pPlan->cPlannedProviders);
2225
2226 Assert::Equal(1ul, pEngineState->packages.cPackages);
2227 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_IGNORED, BURN_PACKAGE_REGISTRATION_STATE_IGNORED);
2228 }
2229
2230 [Fact]
2231 void SingleMsiUninstallTestFromUpgradeBundleWithMinorUpdatePackage()
2232 {
2233 HRESULT hr = S_OK;
2234 BURN_ENGINE_STATE engineState = { };
2235 BURN_ENGINE_STATE* pEngineState = &engineState;
2236 BURN_PLAN* pPlan = &engineState.plan;
2237
2238 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
2239 DetectAsRelatedUpgradeBundle(&engineState, L"{02940F3E-C83E-452D-BFCF-C943777ACEAE}", L"2.0.0.0");
2240 pEngineState->packages.rgPackages[0].currentState = BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED;
2241 pEngineState->packages.rgPackages[0].Msi.operation = BOOTSTRAPPER_RELATED_OPERATION_DOWNGRADE;
2242
2243 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNINSTALL);
2244 NativeAssert::Succeeded(hr, "CorePlan failed");
2245
2246 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNINSTALL, pPlan->action);
2247 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleId);
2248 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleProviderKey);
2249 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
2250 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
2251 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
2252 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
2253 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
2254 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
2255 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
2256
2257 BOOL fRollback = FALSE;
2258 DWORD dwIndex = 0;
2259 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
2260 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
2261
2262 fRollback = TRUE;
2263 dwIndex = 0;
2264 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
2265 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
2266
2267 fRollback = FALSE;
2268 dwIndex = 0;
2269 Assert::Equal(dwIndex, pPlan->cCacheActions);
2270
2271 fRollback = TRUE;
2272 dwIndex = 0;
2273 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
2274
2275 Assert::Equal(0ull, pPlan->qwCacheSizeTotal);
2276
2277 fRollback = FALSE;
2278 dwIndex = 0;
2279 DWORD dwExecuteCheckpointId = 1;
2280 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2281 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2282 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", unregisterActions1, 1);
2283 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2284 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", unregisterActions1, 1);
2285 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2286 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2287 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2288 Assert::Equal(dwIndex, pPlan->cExecuteActions);
2289
2290 fRollback = TRUE;
2291 dwIndex = 0;
2292 dwExecuteCheckpointId = 1;
2293 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2294 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", registerActions1, 1);
2295 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2296 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", registerActions1, 1);
2297 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2298 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2299 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2300 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2301 Assert::Equal(dwIndex, pPlan->cRollbackActions);
2302
2303 Assert::Equal(0ul, pPlan->cExecutePackagesTotal);
2304 Assert::Equal(0ul, pPlan->cOverallProgressTicksTotal);
2305
2306 dwIndex = 0;
2307 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
2308
2309 dwIndex = 0;
2310 Assert::Equal(dwIndex, pPlan->cCleanActions);
2311
2312 UINT uIndex = 0;
2313 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
2314 Assert::Equal(uIndex, pPlan->cPlannedProviders);
2315
2316 Assert::Equal(1ul, pEngineState->packages.cPackages);
2317 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_IGNORED, BURN_PACKAGE_REGISTRATION_STATE_IGNORED);
2318 }
2319
2320 [Fact]
2321 void SingleMsiUnsafeUninstallTest()
2322 {
2323 HRESULT hr = S_OK;
2324 BURN_ENGINE_STATE engineState = { };
2325 BURN_ENGINE_STATE* pEngineState = &engineState;
2326 BURN_PLAN* pPlan = &engineState.plan;
2327
2328 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
2329 DetectPackagesAsPresentAndCached(pEngineState);
2330
2331 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNSAFE_UNINSTALL);
2332 NativeAssert::Succeeded(hr, "CorePlan failed");
2333
2334 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNSAFE_UNINSTALL, pPlan->action);
2335 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleId);
2336 NativeAssert::StringEqual(L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", pPlan->wzBundleProviderKey);
2337 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
2338 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
2339 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
2340 Assert::Equal<BOOL>(TRUE, pPlan->fDisableRollback);
2341 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
2342 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
2343 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
2344
2345 BOOL fRollback = FALSE;
2346 DWORD dwIndex = 0;
2347 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
2348 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
2349
2350 fRollback = TRUE;
2351 dwIndex = 0;
2352 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}");
2353 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
2354
2355 fRollback = FALSE;
2356 dwIndex = 0;
2357 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
2358 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA", FALSE, BURN_CACHE_PACKAGE_TYPE_NONE, BURN_CACHE_PACKAGE_TYPE_REQUIRED);
2359 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageA");
2360 Assert::Equal(dwIndex, pPlan->cCacheActions);
2361
2362 fRollback = TRUE;
2363 dwIndex = 0;
2364 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
2365
2366 Assert::Equal(175674ull, pPlan->qwCacheSizeTotal);
2367
2368 fRollback = FALSE;
2369 dwIndex = 0;
2370 DWORD dwExecuteCheckpointId = 2;
2371 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2372 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2373 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
2374 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2375 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", unregisterActions1, 1);
2376 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2377 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", unregisterActions1, 1);
2378 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2379 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
2380 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2381 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2382 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2383 Assert::Equal(dwIndex, pPlan->cExecuteActions);
2384
2385 fRollback = TRUE;
2386 dwIndex = 0;
2387 dwExecuteCheckpointId = 2;
2388 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2389 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2390 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", registerActions1, 1);
2391 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2392 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", registerActions1, 1);
2393 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2394 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
2395 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2396 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2397 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2398 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2399 Assert::Equal(dwIndex, pPlan->cRollbackActions);
2400
2401 Assert::Equal(1ul, pPlan->cExecutePackagesTotal);
2402 Assert::Equal(2ul, pPlan->cOverallProgressTicksTotal);
2403
2404 dwIndex = 0;
2405 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
2406
2407 dwIndex = 0;
2408 ValidateCleanAction(pPlan, dwIndex++, L"PackageA");
2409 Assert::Equal(dwIndex, pPlan->cCleanActions);
2410
2411 UINT uIndex = 0;
2412 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
2413 ValidatePlannedProvider(pPlan, uIndex++, L"{64633047-D172-4BBB-B202-64337D15C952}", NULL);
2414 Assert::Equal(uIndex, pPlan->cPlannedProviders);
2415
2416 Assert::Equal(1ul, pEngineState->packages.cPackages);
2417 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
2418 }
2419
2420 [Fact]
2421 void SingleMsuInstallTest()
2422 {
2423 HRESULT hr = S_OK;
2424 LONGLONG llPlannedAction = 0;
2425 BURN_ENGINE_STATE engineState = { };
2426 BURN_ENGINE_STATE* pEngineState = &engineState;
2427 BURN_PLAN* pPlan = &engineState.plan;
2428
2429 InitializeEngineStateForCorePlan(wzSingleMsuManifestFileName, pEngineState);
2430 DetectAttachedContainerAsAttached(pEngineState);
2431 DetectPackagesAsAbsent(pEngineState);
2432
2433 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
2434 NativeAssert::Succeeded(hr, "CorePlan failed");
2435
2436 llPlannedAction = VariableGetNumericHelper(&engineState.variables, BURN_BUNDLE_ACTION);
2437
2438 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
2439 Assert::Equal<LONGLONG>(BOOTSTRAPPER_ACTION_INSTALL, llPlannedAction);
2440 NativeAssert::StringEqual(L"{06077C60-DC46-4F4A-8D3C-05F869187191}", pPlan->wzBundleId);
2441 NativeAssert::StringEqual(L"{06077C60-DC46-4F4A-8D3C-05F869187191}", pPlan->wzBundleProviderKey);
2442 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
2443 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
2444 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
2445 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
2446 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
2447 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
2448 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
2449
2450 BOOL fRollback = FALSE;
2451 DWORD dwIndex = 0;
2452 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{06077C60-DC46-4F4A-8D3C-05F869187191}", L"{06077C60-DC46-4F4A-8D3C-05F869187191}");
2453 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
2454
2455 fRollback = TRUE;
2456 dwIndex = 0;
2457 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{06077C60-DC46-4F4A-8D3C-05F869187191}", L"{06077C60-DC46-4F4A-8D3C-05F869187191}");
2458 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
2459
2460 fRollback = FALSE;
2461 dwIndex = 0;
2462 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
2463 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"test.msu", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
2464 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"test.msu");
2465 Assert::Equal(dwIndex, pPlan->cCacheActions);
2466
2467 fRollback = TRUE;
2468 dwIndex = 0;
2469 ValidateCacheRollbackPackage(pPlan, fRollback, dwIndex++, L"test.msu");
2470 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
2471 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
2472
2473 Assert::Equal(140ull, pPlan->qwCacheSizeTotal);
2474
2475 fRollback = FALSE;
2476 dwIndex = 0;
2477 DWORD dwExecuteCheckpointId = 2;
2478 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2479 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2480 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"test.msu");
2481 ValidateExecuteMsuPackage(pPlan, fRollback, dwIndex++, L"test.msu", BOOTSTRAPPER_ACTION_STATE_INSTALL);
2482 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2483 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2484 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2485 Assert::Equal(dwIndex, pPlan->cExecuteActions);
2486
2487 fRollback = TRUE;
2488 dwIndex = 0;
2489 dwExecuteCheckpointId = 2;
2490 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2491 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"test.msu");
2492 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2493 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2494 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2495 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2496 Assert::Equal(dwIndex, pPlan->cRollbackActions);
2497
2498 Assert::Equal(1ul, pPlan->cExecutePackagesTotal);
2499 Assert::Equal(2ul, pPlan->cOverallProgressTicksTotal);
2500
2501 dwIndex = 0;
2502 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
2503
2504 dwIndex = 0;
2505 Assert::Equal(dwIndex, pPlan->cCleanActions);
2506
2507 UINT uIndex = 0;
2508 ValidatePlannedProvider(pPlan, uIndex++, L"{06077C60-DC46-4F4A-8D3C-05F869187191}", NULL);
2509 Assert::Equal(uIndex, pPlan->cPlannedProviders);
2510
2511 Assert::Equal(1ul, pEngineState->packages.cPackages);
2512 }
2513
2514 [Fact]
2515 void SlipstreamInstallTest()
2516 {
2517 HRESULT hr = S_OK;
2518 BURN_ENGINE_STATE engineState = { };
2519 BURN_ENGINE_STATE* pEngineState = &engineState;
2520 BURN_PLAN* pPlan = &engineState.plan;
2521
2522 InitializeEngineStateForCorePlan(wzSlipstreamManifestFileName, pEngineState);
2523 DetectPermanentPackagesAsPresentAndCached(pEngineState);
2524 PlanTestDetectPatchInitialize(pEngineState);
2525
2526 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
2527 NativeAssert::Succeeded(hr, "CorePlan failed");
2528
2529 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
2530 NativeAssert::StringEqual(L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", pPlan->wzBundleId);
2531 NativeAssert::StringEqual(L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", pPlan->wzBundleProviderKey);
2532 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
2533 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
2534 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
2535 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
2536 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
2537 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
2538 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
2539
2540 BOOL fRollback = FALSE;
2541 DWORD dwIndex = 0;
2542 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}");
2543 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
2544
2545 fRollback = TRUE;
2546 dwIndex = 0;
2547 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}");
2548 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
2549
2550 fRollback = FALSE;
2551 dwIndex = 0;
2552 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
2553 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"NetFx48Web", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
2554 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"NetFx48Web");
2555 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 3);
2556 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PatchA", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
2557 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PatchA");
2558 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 5);
2559 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
2560 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageA");
2561 Assert::Equal(dwIndex, pPlan->cCacheActions);
2562
2563 fRollback = TRUE;
2564 dwIndex = 0;
2565 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
2566
2567 Assert::Equal(6130592ull, pPlan->qwCacheSizeTotal);
2568
2569 fRollback = FALSE;
2570 dwIndex = 0;
2571 DWORD dwExecuteCheckpointId = 2;
2572 BURN_EXECUTE_ACTION* pExecuteAction = NULL;
2573 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2574 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2575 dwExecuteCheckpointId += 1; // cache checkpoints
2576 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"NetFx48Web");
2577 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2578 dwExecuteCheckpointId += 1; // cache checkpoints
2579 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PatchA");
2580 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2581 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
2582 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2583 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", registerActions1, 1);
2584 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2585 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
2586 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2587 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", registerActions1, 1);
2588 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2589 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2590 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PatchA", registerActions1, 1);
2591 pExecuteAction = ValidateDeletedExecuteMspTarget(pPlan, fRollback, dwIndex++, L"PatchA", BOOTSTRAPPER_ACTION_STATE_INSTALL, L"{5FF7F534-3FFC-41E0-80CD-E6361E5E7B7B}", TRUE, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, TRUE);
2592 ValidateExecuteMspTargetPatch(pExecuteAction, 0, L"PatchA");
2593 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2594 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PatchA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", registerActions1, 1);
2595 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2596 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2597 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2598 Assert::Equal(dwIndex, pPlan->cExecuteActions);
2599
2600 fRollback = TRUE;
2601 dwIndex = 0;
2602 dwExecuteCheckpointId = 2;
2603 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2604 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2605 dwExecuteCheckpointId += 1; // cache checkpoints
2606 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2607 dwExecuteCheckpointId += 1; // cache checkpoints
2608 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2609 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", unregisterActions1, 1);
2610 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2611 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
2612 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2613 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", unregisterActions1, 1);
2614 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2615 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2616 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PatchA", unregisterActions1, 1);
2617 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2618 pExecuteAction = ValidateDeletedExecuteMspTarget(pPlan, fRollback, dwIndex++, L"PatchA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, L"{5FF7F534-3FFC-41E0-80CD-E6361E5E7B7B}", TRUE, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, TRUE);
2619 ValidateExecuteMspTargetPatch(pExecuteAction, 0, L"PatchA");
2620 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PatchA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", unregisterActions1, 1);
2621 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2622 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2623 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2624 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2625 Assert::Equal(dwIndex, pPlan->cRollbackActions);
2626
2627 Assert::Equal(2ul, pPlan->cExecutePackagesTotal);
2628 Assert::Equal(5ul, pPlan->cOverallProgressTicksTotal);
2629
2630 dwIndex = 0;
2631 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
2632
2633 dwIndex = 0;
2634 Assert::Equal(dwIndex, pPlan->cCleanActions);
2635
2636 UINT uIndex = 0;
2637 ValidatePlannedProvider(pPlan, uIndex++, L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", NULL);
2638 Assert::Equal(uIndex, pPlan->cPlannedProviders);
2639
2640 Assert::Equal(3ul, pEngineState->packages.cPackages);
2641 ValidatePermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"NetFx48Web");
2642 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
2643 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[2], L"PatchA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
2644 }
2645
2646 [Fact]
2647 void SlipstreamUninstallTest()
2648 {
2649 HRESULT hr = S_OK;
2650 BURN_ENGINE_STATE engineState = { };
2651 BURN_ENGINE_STATE* pEngineState = &engineState;
2652 BURN_PLAN* pPlan = &engineState.plan;
2653
2654 InitializeEngineStateForCorePlan(wzSlipstreamManifestFileName, pEngineState);
2655 DetectPackagesAsPresentAndCached(pEngineState);
2656
2657 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNINSTALL);
2658 NativeAssert::Succeeded(hr, "CorePlan failed");
2659
2660 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNINSTALL, pPlan->action);
2661 NativeAssert::StringEqual(L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", pPlan->wzBundleId);
2662 NativeAssert::StringEqual(L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", pPlan->wzBundleProviderKey);
2663 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
2664 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
2665 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
2666 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
2667 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
2668 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
2669 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
2670
2671 BOOL fRollback = FALSE;
2672 DWORD dwIndex = 0;
2673 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}");
2674 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
2675
2676 fRollback = TRUE;
2677 dwIndex = 0;
2678 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}");
2679 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
2680
2681 fRollback = FALSE;
2682 dwIndex = 0;
2683 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
2684 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PatchA", FALSE, BURN_CACHE_PACKAGE_TYPE_NONE, BURN_CACHE_PACKAGE_TYPE_REQUIRED);
2685 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PatchA");
2686 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 6);
2687 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA", FALSE, BURN_CACHE_PACKAGE_TYPE_NONE, BURN_CACHE_PACKAGE_TYPE_REQUIRED);
2688 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageA");
2689 Assert::Equal(dwIndex, pPlan->cCacheActions);
2690
2691 fRollback = TRUE;
2692 dwIndex = 0;
2693 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
2694
2695 Assert::Equal(212992ull, pPlan->qwCacheSizeTotal);
2696
2697 fRollback = FALSE;
2698 dwIndex = 0;
2699 DWORD dwExecuteCheckpointId = 2;
2700 BURN_EXECUTE_ACTION* pExecuteAction = NULL;
2701 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2702 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2703 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PatchA");
2704 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2705 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PatchA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", unregisterActions1, 1);
2706 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2707 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PatchA", unregisterActions1, 1);
2708 pExecuteAction = ValidateDeletedExecuteMspTarget(pPlan, fRollback, dwIndex++, L"PatchA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, L"{5FF7F534-3FFC-41E0-80CD-E6361E5E7B7B}", TRUE, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, TRUE);
2709 ValidateExecuteMspTargetPatch(pExecuteAction, 0, L"PatchA");
2710 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2711 dwExecuteCheckpointId += 1; // cache checkpoints
2712 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2713 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
2714 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2715 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", unregisterActions1, 1);
2716 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2717 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", unregisterActions1, 1);
2718 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2719 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
2720 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2721 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2722 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2723 Assert::Equal(dwIndex, pPlan->cExecuteActions);
2724
2725 fRollback = TRUE;
2726 dwIndex = 0;
2727 dwExecuteCheckpointId = 2;
2728 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2729 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2730 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PatchA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", registerActions1, 1);
2731 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2732 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PatchA", registerActions1, 1);
2733 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2734 pExecuteAction = ValidateDeletedExecuteMspTarget(pPlan, fRollback, dwIndex++, L"PatchA", BOOTSTRAPPER_ACTION_STATE_INSTALL, L"{5FF7F534-3FFC-41E0-80CD-E6361E5E7B7B}", TRUE, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, TRUE);
2735 ValidateExecuteMspTargetPatch(pExecuteAction, 0, L"PatchA");
2736 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2737 dwExecuteCheckpointId += 1; // cache checkpoints
2738 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2739 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", registerActions1, 1);
2740 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2741 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", registerActions1, 1);
2742 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2743 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
2744 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2745 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2746 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2747 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2748 Assert::Equal(dwIndex, pPlan->cRollbackActions);
2749
2750 Assert::Equal(2ul, pPlan->cExecutePackagesTotal);
2751 Assert::Equal(4ul, pPlan->cOverallProgressTicksTotal);
2752
2753 dwIndex = 0;
2754 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
2755
2756 dwIndex = 0;
2757 ValidateCleanAction(pPlan, dwIndex++, L"PatchA");
2758 ValidateCleanAction(pPlan, dwIndex++, L"PackageA");
2759 Assert::Equal(dwIndex, pPlan->cCleanActions);
2760
2761 UINT uIndex = 0;
2762 ValidatePlannedProvider(pPlan, uIndex++, L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", NULL);
2763 ValidatePlannedProvider(pPlan, uIndex++, L"{0A5113E3-06A5-4CE0-8E83-9EB42F6764A6}", NULL);
2764 ValidatePlannedProvider(pPlan, uIndex++, L"{5FF7F534-3FFC-41E0-80CD-E6361E5E7B7B}", NULL);
2765 Assert::Equal(uIndex, pPlan->cPlannedProviders);
2766
2767 Assert::Equal(3ul, pEngineState->packages.cPackages);
2768 ValidatePermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"NetFx48Web");
2769 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
2770 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[2], L"PatchA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
2771 }
2772
2773 [Fact]
2774 void UnuninstallableExePackageForceAbsentTest()
2775 {
2776 HRESULT hr = S_OK;
2777 BURN_ENGINE_STATE engineState = { };
2778 BURN_ENGINE_STATE* pEngineState = &engineState;
2779 BURN_PLAN* pPlan = &engineState.plan;
2780
2781 InitializeEngineStateForCorePlan(wzSlipstreamModifiedManifestFileName, pEngineState);
2782 DetectPackagesAsPresentAndCached(pEngineState);
2783
2784 vfUsePackageRequestState = TRUE;
2785 vPackageRequestState = BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT;
2786
2787 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNINSTALL);
2788 NativeAssert::Succeeded(hr, "CorePlan failed");
2789
2790 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNINSTALL, pPlan->action);
2791 NativeAssert::StringEqual(L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", pPlan->wzBundleId);
2792 NativeAssert::StringEqual(L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", pPlan->wzBundleProviderKey);
2793 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
2794 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
2795 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
2796 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
2797 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
2798 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
2799 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
2800
2801 BOOL fRollback = FALSE;
2802 DWORD dwIndex = 0;
2803 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}");
2804 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
2805
2806 fRollback = TRUE;
2807 dwIndex = 0;
2808 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}");
2809 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
2810
2811 fRollback = FALSE;
2812 dwIndex = 0;
2813 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
2814 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA", FALSE, BURN_CACHE_PACKAGE_TYPE_NONE, BURN_CACHE_PACKAGE_TYPE_REQUIRED);
2815 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageA");
2816 Assert::Equal(dwIndex, pPlan->cCacheActions);
2817
2818 fRollback = TRUE;
2819 dwIndex = 0;
2820 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
2821
2822 Assert::Equal(131072ull, pPlan->qwCacheSizeTotal);
2823
2824 fRollback = FALSE;
2825 dwIndex = 0;
2826 DWORD dwExecuteCheckpointId = 2;
2827 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2828 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2829 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
2830 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2831 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", unregisterActions1, 1);
2832 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2833 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", unregisterActions1, 1);
2834 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2835 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
2836 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2837 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2838 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2839 Assert::Equal(dwIndex, pPlan->cExecuteActions);
2840
2841 fRollback = TRUE;
2842 dwIndex = 0;
2843 dwExecuteCheckpointId = 2;
2844 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2845 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2846 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", registerActions1, 1);
2847 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2848 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", registerActions1, 1);
2849 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2850 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
2851 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2852 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2853 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2854 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2855 Assert::Equal(dwIndex, pPlan->cRollbackActions);
2856
2857 Assert::Equal(1ul, pPlan->cExecutePackagesTotal);
2858 Assert::Equal(2ul, pPlan->cOverallProgressTicksTotal);
2859
2860 dwIndex = 0;
2861 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
2862
2863 dwIndex = 0;
2864 ValidateCleanAction(pPlan, dwIndex++, L"PackageA");
2865 Assert::Equal(dwIndex, pPlan->cCleanActions);
2866
2867 UINT uIndex = 0;
2868 ValidatePlannedProvider(pPlan, uIndex++, L"{DC94A8E0-4BF4-4026-B80B-2755DAFC05D3}", NULL);
2869 ValidatePlannedProvider(pPlan, uIndex++, L"{5FF7F534-3FFC-41E0-80CD-E6361E5E7B7B}", NULL);
2870 Assert::Equal(uIndex, pPlan->cPlannedProviders);
2871
2872 Assert::Equal(2ul, pEngineState->packages.cPackages);
2873 ValidatePermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"NetFx48Web");
2874 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
2875 }
2876
2877 [Fact]
2878 void UnuninstallableExePackageInstallTest()
2879 {
2880 HRESULT hr = S_OK;
2881 BURN_ENGINE_STATE engineState = { };
2882 BURN_ENGINE_STATE* pEngineState = &engineState;
2883 BURN_PLAN* pPlan = &engineState.plan;
2884
2885 InitializeEngineStateForCorePlan(wzSlipstreamModifiedManifestFileName, pEngineState);
2886 DetectPackagesAsAbsent(pEngineState);
2887
2888 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
2889 NativeAssert::Succeeded(hr, "CorePlan failed");
2890
2891 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
2892 NativeAssert::StringEqual(L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", pPlan->wzBundleId);
2893 NativeAssert::StringEqual(L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", pPlan->wzBundleProviderKey);
2894 Assert::Equal<BOOL>(FALSE, pPlan->fEnabledForwardCompatibleBundle);
2895 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
2896 Assert::Equal<BOOL>(TRUE, pPlan->fCanAffectMachineState);
2897 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
2898 Assert::Equal<BOOL>(FALSE, pPlan->fDisallowRemoval);
2899 Assert::Equal<BOOL>(FALSE, pPlan->fDowngrade);
2900 Assert::Equal<DWORD>(BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE | BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY, pPlan->dwRegistrationOperations);
2901
2902 BOOL fRollback = FALSE;
2903 DWORD dwIndex = 0;
2904 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, TRUE, L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}");
2905 Assert::Equal(dwIndex, pPlan->cRegistrationActions);
2906
2907 fRollback = TRUE;
2908 dwIndex = 0;
2909 ValidateDependentRegistrationAction(pPlan, fRollback, dwIndex++, FALSE, L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}");
2910 Assert::Equal(dwIndex, pPlan->cRollbackRegistrationActions);
2911
2912 fRollback = FALSE;
2913 dwIndex = 0;
2914 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
2915 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"NetFx48Web", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
2916 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"NetFx48Web");
2917 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 4);
2918 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA", TRUE, BURN_CACHE_PACKAGE_TYPE_REQUIRED, BURN_CACHE_PACKAGE_TYPE_NONE);
2919 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++, L"PackageA");
2920 Assert::Equal(dwIndex, pPlan->cCacheActions);
2921
2922 fRollback = TRUE;
2923 dwIndex = 0;
2924 ValidateCacheRollbackPackage(pPlan, fRollback, dwIndex++, L"NetFx48Web");
2925 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
2926 ValidateCacheRollbackPackage(pPlan, fRollback, dwIndex++, L"PackageA");
2927 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 4);
2928 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
2929
2930 Assert::Equal(6048672ull, pPlan->qwCacheSizeTotal);
2931
2932 fRollback = FALSE;
2933 dwIndex = 0;
2934 DWORD dwExecuteCheckpointId = 2;
2935 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2936 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2937 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"NetFx48Web");
2938 ValidateExecuteExePackage(pPlan, fRollback, dwIndex++, L"NetFx48Web", BOOTSTRAPPER_ACTION_STATE_INSTALL);
2939 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2940 dwExecuteCheckpointId += 1; // cache checkpoints
2941 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2942 ValidateExecuteWaitCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
2943 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2944 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", registerActions1, 1);
2945 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2946 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
2947 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2948 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", registerActions1, 1);
2949 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2950 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2951 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2952 Assert::Equal(dwIndex, pPlan->cExecuteActions);
2953
2954 fRollback = TRUE;
2955 dwIndex = 0;
2956 dwExecuteCheckpointId = 2;
2957 ValidateExecuteRollbackBoundaryStart(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
2958 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"NetFx48Web");
2959 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2960 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2961 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
2962 dwExecuteCheckpointId += 1; // cache checkpoints
2963 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2964 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", unregisterActions1, 1);
2965 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2966 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, BOOTSTRAPPER_MSI_FILE_VERSIONING_MISSING_OR_OLDER, 0);
2967 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2968 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", unregisterActions1, 1);
2969 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2970 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2971 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
2972 ValidateExecuteRollbackBoundaryEnd(pPlan, fRollback, dwIndex++);
2973 Assert::Equal(dwIndex, pPlan->cRollbackActions);
2974
2975 Assert::Equal(2ul, pPlan->cExecutePackagesTotal);
2976 Assert::Equal(4ul, pPlan->cOverallProgressTicksTotal);
2977
2978 dwIndex = 0;
2979 Assert::Equal(dwIndex, pPlan->cRestoreRelatedBundleActions);
2980
2981 dwIndex = 0;
2982 Assert::Equal(dwIndex, pPlan->cCleanActions);
2983
2984 UINT uIndex = 0;
2985 ValidatePlannedProvider(pPlan, uIndex++, L"{DC94A8E0-4BF4-4026-B80B-2755DAFC05D3}", NULL);
2986 Assert::Equal(uIndex, pPlan->cPlannedProviders);
2987
2988 Assert::Equal(2ul, pEngineState->packages.cPackages);
2989 ValidatePermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"NetFx48Web");
2990 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
2991 }
2992
2993 private:
2994 // This doesn't initialize everything, just enough for CorePlan to work.
2995 void InitializeEngineStateForCorePlan(LPCWSTR wzManifestFileName, BURN_ENGINE_STATE* pEngineState)
2996 {
2997 HRESULT hr = S_OK;
2998 LPWSTR sczFilePath = NULL;
2999
3000 vfUsePackageRequestState = FALSE;
3001 vfUseRelatedBundleRequestState = FALSE;
3002 vfUseRelatedBundlePlanType = FALSE;
3003
3004 ::InitializeCriticalSection(&pEngineState->userExperience.csEngineActive);
3005
3006 hr = CacheInitialize(&pEngineState->cache, &pEngineState->internalCommand);
3007 NativeAssert::Succeeded(hr, "Failed to initialize cache.");
3008
3009 hr = VariableInitialize(&pEngineState->variables);
3010 NativeAssert::Succeeded(hr, "Failed to initialize variables.");
3011
3012 try
3013 {
3014 pin_ptr<const wchar_t> dataDirectory = PtrToStringChars(this->TestContext->TestDirectory);
3015 hr = PathConcat(dataDirectory, L"TestData\\PlanTest", &sczFilePath);
3016 NativeAssert::Succeeded(hr, "Failed to get path to test file directory.");
3017 hr = PathConcat(sczFilePath, wzManifestFileName, &sczFilePath);
3018 NativeAssert::Succeeded(hr, "Failed to get path to test file.");
3019 Assert::True(FileExistsEx(sczFilePath, NULL), "Test file does not exist.");
3020
3021 hr = ManifestLoadXmlFromFile(sczFilePath, pEngineState);
3022 NativeAssert::Succeeded(hr, "Failed to load manifest.");
3023 }
3024 finally
3025 {
3026 ReleaseStr(sczFilePath);
3027 }
3028
3029 pEngineState->section.qwBundleSize = 1234;
3030
3031 hr = CoreInitializeConstants(pEngineState);
3032 NativeAssert::Succeeded(hr, "Failed to initialize core constants");
3033
3034 hr = CacheInitializeSources(&pEngineState->cache, &pEngineState->registration, &pEngineState->variables);
3035 NativeAssert::Succeeded(hr, "Failed to initialize cache sources.");
3036
3037 #if TODO_REIMPLEMENT
3038 pEngineState->userExperience.hUXModule = reinterpret_cast<HMODULE>(1);
3039 pEngineState->userExperience.pfnBAProc = PlanTestBAProc;
3040 #endif
3041 }
3042
3043 void PlanTestDetect(BURN_ENGINE_STATE* pEngineState)
3044 {
3045 DetectReset(&pEngineState->registration, &pEngineState->packages);
3046 PlanReset(&pEngineState->plan, &pEngineState->variables, &pEngineState->containers, &pEngineState->packages, &pEngineState->layoutPayloads);
3047
3048 pEngineState->userExperience.fEngineActive = TRUE;
3049 pEngineState->fDetected = TRUE;
3050 }
3051
3052 void PlanTestDetectPatchInitialize(BURN_ENGINE_STATE* pEngineState)
3053 {
3054 HRESULT hr = MsiEngineDetectInitialize(&pEngineState->packages);
3055 NativeAssert::Succeeded(hr, "MsiEngineDetectInitialize failed");
3056
3057 for (DWORD i = 0; i < pEngineState->packages.cPackages; ++i)
3058 {
3059 BURN_PACKAGE* pPackage = pEngineState->packages.rgPackages + i;
3060
3061 if (BURN_PACKAGE_TYPE_MSP == pPackage->type)
3062 {
3063 for (DWORD j = 0; j < pPackage->Msp.cTargetProductCodes; ++j)
3064 {
3065 BURN_MSPTARGETPRODUCT* pTargetProduct = pPackage->Msp.rgTargetProducts + j;
3066
3067 if (BOOTSTRAPPER_PACKAGE_STATE_UNKNOWN == pTargetProduct->patchPackageState)
3068 {
3069 pTargetProduct->patchPackageState = BOOTSTRAPPER_PACKAGE_STATE_ABSENT;
3070 }
3071 }
3072 }
3073 }
3074 }
3075
3076 void DetectAttachedContainerAsAttached(BURN_ENGINE_STATE* pEngineState)
3077 {
3078 for (DWORD i = 0; i < pEngineState->containers.cContainers; ++i)
3079 {
3080 BURN_CONTAINER* pContainer = pEngineState->containers.rgContainers + i;
3081 if (pContainer->fAttached)
3082 {
3083 pContainer->fActuallyAttached = TRUE;
3084 }
3085 }
3086 }
3087
3088 void DetectCompatibleMsiPackage(BURN_ENGINE_STATE* pEngineState, BURN_PACKAGE* pPackage, LPCWSTR wzProductCode, LPCWSTR wzVersion)
3089 {
3090 HRESULT hr = S_OK;
3091 Assert(BOOTSTRAPPER_PACKAGE_STATE_PRESENT > pPackage->currentState);
3092 Assert(0 < pPackage->cDependencyProviders);
3093 BURN_DEPENDENCY_PROVIDER* pProvider = pPackage->rgDependencyProviders;
3094 BURN_COMPATIBLE_PACKAGE* pCompatiblePackage = &pPackage->compatiblePackage;
3095 pCompatiblePackage->fDetected = TRUE;
3096 pCompatiblePackage->fPlannable = TRUE;
3097 pCompatiblePackage->type = BURN_PACKAGE_TYPE_MSI;
3098
3099 hr = StrAllocFormatted(&pCompatiblePackage->sczCacheId, L"%lsv%ls", wzProductCode, wzVersion);
3100 NativeAssert::Succeeded(hr, "Failed to format cache id");
3101
3102 hr = StrAllocString(&pCompatiblePackage->Msi.sczVersion, wzVersion, 0);
3103 NativeAssert::Succeeded(hr, "Failed to copy MSI version");
3104
3105 hr = VerParseVersion(wzVersion, 0, FALSE, &pCompatiblePackage->Msi.pVersion);
3106 NativeAssert::Succeeded(hr, "Failed to parse MSI version");
3107
3108 hr = StrAllocString(&pCompatiblePackage->compatibleEntry.sczId, wzProductCode, 0);
3109 NativeAssert::Succeeded(hr, "Failed to copy product code");
3110
3111 hr = StrAllocString(&pCompatiblePackage->compatibleEntry.sczVersion, wzVersion, 0);
3112 NativeAssert::Succeeded(hr, "Failed to copy version");
3113
3114 hr = StrAllocString(&pCompatiblePackage->compatibleEntry.sczProviderKey, pProvider->sczKey, 0);
3115 NativeAssert::Succeeded(hr, "Failed to copy provider key");
3116
3117 DetectPackageDependent(pPackage, pEngineState->registration.sczId);
3118 }
3119
3120 void DetectPackageAsAbsent(BURN_PACKAGE* pPackage)
3121 {
3122 pPackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_ABSENT;
3123 if (pPackage->fCanAffectRegistration)
3124 {
3125 pPackage->cacheRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_ABSENT;
3126 pPackage->installRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_ABSENT;
3127 }
3128 }
3129
3130 void DetectPackageAsPresentAndCached(BURN_PACKAGE* pPackage)
3131 {
3132 pPackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_PRESENT;
3133 pPackage->fCached = TRUE;
3134 if (pPackage->fCanAffectRegistration)
3135 {
3136 pPackage->cacheRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_PRESENT;
3137 pPackage->installRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_PRESENT;
3138 }
3139 }
3140
3141 void DetectBundleDependent(BURN_ENGINE_STATE* pEngineState, LPCWSTR wzId)
3142 {
3143 HRESULT hr = S_OK;
3144 BURN_DEPENDENCIES* pDependencies = &pEngineState->dependencies;
3145 BURN_REGISTRATION* pRegistration = &pEngineState->registration;
3146
3147 hr = DepDependencyArrayAlloc(&pRegistration->rgDependents, &pRegistration->cDependents, wzId, NULL);
3148 NativeAssert::Succeeded(hr, "Failed to add package dependent");
3149
3150 if (pDependencies->fSelfDependent || pDependencies->fActiveParent)
3151 {
3152 if (pDependencies->fActiveParent && CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, pDependencies->wzActiveParent, -1, wzId, -1))
3153 {
3154 pRegistration->fParentRegisteredAsDependent = TRUE;
3155 }
3156
3157 if (pDependencies->fSelfDependent && CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, pDependencies->wzSelfDependent, -1, wzId, -1))
3158 {
3159 pRegistration->fSelfRegisteredAsDependent = TRUE;
3160 }
3161 }
3162 }
3163
3164 void DetectPackageDependent(BURN_PACKAGE* pPackage, LPCWSTR wzId)
3165 {
3166 HRESULT hr = S_OK;
3167
3168 for (DWORD i = 0; i < pPackage->cDependencyProviders; ++i)
3169 {
3170 BURN_DEPENDENCY_PROVIDER* pProvider = pPackage->rgDependencyProviders + i;
3171
3172 hr = DepDependencyArrayAlloc(&pProvider->rgDependents, &pProvider->cDependents, wzId, NULL);
3173 NativeAssert::Succeeded(hr, "Failed to add package dependent");
3174
3175 pProvider->fExists = TRUE;
3176 pProvider->fBundleRegisteredAsDependent = TRUE;
3177 }
3178 }
3179
3180 void DetectPackagesAsAbsent(BURN_ENGINE_STATE* pEngineState)
3181 {
3182 PlanTestDetect(pEngineState);
3183
3184 for (DWORD i = 0; i < pEngineState->packages.cPackages; ++i)
3185 {
3186 BURN_PACKAGE* pPackage = pEngineState->packages.rgPackages + i;
3187 DetectPackageAsAbsent(pPackage);
3188 }
3189 }
3190
3191 void DetectPackagesAsPresentAndCached(BURN_ENGINE_STATE* pEngineState)
3192 {
3193 PlanTestDetect(pEngineState);
3194
3195 pEngineState->registration.detectedRegistrationType = BOOTSTRAPPER_REGISTRATION_TYPE_FULL;
3196
3197 if (pEngineState->dependencies.wzSelfDependent)
3198 {
3199 DetectBundleDependent(pEngineState, pEngineState->dependencies.wzSelfDependent);
3200 }
3201
3202 for (DWORD i = 0; i < pEngineState->packages.cPackages; ++i)
3203 {
3204 BURN_PACKAGE* pPackage = pEngineState->packages.rgPackages + i;
3205 DetectPackageAsPresentAndCached(pPackage);
3206 DetectPackageDependent(pPackage, pEngineState->registration.sczId);
3207
3208 if (BURN_PACKAGE_TYPE_MSI == pPackage->type)
3209 {
3210 for (DWORD j = 0; j < pPackage->Msi.cSlipstreamMspPackages; ++j)
3211 {
3212 BURN_PACKAGE* pMspPackage = pPackage->Msi.rgSlipstreamMsps[j].pMspPackage;
3213 MspEngineAddDetectedTargetProduct(&pEngineState->packages, pMspPackage, j, pPackage->Msi.sczProductCode, pPackage->fPerMachine ? MSIINSTALLCONTEXT_MACHINE : MSIINSTALLCONTEXT_USERUNMANAGED);
3214
3215 BURN_MSPTARGETPRODUCT* pTargetProduct = pMspPackage->Msp.rgTargetProducts + (pMspPackage->Msp.cTargetProductCodes - 1);
3216 pTargetProduct->patchPackageState = BOOTSTRAPPER_PACKAGE_STATE_PRESENT;
3217 pTargetProduct->registrationState = BURN_PACKAGE_REGISTRATION_STATE_PRESENT;
3218 }
3219 }
3220 }
3221 }
3222
3223 void DetectPermanentPackagesAsPresentAndCached(BURN_ENGINE_STATE* pEngineState)
3224 {
3225 PlanTestDetect(pEngineState);
3226
3227 pEngineState->registration.detectedRegistrationType = BOOTSTRAPPER_REGISTRATION_TYPE_FULL;
3228
3229 for (DWORD i = 0; i < pEngineState->packages.cPackages; ++i)
3230 {
3231 BURN_PACKAGE* pPackage = pEngineState->packages.rgPackages + i;
3232 if (!pPackage->fPermanent)
3233 {
3234 DetectPackageAsAbsent(pPackage);
3235 }
3236 else
3237 {
3238 DetectPackageAsPresentAndCached(pPackage);
3239 DetectPackageDependent(pPackage, pEngineState->registration.sczId);
3240 }
3241 }
3242 }
3243
3244 BURN_RELATED_BUNDLE* DetectRelatedBundle(
3245 __in BURN_ENGINE_STATE* pEngineState,
3246 __in LPCWSTR wzId,
3247 __in LPCWSTR wzVersion,
3248 __in BOOTSTRAPPER_RELATION_TYPE relationType
3249 )
3250 {
3251 HRESULT hr = S_OK;
3252 BURN_RELATED_BUNDLES* pRelatedBundles = &pEngineState->registration.relatedBundles;
3253 BURN_DEPENDENCY_PROVIDER dependencyProvider = { };
3254 LPCWSTR wzFilePath = pEngineState->registration.sczExecutableName;
3255
3256 hr = StrAllocString(&dependencyProvider.sczKey, wzId, 0);
3257 NativeAssert::Succeeded(hr, "Failed to copy provider key");
3258
3259 hr = StrAllocString(&dependencyProvider.sczDisplayName, wzId, 0);
3260 NativeAssert::Succeeded(hr, "Failed to copy display name");
3261
3262 dependencyProvider.fImported = TRUE;
3263
3264 hr = StrAllocString(&dependencyProvider.sczVersion, wzVersion, 0);
3265 NativeAssert::Succeeded(hr, "Failed to copy version");
3266
3267 hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pRelatedBundles->rgRelatedBundles), pRelatedBundles->cRelatedBundles + 1, sizeof(BURN_RELATED_BUNDLE), 5);
3268 NativeAssert::Succeeded(hr, "Failed to ensure there is space for related bundles.");
3269
3270 BURN_RELATED_BUNDLE* pRelatedBundle = pRelatedBundles->rgRelatedBundles + pRelatedBundles->cRelatedBundles;
3271
3272 hr = VerParseVersion(wzVersion, 0, FALSE, &pRelatedBundle->pVersion);
3273 NativeAssert::Succeeded(hr, "Failed to parse pseudo bundle version: %ls", wzVersion);
3274
3275 pRelatedBundle->fPlannable = TRUE;
3276 pRelatedBundle->detectRelationType = relationType;
3277
3278 hr = PseudoBundleInitializeRelated(&pRelatedBundle->package, TRUE, TRUE, wzId,
3279 #ifdef DEBUG
3280 pRelatedBundle->detectRelationType,
3281 #endif
3282 TRUE, wzFilePath, 0, &dependencyProvider);
3283 NativeAssert::Succeeded(hr, "Failed to initialize related bundle to represent bundle: %ls", wzId);
3284
3285 ++pRelatedBundles->cRelatedBundles;
3286
3287 return pRelatedBundle;
3288 }
3289
3290 void DetectAsRelatedUpgradeBundle(
3291 __in BURN_ENGINE_STATE* pEngineState,
3292 __in LPCWSTR wzId,
3293 __in LPCWSTR wzVersion
3294 )
3295 {
3296 HRESULT hr = StrAllocString(&pEngineState->internalCommand.sczAncestors, wzId, 0);
3297 NativeAssert::Succeeded(hr, "Failed to set registration's ancestors");
3298
3299 hr = StrAllocFormatted(&pEngineState->registration.sczBundlePackageAncestors, L"%ls;%ls", wzId, pEngineState->registration.sczId);
3300 NativeAssert::Succeeded(hr, "Failed to set registration's package ancestors");
3301
3302 pEngineState->command.relationType = BOOTSTRAPPER_RELATION_UPGRADE;
3303
3304 DetectPackagesAsPresentAndCached(pEngineState);
3305 DetectRelatedBundle(pEngineState, wzId, wzVersion, BOOTSTRAPPER_RELATION_UPGRADE);
3306
3307 for (DWORD i = 0; i < pEngineState->packages.cPackages; ++i)
3308 {
3309 BURN_PACKAGE* pPackage = pEngineState->packages.rgPackages + i;
3310 DetectPackageDependent(pPackage, wzId);
3311 }
3312 }
3313
3314 void ValidateCacheContainer(
3315 __in BURN_PLAN* pPlan,
3316 __in BOOL fRollback,
3317 __in DWORD dwIndex,
3318 __in LPCWSTR wzContainerId
3319 )
3320 {
3321 BURN_CACHE_ACTION* pAction = ValidateCacheActionExists(pPlan, fRollback, dwIndex);
3322 Assert::Equal<DWORD>(BURN_CACHE_ACTION_TYPE_CONTAINER, pAction->type);
3323 NativeAssert::StringEqual(wzContainerId, pAction->container.pContainer->sczId);
3324 }
3325
3326 BURN_CACHE_ACTION* ValidateCacheActionExists(BURN_PLAN* pPlan, BOOL fRollback, DWORD dwIndex)
3327 {
3328 Assert::InRange(dwIndex + 1ul, 1ul, (fRollback ? pPlan->cRollbackCacheActions : pPlan->cCacheActions));
3329 return (fRollback ? pPlan->rgRollbackCacheActions : pPlan->rgCacheActions) + dwIndex;
3330 }
3331
3332 void ValidateCacheCheckpoint(
3333 __in BURN_PLAN* pPlan,
3334 __in BOOL fRollback,
3335 __in DWORD dwIndex,
3336 __in DWORD dwId
3337 )
3338 {
3339 BURN_CACHE_ACTION* pAction = ValidateCacheActionExists(pPlan, fRollback, dwIndex);
3340 Assert::Equal<DWORD>(BURN_CACHE_ACTION_TYPE_CHECKPOINT, pAction->type);
3341 Assert::Equal(dwId, pAction->checkpoint.dwId);
3342 }
3343
3344 void ValidateCacheLayoutBundle(
3345 __in BURN_PLAN* pPlan,
3346 __in BOOL fRollback,
3347 __in DWORD dwIndex
3348 )
3349 {
3350 BURN_CACHE_ACTION* pAction = ValidateCacheActionExists(pPlan, fRollback, dwIndex);
3351 Assert::Equal<DWORD>(BURN_CACHE_ACTION_TYPE_LAYOUT_BUNDLE, pAction->type);
3352 }
3353
3354 DWORD ValidateCachePackage(
3355 __in BURN_PLAN* pPlan,
3356 __in BOOL fRollback,
3357 __in DWORD dwIndex,
3358 __in LPCWSTR wzPackageId,
3359 __in BOOL fVital,
3360 __in BURN_CACHE_PACKAGE_TYPE executeCacheType,
3361 __in BURN_CACHE_PACKAGE_TYPE rollbackCacheType
3362 )
3363 {
3364 BURN_CACHE_ACTION* pAction = ValidateCacheActionExists(pPlan, fRollback, dwIndex);
3365 Assert::Equal<DWORD>(BURN_CACHE_ACTION_TYPE_PACKAGE, pAction->type);
3366 NativeAssert::StringEqual(wzPackageId, pAction->package.pPackage->sczId);
3367 Assert::Equal<BOOL>(fVital, pAction->package.pPackage->fCacheVital);
3368 Assert::Equal<DWORD>(executeCacheType, pAction->package.pPackage->executeCacheType);
3369 Assert::Equal<DWORD>(rollbackCacheType, pAction->package.pPackage->rollbackCacheType);
3370 return dwIndex + 1;
3371 }
3372
3373 void ValidateCacheRollbackPackage(
3374 __in BURN_PLAN* pPlan,
3375 __in BOOL fRollback,
3376 __in DWORD dwIndex,
3377 __in LPCWSTR wzPackageId
3378 )
3379 {
3380 BURN_CACHE_ACTION* pAction = ValidateCacheActionExists(pPlan, fRollback, dwIndex);
3381 Assert::Equal<DWORD>(BURN_CACHE_ACTION_TYPE_ROLLBACK_PACKAGE, pAction->type);
3382 NativeAssert::StringEqual(wzPackageId, pAction->rollbackPackage.pPackage->sczId);
3383 }
3384
3385 void ValidateCacheSignalSyncpoint(
3386 __in BURN_PLAN* pPlan,
3387 __in BOOL fRollback,
3388 __in DWORD dwIndex,
3389 __in LPCWSTR wzPackageId
3390 )
3391 {
3392 BURN_CACHE_ACTION* pAction = ValidateCacheActionExists(pPlan, fRollback, dwIndex);
3393 Assert::Equal<DWORD>(BURN_CACHE_ACTION_TYPE_SIGNAL_SYNCPOINT, pAction->type);
3394 NativeAssert::StringEqual(wzPackageId, pAction->syncpoint.pPackage->sczId);
3395 }
3396
3397 void ValidateCleanAction(
3398 __in BURN_PLAN* pPlan,
3399 __in DWORD dwIndex,
3400 __in LPCWSTR wzPackageId
3401 )
3402 {
3403 BURN_CLEAN_ACTION* pCleanAction = ValidateCleanActionExists(pPlan, dwIndex);
3404 Assert::Equal<DWORD>(BURN_CLEAN_ACTION_TYPE_PACKAGE, pCleanAction->type);
3405 Assert::NotEqual((DWORD_PTR)0, (DWORD_PTR)pCleanAction->pPackage);
3406 NativeAssert::StringEqual(wzPackageId, pCleanAction->pPackage->sczId);
3407 }
3408
3409 BURN_CLEAN_ACTION* ValidateCleanActionExists(BURN_PLAN* pPlan, DWORD dwIndex)
3410 {
3411 Assert::InRange(dwIndex + 1ul, 1ul, pPlan->cCleanActions);
3412 return pPlan->rgCleanActions + dwIndex;
3413 }
3414
3415 void ValidateCleanCompatibleAction(
3416 __in BURN_PLAN* pPlan,
3417 __in DWORD dwIndex,
3418 __in LPCWSTR wzPackageId
3419 )
3420 {
3421 BURN_CLEAN_ACTION* pCleanAction = ValidateCleanActionExists(pPlan, dwIndex);
3422 Assert::Equal<DWORD>(BURN_CLEAN_ACTION_TYPE_COMPATIBLE_PACKAGE, pCleanAction->type);
3423 Assert::NotEqual((DWORD_PTR)0, (DWORD_PTR)pCleanAction->pPackage);
3424 NativeAssert::StringEqual(wzPackageId, pCleanAction->pPackage->sczId);
3425 }
3426
3427 BURN_DEPENDENT_REGISTRATION_ACTION* ValidateDependentRegistrationActionExists(BURN_PLAN* pPlan, BOOL fRollback, DWORD dwIndex)
3428 {
3429 Assert::InRange(dwIndex + 1ul, 1ul, (fRollback ? pPlan->cRollbackRegistrationActions : pPlan->cRegistrationActions));
3430 return (fRollback ? pPlan->rgRollbackRegistrationActions : pPlan->rgRegistrationActions) + dwIndex;
3431 }
3432
3433 void ValidateDependentRegistrationAction(
3434 __in BURN_PLAN* pPlan,
3435 __in BOOL fRollback,
3436 __in DWORD dwIndex,
3437 __in BOOL fRegister,
3438 __in LPCWSTR wzBundleId,
3439 __in LPCWSTR wzProviderKey
3440 )
3441 {
3442 BURN_DEPENDENT_REGISTRATION_ACTION* pAction = ValidateDependentRegistrationActionExists(pPlan, fRollback, dwIndex);
3443 Assert::Equal<DWORD>(fRegister ? BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_REGISTER : BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_UNREGISTER, pAction->type);
3444 NativeAssert::StringEqual(wzBundleId, pAction->sczBundleId);
3445 NativeAssert::StringEqual(wzProviderKey, pAction->sczDependentProviderKey);
3446 }
3447
3448 BURN_EXECUTE_ACTION* ValidateExecuteActionExists(BURN_PLAN* pPlan, BOOL fRollback, DWORD dwIndex)
3449 {
3450 Assert::InRange(dwIndex + 1ul, 1ul, (fRollback ? pPlan->cRollbackActions : pPlan->cExecuteActions));
3451 return (fRollback ? pPlan->rgRollbackActions : pPlan->rgExecuteActions) + dwIndex;
3452 }
3453
3454 void ValidateExecuteBeginMsiTransaction(
3455 __in BURN_PLAN* pPlan,
3456 __in BOOL fRollback,
3457 __in DWORD dwIndex,
3458 __in LPCWSTR wzRollbackBoundaryId
3459 )
3460 {
3461 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3462 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_BEGIN_MSI_TRANSACTION, pAction->type);
3463 NativeAssert::StringEqual(wzRollbackBoundaryId, pAction->msiTransaction.pRollbackBoundary->sczId);
3464 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3465 }
3466
3467 void ValidateExecuteCheckpoint(
3468 __in BURN_PLAN* pPlan,
3469 __in BOOL fRollback,
3470 __in DWORD dwIndex,
3471 __in DWORD dwId
3472 )
3473 {
3474 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3475 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_CHECKPOINT, pAction->type);
3476 Assert::Equal(dwId, pAction->checkpoint.dwId);
3477 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3478 }
3479
3480 void ValidateExecuteCommitMsiTransaction(
3481 __in BURN_PLAN* pPlan,
3482 __in BOOL fRollback,
3483 __in DWORD dwIndex,
3484 __in LPCWSTR wzRollbackBoundaryId
3485 )
3486 {
3487 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3488 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_COMMIT_MSI_TRANSACTION, pAction->type);
3489 NativeAssert::StringEqual(wzRollbackBoundaryId, pAction->msiTransaction.pRollbackBoundary->sczId);
3490 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3491 }
3492
3493 void ValidateExecuteRelatedBundle(
3494 __in BURN_PLAN* pPlan,
3495 __in BOOL fRollback,
3496 __in DWORD dwIndex,
3497 __in LPCWSTR wzPackageId,
3498 __in BOOTSTRAPPER_ACTION_STATE action,
3499 __in LPCWSTR wzIgnoreDependencies
3500 )
3501 {
3502 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3503 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_RELATED_BUNDLE, pAction->type);
3504 NativeAssert::StringEqual(wzPackageId, pAction->relatedBundle.pRelatedBundle->package.sczId);
3505 Assert::Equal<DWORD>(action, pAction->relatedBundle.action);
3506 NativeAssert::StringEqual(wzIgnoreDependencies, pAction->relatedBundle.sczIgnoreDependencies);
3507 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3508 }
3509
3510 void ValidateExecuteBundlePackage(
3511 __in BURN_PLAN* pPlan,
3512 __in BOOL fRollback,
3513 __in DWORD dwIndex,
3514 __in LPCWSTR wzPackageId,
3515 __in BOOTSTRAPPER_ACTION_STATE action,
3516 __in LPCWSTR wzParent
3517 )
3518 {
3519 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3520 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_BUNDLE_PACKAGE, pAction->type);
3521 NativeAssert::StringEqual(wzPackageId, pAction->bundlePackage.pPackage->sczId);
3522 Assert::Equal<DWORD>(action, pAction->bundlePackage.action);
3523 NativeAssert::StringEqual(wzParent, pAction->bundlePackage.sczParent);
3524 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3525 }
3526
3527 void ValidateExecuteExePackage(
3528 __in BURN_PLAN* pPlan,
3529 __in BOOL fRollback,
3530 __in DWORD dwIndex,
3531 __in LPCWSTR wzPackageId,
3532 __in BOOTSTRAPPER_ACTION_STATE action
3533 )
3534 {
3535 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3536 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_EXE_PACKAGE, pAction->type);
3537 NativeAssert::StringEqual(wzPackageId, pAction->exePackage.pPackage->sczId);
3538 Assert::Equal<DWORD>(action, pAction->exePackage.action);
3539 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3540 }
3541
3542 void ValidateExecuteMsiPackage(
3543 __in BURN_PLAN* pPlan,
3544 __in BOOL fRollback,
3545 __in DWORD dwIndex,
3546 __in_z LPCWSTR wzPackageId,
3547 __in BOOTSTRAPPER_ACTION_STATE action,
3548 __in BURN_MSI_PROPERTY actionMsiProperty,
3549 __in DWORD uiLevel,
3550 __in BOOL fDisableExternalUiHandler,
3551 __in BOOTSTRAPPER_MSI_FILE_VERSIONING fileVersioning,
3552 __in DWORD dwLoggingAttributes
3553 )
3554 {
3555 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3556 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE, pAction->type);
3557 NativeAssert::StringEqual(wzPackageId, pAction->msiPackage.pPackage->sczId);
3558 Assert::Equal<DWORD>(action, pAction->msiPackage.action);
3559 Assert::Equal<DWORD>(actionMsiProperty, pAction->msiPackage.actionMsiProperty);
3560 Assert::Equal<DWORD>(uiLevel, pAction->msiPackage.uiLevel);
3561 Assert::Equal<BOOL>(fDisableExternalUiHandler, pAction->msiPackage.fDisableExternalUiHandler);
3562 Assert::Equal<DWORD>(fileVersioning, pAction->msiPackage.fileVersioning);
3563 NativeAssert::NotNull(pAction->msiPackage.sczLogPath);
3564 Assert::Equal<DWORD>(dwLoggingAttributes, pAction->msiPackage.dwLoggingAttributes);
3565 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3566 }
3567
3568 BURN_EXECUTE_ACTION* ValidateDeletedExecuteMspTarget(
3569 __in BURN_PLAN* pPlan,
3570 __in BOOL fRollback,
3571 __in DWORD dwIndex,
3572 __in_z LPCWSTR wzPackageId,
3573 __in BOOTSTRAPPER_ACTION_STATE action,
3574 __in_z LPCWSTR wzTargetProductCode,
3575 __in BOOL fPerMachineTarget,
3576 __in BURN_MSI_PROPERTY actionMsiProperty,
3577 __in DWORD uiLevel,
3578 __in BOOL fDisableExternalUiHandler,
3579 __in BOOTSTRAPPER_MSI_FILE_VERSIONING fileVersioning,
3580 __in BOOL fDeleted
3581 )
3582 {
3583 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3584 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_MSP_TARGET, pAction->type);
3585 NativeAssert::StringEqual(wzPackageId, pAction->mspTarget.pPackage->sczId);
3586 Assert::Equal<DWORD>(action, pAction->mspTarget.action);
3587 NativeAssert::StringEqual(wzTargetProductCode, pAction->mspTarget.sczTargetProductCode);
3588 Assert::Equal<BOOL>(fPerMachineTarget, pAction->mspTarget.fPerMachineTarget);
3589 Assert::Equal<DWORD>(actionMsiProperty, pAction->mspTarget.actionMsiProperty);
3590 Assert::Equal<DWORD>(uiLevel, pAction->mspTarget.uiLevel);
3591 Assert::Equal<BOOL>(fDisableExternalUiHandler, pAction->mspTarget.fDisableExternalUiHandler);
3592 Assert::Equal<DWORD>(fileVersioning, pAction->mspTarget.fileVersioning);
3593 NativeAssert::NotNull(pAction->mspTarget.sczLogPath);
3594 Assert::Equal<BOOL>(fDeleted, pAction->fDeleted);
3595 return pAction;
3596 }
3597
3598 void ValidateExecuteMspTargetPatch(
3599 __in BURN_EXECUTE_ACTION* pAction,
3600 __in DWORD dwIndex,
3601 __in_z LPCWSTR wzPackageId
3602 )
3603 {
3604 Assert::InRange(dwIndex + 1ul, 1ul, pAction->mspTarget.cOrderedPatches);
3605 BURN_ORDERED_PATCHES* pOrderedPatch = pAction->mspTarget.rgOrderedPatches + dwIndex;
3606 NativeAssert::StringEqual(wzPackageId, pOrderedPatch->pPackage->sczId);
3607 }
3608
3609 void ValidateExecuteMsuPackage(
3610 __in BURN_PLAN* pPlan,
3611 __in BOOL fRollback,
3612 __in DWORD dwIndex,
3613 __in LPCWSTR wzPackageId,
3614 __in BOOTSTRAPPER_ACTION_STATE action
3615 )
3616 {
3617 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3618 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_MSU_PACKAGE, pAction->type);
3619 NativeAssert::StringEqual(wzPackageId, pAction->msuPackage.pPackage->sczId);
3620 Assert::Equal<DWORD>(action, pAction->msuPackage.action);
3621 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3622 }
3623
3624 void ValidateExecutePackageDependency(
3625 __in BURN_PLAN* pPlan,
3626 __in BOOL fRollback,
3627 __in DWORD dwIndex,
3628 __in LPCWSTR wzPackageId,
3629 __in LPCWSTR wzBundleProviderKey,
3630 __in BURN_DEPENDENCY_ACTION* rgActions,
3631 __in DWORD cActions
3632 )
3633 {
3634 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3635 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_PACKAGE_DEPENDENCY, pAction->type);
3636 NativeAssert::StringEqual(wzPackageId, pAction->packageDependency.pPackage->sczId);
3637 NativeAssert::StringEqual(wzBundleProviderKey, pAction->packageDependency.sczBundleProviderKey);
3638 Assert::Equal<DWORD>(cActions, pAction->packageProvider.pPackage->cDependencyProviders);
3639 for (DWORD i = 0; i < cActions; ++i)
3640 {
3641 const BURN_DEPENDENCY_PROVIDER* pProvider = pAction->packageProvider.pPackage->rgDependencyProviders + i;
3642 Assert::Equal<DWORD>(rgActions[i], fRollback ? pProvider->dependentRollback : pProvider->dependentExecute);
3643 }
3644 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3645 }
3646
3647 void ValidateExecutePackageProvider(
3648 __in BURN_PLAN* pPlan,
3649 __in BOOL fRollback,
3650 __in DWORD dwIndex,
3651 __in LPCWSTR wzPackageId,
3652 __in BURN_DEPENDENCY_ACTION* rgActions,
3653 __in DWORD cActions
3654 )
3655 {
3656 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3657 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_PACKAGE_PROVIDER, pAction->type);
3658 NativeAssert::StringEqual(wzPackageId, pAction->packageProvider.pPackage->sczId);
3659 Assert::Equal<DWORD>(cActions, pAction->packageProvider.pPackage->cDependencyProviders);
3660 for (DWORD i = 0; i < cActions; ++i)
3661 {
3662 const BURN_DEPENDENCY_PROVIDER* pProvider = pAction->packageProvider.pPackage->rgDependencyProviders + i;
3663 Assert::Equal<DWORD>(rgActions[i], fRollback ? pProvider->providerRollback : pProvider->providerExecute);
3664 }
3665 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3666 }
3667
3668 void ValidateExecuteRollbackBoundaryStart(
3669 __in BURN_PLAN* pPlan,
3670 __in BOOL fRollback,
3671 __in DWORD dwIndex,
3672 __in LPCWSTR wzId,
3673 __in BOOL fVital,
3674 __in BOOL fTransaction
3675 )
3676 {
3677 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3678 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY_START, pAction->type);
3679 NativeAssert::StringEqual(wzId, pAction->rollbackBoundary.pRollbackBoundary->sczId);
3680 Assert::Equal<BOOL>(fVital, pAction->rollbackBoundary.pRollbackBoundary->fVital);
3681 Assert::Equal<BOOL>(fTransaction, pAction->rollbackBoundary.pRollbackBoundary->fTransaction);
3682 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3683 }
3684
3685 void ValidateExecuteRollbackBoundaryEnd(
3686 __in BURN_PLAN* pPlan,
3687 __in BOOL fRollback,
3688 __in DWORD dwIndex
3689 )
3690 {
3691 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3692 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY_END, pAction->type);
3693 Assert::Equal<size_t>(NULL, (size_t)(pAction->rollbackBoundary.pRollbackBoundary));
3694 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3695 }
3696
3697 void ValidateExecuteUncachePackage(
3698 __in BURN_PLAN* pPlan,
3699 __in BOOL fRollback,
3700 __in DWORD dwIndex,
3701 __in LPCWSTR wzPackageId
3702 )
3703 {
3704 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3705 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_UNCACHE_PACKAGE, pAction->type);
3706 NativeAssert::StringEqual(wzPackageId, pAction->uncachePackage.pPackage->sczId);
3707 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3708 }
3709
3710 void ValidateExecuteWaitCachePackage(
3711 __in BURN_PLAN* pPlan,
3712 __in BOOL fRollback,
3713 __in DWORD dwIndex,
3714 __in_z LPCWSTR wzPackageId
3715 )
3716 {
3717 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3718 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_WAIT_CACHE_PACKAGE, pAction->type);
3719 NativeAssert::StringEqual(wzPackageId, pAction->waitCachePackage.pPackage->sczId);
3720 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3721 }
3722
3723 void ValidateNonPermanentPackageExpectedStates(
3724 __in BURN_PACKAGE* pPackage,
3725 __in_z LPCWSTR wzPackageId,
3726 __in BURN_PACKAGE_REGISTRATION_STATE expectedCacheState,
3727 __in BURN_PACKAGE_REGISTRATION_STATE expectedInstallState
3728 )
3729 {
3730 NativeAssert::StringEqual(wzPackageId, pPackage->sczId);
3731 Assert::Equal<BOOL>(TRUE, pPackage->fCanAffectRegistration);
3732 Assert::Equal<DWORD>(expectedCacheState, pPackage->expectedCacheRegistrationState);
3733 Assert::Equal<DWORD>(expectedInstallState, pPackage->expectedInstallRegistrationState);
3734 }
3735
3736 void ValidatePermanentPackageExpectedStates(
3737 __in BURN_PACKAGE* pPackage,
3738 __in_z LPCWSTR wzPackageId
3739 )
3740 {
3741 NativeAssert::StringEqual(wzPackageId, pPackage->sczId);
3742 Assert::Equal<BOOL>(FALSE, pPackage->fCanAffectRegistration);
3743 Assert::Equal<DWORD>(BURN_PACKAGE_REGISTRATION_STATE_UNKNOWN, pPackage->expectedCacheRegistrationState);
3744 Assert::Equal<DWORD>(BURN_PACKAGE_REGISTRATION_STATE_UNKNOWN, pPackage->expectedInstallRegistrationState);
3745 }
3746
3747 void ValidatePlannedProvider(
3748 __in BURN_PLAN* pPlan,
3749 __in UINT uIndex,
3750 __in LPCWSTR wzKey,
3751 __in LPCWSTR wzName
3752 )
3753 {
3754 Assert::InRange(uIndex + 1u, 1u, pPlan->cPlannedProviders);
3755
3756 DEPENDENCY* pProvider = pPlan->rgPlannedProviders + uIndex;
3757 NativeAssert::StringEqual(wzKey, pProvider->sczKey);
3758 NativeAssert::StringEqual(wzName, pProvider->sczName);
3759 }
3760
3761 void ValidateRestoreRelatedBundle(
3762 __in BURN_PLAN* pPlan,
3763 __in DWORD dwIndex,
3764 __in LPCWSTR wzPackageId,
3765 __in BOOTSTRAPPER_ACTION_STATE action,
3766 __in LPCWSTR wzIgnoreDependencies
3767 )
3768 {
3769 BURN_EXECUTE_ACTION* pAction = ValidateRestoreRelatedBundleActionExists(pPlan, dwIndex);
3770 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_RELATED_BUNDLE, pAction->type);
3771 NativeAssert::StringEqual(wzPackageId, pAction->relatedBundle.pRelatedBundle->package.sczId);
3772 Assert::Equal<DWORD>(action, pAction->relatedBundle.action);
3773 NativeAssert::StringEqual(wzIgnoreDependencies, pAction->relatedBundle.sczIgnoreDependencies);
3774 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3775 }
3776
3777 BURN_EXECUTE_ACTION* ValidateRestoreRelatedBundleActionExists(BURN_PLAN* pPlan, DWORD dwIndex)
3778 {
3779 Assert::InRange(dwIndex + 1ul, 1ul, pPlan->cRestoreRelatedBundleActions);
3780 return pPlan->rgRestoreRelatedBundleActions + dwIndex;
3781 }
3782
3783 void ValidateUninstallMsiCompatiblePackage(
3784 __in BURN_PLAN* pPlan,
3785 __in BOOL fRollback,
3786 __in DWORD dwIndex,
3787 __in_z LPCWSTR wzPackageId,
3788 __in DWORD dwLoggingAttributes
3789 )
3790 {
3791 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
3792 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_UNINSTALL_MSI_COMPATIBLE_PACKAGE, pAction->type);
3793 NativeAssert::StringEqual(wzPackageId, pAction->uninstallMsiCompatiblePackage.pParentPackage->sczId);
3794 NativeAssert::NotNull(pAction->msiPackage.sczLogPath);
3795 Assert::Equal<DWORD>(dwLoggingAttributes, pAction->uninstallMsiCompatiblePackage.dwLoggingAttributes);
3796 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
3797 }
3798 };
3799 }
3800 }
3801 }
3802 }
3803 }
3804
3805 #if TODO_REIMPLEMENT
3806
3807 static HRESULT WINAPI PlanTestBAProc(
3808 __in BOOTSTRAPPER_APPLICATION_MESSAGE message,
3809 __in const LPVOID /*pvArgs*/,
3810 __inout LPVOID pvResults,
3811 __in_opt LPVOID /*pvContext*/
3812 )
3813 {
3814 switch (message)
3815 {
3816 case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANPACKAGEBEGIN:
3817 if (vfUsePackageRequestState)
3818 {
3819 BA_ONPLANPACKAGEBEGIN_RESULTS* pResults = reinterpret_cast<BA_ONPLANPACKAGEBEGIN_RESULTS*>(pvResults);
3820 pResults->requestedState = vPackageRequestState;
3821 }
3822 break;
3823 case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANRELATEDBUNDLE:
3824 if (vfUseRelatedBundleRequestState)
3825 {
3826 BA_ONPLANRELATEDBUNDLE_RESULTS* pResults = reinterpret_cast<BA_ONPLANRELATEDBUNDLE_RESULTS*>(pvResults);
3827 pResults->requestedState = vRelatedBundleRequestState;
3828 }
3829 break;
3830 case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANRELATEDBUNDLETYPE:
3831 if (vfUseRelatedBundlePlanType)
3832 {
3833 BA_ONPLANRELATEDBUNDLETYPE_RESULTS* pResults = reinterpret_cast<BA_ONPLANRELATEDBUNDLETYPE_RESULTS*>(pvResults);
3834 pResults->requestedType = vRelatedBundlePlanType;
3835 }
3836 break;
3837 }
3838
3839 return S_OK;
3840 }
3841
3842 #endif