[vcpkg-tests] Use PCH.

[vcpkg-update] Fix feature packages with update command.
Fixes #2003.

toolsrc/include/tests.pch.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <CppUnitTest.h>
+
+#include <vcpkg/base/sortedvector.h>
+#include <vcpkg/base/strings.h>
+#include <vcpkg/base/util.h>
+#include <vcpkg/binaryparagraph.h>
+#include <vcpkg/dependencies.h>
+#include <vcpkg/packagespec.h>
+#include <vcpkg/packagespecparseresult.h>
+#include <vcpkg/paragraphs.h>
+#include <vcpkg/sourceparagraph.h>
+#include <vcpkg/statusparagraph.h>
+#include <vcpkg/statusparagraphs.h>
+#include <vcpkg/triplet.h>
+#include <vcpkg/update.h>
+#include <vcpkg/vcpkgcmdarguments.h>

toolsrc/include/tests.utils.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <CppUnitTest.h>
+
+#include <vcpkg/dependencies.h>
+#include <vcpkg/packagespec.h>
+#include <vcpkg/packagespecparseresult.h>
+#include <vcpkg/statusparagraph.h>
+
+#include <memory>
+
+namespace Microsoft::VisualStudio::CppUnitTestFramework
+{
+    std::wstring ToString(const vcpkg::Dependencies::InstallPlanType& t);
+    std::wstring ToString(const vcpkg::Dependencies::RequestType& t);
+    std::wstring ToString(const vcpkg::PackageSpecParseResult& t);
+    std::wstring ToString(const vcpkg::PackageSpec& t);
+}
+
+std::unique_ptr<vcpkg::StatusParagraph> make_status_pgh(const char* name,
+                                                        const char* depends = "",
+                                                        const char* triplet = "x86-windows");
+std::unique_ptr<vcpkg::StatusParagraph> make_status_feature_pgh(const char* name,
+                                                                const char* feature,
+                                                                const char* depends = "",
+                                                                const char* triplet = "x86-windows");

toolsrc/include/vcpkg/base/sortedvector.h

@@ -44,6 +44,8 @@ namespace vcpkg
 
         size_type size() const { return this->m_data.size(); }
 
+        const T& operator[](int i) const { return this->m_data[i]; }
+
     private:
         std::vector<T> m_data;
     };

toolsrc/include/vcpkg/update.h

@@ -16,6 +16,7 @@ namespace vcpkg::Update
         VersionDiff version_diff;
     };
 
-    std::vector<OutdatedPackage> find_outdated_packages(const VcpkgPaths& paths, const StatusParagraphs& status_db);
+    std::vector<OutdatedPackage> find_outdated_packages(const std::map<std::string, VersionT>& src_names_to_versions,
+                                                        const StatusParagraphs& status_db);
     void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths);
 }

toolsrc/include/vcpkg/versiont.h

@@ -8,8 +8,9 @@ namespace vcpkg
         VersionT();
         VersionT(const std::string& value);
 
-        std::string to_string() const;
+        const std::string& to_string() const;
 
+    private:
         std::string value;
     };
 

toolsrc/src/tests.arguments.cpp

@@ -1,5 +1,4 @@
-#include <CppUnitTest.h>
-#include <vcpkg/vcpkgcmdarguments.h>
+#include "tests.pch.h"
 
 #pragma comment(lib, "version")
 #pragma comment(lib, "winhttp")

toolsrc/src/tests.dependencies.cpp

@@ -1,6 +1,4 @@
-#include <CppUnitTest.h>
-#include <vcpkg/sourceparagraph.h>
-#include <vcpkg/triplet.h>
+#include "tests.pch.h"
 
 #pragma comment(lib, "version")
 #pragma comment(lib, "winhttp")

toolsrc/src/tests.packagespec.cpp

@@ -1,32 +1,12 @@
-#include <CppUnitTest.h>
-#include <vcpkg/binaryparagraph.h>
-#include <vcpkg/paragraphs.h>
+#include "tests.pch.h"
 
-#include <vcpkg/base/strings.h>
-#include <vcpkg/base/util.h>
+#include <tests.utils.h>
 
 #pragma comment(lib, "version")
 #pragma comment(lib, "winhttp")
 
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
-namespace Microsoft::VisualStudio::CppUnitTestFramework
-{
-    template<>
-    inline std::wstring ToString<vcpkg::PackageSpecParseResult>(const vcpkg::PackageSpecParseResult& t)
-    {
-        return ToString(static_cast<uint32_t>(t));
-    }
-
-    template<>
-    inline std::wstring ToString<vcpkg::PackageSpec>(const vcpkg::PackageSpec& t)
-    {
-        return ToString(t.to_string());
-    }
-}
-
-namespace Strings = vcpkg::Strings;
-
 namespace UnitTest1
 {
     using namespace vcpkg;

toolsrc/src/tests.paragraph.cpp

@@ -1,8 +1,4 @@
-#include <CppUnitTest.h>
-#include <vcpkg/binaryparagraph.h>
-#include <vcpkg/paragraphs.h>
-
-#include <vcpkg/base/strings.h>
+#include "tests.pch.h"
 
 #pragma comment(lib, "version")
 #pragma comment(lib, "winhttp")

toolsrc/src/tests.pch.cpp

@@ -0,0 +1 @@
+#include "tests.pch.h"

toolsrc/src/tests.plan.cpp

@@ -1,41 +1,11 @@
-#include <CppUnitTest.h>
-#include <vcpkg/dependencies.h>
+#include "tests.pch.h"
 
-#include <vcpkg/base/util.h>
+#include <tests.utils.h>
 
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
 using namespace vcpkg;
 
-namespace Microsoft::VisualStudio::CppUnitTestFramework
-{
-    template<>
-    inline std::wstring ToString<vcpkg::Dependencies::InstallPlanType>(const vcpkg::Dependencies::InstallPlanType& t)
-    {
-        switch (t)
-        {
-            case Dependencies::InstallPlanType::ALREADY_INSTALLED: return L"ALREADY_INSTALLED";
-            case Dependencies::InstallPlanType::BUILD_AND_INSTALL: return L"BUILD_AND_INSTALL";
-            case Dependencies::InstallPlanType::INSTALL: return L"INSTALL";
-            case Dependencies::InstallPlanType::EXCLUDED: return L"EXCLUDED";
-            case Dependencies::InstallPlanType::UNKNOWN: return L"UNKNOWN";
-            default: return ToString(static_cast<int>(t));
-        }
-    }
-
-    template<>
-    inline std::wstring ToString<vcpkg::Dependencies::RequestType>(const vcpkg::Dependencies::RequestType& t)
-    {
-        switch (t)
-        {
-            case Dependencies::RequestType::AUTO_SELECTED: return L"AUTO_SELECTED";
-            case Dependencies::RequestType::USER_REQUESTED: return L"USER_REQUESTED";
-            case Dependencies::RequestType::UNKNOWN: return L"UNKNOWN";
-            default: return ToString(static_cast<int>(t));
-        }
-    }
-}
-
 namespace UnitTest1
 {
     static std::unique_ptr<SourceControlFile> make_control_file(
@@ -96,32 +66,6 @@ namespace UnitTest1
         Assert::AreEqual(pkg_name.c_str(), plan.spec.name().c_str());
     }
 
-    static std::unique_ptr<StatusParagraph> make_status_pgh(const char* name,
-                                                            const char* depends = "",
-                                                            const char* triplet = "x86-windows")
-    {
-        using Pgh = std::unordered_map<std::string, std::string>;
-        return std::make_unique<StatusParagraph>(Pgh{{"Package", name},
-                                                     {"Version", "1"},
-                                                     {"Architecture", triplet},
-                                                     {"Multi-Arch", "same"},
-                                                     {"Depends", depends},
-                                                     {"Status", "install ok installed"}});
-    }
-    static std::unique_ptr<StatusParagraph> make_status_feature_pgh(const char* name,
-                                                                    const char* feature,
-                                                                    const char* depends = "",
-                                                                    const char* triplet = "x86-windows")
-    {
-        using Pgh = std::unordered_map<std::string, std::string>;
-        return std::make_unique<StatusParagraph>(Pgh{{"Package", name},
-                                                     {"Version", "1"},
-                                                     {"Feature", feature},
-                                                     {"Architecture", triplet},
-                                                     {"Multi-Arch", "same"},
-                                                     {"Depends", depends},
-                                                     {"Status", "install ok installed"}});
-    }
     struct PackageSpecMap
     {
         std::unordered_map<std::string, SourceControlFile> map;

toolsrc/src/tests.statusparagraphs.cpp

@@ -1,9 +1,4 @@
-#include <CppUnitTest.h>
-
-#include <vcpkg/base/util.h>
-#include <vcpkg/paragraphs.h>
-#include <vcpkg/statusparagraph.h>
-#include <vcpkg/statusparagraphs.h>
+#include "tests.pch.h"
 
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 

toolsrc/src/tests.update.cpp

@@ -0,0 +1,96 @@
+#include "tests.pch.h"
+
+#include <tests.utils.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+using namespace vcpkg;
+using namespace vcpkg::Update;
+
+namespace UnitTest1
+{
+    class UpdateTests : public TestClass<UpdateTests>
+    {
+        TEST_METHOD(find_outdated_packages_basic)
+        {
+            std::vector<std::unique_ptr<StatusParagraph>> status_paragraphs;
+            status_paragraphs.push_back(make_status_pgh("a"));
+            status_paragraphs.back()->package.version = "2";
+
+            StatusParagraphs status_db(std::move(status_paragraphs));
+
+            std::map<std::string, VersionT> port_versions;
+            port_versions["a"] = VersionT("0");
+
+            auto pkgs = SortedVector<OutdatedPackage>(Update::find_outdated_packages(port_versions, status_db),
+                                                      &OutdatedPackage::compare_by_name);
+
+            Assert::AreEqual(size_t(1), pkgs.size());
+            Assert::AreEqual("2", pkgs[0].version_diff.left.to_string().c_str());
+            Assert::AreEqual("0", pkgs[0].version_diff.right.to_string().c_str());
+        }
+
+        TEST_METHOD(find_outdated_packages_features)
+        {
+            std::vector<std::unique_ptr<StatusParagraph>> status_paragraphs;
+            status_paragraphs.push_back(make_status_pgh("a"));
+            status_paragraphs.back()->package.version = "2";
+
+            status_paragraphs.push_back(make_status_feature_pgh("a", "b"));
+            status_paragraphs.back()->package.version = "2";
+
+            StatusParagraphs status_db(std::move(status_paragraphs));
+
+            std::map<std::string, VersionT> port_versions;
+            port_versions["a"] = VersionT("0");
+
+            auto pkgs = SortedVector<OutdatedPackage>(Update::find_outdated_packages(port_versions, status_db),
+                                                      &OutdatedPackage::compare_by_name);
+
+            Assert::AreEqual(size_t(1), pkgs.size());
+            Assert::AreEqual("2", pkgs[0].version_diff.left.to_string().c_str());
+            Assert::AreEqual("0", pkgs[0].version_diff.right.to_string().c_str());
+        }
+
+        TEST_METHOD(find_outdated_packages_features_2)
+        {
+            std::vector<std::unique_ptr<StatusParagraph>> status_paragraphs;
+            status_paragraphs.push_back(make_status_pgh("a"));
+            status_paragraphs.back()->package.version = "2";
+
+            status_paragraphs.push_back(make_status_feature_pgh("a", "b"));
+            status_paragraphs.back()->package.version = "0";
+            status_paragraphs.back()->state = InstallState::NOT_INSTALLED;
+            status_paragraphs.back()->want = Want::PURGE;
+
+            StatusParagraphs status_db(std::move(status_paragraphs));
+
+            std::map<std::string, VersionT> port_versions;
+            port_versions["a"] = VersionT("0");
+
+            auto pkgs = SortedVector<OutdatedPackage>(Update::find_outdated_packages(port_versions, status_db),
+                                                      &OutdatedPackage::compare_by_name);
+
+            Assert::AreEqual(size_t(1), pkgs.size());
+            Assert::AreEqual("2", pkgs[0].version_diff.left.to_string().c_str());
+            Assert::AreEqual("0", pkgs[0].version_diff.right.to_string().c_str());
+        }
+
+        TEST_METHOD(find_outdated_packages_none)
+        {
+            std::vector<std::unique_ptr<StatusParagraph>> status_paragraphs;
+            status_paragraphs.push_back(make_status_pgh("a"));
+            status_paragraphs.back()->package.version = "2";
+
+            StatusParagraphs status_db(std::move(status_paragraphs));
+
+            std::map<std::string, VersionT> port_versions;
+            port_versions["a"] = VersionT("2");
+
+            auto pkgs = SortedVector<OutdatedPackage>(Update::find_outdated_packages(port_versions, status_db),
+                                                      &OutdatedPackage::compare_by_name);
+
+            Assert::AreEqual(size_t(0), pkgs.size());
+        }
+    };
+}

toolsrc/src/tests.utils.cpp

@@ -0,0 +1,62 @@
+#include "tests.pch.h"
+
+#include "tests.utils.h"
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace vcpkg;
+
+namespace Microsoft::VisualStudio::CppUnitTestFramework
+{
+    std::wstring ToString(const vcpkg::Dependencies::InstallPlanType& t)
+    {
+        switch (t)
+        {
+            case Dependencies::InstallPlanType::ALREADY_INSTALLED: return L"ALREADY_INSTALLED";
+            case Dependencies::InstallPlanType::BUILD_AND_INSTALL: return L"BUILD_AND_INSTALL";
+            case Dependencies::InstallPlanType::INSTALL: return L"INSTALL";
+            case Dependencies::InstallPlanType::EXCLUDED: return L"EXCLUDED";
+            case Dependencies::InstallPlanType::UNKNOWN: return L"UNKNOWN";
+            default: return ToString(static_cast<int>(t));
+        }
+    }
+
+    std::wstring ToString(const vcpkg::Dependencies::RequestType& t)
+    {
+        switch (t)
+        {
+            case Dependencies::RequestType::AUTO_SELECTED: return L"AUTO_SELECTED";
+            case Dependencies::RequestType::USER_REQUESTED: return L"USER_REQUESTED";
+            case Dependencies::RequestType::UNKNOWN: return L"UNKNOWN";
+            default: return ToString(static_cast<int>(t));
+        }
+    }
+
+    std::wstring ToString(const vcpkg::PackageSpecParseResult& t) { return ToString(static_cast<uint32_t>(t)); }
+
+    std::wstring ToString(const vcpkg::PackageSpec& t) { return ToString(t.to_string()); }
+}
+
+std::unique_ptr<StatusParagraph> make_status_pgh(const char* name, const char* depends, const char* triplet)
+{
+    using Pgh = std::unordered_map<std::string, std::string>;
+    return std::make_unique<StatusParagraph>(Pgh{{"Package", name},
+                                                 {"Version", "1"},
+                                                 {"Architecture", triplet},
+                                                 {"Multi-Arch", "same"},
+                                                 {"Depends", depends},
+                                                 {"Status", "install ok installed"}});
+}
+std::unique_ptr<StatusParagraph> make_status_feature_pgh(const char* name,
+                                                         const char* feature,
+                                                         const char* depends,
+                                                         const char* triplet)
+{
+    using Pgh = std::unordered_map<std::string, std::string>;
+    return std::make_unique<StatusParagraph>(Pgh{{"Package", name},
+                                                 {"Version", "1"},
+                                                 {"Feature", feature},
+                                                 {"Architecture", triplet},
+                                                 {"Multi-Arch", "same"},
+                                                 {"Depends", depends},
+                                                 {"Status", "install ok installed"}});
+}

toolsrc/src/vcpkg/remove.cpp

@@ -6,6 +6,7 @@
 #include <vcpkg/dependencies.h>
 #include <vcpkg/help.h>
 #include <vcpkg/input.h>
+#include <vcpkg/paragraphs.h>
 #include <vcpkg/remove.h>
 #include <vcpkg/update.h>
 #include <vcpkg/vcpkglib.h>
@@ -206,8 +207,10 @@ namespace vcpkg::Remove
                 System::println(System::Color::error, "Error: 'remove' accepts either libraries or '--outdated'");
                 Checks::exit_fail(VCPKG_LINE_INFO);
             }
-            specs = Util::fmap(Update::find_outdated_packages(paths, status_db),
-                               [](auto&& outdated) { return outdated.spec; });
+            specs = Util::fmap(
+                Update::find_outdated_packages(
+                    Paragraphs::load_all_port_names_and_versions(paths.get_filesystem(), paths.ports), status_db),
+                [](auto&& outdated) { return outdated.spec; });
 
             if (specs.empty())
             {

toolsrc/src/vcpkg/update.cpp

@@ -14,15 +14,20 @@ namespace vcpkg::Update
         return left.spec.name() < right.spec.name();
     }
 
-    std::vector<OutdatedPackage> find_outdated_packages(const VcpkgPaths& paths, const StatusParagraphs& status_db)
+    std::vector<OutdatedPackage> find_outdated_packages(const std::map<std::string, VersionT>& src_names_to_versions,
+                                                        const StatusParagraphs& status_db)
     {
-        const std::map<std::string, VersionT> src_names_to_versions =
-            Paragraphs::load_all_port_names_and_versions(paths.get_filesystem(), paths.ports);
         const std::vector<StatusParagraph*> installed_packages = get_installed_ports(status_db);
 
         std::vector<OutdatedPackage> output;
         for (const StatusParagraph* pgh : installed_packages)
         {
+            if (!pgh->package.feature.empty())
+            {
+                // Skip feature packages; only consider master packages for needing updates.
+                continue;
+            }
+
             const auto it = src_names_to_versions.find(pgh->package.spec.name());
             if (it == src_names_to_versions.end())
             {
@@ -53,8 +58,10 @@ namespace vcpkg::Update
 
         const StatusParagraphs status_db = database_load_check(paths);
 
-        const auto outdated_packages =
-            SortedVector<OutdatedPackage>(find_outdated_packages(paths, status_db), &OutdatedPackage::compare_by_name);
+        const auto outdated_packages = SortedVector<OutdatedPackage>(
+            find_outdated_packages(Paragraphs::load_all_port_names_and_versions(paths.get_filesystem(), paths.ports),
+                                   status_db),
+            &OutdatedPackage::compare_by_name);
 
         if (outdated_packages.empty())
         {

toolsrc/src/vcpkg/versiont.cpp

@@ -7,13 +7,16 @@ namespace vcpkg
 {
     VersionT::VersionT() : value("0.0.0") {}
     VersionT::VersionT(const std::string& value) : value(value) {}
-    std::string VersionT::to_string() const { return value; }
-    bool operator==(const VersionT& left, const VersionT& right) { return left.value == right.value; }
-    bool operator!=(const VersionT& left, const VersionT& right) { return left.value != right.value; }
-    std::string to_printf_arg(const VersionT& version) { return version.value; }
+    const std::string& VersionT::to_string() const { return value; }
+    bool operator==(const VersionT& left, const VersionT& right) { return left.to_string() == right.to_string(); }
+    bool operator!=(const VersionT& left, const VersionT& right) { return left.to_string() != right.to_string(); }
+    std::string to_printf_arg(const VersionT& version) { return version.to_string(); }
 
     VersionDiff::VersionDiff() : left(), right() {}
     VersionDiff::VersionDiff(const VersionT& left, const VersionT& right) : left(left), right(right) {}
 
-    std::string VersionDiff::to_string() const { return Strings::format("%s -> %s", left.value, right.value); }
+    std::string VersionDiff::to_string() const
+    {
+        return Strings::format("%s -> %s", left.to_string(), right.to_string());
+    }
 }

toolsrc/vcpkgtest/vcpkgtest.vcxproj

@@ -23,14 +23,26 @@
     <ClCompile Include="..\src\tests.dependencies.cpp" />
     <ClCompile Include="..\src\tests.packagespec.cpp" />
     <ClCompile Include="..\src\tests.paragraph.cpp" />
+    <ClCompile Include="..\src\tests.pch.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
+    </ClCompile>
     <ClCompile Include="..\src\tests.plan.cpp" />
     <ClCompile Include="..\src\tests.statusparagraphs.cpp" />
+    <ClCompile Include="..\src\tests.update.cpp" />
+    <ClCompile Include="..\src\tests.utils.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\vcpkglib\vcpkglib.vcxproj">
       <Project>{b98c92b7-2874-4537-9d46-d14e5c237f04}</Project>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\include\tests.pch.h" />
+    <ClInclude Include="..\include\tests.utils.h" />
+  </ItemGroup>
   <PropertyGroup Label="Globals">
     <ProjectGuid>{F27B8DB0-1279-4AF8-A2E3-1D49C4F0220D}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
@@ -93,13 +105,13 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeader>Use</PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>..\include;$(VCInstallDir)UnitTest\include;$(VsInstallRoot)\VC\Auxiliary\VS\UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <UseFullPaths>true</UseFullPaths>
-      <PrecompiledHeaderFile />
+      <PrecompiledHeaderFile>tests.pch.h</PrecompiledHeaderFile>
       <AdditionalOptions>/std:c++latest %(AdditionalOptions)</AdditionalOptions>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <MinimalRebuild>false</MinimalRebuild>
@@ -111,13 +123,13 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeader>Use</PrecompiledHeader>
       <WarningLevel>Level4</WarningLevel>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>..\include;$(VCInstallDir)UnitTest\include;$(VsInstallRoot)\VC\Auxiliary\VS\UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <UseFullPaths>true</UseFullPaths>
-      <PrecompiledHeaderFile />
+      <PrecompiledHeaderFile>tests.pch.h</PrecompiledHeaderFile>
       <AdditionalOptions>/std:c++latest %(AdditionalOptions)</AdditionalOptions>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <MinimalRebuild>false</MinimalRebuild>
@@ -130,14 +142,14 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeader>Use</PrecompiledHeader>
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>..\include;$(VCInstallDir)UnitTest\include;$(VsInstallRoot)\VC\Auxiliary\VS\UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <UseFullPaths>true</UseFullPaths>
-      <PrecompiledHeaderFile />
+      <PrecompiledHeaderFile>tests.pch.h</PrecompiledHeaderFile>
       <AdditionalOptions>/std:c++latest %(AdditionalOptions)</AdditionalOptions>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
@@ -151,14 +163,14 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeader>Use</PrecompiledHeader>
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>..\include;$(VCInstallDir)UnitTest\include;$(VsInstallRoot)\VC\Auxiliary\VS\UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <UseFullPaths>true</UseFullPaths>
-      <PrecompiledHeaderFile />
+      <PrecompiledHeaderFile>tests.pch.h</PrecompiledHeaderFile>
       <AdditionalOptions>/std:c++latest %(AdditionalOptions)</AdditionalOptions>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>

toolsrc/vcpkgtest/vcpkgtest.vcxproj.filters

@@ -33,5 +33,22 @@
     <ClCompile Include="..\src\tests.plan.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\src\tests.update.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\tests.pch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\tests.utils.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\include\tests.pch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\tests.utils.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>