aboutsummaryrefslogtreecommitdiff
path: root/src/burn/test/BurnUnitTest/PlanTest.cpp
diff options
context:
space:
mode:
authorRob Mensching <rob@firegiant.com>2021-05-11 07:42:44 -0700
committerRob Mensching <rob@firegiant.com>2021-05-11 07:42:44 -0700
commitafc20ecb53ad3ade524aceefa30d98a3d84fd479 (patch)
tree4fb762f65dc195ccb104a6c1fcce7c40e7693e98 /src/burn/test/BurnUnitTest/PlanTest.cpp
parent8e1207c4c5e451ba1a087f0fa11b63964ac35f3c (diff)
parentaf10c45d7b3a44af0b461a557847fe03263dcc10 (diff)
downloadwix-afc20ecb53ad3ade524aceefa30d98a3d84fd479.tar.gz
wix-afc20ecb53ad3ade524aceefa30d98a3d84fd479.tar.bz2
wix-afc20ecb53ad3ade524aceefa30d98a3d84fd479.zip
Merge burn
Diffstat (limited to 'src/burn/test/BurnUnitTest/PlanTest.cpp')
-rw-r--r--src/burn/test/BurnUnitTest/PlanTest.cpp1473
1 files changed, 1473 insertions, 0 deletions
diff --git a/src/burn/test/BurnUnitTest/PlanTest.cpp b/src/burn/test/BurnUnitTest/PlanTest.cpp
new file mode 100644
index 00000000..a7c1d83c
--- /dev/null
+++ b/src/burn/test/BurnUnitTest/PlanTest.cpp
@@ -0,0 +1,1473 @@
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
5static 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
12static LPCWSTR wzMsiTransactionManifestFileName = L"MsiTransaction_BundleAv1_manifest.xml";
13static LPCWSTR wzSingleMsiManifestFileName = L"BasicFunctionality_BundleA_manifest.xml";
14static LPCWSTR wzSlipstreamManifestFileName = L"Slipstream_BundleA_manifest.xml";
15
16namespace Microsoft
17{
18namespace Tools
19{
20namespace WindowsInstallerXml
21{
22namespace Test
23{
24namespace Bootstrapper
25{
26 using namespace System;
27 using namespace Xunit;
28
29 public ref class PlanTest : BurnUnitTest
30 {
31 public:
32 PlanTest(BurnTestFixture^ fixture) : BurnUnitTest(fixture)
33 {
34 }
35
36 [Fact]
37 void MsiTransactionInstallTest()
38 {
39 HRESULT hr = S_OK;
40 BURN_ENGINE_STATE engineState = { };
41 BURN_ENGINE_STATE* pEngineState = &engineState;
42 BURN_PLAN* pPlan = &engineState.plan;
43
44 InitializeEngineStateForCorePlan(wzMsiTransactionManifestFileName, pEngineState);
45 DetectPackagesAsAbsent(pEngineState);
46 DetectUpgradeBundle(pEngineState, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", L"1.0.0.0");
47
48 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
49 NativeAssert::Succeeded(hr, "CorePlan failed");
50
51 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
52 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
53 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
54
55 BOOL fRollback = FALSE;
56 DWORD dwIndex = 0;
57 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
58 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
59 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++);
60 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 9);
61 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageB");
62 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++);
63 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 14);
64 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageC");
65 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++);
66 Assert::Equal(dwIndex, pPlan->cCacheActions);
67
68 fRollback = TRUE;
69 dwIndex = 0;
70 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
71 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
72
73 Assert::Equal(107082ull, pPlan->qwEstimatedSize);
74 Assert::Equal(506145ull, pPlan->qwCacheSizeTotal);
75
76 fRollback = FALSE;
77 dwIndex = 0;
78 DWORD dwExecuteCheckpointId = 2;
79 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
80 ValidateExecuteWaitSyncpoint(pPlan, fRollback, dwIndex++, pPlan->rgCacheActions[2].syncpoint.hEvent);
81 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
82 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
83 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", BURN_DEPENDENCY_ACTION_REGISTER);
84 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
85 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
86 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
87 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", BURN_DEPENDENCY_ACTION_REGISTER);
88 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
89 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
90 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ", TRUE, TRUE);
91 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
92 ValidateExecuteBeginMsiTransaction(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ");
93 ValidateExecuteWaitSyncpoint(pPlan, fRollback, dwIndex++, pPlan->rgCacheActions[5].syncpoint.hEvent);
94 dwExecuteCheckpointId += 1; // cache checkpoints
95 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
96 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
97 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageB", BURN_DEPENDENCY_ACTION_REGISTER);
98 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageB", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
99 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
100 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageB", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", BURN_DEPENDENCY_ACTION_REGISTER);
101 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
102 ValidateExecuteWaitSyncpoint(pPlan, fRollback, dwIndex++, pPlan->rgCacheActions[8].syncpoint.hEvent);
103 dwExecuteCheckpointId += 1; // cache checkpoints
104 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
105 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
106 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageC", BURN_DEPENDENCY_ACTION_REGISTER);
107 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageC", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
108 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
109 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageC", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", BURN_DEPENDENCY_ACTION_REGISTER);
110 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
111 ValidateExecuteCommitMsiTransaction(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ");
112 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
113 ValidateExecuteExePackage(pPlan, fRollback, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, NULL);
114 Assert::Equal(dwIndex, pPlan->cExecuteActions);
115
116 fRollback = TRUE;
117 dwIndex = 0;
118 dwExecuteCheckpointId = 2;
119 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
120 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
121 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
122 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", BURN_DEPENDENCY_ACTION_UNREGISTER);
123 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
124 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
125 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
126 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", BURN_DEPENDENCY_ACTION_UNREGISTER);
127 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
128 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
129 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
130 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ", TRUE, TRUE);
131 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
132 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PackageB");
133 dwExecuteCheckpointId += 1; // cache checkpoints
134 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
135 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageB", BURN_DEPENDENCY_ACTION_UNREGISTER);
136 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
137 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageB", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", BURN_DEPENDENCY_ACTION_UNREGISTER);
138 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
139 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
140 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PackageC");
141 dwExecuteCheckpointId += 1; // cache checkpoints
142 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
143 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageC", BURN_DEPENDENCY_ACTION_UNREGISTER);
144 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
145 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageC", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", BURN_DEPENDENCY_ACTION_UNREGISTER);
146 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
147 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
148 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
149 ValidateExecuteExePackage(pPlan, fRollback, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
150 Assert::Equal(dwIndex, pPlan->cRollbackActions);
151
152 Assert::Equal(4ul, pPlan->cExecutePackagesTotal);
153 Assert::Equal(7ul, pPlan->cOverallProgressTicksTotal);
154
155 dwIndex = 0;
156 Assert::Equal(dwIndex, pPlan->cCleanActions);
157
158 UINT uIndex = 0;
159 ValidatePlannedProvider(pPlan, uIndex++, L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", NULL);
160 Assert::Equal(uIndex, pPlan->cPlannedProviders);
161
162 Assert::Equal(3ul, pEngineState->packages.cPackages);
163 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
164 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"PackageB", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
165 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[2], L"PackageC", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
166 }
167
168 [Fact]
169 void MsiTransactionUninstallTest()
170 {
171 HRESULT hr = S_OK;
172 BURN_ENGINE_STATE engineState = { };
173 BURN_ENGINE_STATE* pEngineState = &engineState;
174 BURN_PLAN* pPlan = &engineState.plan;
175
176 InitializeEngineStateForCorePlan(wzMsiTransactionManifestFileName, pEngineState);
177 DetectPackagesAsPresentAndCached(pEngineState);
178
179 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNINSTALL);
180 NativeAssert::Succeeded(hr, "CorePlan failed");
181
182 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNINSTALL, pPlan->action);
183 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
184 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
185
186 BOOL fRollback = FALSE;
187 DWORD dwIndex = 0;
188 Assert::Equal(dwIndex, pPlan->cCacheActions);
189
190 fRollback = TRUE;
191 dwIndex = 0;
192 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
193
194 Assert::Equal(0ull, pPlan->qwEstimatedSize);
195 Assert::Equal(0ull, pPlan->qwCacheSizeTotal);
196
197 fRollback = FALSE;
198 dwIndex = 0;
199 DWORD dwExecuteCheckpointId = 1;
200 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ", TRUE, TRUE);
201 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
202 ValidateExecuteBeginMsiTransaction(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ");
203 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
204 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageC", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", BURN_DEPENDENCY_ACTION_UNREGISTER);
205 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
206 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageC", BURN_DEPENDENCY_ACTION_UNREGISTER);
207 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageC", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
208 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
209 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
210 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageB", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", BURN_DEPENDENCY_ACTION_UNREGISTER);
211 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
212 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageB", BURN_DEPENDENCY_ACTION_UNREGISTER);
213 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageB", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
214 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
215 ValidateExecuteCommitMsiTransaction(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ");
216 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
217 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
218 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
219 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", BURN_DEPENDENCY_ACTION_UNREGISTER);
220 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
221 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", BURN_DEPENDENCY_ACTION_UNREGISTER);
222 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
223 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
224 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
225 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
226 Assert::Equal(dwIndex, pPlan->cExecuteActions);
227
228 fRollback = TRUE;
229 dwIndex = 0;
230 dwExecuteCheckpointId = 1;
231 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ", TRUE, TRUE);
232 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
233 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageC", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", BURN_DEPENDENCY_ACTION_REGISTER);
234 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
235 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageC", BURN_DEPENDENCY_ACTION_REGISTER);
236 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
237 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
238 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageB", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", BURN_DEPENDENCY_ACTION_REGISTER);
239 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
240 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageB", BURN_DEPENDENCY_ACTION_REGISTER);
241 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
242 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
243 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
244 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
245 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", BURN_DEPENDENCY_ACTION_REGISTER);
246 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
247 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", BURN_DEPENDENCY_ACTION_REGISTER);
248 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
249 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
250 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
251 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
252 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
253 Assert::Equal(dwIndex, pPlan->cRollbackActions);
254
255 Assert::Equal(3ul, pPlan->cExecutePackagesTotal);
256 Assert::Equal(3ul, pPlan->cOverallProgressTicksTotal);
257
258 dwIndex = 0;
259 ValidateCleanAction(pPlan, dwIndex++, L"PackageC");
260 ValidateCleanAction(pPlan, dwIndex++, L"PackageB");
261 ValidateCleanAction(pPlan, dwIndex++, L"PackageA");
262 Assert::Equal(dwIndex, pPlan->cCleanActions);
263
264 UINT uIndex = 0;
265 ValidatePlannedProvider(pPlan, uIndex++, L"{E6469F05-BDC8-4EB8-B218-67412543EFAA}", NULL);
266 ValidatePlannedProvider(pPlan, uIndex++, L"{A497C5E5-C78B-4F0B-BF72-B33E1DB1C4B8}", NULL);
267 ValidatePlannedProvider(pPlan, uIndex++, L"{D1D01094-23CE-4AF0-84B6-4A1A133F21D3}", NULL);
268 ValidatePlannedProvider(pPlan, uIndex++, L"{01E6B748-7B95-4BA9-976D-B6F35076CEF4}", NULL);
269 Assert::Equal(uIndex, pPlan->cPlannedProviders);
270
271 Assert::Equal(3ul, pEngineState->packages.cPackages);
272 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
273 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"PackageB", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
274 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[2], L"PackageC", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
275 }
276
277 [Fact]
278 void RelatedBundleMissingFromCacheTest()
279 {
280 HRESULT hr = S_OK;
281 BURN_ENGINE_STATE engineState = { };
282 BURN_ENGINE_STATE* pEngineState = &engineState;
283 BURN_PLAN* pPlan = &engineState.plan;
284
285 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
286 DetectAttachedContainerAsAttached(pEngineState);
287 DetectPackagesAsAbsent(pEngineState);
288 BURN_RELATED_BUNDLE* pRelatedBundle = DetectUpgradeBundle(pEngineState, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", L"0.9.0.0");
289 pRelatedBundle->fPlannable = FALSE;
290
291 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
292 NativeAssert::Succeeded(hr, "CorePlan failed");
293
294 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
295 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
296 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
297
298 BOOL fRollback = FALSE;
299 DWORD dwIndex = 0;
300 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
301 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
302 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++);
303 Assert::Equal(dwIndex, pPlan->cCacheActions);
304
305 fRollback = TRUE;
306 dwIndex = 0;
307 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
308 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
309
310 Assert::Equal(35694ull, pPlan->qwEstimatedSize);
311 Assert::Equal(168715ull, pPlan->qwCacheSizeTotal);
312
313 fRollback = FALSE;
314 dwIndex = 0;
315 DWORD dwExecuteCheckpointId = 2;
316 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
317 ValidateExecuteWaitSyncpoint(pPlan, fRollback, dwIndex++, pPlan->rgCacheActions[2].syncpoint.hEvent);
318 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
319 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
320 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", BURN_DEPENDENCY_ACTION_REGISTER);
321 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
322 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
323 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
324 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", BURN_DEPENDENCY_ACTION_REGISTER);
325 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
326 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
327 Assert::Equal(dwIndex, pPlan->cExecuteActions);
328
329 fRollback = TRUE;
330 dwIndex = 0;
331 dwExecuteCheckpointId = 2;
332 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
333 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
334 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
335 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", BURN_DEPENDENCY_ACTION_UNREGISTER);
336 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
337 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
338 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
339 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", BURN_DEPENDENCY_ACTION_UNREGISTER);
340 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
341 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
342 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
343 Assert::Equal(dwIndex, pPlan->cRollbackActions);
344
345 Assert::Equal(1ul, pPlan->cExecutePackagesTotal);
346 Assert::Equal(2ul, pPlan->cOverallProgressTicksTotal);
347
348 dwIndex = 0;
349 Assert::Equal(dwIndex, pPlan->cCleanActions);
350
351 UINT uIndex = 0;
352 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
353 Assert::Equal(uIndex, pPlan->cPlannedProviders);
354
355 Assert::Equal(1ul, pEngineState->packages.cPackages);
356 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
357 }
358
359 [Fact]
360 void SingleMsiCacheTest()
361 {
362 HRESULT hr = S_OK;
363 BURN_ENGINE_STATE engineState = { };
364 BURN_ENGINE_STATE* pEngineState = &engineState;
365 BURN_PLAN* pPlan = &engineState.plan;
366
367 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
368 DetectAttachedContainerAsAttached(pEngineState);
369 DetectPackagesAsAbsent(pEngineState);
370 DetectUpgradeBundle(pEngineState, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", L"0.9.0.0");
371
372 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_CACHE);
373 NativeAssert::Succeeded(hr, "CorePlan failed");
374
375 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_CACHE, pPlan->action);
376 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
377 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
378
379 BOOL fRollback = FALSE;
380 DWORD dwIndex = 0;
381 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
382 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
383 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++);
384 Assert::Equal(dwIndex, pPlan->cCacheActions);
385
386 fRollback = TRUE;
387 dwIndex = 0;
388 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
389
390 Assert::Equal(33743ull, pPlan->qwEstimatedSize);
391 Assert::Equal(168715ull, pPlan->qwCacheSizeTotal);
392
393 fRollback = FALSE;
394 dwIndex = 0;
395 DWORD dwExecuteCheckpointId = 2;
396 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
397 ValidateExecuteWaitSyncpoint(pPlan, fRollback, dwIndex++, pPlan->rgCacheActions[2].syncpoint.hEvent);
398 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
399 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
400 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
401 Assert::Equal(dwIndex, pPlan->cExecuteActions);
402
403 fRollback = TRUE;
404 dwIndex = 0;
405 dwExecuteCheckpointId = 2;
406 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
407 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
408 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
409 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", BURN_DEPENDENCY_ACTION_UNREGISTER);
410 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
411 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
412 Assert::Equal(dwIndex, pPlan->cRollbackActions);
413
414 Assert::Equal(0ul, pPlan->cExecutePackagesTotal);
415 Assert::Equal(1ul, pPlan->cOverallProgressTicksTotal);
416
417 dwIndex = 0;
418 Assert::Equal(dwIndex, pPlan->cCleanActions);
419
420 UINT uIndex = 0;
421 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
422 Assert::Equal(uIndex, pPlan->cPlannedProviders);
423
424 Assert::Equal(1ul, pEngineState->packages.cPackages);
425 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
426 }
427
428 [Fact]
429 void SingleMsiInstallTest()
430 {
431 HRESULT hr = S_OK;
432 BURN_ENGINE_STATE engineState = { };
433 BURN_ENGINE_STATE* pEngineState = &engineState;
434 BURN_PLAN* pPlan = &engineState.plan;
435
436 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
437 DetectAttachedContainerAsAttached(pEngineState);
438 DetectPackagesAsAbsent(pEngineState);
439 DetectUpgradeBundle(pEngineState, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", L"0.9.0.0");
440
441 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
442 NativeAssert::Succeeded(hr, "CorePlan failed");
443
444 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
445 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
446 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
447
448 BOOL fRollback = FALSE;
449 DWORD dwIndex = 0;
450 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
451 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
452 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++);
453 Assert::Equal(dwIndex, pPlan->cCacheActions);
454
455 fRollback = TRUE;
456 dwIndex = 0;
457 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
458 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
459
460 Assert::Equal(35694ull, pPlan->qwEstimatedSize);
461 Assert::Equal(168715ull, pPlan->qwCacheSizeTotal);
462
463 fRollback = FALSE;
464 dwIndex = 0;
465 DWORD dwExecuteCheckpointId = 2;
466 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
467 ValidateExecuteWaitSyncpoint(pPlan, fRollback, dwIndex++, pPlan->rgCacheActions[2].syncpoint.hEvent);
468 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
469 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
470 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", BURN_DEPENDENCY_ACTION_REGISTER);
471 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
472 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
473 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
474 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", BURN_DEPENDENCY_ACTION_REGISTER);
475 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
476 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
477 ValidateExecuteExePackage(pPlan, fRollback, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, NULL);
478 Assert::Equal(dwIndex, pPlan->cExecuteActions);
479
480 fRollback = TRUE;
481 dwIndex = 0;
482 dwExecuteCheckpointId = 2;
483 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
484 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
485 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
486 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", BURN_DEPENDENCY_ACTION_UNREGISTER);
487 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
488 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
489 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
490 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", BURN_DEPENDENCY_ACTION_UNREGISTER);
491 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
492 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
493 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
494 ValidateExecuteExePackage(pPlan, fRollback, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_INSTALL, NULL);
495 Assert::Equal(dwIndex, pPlan->cRollbackActions);
496
497 Assert::Equal(2ul, pPlan->cExecutePackagesTotal);
498 Assert::Equal(3ul, pPlan->cOverallProgressTicksTotal);
499
500 dwIndex = 0;
501 Assert::Equal(dwIndex, pPlan->cCleanActions);
502
503 UINT uIndex = 0;
504 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
505 Assert::Equal(uIndex, pPlan->cPlannedProviders);
506
507 Assert::Equal(1ul, pEngineState->packages.cPackages);
508 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
509 }
510
511 [Fact]
512 void SingleMsiInstalledWithNoInstalledPackagesModifyTest()
513 {
514 HRESULT hr = S_OK;
515 BURN_ENGINE_STATE engineState = { };
516 BURN_ENGINE_STATE* pEngineState = &engineState;
517 BURN_PLAN* pPlan = &engineState.plan;
518
519 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
520 DetectPackagesAsAbsent(pEngineState);
521
522 pEngineState->registration.fInstalled = TRUE;
523
524 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_MODIFY);
525 NativeAssert::Succeeded(hr, "CorePlan failed");
526
527 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_MODIFY, pPlan->action);
528 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
529 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
530
531 BOOL fRollback = FALSE;
532 DWORD dwIndex = 0;
533 Assert::Equal(dwIndex, pPlan->cCacheActions);
534
535 fRollback = TRUE;
536 dwIndex = 0;
537 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
538
539 Assert::Equal(0ull, pPlan->qwEstimatedSize);
540 Assert::Equal(0ull, pPlan->qwCacheSizeTotal);
541
542 fRollback = FALSE;
543 dwIndex = 0;
544 DWORD dwExecuteCheckpointId = 1;
545 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
546 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
547 Assert::Equal(dwIndex, pPlan->cExecuteActions);
548
549 fRollback = TRUE;
550 dwIndex = 0;
551 dwExecuteCheckpointId = 1;
552 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
553 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
554 Assert::Equal(dwIndex, pPlan->cRollbackActions);
555
556 Assert::Equal(0ul, pPlan->cExecutePackagesTotal);
557 Assert::Equal(0ul, pPlan->cOverallProgressTicksTotal);
558
559 dwIndex = 0;
560 ValidateCleanAction(pPlan, dwIndex++, L"PackageA");
561 Assert::Equal(dwIndex, pPlan->cCleanActions);
562
563 UINT uIndex = 0;
564 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
565 Assert::Equal(uIndex, pPlan->cPlannedProviders);
566
567 Assert::Equal(1ul, pEngineState->packages.cPackages);
568 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
569 }
570
571 [Fact]
572 void SingleMsiUninstallTest()
573 {
574 HRESULT hr = S_OK;
575 BURN_ENGINE_STATE engineState = { };
576 BURN_ENGINE_STATE* pEngineState = &engineState;
577 BURN_PLAN* pPlan = &engineState.plan;
578
579 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
580 DetectPackagesAsPresentAndCached(pEngineState);
581
582 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNINSTALL);
583 NativeAssert::Succeeded(hr, "CorePlan failed");
584
585 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNINSTALL, pPlan->action);
586 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
587 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
588
589 BOOL fRollback = FALSE;
590 DWORD dwIndex = 0;
591 Assert::Equal(dwIndex, pPlan->cCacheActions);
592
593 fRollback = TRUE;
594 dwIndex = 0;
595 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
596
597 Assert::Equal(0ull, pPlan->qwEstimatedSize);
598 Assert::Equal(0ull, pPlan->qwCacheSizeTotal);
599
600 fRollback = FALSE;
601 dwIndex = 0;
602 DWORD dwExecuteCheckpointId = 1;
603 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
604 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
605 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", BURN_DEPENDENCY_ACTION_UNREGISTER);
606 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
607 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", BURN_DEPENDENCY_ACTION_UNREGISTER);
608 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
609 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
610 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
611 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
612 Assert::Equal(dwIndex, pPlan->cExecuteActions);
613
614 fRollback = TRUE;
615 dwIndex = 0;
616 dwExecuteCheckpointId = 1;
617 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
618 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", BURN_DEPENDENCY_ACTION_REGISTER);
619 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
620 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", BURN_DEPENDENCY_ACTION_REGISTER);
621 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
622 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
623 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
624 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
625 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
626 Assert::Equal(dwIndex, pPlan->cRollbackActions);
627
628 Assert::Equal(1ul, pPlan->cExecutePackagesTotal);
629 Assert::Equal(1ul, pPlan->cOverallProgressTicksTotal);
630
631 dwIndex = 0;
632 ValidateCleanAction(pPlan, dwIndex++, L"PackageA");
633 Assert::Equal(dwIndex, pPlan->cCleanActions);
634
635 UINT uIndex = 0;
636 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
637 ValidatePlannedProvider(pPlan, uIndex++, L"{64633047-D172-4BBB-B202-64337D15C952}", NULL);
638 Assert::Equal(uIndex, pPlan->cPlannedProviders);
639
640 Assert::Equal(1ul, pEngineState->packages.cPackages);
641 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
642 }
643
644 [Fact]
645 void SingleMsiUninstallTestFromUpgradeBundleWithSameExactPackage()
646 {
647 HRESULT hr = S_OK;
648 BURN_ENGINE_STATE engineState = { };
649 BURN_ENGINE_STATE* pEngineState = &engineState;
650 BURN_PLAN* pPlan = &engineState.plan;
651
652 InitializeEngineStateForCorePlan(wzSingleMsiManifestFileName, pEngineState);
653 DetectAsRelatedUpgradeBundle(&engineState, L"{02940F3E-C83E-452D-BFCF-C943777ACEAE}", L"2.0.0.0");
654
655 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNINSTALL);
656 NativeAssert::Succeeded(hr, "CorePlan failed");
657
658 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNINSTALL, pPlan->action);
659 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
660 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
661
662 BOOL fRollback = FALSE;
663 DWORD dwIndex = 0;
664 Assert::Equal(dwIndex, pPlan->cCacheActions);
665
666 fRollback = TRUE;
667 dwIndex = 0;
668 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
669
670 Assert::Equal(0ull, pPlan->qwEstimatedSize);
671 Assert::Equal(0ull, pPlan->qwCacheSizeTotal);
672
673 fRollback = FALSE;
674 dwIndex = 0;
675 DWORD dwExecuteCheckpointId = 1;
676 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
677 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
678 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", BURN_DEPENDENCY_ACTION_UNREGISTER);
679 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
680 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
681 Assert::Equal(dwIndex, pPlan->cExecuteActions);
682
683 fRollback = TRUE;
684 dwIndex = 0;
685 dwExecuteCheckpointId = 1;
686 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
687 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", BURN_DEPENDENCY_ACTION_REGISTER);
688 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
689 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
690 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
691 Assert::Equal(dwIndex, pPlan->cRollbackActions);
692
693 Assert::Equal(0ul, pPlan->cExecutePackagesTotal);
694 Assert::Equal(0ul, pPlan->cOverallProgressTicksTotal);
695
696 dwIndex = 0;
697 Assert::Equal(dwIndex, pPlan->cCleanActions);
698
699 UINT uIndex = 0;
700 ValidatePlannedProvider(pPlan, uIndex++, L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", NULL);
701 Assert::Equal(uIndex, pPlan->cPlannedProviders);
702
703 Assert::Equal(1ul, pEngineState->packages.cPackages);
704 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_IGNORED, BURN_PACKAGE_REGISTRATION_STATE_IGNORED);
705 }
706
707 [Fact]
708 void SlipstreamInstallTest()
709 {
710 HRESULT hr = S_OK;
711 BURN_ENGINE_STATE engineState = { };
712 BURN_ENGINE_STATE* pEngineState = &engineState;
713 BURN_PLAN* pPlan = &engineState.plan;
714
715 InitializeEngineStateForCorePlan(wzSlipstreamManifestFileName, pEngineState);
716 DetectPermanentPackagesAsPresentAndCached(pEngineState);
717 PlanTestDetectPatchInitialize(pEngineState);
718
719 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_INSTALL);
720 NativeAssert::Succeeded(hr, "CorePlan failed");
721
722 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_INSTALL, pPlan->action);
723 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
724 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
725
726 BOOL fRollback = FALSE;
727 DWORD dwIndex = 0;
728 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 1);
729 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PatchA");
730 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++);
731 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 2);
732 ValidateCachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
733 ValidateCacheSignalSyncpoint(pPlan, fRollback, dwIndex++);
734 Assert::Equal(dwIndex, pPlan->cCacheActions);
735
736 fRollback = TRUE;
737 dwIndex = 0;
738 ValidateCacheCheckpoint(pPlan, fRollback, dwIndex++, 2);
739 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
740
741 Assert::Equal(3055111ull, pPlan->qwEstimatedSize);
742 Assert::Equal(212992ull, pPlan->qwCacheSizeTotal);
743
744 fRollback = FALSE;
745 dwIndex = 0;
746 DWORD dwExecuteCheckpointId = 3;
747 BURN_EXECUTE_ACTION* pExecuteAction = NULL;
748 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
749 ValidateExecuteWaitSyncpoint(pPlan, fRollback, dwIndex++, pPlan->rgCacheActions[5].syncpoint.hEvent);
750 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
751 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
752 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", BURN_DEPENDENCY_ACTION_REGISTER);
753 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
754 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
755 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
756 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", BURN_DEPENDENCY_ACTION_REGISTER);
757 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
758 ValidateExecuteWaitSyncpoint(pPlan, fRollback, dwIndex++, pPlan->rgCacheActions[2].syncpoint.hEvent);
759 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
760 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
761 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PatchA", BURN_DEPENDENCY_ACTION_REGISTER);
762 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, TRUE);
763 ValidateExecuteMspTargetPatch(pExecuteAction, 0, L"PatchA");
764 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
765 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PatchA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", BURN_DEPENDENCY_ACTION_REGISTER);
766 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
767 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
768 Assert::Equal(dwIndex, pPlan->cExecuteActions);
769
770 fRollback = TRUE;
771 dwIndex = 0;
772 dwExecuteCheckpointId = 3;
773 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
774 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PackageA");
775 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
776 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", BURN_DEPENDENCY_ACTION_UNREGISTER);
777 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
778 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
779 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
780 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", BURN_DEPENDENCY_ACTION_UNREGISTER);
781 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
782 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
783 ValidateExecuteUncachePackage(pPlan, fRollback, dwIndex++, L"PatchA");
784 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
785 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PatchA", BURN_DEPENDENCY_ACTION_UNREGISTER);
786 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
787 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, TRUE);
788 ValidateExecuteMspTargetPatch(pExecuteAction, 0, L"PatchA");
789 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PatchA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", BURN_DEPENDENCY_ACTION_UNREGISTER);
790 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
791 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
792 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
793 Assert::Equal(dwIndex, pPlan->cRollbackActions);
794
795 Assert::Equal(2ul, pPlan->cExecutePackagesTotal);
796 Assert::Equal(4ul, pPlan->cOverallProgressTicksTotal);
797
798 dwIndex = 0;
799 Assert::Equal(dwIndex, pPlan->cCleanActions);
800
801 UINT uIndex = 0;
802 ValidatePlannedProvider(pPlan, uIndex++, L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", NULL);
803 Assert::Equal(uIndex, pPlan->cPlannedProviders);
804
805 Assert::Equal(3ul, pEngineState->packages.cPackages);
806 ValidatePermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"NetFx48Web");
807 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
808 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[2], L"PatchA", BURN_PACKAGE_REGISTRATION_STATE_PRESENT, BURN_PACKAGE_REGISTRATION_STATE_PRESENT);
809 }
810
811 [Fact]
812 void SlipstreamUninstallTest()
813 {
814 HRESULT hr = S_OK;
815 BURN_ENGINE_STATE engineState = { };
816 BURN_ENGINE_STATE* pEngineState = &engineState;
817 BURN_PLAN* pPlan = &engineState.plan;
818
819 InitializeEngineStateForCorePlan(wzSlipstreamManifestFileName, pEngineState);
820 DetectPackagesAsPresentAndCached(pEngineState);
821
822 hr = CorePlan(pEngineState, BOOTSTRAPPER_ACTION_UNINSTALL);
823 NativeAssert::Succeeded(hr, "CorePlan failed");
824
825 Assert::Equal<DWORD>(BOOTSTRAPPER_ACTION_UNINSTALL, pPlan->action);
826 Assert::Equal<BOOL>(TRUE, pPlan->fPerMachine);
827 Assert::Equal<BOOL>(FALSE, pPlan->fDisableRollback);
828
829 BOOL fRollback = FALSE;
830 DWORD dwIndex = 0;
831 Assert::Equal(dwIndex, pPlan->cCacheActions);
832
833 fRollback = TRUE;
834 dwIndex = 0;
835 Assert::Equal(dwIndex, pPlan->cRollbackCacheActions);
836
837 Assert::Equal(0ull, pPlan->qwEstimatedSize);
838 Assert::Equal(0ull, pPlan->qwCacheSizeTotal);
839
840 fRollback = FALSE;
841 dwIndex = 0;
842 DWORD dwExecuteCheckpointId = 1;
843 BURN_EXECUTE_ACTION* pExecuteAction = NULL;
844 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
845 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
846 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PatchA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", BURN_DEPENDENCY_ACTION_UNREGISTER);
847 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
848 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PatchA", BURN_DEPENDENCY_ACTION_UNREGISTER);
849 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, TRUE);
850 ValidateExecuteMspTargetPatch(pExecuteAction, 0, L"PatchA");
851 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
852 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
853 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", BURN_DEPENDENCY_ACTION_UNREGISTER);
854 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
855 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", BURN_DEPENDENCY_ACTION_UNREGISTER);
856 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
857 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, BURN_MSI_PROPERTY_UNINSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
858 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
859 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
860 Assert::Equal(dwIndex, pPlan->cExecuteActions);
861
862 fRollback = TRUE;
863 dwIndex = 0;
864 dwExecuteCheckpointId = 1;
865 ValidateExecuteRollbackBoundary(pPlan, fRollback, dwIndex++, L"WixDefaultBoundary", TRUE, FALSE);
866 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PatchA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", BURN_DEPENDENCY_ACTION_REGISTER);
867 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
868 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PatchA", BURN_DEPENDENCY_ACTION_REGISTER);
869 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
870 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, TRUE);
871 ValidateExecuteMspTargetPatch(pExecuteAction, 0, L"PatchA");
872 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
873 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", BURN_DEPENDENCY_ACTION_REGISTER);
874 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
875 ValidateExecutePackageProvider(pPlan, fRollback, dwIndex++, L"PackageA", BURN_DEPENDENCY_ACTION_REGISTER);
876 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
877 ValidateExecuteMsiPackage(pPlan, fRollback, dwIndex++, L"PackageA", BOOTSTRAPPER_ACTION_STATE_INSTALL, BURN_MSI_PROPERTY_INSTALL, INSTALLUILEVEL_NONE, FALSE, 0);
878 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
879 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
880 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);
881 Assert::Equal(dwIndex, pPlan->cRollbackActions);
882
883 Assert::Equal(2ul, pPlan->cExecutePackagesTotal);
884 Assert::Equal(2ul, pPlan->cOverallProgressTicksTotal);
885
886 dwIndex = 0;
887 ValidateCleanAction(pPlan, dwIndex++, L"PatchA");
888 ValidateCleanAction(pPlan, dwIndex++, L"PackageA");
889 Assert::Equal(dwIndex, pPlan->cCleanActions);
890
891 UINT uIndex = 0;
892 ValidatePlannedProvider(pPlan, uIndex++, L"{22D1DDBA-284D-40A7-BD14-95EA07906F21}", NULL);
893 ValidatePlannedProvider(pPlan, uIndex++, L"{0A5113E3-06A5-4CE0-8E83-9EB42F6764A6}", NULL);
894 ValidatePlannedProvider(pPlan, uIndex++, L"{5FF7F534-3FFC-41E0-80CD-E6361E5E7B7B}", NULL);
895 Assert::Equal(uIndex, pPlan->cPlannedProviders);
896
897 Assert::Equal(3ul, pEngineState->packages.cPackages);
898 ValidatePermanentPackageExpectedStates(&pEngineState->packages.rgPackages[0], L"NetFx48Web");
899 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[1], L"PackageA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
900 ValidateNonPermanentPackageExpectedStates(&pEngineState->packages.rgPackages[2], L"PatchA", BURN_PACKAGE_REGISTRATION_STATE_ABSENT, BURN_PACKAGE_REGISTRATION_STATE_ABSENT);
901 }
902
903 private:
904 // This doesn't initialize everything, just enough for CorePlan to work.
905 void InitializeEngineStateForCorePlan(LPCWSTR wzManifestFileName, BURN_ENGINE_STATE* pEngineState)
906 {
907 HRESULT hr = S_OK;
908 LPWSTR sczFilePath = NULL;
909
910 ::InitializeCriticalSection(&pEngineState->userExperience.csEngineActive);
911
912 hr = VariableInitialize(&pEngineState->variables);
913 NativeAssert::Succeeded(hr, "Failed to initialize variables.");
914
915 try
916 {
917 pin_ptr<const wchar_t> dataDirectory = PtrToStringChars(this->TestContext->TestDirectory);
918 hr = PathConcat(dataDirectory, L"TestData\\PlanTest", &sczFilePath);
919 NativeAssert::Succeeded(hr, "Failed to get path to test file directory.");
920 hr = PathConcat(sczFilePath, wzManifestFileName, &sczFilePath);
921 NativeAssert::Succeeded(hr, "Failed to get path to test file.");
922 Assert::True(FileExistsEx(sczFilePath, NULL), "Test file does not exist.");
923
924 hr = ManifestLoadXmlFromFile(sczFilePath, pEngineState);
925 NativeAssert::Succeeded(hr, "Failed to load manifest.");
926 }
927 finally
928 {
929 ReleaseStr(sczFilePath);
930 }
931
932 hr = CoreInitializeConstants(pEngineState);
933 NativeAssert::Succeeded(hr, "Failed to initialize core constants");
934
935 pEngineState->userExperience.pfnBAProc = PlanTestBAProc;
936 }
937
938 void PlanTestDetect(BURN_ENGINE_STATE* pEngineState)
939 {
940 HRESULT hr = S_OK;
941 BURN_REGISTRATION* pRegistration = &pEngineState->registration;
942
943 DetectReset(pRegistration, &pEngineState->packages);
944 PlanReset(&pEngineState->plan, &pEngineState->containers, &pEngineState->packages, &pEngineState->layoutPayloads);
945
946 hr = DepDependencyArrayAlloc(&pRegistration->rgIgnoredDependencies, &pRegistration->cIgnoredDependencies, pRegistration->sczProviderKey, NULL);
947 NativeAssert::Succeeded(hr, "Failed to add the bundle provider key to the list of dependencies to ignore.");
948
949 pEngineState->userExperience.fEngineActive = TRUE;
950 pEngineState->fDetected = TRUE;
951 }
952
953 void PlanTestDetectPatchInitialize(BURN_ENGINE_STATE* pEngineState)
954 {
955 HRESULT hr = MsiEngineDetectInitialize(&pEngineState->packages);
956 NativeAssert::Succeeded(hr, "MsiEngineDetectInitialize failed");
957
958 for (DWORD i = 0; i < pEngineState->packages.cPackages; ++i)
959 {
960 BURN_PACKAGE* pPackage = pEngineState->packages.rgPackages + i;
961
962 if (BURN_PACKAGE_TYPE_MSP == pPackage->type)
963 {
964 for (DWORD j = 0; j < pPackage->Msp.cTargetProductCodes; ++j)
965 {
966 BURN_MSPTARGETPRODUCT* pTargetProduct = pPackage->Msp.rgTargetProducts + j;
967
968 if (BOOTSTRAPPER_PACKAGE_STATE_UNKNOWN == pTargetProduct->patchPackageState)
969 {
970 pTargetProduct->patchPackageState = BOOTSTRAPPER_PACKAGE_STATE_ABSENT;
971 }
972 }
973 }
974 }
975 }
976
977 void DetectAttachedContainerAsAttached(BURN_ENGINE_STATE* pEngineState)
978 {
979 for (DWORD i = 0; i < pEngineState->containers.cContainers; ++i)
980 {
981 BURN_CONTAINER* pContainer = pEngineState->containers.rgContainers + i;
982 if (pContainer->fAttached)
983 {
984 pContainer->fActuallyAttached = TRUE;
985 }
986 }
987 }
988
989 void DetectPackageAsAbsent(BURN_PACKAGE* pPackage)
990 {
991 pPackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_ABSENT;
992 if (pPackage->fCanAffectRegistration)
993 {
994 pPackage->cacheRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_ABSENT;
995 pPackage->installRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_ABSENT;
996 }
997 }
998
999 void DetectPackageAsPresentAndCached(BURN_PACKAGE* pPackage)
1000 {
1001 pPackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_PRESENT;
1002 pPackage->fCached = TRUE;
1003 if (pPackage->fCanAffectRegistration)
1004 {
1005 pPackage->cacheRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_PRESENT;
1006 pPackage->installRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_PRESENT;
1007 }
1008 }
1009
1010 void DetectPackageDependent(BURN_PACKAGE* pPackage, LPCWSTR wzId)
1011 {
1012 HRESULT hr = S_OK;
1013
1014 for (DWORD i = 0; i < pPackage->cDependencyProviders; ++i)
1015 {
1016 BURN_DEPENDENCY_PROVIDER* pProvider = pPackage->rgDependencyProviders + i;
1017
1018 hr = DepDependencyArrayAlloc(&pProvider->rgDependents, &pProvider->cDependents, wzId, NULL);
1019 NativeAssert::Succeeded(hr, "Failed to add package dependent");
1020 }
1021 }
1022
1023 void DetectPackagesAsAbsent(BURN_ENGINE_STATE* pEngineState)
1024 {
1025 PlanTestDetect(pEngineState);
1026
1027 for (DWORD i = 0; i < pEngineState->packages.cPackages; ++i)
1028 {
1029 BURN_PACKAGE* pPackage = pEngineState->packages.rgPackages + i;
1030 DetectPackageAsAbsent(pPackage);
1031 }
1032 }
1033
1034 void DetectPackagesAsPresentAndCached(BURN_ENGINE_STATE* pEngineState)
1035 {
1036 PlanTestDetect(pEngineState);
1037
1038 pEngineState->registration.fInstalled = TRUE;
1039
1040 for (DWORD i = 0; i < pEngineState->packages.cPackages; ++i)
1041 {
1042 BURN_PACKAGE* pPackage = pEngineState->packages.rgPackages + i;
1043 DetectPackageAsPresentAndCached(pPackage);
1044 DetectPackageDependent(pPackage, pEngineState->registration.sczId);
1045
1046 if (BURN_PACKAGE_TYPE_MSI == pPackage->type)
1047 {
1048 for (DWORD j = 0; j < pPackage->Msi.cSlipstreamMspPackages; ++j)
1049 {
1050 pPackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED;
1051
1052 BURN_PACKAGE* pMspPackage = pPackage->Msi.rgSlipstreamMsps[j].pMspPackage;
1053 MspEngineAddDetectedTargetProduct(&pEngineState->packages, pMspPackage, j, pPackage->Msi.sczProductCode, pPackage->fPerMachine ? MSIINSTALLCONTEXT_MACHINE : MSIINSTALLCONTEXT_USERUNMANAGED);
1054
1055 BURN_MSPTARGETPRODUCT* pTargetProduct = pMspPackage->Msp.rgTargetProducts + (pMspPackage->Msp.cTargetProductCodes - 1);
1056 pTargetProduct->patchPackageState = BOOTSTRAPPER_PACKAGE_STATE_PRESENT;
1057 pTargetProduct->registrationState = BURN_PACKAGE_REGISTRATION_STATE_PRESENT;
1058 }
1059 }
1060 }
1061 }
1062
1063 void DetectPermanentPackagesAsPresentAndCached(BURN_ENGINE_STATE* pEngineState)
1064 {
1065 PlanTestDetect(pEngineState);
1066
1067 pEngineState->registration.fInstalled = TRUE;
1068
1069 for (DWORD i = 0; i < pEngineState->packages.cPackages; ++i)
1070 {
1071 BURN_PACKAGE* pPackage = pEngineState->packages.rgPackages + i;
1072 if (pPackage->fUninstallable)
1073 {
1074 DetectPackageAsAbsent(pPackage);
1075 }
1076 else
1077 {
1078 DetectPackageAsPresentAndCached(pPackage);
1079 DetectPackageDependent(pPackage, pEngineState->registration.sczId);
1080 }
1081 }
1082 }
1083
1084 BURN_RELATED_BUNDLE* DetectUpgradeBundle(
1085 __in BURN_ENGINE_STATE* pEngineState,
1086 __in LPCWSTR wzId,
1087 __in LPCWSTR wzVersion
1088 )
1089 {
1090 HRESULT hr = S_OK;
1091 BURN_RELATED_BUNDLES* pRelatedBundles = &pEngineState->registration.relatedBundles;
1092 BURN_DEPENDENCY_PROVIDER dependencyProvider = { };
1093
1094 hr = StrAllocString(&dependencyProvider.sczKey, wzId, 0);
1095 NativeAssert::Succeeded(hr, "Failed to copy provider key");
1096
1097 dependencyProvider.fImported = TRUE;
1098
1099 hr = StrAllocString(&dependencyProvider.sczVersion, wzVersion, 0);
1100 NativeAssert::Succeeded(hr, "Failed to copy version");
1101
1102 hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pRelatedBundles->rgRelatedBundles), pRelatedBundles->cRelatedBundles + 1, sizeof(BURN_RELATED_BUNDLE), 5);
1103 NativeAssert::Succeeded(hr, "Failed to ensure there is space for related bundles.");
1104
1105 BURN_RELATED_BUNDLE* pRelatedBundle = pRelatedBundles->rgRelatedBundles + pRelatedBundles->cRelatedBundles;
1106
1107 hr = VerParseVersion(wzVersion, 0, FALSE, &pRelatedBundle->pVersion);
1108 NativeAssert::Succeeded(hr, "Failed to parse pseudo bundle version: %ls", wzVersion);
1109
1110 pRelatedBundle->fPlannable = TRUE;
1111 pRelatedBundle->relationType = BOOTSTRAPPER_RELATION_UPGRADE;
1112
1113 hr = PseudoBundleInitialize(0, &pRelatedBundle->package, TRUE, wzId, pRelatedBundle->relationType, BOOTSTRAPPER_PACKAGE_STATE_PRESENT, TRUE, NULL, NULL, NULL, 0, FALSE, L"-quiet", L"-repair -quiet", L"-uninstall -quiet", &dependencyProvider, NULL, 0);
1114 NativeAssert::Succeeded(hr, "Failed to initialize related bundle to represent bundle: %ls", wzId);
1115
1116 ++pRelatedBundles->cRelatedBundles;
1117
1118 return pRelatedBundle;
1119 }
1120
1121 void DetectAsRelatedUpgradeBundle(
1122 __in BURN_ENGINE_STATE* pEngineState,
1123 __in LPCWSTR wzId,
1124 __in LPCWSTR wzVersion
1125 )
1126 {
1127 HRESULT hr = StrAllocString(&pEngineState->registration.sczAncestors, wzId, 0);
1128 NativeAssert::Succeeded(hr, "Failed to set registration's ancestors");
1129
1130 pEngineState->command.relationType = BOOTSTRAPPER_RELATION_UPGRADE;
1131
1132 DetectPackagesAsPresentAndCached(pEngineState);
1133 DetectUpgradeBundle(pEngineState, wzId, wzVersion);
1134
1135 for (DWORD i = 0; i < pEngineState->packages.cPackages; ++i)
1136 {
1137 BURN_PACKAGE* pPackage = pEngineState->packages.rgPackages + i;
1138 DetectPackageDependent(pPackage, wzId);
1139 }
1140 }
1141
1142 void ValidateCacheContainer(
1143 __in BURN_PLAN* pPlan,
1144 __in BOOL fRollback,
1145 __in DWORD dwIndex,
1146 __in LPCWSTR wzContainerId
1147 )
1148 {
1149 BURN_CACHE_ACTION* pAction = ValidateCacheActionExists(pPlan, fRollback, dwIndex);
1150 Assert::Equal<DWORD>(BURN_CACHE_ACTION_TYPE_CONTAINER, pAction->type);
1151 NativeAssert::StringEqual(wzContainerId, pAction->container.pContainer->sczId);
1152 }
1153
1154 BURN_CACHE_ACTION* ValidateCacheActionExists(BURN_PLAN* pPlan, BOOL fRollback, DWORD dwIndex)
1155 {
1156 Assert::InRange(dwIndex + 1ul, 1ul, (fRollback ? pPlan->cRollbackCacheActions : pPlan->cCacheActions));
1157 return (fRollback ? pPlan->rgRollbackCacheActions : pPlan->rgCacheActions) + dwIndex;
1158 }
1159
1160 void ValidateCacheCheckpoint(
1161 __in BURN_PLAN* pPlan,
1162 __in BOOL fRollback,
1163 __in DWORD dwIndex,
1164 __in DWORD dwId
1165 )
1166 {
1167 BURN_CACHE_ACTION* pAction = ValidateCacheActionExists(pPlan, fRollback, dwIndex);
1168 Assert::Equal<DWORD>(BURN_CACHE_ACTION_TYPE_CHECKPOINT, pAction->type);
1169 Assert::Equal(dwId, pAction->checkpoint.dwId);
1170 }
1171
1172 DWORD ValidateCachePackage(
1173 __in BURN_PLAN* pPlan,
1174 __in BOOL fRollback,
1175 __in DWORD dwIndex,
1176 __in LPCWSTR wzPackageId
1177 )
1178 {
1179 BURN_CACHE_ACTION* pAction = ValidateCacheActionExists(pPlan, fRollback, dwIndex);
1180 Assert::Equal<DWORD>(BURN_CACHE_ACTION_TYPE_PACKAGE, pAction->type);
1181 NativeAssert::StringEqual(wzPackageId, pAction->package.pPackage->sczId);
1182 return dwIndex + 1;
1183 }
1184
1185 void ValidateCacheRollbackPackage(
1186 __in BURN_PLAN* pPlan,
1187 __in BOOL fRollback,
1188 __in DWORD dwIndex,
1189 __in LPCWSTR wzPackageId
1190 )
1191 {
1192 BURN_CACHE_ACTION* pAction = ValidateCacheActionExists(pPlan, fRollback, dwIndex);
1193 Assert::Equal<DWORD>(BURN_CACHE_ACTION_TYPE_ROLLBACK_PACKAGE, pAction->type);
1194 NativeAssert::StringEqual(wzPackageId, pAction->rollbackPackage.pPackage->sczId);
1195 }
1196
1197 void ValidateCacheSignalSyncpoint(
1198 __in BURN_PLAN* pPlan,
1199 __in BOOL fRollback,
1200 __in DWORD dwIndex
1201 )
1202 {
1203 BURN_CACHE_ACTION* pAction = ValidateCacheActionExists(pPlan, fRollback, dwIndex);
1204 Assert::Equal<DWORD>(BURN_CACHE_ACTION_TYPE_SIGNAL_SYNCPOINT, pAction->type);
1205 Assert::NotEqual((DWORD_PTR)NULL, (DWORD_PTR)pAction->syncpoint.hEvent);
1206 }
1207
1208 void ValidateCleanAction(
1209 __in BURN_PLAN* pPlan,
1210 __in DWORD dwIndex,
1211 __in LPCWSTR wzPackageId
1212 )
1213 {
1214 Assert::InRange(dwIndex + 1ul, 1ul, pPlan->cCleanActions);
1215
1216 BURN_CLEAN_ACTION* pCleanAction = pPlan->rgCleanActions + dwIndex;
1217 Assert::NotEqual((DWORD_PTR)0, (DWORD_PTR)pCleanAction->pPackage);
1218 NativeAssert::StringEqual(wzPackageId, pCleanAction->pPackage->sczId);
1219 }
1220
1221 BURN_EXECUTE_ACTION* ValidateExecuteActionExists(BURN_PLAN* pPlan, BOOL fRollback, DWORD dwIndex)
1222 {
1223 Assert::InRange(dwIndex + 1ul, 1ul, (fRollback ? pPlan->cRollbackActions : pPlan->cExecuteActions));
1224 return (fRollback ? pPlan->rgRollbackActions : pPlan->rgExecuteActions) + dwIndex;
1225 }
1226
1227 void ValidateExecuteBeginMsiTransaction(
1228 __in BURN_PLAN* pPlan,
1229 __in BOOL fRollback,
1230 __in DWORD dwIndex,
1231 __in LPCWSTR wzRollbackBoundaryId
1232 )
1233 {
1234 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
1235 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_BEGIN_MSI_TRANSACTION, pAction->type);
1236 NativeAssert::StringEqual(wzRollbackBoundaryId, pAction->msiTransaction.pRollbackBoundary->sczId);
1237 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
1238 }
1239
1240 void ValidateExecuteCheckpoint(
1241 __in BURN_PLAN* pPlan,
1242 __in BOOL fRollback,
1243 __in DWORD dwIndex,
1244 __in DWORD dwId
1245 )
1246 {
1247 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
1248 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_CHECKPOINT, pAction->type);
1249 Assert::Equal(dwId, pAction->checkpoint.dwId);
1250 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
1251 }
1252
1253 void ValidateExecuteCommitMsiTransaction(
1254 __in BURN_PLAN* pPlan,
1255 __in BOOL fRollback,
1256 __in DWORD dwIndex,
1257 __in LPCWSTR wzRollbackBoundaryId
1258 )
1259 {
1260 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
1261 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_COMMIT_MSI_TRANSACTION, pAction->type);
1262 NativeAssert::StringEqual(wzRollbackBoundaryId, pAction->msiTransaction.pRollbackBoundary->sczId);
1263 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
1264 }
1265
1266 void ValidateExecuteExePackage(
1267 __in BURN_PLAN* pPlan,
1268 __in BOOL fRollback,
1269 __in DWORD dwIndex,
1270 __in LPCWSTR wzPackageId,
1271 __in BOOTSTRAPPER_ACTION_STATE action,
1272 __in LPCWSTR wzIgnoreDependencies
1273 )
1274 {
1275 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
1276 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_EXE_PACKAGE, pAction->type);
1277 NativeAssert::StringEqual(wzPackageId, pAction->exePackage.pPackage->sczId);
1278 Assert::Equal<DWORD>(action, pAction->exePackage.action);
1279 NativeAssert::StringEqual(wzIgnoreDependencies, pAction->exePackage.sczIgnoreDependencies);
1280 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
1281 }
1282
1283 void ValidateExecuteMsiPackage(
1284 __in BURN_PLAN* pPlan,
1285 __in BOOL fRollback,
1286 __in DWORD dwIndex,
1287 __in_z LPCWSTR wzPackageId,
1288 __in BOOTSTRAPPER_ACTION_STATE action,
1289 __in BURN_MSI_PROPERTY actionMsiProperty,
1290 __in DWORD uiLevel,
1291 __in BOOL fDisableExternalUiHandler,
1292 __in DWORD dwLoggingAttributes
1293 )
1294 {
1295 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
1296 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE, pAction->type);
1297 NativeAssert::StringEqual(wzPackageId, pAction->msiPackage.pPackage->sczId);
1298 Assert::Equal<DWORD>(action, pAction->msiPackage.action);
1299 Assert::Equal<DWORD>(actionMsiProperty, pAction->msiPackage.actionMsiProperty);
1300 Assert::Equal<DWORD>(uiLevel, pAction->msiPackage.uiLevel);
1301 Assert::Equal<BOOL>(fDisableExternalUiHandler, pAction->msiPackage.fDisableExternalUiHandler);
1302 NativeAssert::NotNull(pAction->msiPackage.sczLogPath);
1303 Assert::Equal<DWORD>(dwLoggingAttributes, pAction->msiPackage.dwLoggingAttributes);
1304 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
1305 }
1306
1307 BURN_EXECUTE_ACTION* ValidateDeletedExecuteMspTarget(
1308 __in BURN_PLAN* pPlan,
1309 __in BOOL fRollback,
1310 __in DWORD dwIndex,
1311 __in_z LPCWSTR wzPackageId,
1312 __in BOOTSTRAPPER_ACTION_STATE action,
1313 __in_z LPCWSTR wzTargetProductCode,
1314 __in BOOL fPerMachineTarget,
1315 __in BURN_MSI_PROPERTY actionMsiProperty,
1316 __in DWORD uiLevel,
1317 __in BOOL fDisableExternalUiHandler,
1318 __in BOOL fDeleted
1319 )
1320 {
1321 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
1322 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_MSP_TARGET, pAction->type);
1323 NativeAssert::StringEqual(wzPackageId, pAction->mspTarget.pPackage->sczId);
1324 Assert::Equal<DWORD>(action, pAction->mspTarget.action);
1325 NativeAssert::StringEqual(wzTargetProductCode, pAction->mspTarget.sczTargetProductCode);
1326 Assert::Equal<BOOL>(fPerMachineTarget, pAction->mspTarget.fPerMachineTarget);
1327 Assert::Equal<DWORD>(actionMsiProperty, pAction->mspTarget.actionMsiProperty);
1328 Assert::Equal<DWORD>(uiLevel, pAction->mspTarget.uiLevel);
1329 Assert::Equal<BOOL>(fDisableExternalUiHandler, pAction->mspTarget.fDisableExternalUiHandler);
1330 NativeAssert::NotNull(pAction->mspTarget.sczLogPath);
1331 Assert::Equal<BOOL>(fDeleted, pAction->fDeleted);
1332 return pAction;
1333 }
1334
1335 void ValidateExecuteMspTargetPatch(
1336 __in BURN_EXECUTE_ACTION* pAction,
1337 __in DWORD dwIndex,
1338 __in_z LPCWSTR wzPackageId
1339 )
1340 {
1341 Assert::InRange(dwIndex + 1ul, 1ul, pAction->mspTarget.cOrderedPatches);
1342 BURN_ORDERED_PATCHES* pOrderedPatch = pAction->mspTarget.rgOrderedPatches + dwIndex;
1343 NativeAssert::StringEqual(wzPackageId, pOrderedPatch->pPackage->sczId);
1344 }
1345
1346 void ValidateExecutePackageDependency(
1347 __in BURN_PLAN* pPlan,
1348 __in BOOL fRollback,
1349 __in DWORD dwIndex,
1350 __in LPCWSTR wzPackageId,
1351 __in LPCWSTR wzBundleProviderKey,
1352 __in BURN_DEPENDENCY_ACTION action
1353 )
1354 {
1355 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
1356 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_PACKAGE_DEPENDENCY, pAction->type);
1357 NativeAssert::StringEqual(wzPackageId, pAction->packageDependency.pPackage->sczId);
1358 NativeAssert::StringEqual(wzBundleProviderKey, pAction->packageDependency.sczBundleProviderKey);
1359 Assert::Equal<DWORD>(action, pAction->packageDependency.action);
1360 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
1361 }
1362
1363 void ValidateExecutePackageProvider(
1364 __in BURN_PLAN* pPlan,
1365 __in BOOL fRollback,
1366 __in DWORD dwIndex,
1367 __in LPCWSTR wzPackageId,
1368 __in BURN_DEPENDENCY_ACTION action
1369 )
1370 {
1371 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
1372 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_PACKAGE_PROVIDER, pAction->type);
1373 NativeAssert::StringEqual(wzPackageId, pAction->packageProvider.pPackage->sczId);
1374 Assert::Equal<DWORD>(action, pAction->packageProvider.action);
1375 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
1376 }
1377
1378 void ValidateExecuteRollbackBoundary(
1379 __in BURN_PLAN* pPlan,
1380 __in BOOL fRollback,
1381 __in DWORD dwIndex,
1382 __in LPCWSTR wzId,
1383 __in BOOL fVital,
1384 __in BOOL fTransaction
1385 )
1386 {
1387 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
1388 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY, pAction->type);
1389 NativeAssert::StringEqual(wzId, pAction->rollbackBoundary.pRollbackBoundary->sczId);
1390 Assert::Equal<BOOL>(fVital, pAction->rollbackBoundary.pRollbackBoundary->fVital);
1391 Assert::Equal<BOOL>(fTransaction, pAction->rollbackBoundary.pRollbackBoundary->fTransaction);
1392 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
1393 }
1394
1395 void ValidateExecuteUncachePackage(
1396 __in BURN_PLAN* pPlan,
1397 __in BOOL fRollback,
1398 __in DWORD dwIndex,
1399 __in LPCWSTR wzPackageId
1400 )
1401 {
1402 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
1403 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_UNCACHE_PACKAGE, pAction->type);
1404 NativeAssert::StringEqual(wzPackageId, pAction->uncachePackage.pPackage->sczId);
1405 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
1406 }
1407
1408 void ValidateExecuteWaitSyncpoint(
1409 __in BURN_PLAN* pPlan,
1410 __in BOOL fRollback,
1411 __in DWORD dwIndex,
1412 __in HANDLE hEvent
1413 )
1414 {
1415 BURN_EXECUTE_ACTION* pAction = ValidateExecuteActionExists(pPlan, fRollback, dwIndex);
1416 Assert::Equal<DWORD>(BURN_EXECUTE_ACTION_TYPE_WAIT_SYNCPOINT, pAction->type);
1417 Assert::Equal((DWORD_PTR)hEvent, (DWORD_PTR)pAction->syncpoint.hEvent);
1418 Assert::Equal<BOOL>(FALSE, pAction->fDeleted);
1419 }
1420
1421 void ValidateNonPermanentPackageExpectedStates(
1422 __in BURN_PACKAGE* pPackage,
1423 __in_z LPCWSTR wzPackageId,
1424 __in BURN_PACKAGE_REGISTRATION_STATE expectedCacheState,
1425 __in BURN_PACKAGE_REGISTRATION_STATE expectedInstallState
1426 )
1427 {
1428 NativeAssert::StringEqual(wzPackageId, pPackage->sczId);
1429 Assert::Equal<BOOL>(TRUE, pPackage->fCanAffectRegistration);
1430 Assert::Equal<DWORD>(expectedCacheState, pPackage->expectedCacheRegistrationState);
1431 Assert::Equal<DWORD>(expectedInstallState, pPackage->expectedInstallRegistrationState);
1432 }
1433
1434 void ValidatePermanentPackageExpectedStates(
1435 __in BURN_PACKAGE* pPackage,
1436 __in_z LPCWSTR wzPackageId
1437 )
1438 {
1439 NativeAssert::StringEqual(wzPackageId, pPackage->sczId);
1440 Assert::Equal<BOOL>(FALSE, pPackage->fCanAffectRegistration);
1441 Assert::Equal<DWORD>(BURN_PACKAGE_REGISTRATION_STATE_UNKNOWN, pPackage->expectedCacheRegistrationState);
1442 Assert::Equal<DWORD>(BURN_PACKAGE_REGISTRATION_STATE_UNKNOWN, pPackage->expectedInstallRegistrationState);
1443 }
1444
1445 void ValidatePlannedProvider(
1446 __in BURN_PLAN* pPlan,
1447 __in UINT uIndex,
1448 __in LPCWSTR wzKey,
1449 __in LPCWSTR wzName
1450 )
1451 {
1452 Assert::InRange(uIndex + 1u, 1u, pPlan->cPlannedProviders);
1453
1454 DEPENDENCY* pProvider = pPlan->rgPlannedProviders + uIndex;
1455 NativeAssert::StringEqual(wzKey, pProvider->sczKey);
1456 NativeAssert::StringEqual(wzName, pProvider->sczName);
1457 }
1458 };
1459}
1460}
1461}
1462}
1463}
1464
1465static HRESULT WINAPI PlanTestBAProc(
1466 __in BOOTSTRAPPER_APPLICATION_MESSAGE /*message*/,
1467 __in const LPVOID /*pvArgs*/,
1468 __inout LPVOID /*pvResults*/,
1469 __in_opt LPVOID /*pvContext*/
1470 )
1471{
1472 return S_OK;
1473}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-11-27 12:53:29 +0000