@joebigelow / wix-1
Code Commits Issues Pulls Sessions CI/CD
main
main
cpp 219 lines 8.38 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 namespace Microsoft
6 {
7 namespace Tools
8 {
9 namespace WindowsInstallerXml
10 {
11 namespace Test
12 {
13 namespace Bootstrapper
14 {
15 using namespace System;
16 using namespace Xunit;
17
18 public ref class VariantTest : BurnUnitTest
19 {
20 public:
21 VariantTest(BurnTestFixture^ fixture) : BurnUnitTest(fixture)
22 {
23 }
24
25 [Fact]
26 void VariantBasicTest()
27 {
28 BURN_VARIANT expectedVariants[10];
29 BURN_VARIANT actualVariants[10];
30
31 memset(expectedVariants, 0, sizeof(expectedVariants));
32 memset(actualVariants, 0, sizeof(actualVariants));
33
34 try
35 {
36 InitNumericValue(expectedVariants + 0, 2, FALSE, L"PROP1", actualVariants + 0);
37 InitStringValue(expectedVariants + 1, L"VAL2", FALSE, L"PROP2", actualVariants + 1);
38 InitVersionValue(expectedVariants + 2, L"1.1.0.0", FALSE, L"PROP3", actualVariants + 2);
39 InitNoneValue(expectedVariants + 3, FALSE, L"PROP4", actualVariants + 3);
40 InitNoneValue(expectedVariants + 4, TRUE, L"PROP5", actualVariants + 4);
41 InitVersionValue(expectedVariants + 5, L"1.1.1.0", TRUE, L"PROP6", actualVariants + 5);
42 InitStringValue(expectedVariants + 6, L"7", TRUE, L"PROP7", actualVariants + 6);
43 InitNumericValue(expectedVariants + 7, 11, TRUE, L"PROP8", actualVariants + 7);
44 InitFormattedValue(expectedVariants + 8, L"VAL9", FALSE, L"PROP9", actualVariants + 8);
45 InitFormattedValue(expectedVariants + 9, L"VAL10", TRUE, L"PROP10", actualVariants + 9);
46
47 VerifyNumericValue(expectedVariants + 0, actualVariants + 0);
48 VerifyStringValue(expectedVariants + 1, actualVariants + 1);
49 VerifyVersionValue(expectedVariants + 2, actualVariants + 2);
50 VerifyNoneValue(expectedVariants + 3, actualVariants + 3);
51 VerifyNoneValue(expectedVariants + 4, actualVariants + 4);
52 VerifyVersionValue(expectedVariants + 5, actualVariants + 5);
53 VerifyStringValue(expectedVariants + 6, actualVariants + 6);
54 VerifyNumericValue(expectedVariants + 7, actualVariants + 7);
55 VerifyFormattedValue(expectedVariants + 8, actualVariants + 8);
56 VerifyFormattedValue(expectedVariants + 9, actualVariants + 9);
57 }
58 finally
59 {
60 for (DWORD i = 0; i < 10; i++)
61 {
62 BVariantUninitialize(expectedVariants + i);
63 BVariantUninitialize(actualVariants + i);
64 }
65 }
66 }
67
68 private:
69 void InitFormattedValue(BURN_VARIANT* pValue, LPWSTR wzValue, BOOL /*fHidden*/, LPCWSTR wz, BURN_VARIANT* pActualValue)
70 {
71 HRESULT hr = S_OK;
72 pValue->Type = BURN_VARIANT_TYPE_FORMATTED;
73
74 hr = StrAllocString(&pValue->sczValue, wzValue, 0);
75 NativeAssert::Succeeded(hr, "Failed to alloc string: {0}", wzValue);
76
77 hr = BVariantCopy(pValue, pActualValue);
78 NativeAssert::Succeeded(hr, "Failed to copy variant {0}", wz);
79 }
80
81 void InitNoneValue(BURN_VARIANT* pValue, BOOL /*fHidden*/, LPCWSTR wz, BURN_VARIANT* pActualValue)
82 {
83 HRESULT hr = S_OK;
84 pValue->Type = BURN_VARIANT_TYPE_NONE;
85
86 hr = BVariantCopy(pValue, pActualValue);
87 NativeAssert::Succeeded(hr, "Failed to copy variant {0}", wz);
88 }
89
90 void InitNumericValue(BURN_VARIANT* pValue, LONGLONG llValue, BOOL /*fHidden*/, LPCWSTR wz, BURN_VARIANT* pActualValue)
91 {
92 HRESULT hr = S_OK;
93 pValue->Type = BURN_VARIANT_TYPE_NUMERIC;
94 pValue->llValue = llValue;
95
96 hr = BVariantCopy(pValue, pActualValue);
97 NativeAssert::Succeeded(hr, "Failed to copy variant {0}", wz);
98 }
99
100 void InitStringValue(BURN_VARIANT* pValue, LPWSTR wzValue, BOOL /*fHidden*/, LPCWSTR wz, BURN_VARIANT* pActualValue)
101 {
102 HRESULT hr = S_OK;
103 pValue->Type = BURN_VARIANT_TYPE_STRING;
104
105 hr = StrAllocString(&pValue->sczValue, wzValue, 0);
106 NativeAssert::Succeeded(hr, "Failed to alloc string: {0}", wzValue);
107
108 hr = BVariantCopy(pValue, pActualValue);
109 NativeAssert::Succeeded(hr, "Failed to copy variant {0}", wz);
110 }
111
112 void InitVersionValue(BURN_VARIANT* pValue, LPCWSTR wzValue, BOOL /*fHidden*/, LPCWSTR wz, BURN_VARIANT* pActualValue)
113 {
114 HRESULT hr = S_OK;
115 VERUTIL_VERSION* pVersion = NULL;
116
117 try
118 {
119 hr = VerParseVersion(wzValue, 0, FALSE, &pVersion);
120 NativeAssert::Succeeded(hr, "Failed to parse version {0}", wzValue);
121
122 pValue->Type = BURN_VARIANT_TYPE_VERSION;
123 pValue->pValue = pVersion;
124 pVersion = NULL;
125
126 hr = BVariantCopy(pValue, pActualValue);
127 NativeAssert::Succeeded(hr, "Failed to copy variant {0}", wz);
128 }
129 finally
130 {
131 ReleaseVerutilVersion(pVersion);
132 }
133 }
134
135 void VerifyFormattedValue(BURN_VARIANT* pExpectedValue, BURN_VARIANT* pActualValue)
136 {
137 HRESULT hr = S_OK;
138 LPWSTR sczValue = NULL;
139 NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_FORMATTED, pExpectedValue->Type);
140 NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_FORMATTED, pActualValue->Type);
141
142 try
143 {
144 hr = BVariantGetString(pActualValue, &sczValue);
145 NativeAssert::Succeeded(hr, "Failed to get string value");
146
147 NativeAssert::StringEqual(pExpectedValue->sczValue, sczValue);
148 }
149 finally
150 {
151 ReleaseStr(sczValue);
152 }
153 }
154
155 void VerifyNumericValue(BURN_VARIANT* pExpectedValue, BURN_VARIANT* pActualValue)
156 {
157 HRESULT hr = S_OK;
158 LONGLONG llValue = 0;
159 NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_NUMERIC, pExpectedValue->Type);
160 NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_NUMERIC, pActualValue->Type);
161
162 hr = BVariantGetNumeric(pActualValue, &llValue);
163 NativeAssert::Succeeded(hr, "Failed to get numeric value");
164
165 NativeAssert::Equal<LONGLONG>(pExpectedValue->llValue, llValue);
166 }
167
168 void VerifyNoneValue(BURN_VARIANT* pExpectedValue, BURN_VARIANT* pActualValue)
169 {
170 NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_NONE, pExpectedValue->Type);
171 NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_NONE, pActualValue->Type);
172 NativeAssert::Equal<LONGLONG>(pExpectedValue->llValue, pActualValue->llValue);
173 }
174
175 void VerifyStringValue(BURN_VARIANT* pExpectedValue, BURN_VARIANT* pActualValue)
176 {
177 HRESULT hr = S_OK;
178 LPWSTR sczValue = NULL;
179 NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_STRING, pExpectedValue->Type);
180 NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_STRING, pActualValue->Type);
181
182 try
183 {
184 hr = BVariantGetString(pActualValue, &sczValue);
185 NativeAssert::Succeeded(hr, "Failed to get string value");
186
187 NativeAssert::StringEqual(pExpectedValue->sczValue, sczValue);
188 }
189 finally
190 {
191 ReleaseStr(sczValue);
192 }
193 }
194
195 void VerifyVersionValue(BURN_VARIANT* pExpectedValue, BURN_VARIANT* pActualValue)
196 {
197 HRESULT hr = S_OK;
198 VERUTIL_VERSION* pValue = NULL;
199 NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_VERSION, pExpectedValue->Type);
200 NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_VERSION, pActualValue->Type);
201
202 try
203 {
204 hr = BVariantGetVersion(pActualValue, &pValue);
205 NativeAssert::Succeeded(hr, "Failed to get version value");
206
207 NativeAssert::StringEqual(pExpectedValue->pValue->sczVersion, pActualValue->pValue->sczVersion);
208 }
209 finally
210 {
211 ReleaseVerutilVersion(pValue);
212 }
213 }
214 };
215 }
216 }
217 }
218 }
219 }