Add VariantTest.

4 files changed, 209 insertions, 4 deletions

diff --git a/src/test/BurnUnitTest/BurnTestFixture.h b/src/test/BurnUnitTest/BurnTestFixture.h
index f158c192..6b041641 100644
--- a/src/test/BurnUnitTest/BurnTestFixture.h
+++ b/src/test/BurnUnitTest/BurnTestFixture.h
@@ -26,6 +26,9 @@ namespace Bootstrapper
             hr = RegInitialize();
             TestThrowOnFailure(hr, L"Failed to initialize Regutil.");
 
+            hr = CrypInitialize();
+            TestThrowOnFailure(hr, L"Failed to initialize Cryputil.");
+
             PlatformInitialize();
 
             this->testDirectory = WixBuildTools::TestSupport::TestData::Get();
@@ -38,6 +41,7 @@ namespace Bootstrapper
 
         ~BurnTestFixture()
         {
+            CrypUninitialize();
             XmlUninitialize();
             RegUninitialize();
             LogUninitialize(FALSE);
diff --git a/src/test/BurnUnitTest/BurnUnitTest.vcxproj b/src/test/BurnUnitTest/BurnUnitTest.vcxproj
index 93b3e562..3f3c7b4f 100644
--- a/src/test/BurnUnitTest/BurnUnitTest.vcxproj
+++ b/src/test/BurnUnitTest/BurnUnitTest.vcxproj
@@ -46,6 +46,7 @@
     <ClCompile Include="SearchTest.cpp" />
     <ClCompile Include="VariableHelpers.cpp" />
     <ClCompile Include="VariableTest.cpp" />
+    <ClCompile Include="VariantTest.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="BurnTestException.h" />
diff --git a/src/test/BurnUnitTest/BurnUnitTest.vcxproj.filters b/src/test/BurnUnitTest/BurnUnitTest.vcxproj.filters
index bee5d15e..14261ba0 100644
--- a/src/test/BurnUnitTest/BurnUnitTest.vcxproj.filters
+++ b/src/test/BurnUnitTest/BurnUnitTest.vcxproj.filters
@@ -18,6 +18,9 @@
     <ClCompile Include="AssemblyInfo.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="CacheTest.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="ElevationTest.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -27,6 +30,9 @@
     <ClCompile Include="ManifestTest.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="precomp.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="RegistrationTest.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -39,10 +45,7 @@
     <ClCompile Include="VariableTest.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="CacheTest.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="$(WixRoot)src\common\precomp.cpp">
+    <ClCompile Include="VariantTest.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>
diff --git a/src/test/BurnUnitTest/VariantTest.cpp b/src/test/BurnUnitTest/VariantTest.cpp
new file mode 100644
index 00000000..dd679f08
--- /dev/null
+++ b/src/test/BurnUnitTest/VariantTest.cpp
@@ -0,0 +1,197 @@
+// 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.
+
+#include "precomp.h"
+
+namespace Microsoft
+{
+namespace Tools
+{
+namespace WindowsInstallerXml
+{
+namespace Test
+{
+namespace Bootstrapper
+{
+    using namespace System;
+    using namespace Xunit;
+
+    public ref class VariantTest : BurnUnitTest
+    {
+    public:
+        VariantTest(BurnTestFixture^ fixture) : BurnUnitTest(fixture)
+        {
+        }
+
+        [Fact]
+        void VariantBasicTest()
+        {
+            BURN_VARIANT expectedVariants[8];
+            BURN_VARIANT actualVariants[8];
+            for (DWORD i = 0; i < 8; i++)
+            {
+                BVariantUninitialize(expectedVariants + i);
+                BVariantUninitialize(actualVariants + i);
+            }
+
+            try
+            {
+                InitNumericValue(expectedVariants + 0, 2, FALSE, L"PROP1", actualVariants + 0);
+                InitStringValue(expectedVariants + 1, L"VAL2", FALSE, L"PROP2", actualVariants + 1);
+                InitVersionValue(expectedVariants + 2, MAKEQWORDVERSION(1, 1, 0, 0), FALSE, L"PROP3", actualVariants + 2);
+                InitNoneValue(expectedVariants + 3, FALSE, L"PROP4", actualVariants + 3);
+                InitNoneValue(expectedVariants + 4, TRUE, L"PROP5", actualVariants + 4);
+                InitVersionValue(expectedVariants + 5, MAKEQWORDVERSION(1, 1, 1, 0), TRUE, L"PROP6", actualVariants + 5);
+                InitStringValue(expectedVariants + 6, L"7", TRUE, L"PROP7", actualVariants + 6);
+                InitNumericValue(expectedVariants + 7, 11, TRUE, L"PROP8", actualVariants + 7);
+
+                VerifyNumericValue(expectedVariants + 0, actualVariants + 0);
+                VerifyStringValue(expectedVariants + 1, actualVariants + 1);
+                VerifyVersionValue(expectedVariants + 2, actualVariants + 2);
+                VerifyNoneValue(expectedVariants + 3, actualVariants + 3);
+                VerifyNoneValue(expectedVariants + 4, actualVariants + 4);
+                VerifyVersionValue(expectedVariants + 5, actualVariants + 5);
+                VerifyStringValue(expectedVariants + 6, actualVariants + 6);
+                VerifyNumericValue(expectedVariants + 7, actualVariants + 7);
+            }
+            finally
+            {
+                for (DWORD i = 0; i < 8; i++)
+                {
+                    BVariantUninitialize(expectedVariants + i);
+                    BVariantUninitialize(actualVariants + i);
+                }
+            }
+        }
+
+    private:
+        void InitNoneValue(BURN_VARIANT* pValue, BOOL fHidden, LPCWSTR wz, BURN_VARIANT* pActualValue)
+        {
+            HRESULT hr = S_OK;
+            pValue->Type = BURN_VARIANT_TYPE_NONE;
+
+            hr = BVariantCopy(pValue, pActualValue);
+            NativeAssert::Succeeded(hr, "Failed to copy variant {0}", wz);
+
+            if (fHidden)
+            {
+                hr = BVariantSetEncryption(pActualValue, TRUE);
+                NativeAssert::Succeeded(hr, "Failed to encrypt variant {0}", wz);
+
+                NativeAssert::True(pActualValue->fEncryptValue);
+            }
+        }
+
+        void InitNumericValue(BURN_VARIANT* pValue, LONGLONG llValue, BOOL fHidden, LPCWSTR wz, BURN_VARIANT* pActualValue)
+        {
+            HRESULT hr = S_OK;
+            pValue->Type = BURN_VARIANT_TYPE_NUMERIC;
+            pValue->llValue = llValue;
+
+            hr = BVariantCopy(pValue, pActualValue);
+            NativeAssert::Succeeded(hr, "Failed to copy variant {0}", wz);
+
+            if (fHidden)
+            {
+                hr = BVariantSetEncryption(pActualValue, TRUE);
+                NativeAssert::Succeeded(hr, "Failed to encrypt variant {0}", wz);
+
+                NativeAssert::True(pActualValue->fEncryptValue);
+            }
+        }
+
+        void InitStringValue(BURN_VARIANT* pValue, LPWSTR wzValue, BOOL fHidden, LPCWSTR wz, BURN_VARIANT* pActualValue)
+        {
+            HRESULT hr = S_OK;
+            pValue->Type = BURN_VARIANT_TYPE_STRING;
+
+            hr = StrAllocString(&pValue->sczValue, wzValue, 0);
+            NativeAssert::Succeeded(hr, "Failed to alloc string: {0}", wzValue);
+
+            hr = BVariantCopy(pValue, pActualValue);
+            NativeAssert::Succeeded(hr, "Failed to copy variant {0}", wz);
+
+            if (fHidden)
+            {
+                hr = BVariantSetEncryption(pActualValue, TRUE);
+                NativeAssert::Succeeded(hr, "Failed to encrypt variant {0}", wz);
+
+                NativeAssert::True(pActualValue->fEncryptValue);
+            }
+        }
+
+        void InitVersionValue(BURN_VARIANT* pValue, DWORD64 qwValue, BOOL fHidden, LPCWSTR wz, BURN_VARIANT* pActualValue)
+        {
+            HRESULT hr = S_OK;
+            pValue->Type = BURN_VARIANT_TYPE_VERSION;
+            pValue->qwValue = qwValue;
+
+            hr = BVariantCopy(pValue, pActualValue);
+            NativeAssert::Succeeded(hr, "Failed to copy variant {0}", wz);
+
+            if (fHidden)
+            {
+                hr = BVariantSetEncryption(pActualValue, TRUE);
+                NativeAssert::Succeeded(hr, "Failed to encrypt variant {0}", wz);
+
+                NativeAssert::True(pActualValue->fEncryptValue);
+            }
+        }
+
+        void VerifyNumericValue(BURN_VARIANT* pExpectedValue, BURN_VARIANT* pActualValue)
+        {
+            HRESULT hr = S_OK;
+            LONGLONG llValue = 0;
+            NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_NUMERIC, pExpectedValue->Type);
+            NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_NUMERIC, pActualValue->Type);
+
+            hr = BVariantGetNumeric(pActualValue, &llValue);
+            NativeAssert::Succeeded(hr, "Failed to get numeric value");
+
+            NativeAssert::Equal<LONGLONG>(pExpectedValue->llValue, llValue);
+        }
+
+        void VerifyNoneValue(BURN_VARIANT* pExpectedValue, BURN_VARIANT* pActualValue)
+        {
+            NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_NONE, pExpectedValue->Type);
+            NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_NONE, pActualValue->Type);
+            NativeAssert::Equal<LONGLONG>(pExpectedValue->llValue, pActualValue->llValue);
+        }
+
+        void VerifyStringValue(BURN_VARIANT* pExpectedValue, BURN_VARIANT* pActualValue)
+        {
+            HRESULT hr = S_OK;
+            LPWSTR sczValue = NULL;
+            NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_STRING, pExpectedValue->Type);
+            NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_STRING, pActualValue->Type);
+
+            try
+            {
+                hr = BVariantGetString(pActualValue, &sczValue);
+                NativeAssert::Succeeded(hr, "Failed to get numeric value");
+
+                NativeAssert::StringEqual(pExpectedValue->sczValue, sczValue);
+            }
+            finally
+            {
+                ReleaseStr(sczValue);
+            }
+        }
+
+        void VerifyVersionValue(BURN_VARIANT* pExpectedValue, BURN_VARIANT* pActualValue)
+        {
+            HRESULT hr = S_OK;
+            DWORD64 qwValue = 0;
+            NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_VERSION, pExpectedValue->Type);
+            NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_VERSION, pActualValue->Type);
+
+            hr = BVariantGetVersion(pActualValue, &qwValue);
+            NativeAssert::Succeeded(hr, "Failed to get numeric value");
+
+            NativeAssert::Equal<DWORD64>(pExpectedValue->qwValue, qwValue);
+        }
+    };
+}
+}
+}
+}
+}