WIXFEAT:4763 Change "string" variable type to literal and add "formatted".

5 files changed, 181 insertions, 37 deletions

diff --git a/src/test/BurnUnitTest/SearchTest.cpp b/src/test/BurnUnitTest/SearchTest.cpp
index 48ab60aa..32107d87 100644
--- a/src/test/BurnUnitTest/SearchTest.cpp
+++ b/src/test/BurnUnitTest/SearchTest.cpp
@@ -66,8 +66,8 @@ namespace Bootstrapper
                 pin_ptr<const WCHAR> wzDirectory1 = PtrToStringChars(this->TestContext->TestDirectory);
                 pin_ptr<const WCHAR> wzDirectory2 = PtrToStringChars(System::IO::Path::Combine(this->TestContext->TestDirectory, gcnew String(L"none")));
 
-                VariableSetStringHelper(&variables, L"Directory1", wzDirectory1);
-                VariableSetStringHelper(&variables, L"Directory2", wzDirectory2);
+                VariableSetStringHelper(&variables, L"Directory1", wzDirectory1, FALSE);
+                VariableSetStringHelper(&variables, L"Directory2", wzDirectory2, FALSE);
 
                 LPCWSTR wzDocument =
                     L"<Bundle>"
@@ -117,8 +117,8 @@ namespace Bootstrapper
                 hr = FileVersion(wzFile2, &uliVersion.HighPart, &uliVersion.LowPart);
                 TestThrowOnFailure(hr, L"Failed to get DLL version.");
 
-                VariableSetStringHelper(&variables, L"File1", wzFile1);
-                VariableSetStringHelper(&variables, L"File2", wzFile2);
+                VariableSetStringHelper(&variables, L"File1", wzFile1, FALSE);
+                VariableSetStringHelper(&variables, L"File2", wzFile2, FALSE);
 
                 LPCWSTR wzDocument =
                     L"<Bundle>"
@@ -191,8 +191,8 @@ namespace Bootstrapper
                     Assert::True(SUCCEEDED(hr));
                 }
 
-                VariableSetStringHelper(&variables, L"MyKey", L"SOFTWARE\\Microsoft\\WiX_Burn_UnitTest\\Value");
-                VariableSetStringHelper(&variables, L"MyValue", L"String");
+                VariableSetStringHelper(&variables, L"MyKey", L"SOFTWARE\\Microsoft\\WiX_Burn_UnitTest\\Value", FALSE);
+                VariableSetStringHelper(&variables, L"MyValue", L"String", FALSE);
 
                 LPCWSTR wzDocument =
                     L"<Bundle>"
@@ -219,8 +219,9 @@ namespace Bootstrapper
                     L"    <RegistrySearch Id='Search21' Type='value' Root='HKCU' Key='SOFTWARE\\Classes\\CLSID\\WiX_Burn_UnitTest\\Bitness' Value='TestStringSpecificToBitness' Variable='Variable21' VariableType='string' Win64='no' />"
                     L"    <RegistrySearch Id='Search22' Type='value' Root='HKCU' Key='SOFTWARE\\Classes\\CLSID\\WiX_Burn_UnitTest\\Bitness' Value='TestStringSpecificToBitness' Variable='Variable22' VariableType='string' Win64='yes' />"
                     L"    <RegistrySearch Id='Search23' Type='exists' Root='HKU' Key='.DEFAULT\\Environment' Variable='Variable23' />"
-                    L"    <RegistrySearch Id='Search23' Type='exists' Root='HKU' Key='.DEFAULT\\System\\NetworkServiceSidSubkeyDoesNotExist' Variable='Variable24' />"
-                    L"    <RegistrySearch Id='Search24' Type='value' Root='HKCR' Key='.msi' Variable='Variable25' VariableType='string' />"
+                    L"    <RegistrySearch Id='Search24' Type='exists' Root='HKU' Key='.DEFAULT\\System\\NetworkServiceSidSubkeyDoesNotExist' Variable='Variable24' />"
+                    L"    <RegistrySearch Id='Search25' Type='value' Root='HKCR' Key='.msi' Variable='Variable25' VariableType='string' />"
+                    L"    <RegistrySearch Id='Search26' Type='value' Root='HKCR' Key='.msi' Variable='Variable26' VariableType='formatted' />"
                     L"</Bundle>";
 
                 // load XML document
@@ -263,6 +264,7 @@ namespace Bootstrapper
                 Assert::Equal(1ll, VariableGetNumericHelper(&variables, L"Variable23"));
                 Assert::Equal(0ll, VariableGetNumericHelper(&variables, L"Variable24"));
                 Assert::Equal<String^>(gcnew String(L"Msi.Package"), VariableGetStringHelper(&variables, L"Variable25"));
+                Assert::Equal<String^>(gcnew String(L"Msi.Package"), VariableGetStringHelper(&variables, L"Variable26"));
             }
             finally
             {
@@ -525,6 +527,75 @@ namespace Bootstrapper
                 SearchesUninitialize(&searches);
             }
         }
+
+        [Fact]
+        void SetVariableSearchTest()
+        {
+            HRESULT hr = S_OK;
+            IXMLDOMElement* pixeBundle = NULL;
+            BURN_VARIABLES variables = { };
+            BURN_SEARCHES searches = { };
+            BURN_EXTENSIONS burnExtensions = { };
+            try
+            {
+                LPCWSTR wzDocument =
+                    L"<Bundle>"
+                    L"    <SetVariable Id='Search1' Type='string' Value='VAL1' Variable='PROP1' />"
+                    L"    <SetVariable Id='Search2' Type='numeric' Value='2' Variable='PROP2' />"
+                    L"    <SetVariable Id='Search3' Type='string' Value='VAL3' Variable='PROP3' />"
+                    L"    <SetVariable Id='Search4' Type='string' Value='VAL4' Variable='PROP4' />"
+                    L"    <SetVariable Id='Search5' Type='string' Value='VAL5' Variable='PROP5' />"
+                    L"    <SetVariable Id='Search6' Type='string' Value='VAL6' Variable='PROP6' />"
+                    L"    <SetVariable Id='Search7' Type='string' Value='7' Variable='PROP7' />"
+                    L"    <SetVariable Id='Search8' Type='version' Value='1.1.0.0' Variable='PROP8' />"
+                    L"    <SetVariable Id='Search9' Type='formatted' Value='[VAL9]' Variable='PROP9' />"
+                    L"    <SetVariable Id='Search10' Type='numeric' Value='42' Variable='OVERWRITTEN_STRING' />"
+                    L"    <SetVariable Id='Search11' Type='string' Value='NEW' Variable='OVERWRITTEN_NUMBER' />"
+                    L"    <SetVariable Id='Search12' Variable='REMOVED_NUMBER' />"
+                    L"</Bundle>";
+
+                hr = VariableInitialize(&variables);
+                TestThrowOnFailure(hr, L"Failed to initialize variables.");
+
+                // set variables
+                VariableSetStringHelper(&variables, L"OVERWRITTEN_STRING", L"ORIGINAL", FALSE);
+                VariableSetNumericHelper(&variables, L"OVERWRITTEN_NUMBER", 5);
+                VariableSetNumericHelper(&variables, L"REMOVED_NUMBER", 22);
+
+                // load XML document
+                LoadBundleXmlHelper(wzDocument, &pixeBundle);
+
+                hr = SearchesParseFromXml(&searches, &burnExtensions, pixeBundle);
+                TestThrowOnFailure(hr, L"Failed to parse searches from XML.");
+
+                // execute searches
+                hr = SearchesExecute(&searches, &variables);
+                TestThrowOnFailure(hr, L"Failed to execute searches.");
+
+                // check variable values
+                Assert::Equal<String^>(gcnew String(L"VAL1"), VariableGetStringHelper(&variables, L"PROP1"));
+                Assert::Equal(2ll, VariableGetNumericHelper(&variables, L"PROP2"));
+                Assert::Equal<String^>(gcnew String(L"2"), VariableGetStringHelper(&variables, L"PROP2"));
+                Assert::Equal<String^>(gcnew String(L"VAL3"), VariableGetStringHelper(&variables, L"PROP3"));
+                Assert::Equal<String^>(gcnew String(L"VAL4"), VariableGetStringHelper(&variables, L"PROP4"));
+                Assert::Equal<String^>(gcnew String(L"VAL5"), VariableGetStringHelper(&variables, L"PROP5"));
+                Assert::Equal<String^>(gcnew String(L"VAL6"), VariableGetStringHelper(&variables, L"PROP6"));
+                Assert::Equal(7ll, VariableGetNumericHelper(&variables, L"PROP7"));
+                Assert::Equal(MAKEQWORDVERSION(1, 1, 0, 0), VariableGetVersionHelper(&variables, L"PROP8"));
+                Assert::Equal<String^>(gcnew String(L"1.1.0.0"), VariableGetStringHelper(&variables, L"PROP8"));
+                Assert::Equal<String^>(gcnew String(L"[VAL9]"), VariableGetStringHelper(&variables, L"PROP9"));
+
+                Assert::Equal(42ll, VariableGetNumericHelper(&variables, L"OVERWRITTEN_STRING"));
+                Assert::Equal<String^>(gcnew String(L"NEW"), VariableGetStringHelper(&variables, L"OVERWRITTEN_NUMBER"));
+                Assert::Equal((int)BURN_VARIANT_TYPE_NONE, VariableGetTypeHelper(&variables, L"REMOVED_NUMBER"));
+            }
+            finally
+            {
+                ReleaseObject(pixeBundle);
+                VariablesUninitialize(&variables);
+                SearchesUninitialize(&searches);
+            }
+        }
     };
 }
 }
diff --git a/src/test/BurnUnitTest/VariableHelpers.cpp b/src/test/BurnUnitTest/VariableHelpers.cpp
index 9ce46a76..fdfb9191 100644
--- a/src/test/BurnUnitTest/VariableHelpers.cpp
+++ b/src/test/BurnUnitTest/VariableHelpers.cpp
@@ -17,11 +17,11 @@ namespace Test
 {
 namespace Bootstrapper
 {
-    void VariableSetStringHelper(BURN_VARIABLES* pVariables, LPCWSTR wzVariable, LPCWSTR wzValue)
+    void VariableSetStringHelper(BURN_VARIABLES* pVariables, LPCWSTR wzVariable, LPCWSTR wzValue, BOOL fFormatted)
     {
         HRESULT hr = S_OK;
 
-        hr = VariableSetString(pVariables, wzVariable, wzValue, FALSE);
+        hr = VariableSetString(pVariables, wzVariable, wzValue, FALSE, fFormatted);
         TestThrowOnFailure2(hr, L"Failed to set %s to: %s", wzVariable, wzValue);
     }
 
diff --git a/src/test/BurnUnitTest/VariableHelpers.h b/src/test/BurnUnitTest/VariableHelpers.h
index 98c52649..8c2b081a 100644
--- a/src/test/BurnUnitTest/VariableHelpers.h
+++ b/src/test/BurnUnitTest/VariableHelpers.h
@@ -14,7 +14,7 @@ namespace Bootstrapper
 {
 
 
-void VariableSetStringHelper(BURN_VARIABLES* pVariables, LPCWSTR wzVariable, LPCWSTR wzValue);
+void VariableSetStringHelper(BURN_VARIABLES* pVariables, LPCWSTR wzVariable, LPCWSTR wzValue, BOOL fFormatted);
 void VariableSetNumericHelper(BURN_VARIABLES* pVariables, LPCWSTR wzVariable, LONGLONG llValue);
 void VariableSetVersionHelper(BURN_VARIABLES* pVariables, LPCWSTR wzVariable, DWORD64 qwValue);
 System::String^ VariableGetStringHelper(BURN_VARIABLES* pVariables, LPCWSTR wzVariable);
diff --git a/src/test/BurnUnitTest/VariableTest.cpp b/src/test/BurnUnitTest/VariableTest.cpp
index 7d670744..0b49a530 100644
--- a/src/test/BurnUnitTest/VariableTest.cpp
+++ b/src/test/BurnUnitTest/VariableTest.cpp
@@ -35,21 +35,22 @@ namespace Bootstrapper
                 TestThrowOnFailure(hr, L"Failed to initialize variables.");
 
                 // set variables
-                VariableSetStringHelper(&variables, L"PROP1", L"VAL1");
+                VariableSetStringHelper(&variables, L"PROP1", L"VAL1", FALSE);
                 VariableSetNumericHelper(&variables, L"PROP2", 2);
-                VariableSetStringHelper(&variables, L"PROP5", L"VAL5");
-                VariableSetStringHelper(&variables, L"PROP3", L"VAL3");
-                VariableSetStringHelper(&variables, L"PROP4", L"VAL4");
-                VariableSetStringHelper(&variables, L"PROP6", L"VAL6");
-                VariableSetStringHelper(&variables, L"PROP7", L"7");
+                VariableSetStringHelper(&variables, L"PROP5", L"VAL5", FALSE);
+                VariableSetStringHelper(&variables, L"PROP3", L"VAL3", FALSE);
+                VariableSetStringHelper(&variables, L"PROP4", L"VAL4", FALSE);
+                VariableSetStringHelper(&variables, L"PROP6", L"VAL6", FALSE);
+                VariableSetStringHelper(&variables, L"PROP7", L"7", FALSE);
                 VariableSetVersionHelper(&variables, L"PROP8", MAKEQWORDVERSION(1,1,0,0));
+                VariableSetStringHelper(&variables, L"PROP9", L"[VAL9]", TRUE);
 
                 // set overwritten variables
-                VariableSetStringHelper(&variables, L"OVERWRITTEN_STRING", L"ORIGINAL");
+                VariableSetStringHelper(&variables, L"OVERWRITTEN_STRING", L"ORIGINAL", FALSE);
                 VariableSetNumericHelper(&variables, L"OVERWRITTEN_STRING", 42);
 
                 VariableSetNumericHelper(&variables, L"OVERWRITTEN_NUMBER", 5);
-                VariableSetStringHelper(&variables, L"OVERWRITTEN_NUMBER", L"NEW");
+                VariableSetStringHelper(&variables, L"OVERWRITTEN_NUMBER", L"NEW", FALSE);
 
                 // get and verify variable values
                 Assert::Equal<String^>(gcnew String(L"VAL1"), VariableGetStringHelper(&variables, L"PROP1"));
@@ -62,6 +63,7 @@ namespace Bootstrapper
                 Assert::Equal(7ll, VariableGetNumericHelper(&variables, L"PROP7"));
                 Assert::Equal(MAKEQWORDVERSION(1,1,0,0), VariableGetVersionHelper(&variables, L"PROP8"));
                 Assert::Equal<String^>(gcnew String(L"1.1.0.0"), VariableGetStringHelper(&variables, L"PROP8"));
+                Assert::Equal<String^>(gcnew String(L"[VAL9]"), VariableGetStringHelper(&variables, L"PROP9"));
 
                 Assert::Equal(42ll, VariableGetNumericHelper(&variables, L"OVERWRITTEN_STRING"));
                 Assert::Equal<String^>(gcnew String(L"NEW"), VariableGetStringHelper(&variables, L"OVERWRITTEN_NUMBER"));
@@ -87,6 +89,7 @@ namespace Bootstrapper
                     L"    <Variable Id='Var3' Type='version' Value='1.2.3.4' Hidden='no' Persisted='no' />"
                     L"    <Variable Id='Var4' Hidden='no' Persisted='no' />"
                     L"    <Variable Id='Var5' Type='string' Value='' Hidden='no' Persisted='no' />"
+                    L"    <Variable Id='Var6' Type='formatted' Value='[Formatted]' Hidden='no' Persisted='no' />"
                     L"</Bundle>";
 
                 hr = VariableInitialize(&variables);
@@ -103,10 +106,12 @@ namespace Bootstrapper
                 Assert::Equal((int)BURN_VARIANT_TYPE_STRING, VariableGetTypeHelper(&variables, L"Var2"));
                 Assert::Equal((int)BURN_VARIANT_TYPE_VERSION, VariableGetTypeHelper(&variables, L"Var3"));
                 Assert::Equal((int)BURN_VARIANT_TYPE_NONE, VariableGetTypeHelper(&variables, L"Var4"));
+                Assert::Equal((int)BURN_VARIANT_TYPE_FORMATTED, VariableGetTypeHelper(&variables, L"Var6"));
 
                 Assert::Equal(1ll, VariableGetNumericHelper(&variables, L"Var1"));
                 Assert::Equal<String^>(gcnew String(L"String value."), VariableGetStringHelper(&variables, L"Var2"));
                 Assert::Equal(MAKEQWORDVERSION(1,2,3,4), VariableGetVersionHelper(&variables, L"Var3"));
+                Assert::Equal<String^>(gcnew String(L"[Formatted]"), VariableGetStringHelper(&variables, L"Var6"));
             }
             finally
             {
@@ -128,9 +133,13 @@ namespace Bootstrapper
                 TestThrowOnFailure(hr, L"Failed to initialize variables.");
 
                 // set variables
-                VariableSetStringHelper(&variables, L"PROP1", L"VAL1");
-                VariableSetStringHelper(&variables, L"PROP2", L"VAL2");
+                VariableSetStringHelper(&variables, L"PROP1", L"VAL1", FALSE);
+                VariableSetStringHelper(&variables, L"PROP2", L"VAL2", FALSE);
                 VariableSetNumericHelper(&variables, L"PROP3", 3);
+                VariableSetStringHelper(&variables, L"PROP4", L"[PROP1]", FALSE);
+                VariableSetStringHelper(&variables, L"PROP5", L"[PROP2]", FALSE);
+                VariableSetStringHelper(&variables, L"PROP6", L"[PROP4]", TRUE);
+                VariableSetStringHelper(&variables, L"PROP7", L"[PROP5]", TRUE);
 
                 // test string formatting
                 Assert::Equal<String^>(gcnew String(L"NOPROP"), VariableFormatStringHelper(&variables, L"NOPROP"));
@@ -148,6 +157,10 @@ namespace Bootstrapper
                 Assert::Equal<String^>(gcnew String(L"[NONE"), VariableFormatStringHelper(&variables, L"[NONE"));
                 Assert::Equal<String^>(gcnew String(L"VAL2"), VariableGetFormattedHelper(&variables, L"PROP2"));
                 Assert::Equal<String^>(gcnew String(L"3"), VariableGetFormattedHelper(&variables, L"PROP3"));
+                Assert::Equal<String^>(gcnew String(L"[PROP1]"), VariableGetFormattedHelper(&variables, L"PROP4"));
+                Assert::Equal<String^>(gcnew String(L"[PROP2]"), VariableGetFormattedHelper(&variables, L"PROP5"));
+                Assert::Equal<String^>(gcnew String(L"[PROP1]"), VariableGetFormattedHelper(&variables, L"PROP6"));
+                Assert::Equal<String^>(gcnew String(L"[PROP2]"), VariableGetFormattedHelper(&variables, L"PROP7"));
 
                 hr = VariableFormatString(&variables, L"PRE [PROP1] POST", &scz, &cch);
                 TestThrowOnFailure(hr, L"Failed to format string");
@@ -186,15 +199,15 @@ namespace Bootstrapper
                 TestThrowOnFailure(hr, L"Failed to initialize variables.");
 
                 // set variables
-                VariableSetStringHelper(&variables, L"PROP1", L"VAL1");
-                VariableSetStringHelper(&variables, L"PROP2", L"VAL2");
-                VariableSetStringHelper(&variables, L"PROP3", L"VAL3");
-                VariableSetStringHelper(&variables, L"PROP4", L"BEGIN MID END");
+                VariableSetStringHelper(&variables, L"PROP1", L"VAL1", FALSE);
+                VariableSetStringHelper(&variables, L"PROP2", L"VAL2", FALSE);
+                VariableSetStringHelper(&variables, L"PROP3", L"VAL3", FALSE);
+                VariableSetStringHelper(&variables, L"PROP4", L"BEGIN MID END", FALSE);
                 VariableSetNumericHelper(&variables, L"PROP5", 5);
                 VariableSetNumericHelper(&variables, L"PROP6", 6);
-                VariableSetStringHelper(&variables, L"PROP7", L"");
+                VariableSetStringHelper(&variables, L"PROP7", L"", FALSE);
                 VariableSetNumericHelper(&variables, L"PROP8", 0);
-                VariableSetStringHelper(&variables, L"_PROP9", L"VAL9");
+                VariableSetStringHelper(&variables, L"_PROP9", L"VAL9", FALSE);
                 VariableSetNumericHelper(&variables, L"PROP10", -10);
                 VariableSetNumericHelper(&variables, L"PROP11", 9223372036854775807ll);
                 VariableSetNumericHelper(&variables, L"PROP12", -9223372036854775808ll);
@@ -208,7 +221,11 @@ namespace Bootstrapper
                 VariableSetVersionHelper(&variables, L"PROP20", MAKEQWORDVERSION(1,1,1,1));
                 VariableSetNumericHelper(&variables, L"vPROP21", 1);
                 VariableSetVersionHelper(&variables, L"PROP22", MAKEQWORDVERSION(65535,65535,65535,65535));
-                VariableSetStringHelper(&variables, L"PROP23", L"1.1.1");
+                VariableSetStringHelper(&variables, L"PROP23", L"1.1.1", FALSE);
+                VariableSetStringHelper(&variables, L"PROP24", L"[PROP1]", TRUE);
+                VariableSetStringHelper(&variables, L"PROP25", L"[PROP7]", TRUE);
+                VariableSetStringHelper(&variables, L"PROP26", L"[PROP8]", TRUE);
+                VariableSetStringHelper(&variables, L"PROP27", L"[PROP16]", TRUE);
 
                 // test conditions
                 Assert::True(EvaluateConditionHelper(&variables, L"PROP1"));
@@ -218,6 +235,10 @@ namespace Bootstrapper
                 Assert::True(EvaluateConditionHelper(&variables, L"_PROP9"));
                 Assert::False(EvaluateConditionHelper(&variables, L"PROP16"));
                 Assert::True(EvaluateConditionHelper(&variables, L"PROP17"));
+                Assert::True(EvaluateConditionHelper(&variables, L"PROP24"));
+                Assert::True(EvaluateConditionHelper(&variables, L"PROP25"));
+                Assert::True(EvaluateConditionHelper(&variables, L"PROP26"));
+                Assert::True(EvaluateConditionHelper(&variables, L"PROP27"));
 
                 Assert::True(EvaluateConditionHelper(&variables, L"PROP1 = \"VAL1\""));
                 Assert::False(EvaluateConditionHelper(&variables, L"NONE = \"NOT\""));
@@ -365,10 +386,11 @@ namespace Bootstrapper
                 hr = VariableInitialize(&variables1);
                 TestThrowOnFailure(hr, L"Failed to initialize variables.");
 
-                VariableSetStringHelper(&variables1, L"PROP1", L"VAL1");
+                VariableSetStringHelper(&variables1, L"PROP1", L"VAL1", FALSE);
                 VariableSetNumericHelper(&variables1, L"PROP2", 2);
                 VariableSetVersionHelper(&variables1, L"PROP3", MAKEQWORDVERSION(1,1,1,1));
-                VariableSetStringHelper(&variables1, L"PROP4", L"VAL4");
+                VariableSetStringHelper(&variables1, L"PROP4", L"VAL4", FALSE);
+                VariableSetStringHelper(&variables1, L"PROP5", L"[PROP1]", TRUE);
 
                 hr = VariableSerialize(&variables1, FALSE, &pbBuffer, &cbBuffer);
                 TestThrowOnFailure(hr, L"Failed to serialize variables.");
@@ -384,6 +406,13 @@ namespace Bootstrapper
                 Assert::Equal(2ll, VariableGetNumericHelper(&variables2, L"PROP2"));
                 Assert::Equal(MAKEQWORDVERSION(1,1,1,1), VariableGetVersionHelper(&variables2, L"PROP3"));
                 Assert::Equal<String^>(gcnew String(L"VAL4"), VariableGetStringHelper(&variables2, L"PROP4"));
+                Assert::Equal<String^>(gcnew String(L"[PROP1]"), VariableGetStringHelper(&variables2, L"PROP5"));
+
+                Assert::Equal((int)BURN_VARIANT_TYPE_STRING, VariableGetTypeHelper(&variables2, L"PROP1"));
+                Assert::Equal((int)BURN_VARIANT_TYPE_NUMERIC, VariableGetTypeHelper(&variables2, L"PROP2"));
+                Assert::Equal((int)BURN_VARIANT_TYPE_VERSION, VariableGetTypeHelper(&variables2, L"PROP3"));
+                Assert::Equal((int)BURN_VARIANT_TYPE_STRING, VariableGetTypeHelper(&variables2, L"PROP4"));
+                Assert::Equal((int)BURN_VARIANT_TYPE_FORMATTED, VariableGetTypeHelper(&variables2, L"PROP5"));
             }
             finally
             {
@@ -420,7 +449,7 @@ namespace Bootstrapper
                 }
 
                 // attempt to set a built-in property
-                hr = VariableSetString(&variables, L"VersionNT", L"VAL", FALSE);
+                hr = VariableSetString(&variables, L"VersionNT", L"VAL", FALSE, FALSE);
                 Assert::Equal(E_INVALIDARG, hr);
                 Assert::False(EvaluateConditionHelper(&variables, L"VersionNT = \"VAL\""));
 
diff --git a/src/test/BurnUnitTest/VariantTest.cpp b/src/test/BurnUnitTest/VariantTest.cpp
index d16ac699..c982db72 100644
--- a/src/test/BurnUnitTest/VariantTest.cpp
+++ b/src/test/BurnUnitTest/VariantTest.cpp
@@ -25,9 +25,9 @@ namespace Bootstrapper
         [Fact]
         void VariantBasicTest()
         {
-            BURN_VARIANT expectedVariants[8];
-            BURN_VARIANT actualVariants[8];
-            for (DWORD i = 0; i < 8; i++)
+            BURN_VARIANT expectedVariants[10];
+            BURN_VARIANT actualVariants[10];
+            for (DWORD i = 0; i < 10; i++)
             {
                 BVariantUninitialize(expectedVariants + i);
                 BVariantUninitialize(actualVariants + i);
@@ -43,6 +43,8 @@ namespace Bootstrapper
                 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);
+                InitFormattedValue(expectedVariants + 8, L"VAL9", FALSE, L"PROP9", actualVariants + 8);
+                InitFormattedValue(expectedVariants + 9, L"VAL10", TRUE, L"PROP10", actualVariants + 9);
 
                 VerifyNumericValue(expectedVariants + 0, actualVariants + 0);
                 VerifyStringValue(expectedVariants + 1, actualVariants + 1);
@@ -52,10 +54,12 @@ namespace Bootstrapper
                 VerifyVersionValue(expectedVariants + 5, actualVariants + 5);
                 VerifyStringValue(expectedVariants + 6, actualVariants + 6);
                 VerifyNumericValue(expectedVariants + 7, actualVariants + 7);
+                VerifyFormattedValue(expectedVariants + 8, actualVariants + 8);
+                VerifyFormattedValue(expectedVariants + 9, actualVariants + 9);
             }
             finally
             {
-                for (DWORD i = 0; i < 8; i++)
+                for (DWORD i = 0; i < 10; i++)
                 {
                     BVariantUninitialize(expectedVariants + i);
                     BVariantUninitialize(actualVariants + i);
@@ -64,6 +68,26 @@ namespace Bootstrapper
         }
 
     private:
+        void InitFormattedValue(BURN_VARIANT* pValue, LPWSTR wzValue, BOOL fHidden, LPCWSTR wz, BURN_VARIANT* pActualValue)
+        {
+            HRESULT hr = S_OK;
+            pValue->Type = BURN_VARIANT_TYPE_FORMATTED;
+
+            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->fEncryptString);
+            }
+        }
+
         void InitNoneValue(BURN_VARIANT* pValue, BOOL fHidden, LPCWSTR wz, BURN_VARIANT* pActualValue)
         {
             HRESULT hr = S_OK;
@@ -137,6 +161,26 @@ namespace Bootstrapper
             }
         }
 
+        void VerifyFormattedValue(BURN_VARIANT* pExpectedValue, BURN_VARIANT* pActualValue)
+        {
+            HRESULT hr = S_OK;
+            LPWSTR sczValue = NULL;
+            NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_FORMATTED, pExpectedValue->Type);
+            NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_FORMATTED, pActualValue->Type);
+
+            try
+            {
+                hr = BVariantGetString(pActualValue, &sczValue);
+                NativeAssert::Succeeded(hr, "Failed to get string value");
+
+                NativeAssert::StringEqual(pExpectedValue->sczValue, sczValue);
+            }
+            finally
+            {
+                ReleaseStr(sczValue);
+            }
+        }
+
         void VerifyNumericValue(BURN_VARIANT* pExpectedValue, BURN_VARIANT* pActualValue)
         {
             HRESULT hr = S_OK;
@@ -167,7 +211,7 @@ namespace Bootstrapper
             try
             {
                 hr = BVariantGetString(pActualValue, &sczValue);
-                NativeAssert::Succeeded(hr, "Failed to get numeric value");
+                NativeAssert::Succeeded(hr, "Failed to get string value");
 
                 NativeAssert::StringEqual(pExpectedValue->sczValue, sczValue);
             }
@@ -185,7 +229,7 @@ namespace Bootstrapper
             NativeAssert::Equal<DWORD>(BURN_VARIANT_TYPE_VERSION, pActualValue->Type);
 
             hr = BVariantGetVersion(pActualValue, &qwValue);
-            NativeAssert::Succeeded(hr, "Failed to get numeric value");
+            NativeAssert::Succeeded(hr, "Failed to get version value");
 
             NativeAssert::Equal<DWORD64>(pExpectedValue->qwValue, qwValue);
         }