From e845e7c68ae792ab2ccd4ca2f054700dde624375 Mon Sep 17 00:00:00 2001 From: Sean Hall Date: Fri, 17 Jul 2020 21:28:38 +1000 Subject: Add VariantTest. --- src/test/BurnUnitTest/BurnTestFixture.h | 4 + src/test/BurnUnitTest/BurnUnitTest.vcxproj | 1 + src/test/BurnUnitTest/BurnUnitTest.vcxproj.filters | 11 +- src/test/BurnUnitTest/VariantTest.cpp | 197 +++++++++++++++++++++ 4 files changed, 209 insertions(+), 4 deletions(-) create mode 100644 src/test/BurnUnitTest/VariantTest.cpp (limited to 'src/test/BurnUnitTest') 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 @@ + 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 @@ Source Files + + Source Files + Source Files @@ -27,6 +30,9 @@ Source Files + + Source Files + Source Files @@ -39,10 +45,7 @@ Source Files - - Source Files - - + Source Files 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(BURN_VARIANT_TYPE_NUMERIC, pExpectedValue->Type); + NativeAssert::Equal(BURN_VARIANT_TYPE_NUMERIC, pActualValue->Type); + + hr = BVariantGetNumeric(pActualValue, &llValue); + NativeAssert::Succeeded(hr, "Failed to get numeric value"); + + NativeAssert::Equal(pExpectedValue->llValue, llValue); + } + + void VerifyNoneValue(BURN_VARIANT* pExpectedValue, BURN_VARIANT* pActualValue) + { + NativeAssert::Equal(BURN_VARIANT_TYPE_NONE, pExpectedValue->Type); + NativeAssert::Equal(BURN_VARIANT_TYPE_NONE, pActualValue->Type); + NativeAssert::Equal(pExpectedValue->llValue, pActualValue->llValue); + } + + void VerifyStringValue(BURN_VARIANT* pExpectedValue, BURN_VARIANT* pActualValue) + { + HRESULT hr = S_OK; + LPWSTR sczValue = NULL; + NativeAssert::Equal(BURN_VARIANT_TYPE_STRING, pExpectedValue->Type); + NativeAssert::Equal(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(BURN_VARIANT_TYPE_VERSION, pExpectedValue->Type); + NativeAssert::Equal(BURN_VARIANT_TYPE_VERSION, pActualValue->Type); + + hr = BVariantGetVersion(pActualValue, &qwValue); + NativeAssert::Succeeded(hr, "Failed to get numeric value"); + + NativeAssert::Equal(pExpectedValue->qwValue, qwValue); + } + }; +} +} +} +} +} -- cgit v1.2.3-55-g6feb