Run clang-foramt over tests and remaining cpp files

5 files changed, 137 insertions, 166 deletions

diff --git a/toolsrc/src/tests_arguments.cpp b/toolsrc/src/tests_arguments.cpp
index 33121b93a..eef04cc61 100644
--- a/toolsrc/src/tests_arguments.cpp
+++ b/toolsrc/src/tests_arguments.cpp
@@ -1,8 +1,8 @@
 #include "CppUnitTest.h"

 #include "VcpkgCmdArguments.h"

 

-#pragma comment(lib,"version")

-#pragma comment(lib,"winhttp")

+#pragma comment(lib, "version")

+#pragma comment(lib, "winhttp")

 

 using namespace Microsoft::VisualStudio::CppUnitTestFramework;

 

@@ -10,19 +10,13 @@ using namespace vcpkg;
 

 namespace UnitTest1

 {

-    TEST_CLASS(ArgumentTests)

+    struct ArgumentTests : TestClass<ArgumentTests>

     {

-    public:

         TEST_METHOD(create_from_arg_sequence_options_lower)

         {

-            std::vector<std::string> t = {

-                "--vcpkg-root", "C:\vcpkg",

-                "--debug",

-                "--sendmetrics",

-                "--printmetrics"

-            };

+            std::vector<std::string> t = { "--vcpkg-root", "C:\\vcpkg", "--debug", "--sendmetrics", "--printmetrics" };

             auto v = VcpkgCmdArguments::create_from_arg_sequence(t.data(), t.data() + t.size());

-            Assert::AreEqual("C:\vcpkg", v.vcpkg_root_dir.get()->c_str());

+            Assert::AreEqual("C:\\vcpkg", v.vcpkg_root_dir.get()->c_str());

             Assert::IsTrue(vcpkg::OptBoolC::ENABLED == v.debug);

             Assert::IsTrue(vcpkg::OptBoolC::ENABLED == v.sendmetrics);

             Assert::IsTrue(vcpkg::OptBoolC::ENABLED == v.printmetrics);

@@ -30,17 +24,12 @@ namespace UnitTest1
 

         TEST_METHOD(create_from_arg_sequence_options_upper)

         {

-            std::vector<std::string> t = {

-                "--VCPKG-ROOT", "C:\vcpkg",

-                "--DEBUG",

-                "--SENDMETRICS",

-                "--PRINTMETRICS"

-            };

+            std::vector<std::string> t = { "--VCPKG-ROOT", "C:\\vcpkg", "--DEBUG", "--SENDMETRICS", "--PRINTMETRICS" };

             auto v = VcpkgCmdArguments::create_from_arg_sequence(t.data(), t.data() + t.size());

-            Assert::AreEqual("C:\vcpkg", v.vcpkg_root_dir.get()->c_str());

+            Assert::AreEqual("C:\\vcpkg", v.vcpkg_root_dir.get()->c_str());

             Assert::IsTrue(vcpkg::OptBoolC::ENABLED == v.debug);

             Assert::IsTrue(vcpkg::OptBoolC::ENABLED == v.sendmetrics);

             Assert::IsTrue(vcpkg::OptBoolC::ENABLED == v.printmetrics);

         }

     };

-}

+}
\ No newline at end of file
diff --git a/toolsrc/src/tests_dependencies.cpp b/toolsrc/src/tests_dependencies.cpp
index 25504d407..66fdee42b 100644
--- a/toolsrc/src/tests_dependencies.cpp
+++ b/toolsrc/src/tests_dependencies.cpp
@@ -2,8 +2,8 @@
 #include "SourceParagraph.h"
 #include "Triplet.h"
 
-#pragma comment(lib,"version")
-#pragma comment(lib,"winhttp")
+#pragma comment(lib, "version")
+#pragma comment(lib, "winhttp")
 
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
@@ -11,9 +11,8 @@ using namespace vcpkg;
 
 namespace UnitTest1
 {
-    TEST_CLASS(DependencyTests)
+    struct ArgumentTests : TestClass<ArgumentTests>
     {
-    public:
         TEST_METHOD(parse_depends_one)
         {
             auto v = expand_qualified_dependencies(parse_depends("libA [windows]"));
diff --git a/toolsrc/src/tests_paragraph.cpp b/toolsrc/src/tests_paragraph.cpp
index 20bacf170..50548dbc1 100644
--- a/toolsrc/src/tests_paragraph.cpp
+++ b/toolsrc/src/tests_paragraph.cpp
@@ -1,16 +1,16 @@
+#include "BinaryParagraph.h"
 #include "CppUnitTest.h"
 #include "Paragraphs.h"
-#include "BinaryParagraph.h"
 #include "vcpkg_Strings.h"
 
-#pragma comment(lib,"version")
-#pragma comment(lib,"winhttp")
+#pragma comment(lib, "version")
+#pragma comment(lib, "winhttp")
 
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
 namespace Microsoft::VisualStudio::CppUnitTestFramework
 {
-    template <>
+    template<>
     inline std::wstring ToString<vcpkg::PackageSpecParseResult>(const vcpkg::PackageSpecParseResult& t)
     {
         return ToString(static_cast<uint32_t>(t));
@@ -21,15 +21,11 @@ namespace Strings = vcpkg::Strings;
 
 namespace UnitTest1
 {
-    TEST_CLASS(ControlParsing)
+    struct ArgumentTests : TestClass<ArgumentTests>
     {
-    public:
         TEST_METHOD(SourceParagraph_Construct_Minimum)
         {
-            vcpkg::SourceParagraph pgh({
-                { "Source", "zlib" },
-                { "Version", "1.2.8" }
-            });
+            vcpkg::SourceParagraph pgh({ { "Source", "zlib" }, { "Version", "1.2.8" } });
 
             Assert::AreEqual("zlib", pgh.name.c_str());
             Assert::AreEqual("1.2.8", pgh.version.c_str());
@@ -40,13 +36,11 @@ namespace UnitTest1
 
         TEST_METHOD(SourceParagraph_Construct_Maximum)
         {
-            vcpkg::SourceParagraph pgh({
-                { "Source", "s" },
-                { "Version", "v" },
-                { "Maintainer", "m" },
-                { "Description", "d" },
-                { "Build-Depends", "bd" }
-            });
+            vcpkg::SourceParagraph pgh({ { "Source", "s" },
+                                         { "Version", "v" },
+                                         { "Maintainer", "m" },
+                                         { "Description", "d" },
+                                         { "Build-Depends", "bd" } });
             Assert::AreEqual("s", pgh.name.c_str());
             Assert::AreEqual("v", pgh.version.c_str());
             Assert::AreEqual("m", pgh.maintainer.c_str());
@@ -57,11 +51,8 @@ namespace UnitTest1
 
         TEST_METHOD(SourceParagraph_Two_Depends)
         {
-            vcpkg::SourceParagraph pgh({
-                { "Source", "zlib" },
-                { "Version", "1.2.8" },
-                { "Build-Depends", "z, openssl" }
-            });
+            vcpkg::SourceParagraph pgh(
+                { { "Source", "zlib" }, { "Version", "1.2.8" }, { "Build-Depends", "z, openssl" } });
 
             Assert::AreEqual(size_t(2), pgh.depends.size());
             Assert::AreEqual("z", pgh.depends[0].name.c_str());
@@ -70,11 +61,8 @@ namespace UnitTest1
 
         TEST_METHOD(SourceParagraph_Three_Depends)
         {
-            vcpkg::SourceParagraph pgh({
-                { "Source", "zlib" },
-                { "Version", "1.2.8" },
-                { "Build-Depends", "z, openssl, xyz" }
-            });
+            vcpkg::SourceParagraph pgh(
+                { { "Source", "zlib" }, { "Version", "1.2.8" }, { "Build-Depends", "z, openssl, xyz" } });
 
             Assert::AreEqual(size_t(3), pgh.depends.size());
             Assert::AreEqual("z", pgh.depends[0].name.c_str());
@@ -84,11 +72,8 @@ namespace UnitTest1
 
         TEST_METHOD(SourceParagraph_Construct_Qualified_Depends)
         {
-            vcpkg::SourceParagraph pgh({
-                { "Source", "zlib" },
-                { "Version", "1.2.8" },
-                { "Build-Depends", "libA [windows], libB [uwp]" }
-            });
+            vcpkg::SourceParagraph pgh(
+                { { "Source", "zlib" }, { "Version", "1.2.8" }, { "Build-Depends", "libA [windows], libB [uwp]" } });
 
             Assert::AreEqual("zlib", pgh.name.c_str());
             Assert::AreEqual("1.2.8", pgh.version.c_str());
@@ -120,15 +105,13 @@ namespace UnitTest1
 
         TEST_METHOD(BinaryParagraph_Construct_Maximum)
         {
-            vcpkg::BinaryParagraph pgh({
-                { "Package", "s" },
-                { "Version", "v" },
-                { "Architecture", "x86-windows" },
-                { "Multi-Arch", "same" },
-                { "Maintainer", "m" },
-                { "Description", "d" },
-                { "Depends", "bd" }
-            });
+            vcpkg::BinaryParagraph pgh({ { "Package", "s" },
+                                         { "Version", "v" },
+                                         { "Architecture", "x86-windows" },
+                                         { "Multi-Arch", "same" },
+                                         { "Maintainer", "m" },
+                                         { "Description", "d" },
+                                         { "Depends", "bd" } });
             Assert::AreEqual("s", pgh.spec.name().c_str());
             Assert::AreEqual("v", pgh.version.c_str());
             Assert::AreEqual("m", pgh.maintainer.c_str());
@@ -171,9 +154,8 @@ namespace UnitTest1
 
         TEST_METHOD(parse_paragraphs_one_pgh)
         {
-            const char* str =
-                "f1: v1\n"
-                "f2: v2";
+            const char* str = "f1: v1\n"
+                              "f2: v2";
             auto pghs = vcpkg::Paragraphs::parse_paragraphs(str).value_or_exit(VCPKG_LINE_INFO);
             Assert::AreEqual(size_t(1), pghs.size());
             Assert::AreEqual(size_t(2), pghs[0].size());
@@ -183,12 +165,11 @@ namespace UnitTest1
 
         TEST_METHOD(parse_paragraphs_two_pgh)
         {
-            const char* str =
-                "f1: v1\n"
-                "f2: v2\n"
-                "\n"
-                "f3: v3\n"
-                "f4: v4";
+            const char* str = "f1: v1\n"
+                              "f2: v2\n"
+                              "\n"
+                              "f3: v3\n"
+                              "f4: v4";
             auto pghs = vcpkg::Paragraphs::parse_paragraphs(str).value_or_exit(VCPKG_LINE_INFO);
             Assert::AreEqual(size_t(2), pghs.size());
             Assert::AreEqual(size_t(2), pghs[0].size());
@@ -201,12 +182,11 @@ namespace UnitTest1
 
         TEST_METHOD(parse_paragraphs_field_names)
         {
-            const char* str =
-                "1:\n"
-                "f:\n"
-                "F:\n"
-                "0:\n"
-                "F-2:\n";
+            const char* str = "1:\n"
+                              "f:\n"
+                              "F:\n"
+                              "0:\n"
+                              "F-2:\n";
             auto pghs = vcpkg::Paragraphs::parse_paragraphs(str).value_or_exit(VCPKG_LINE_INFO);
             Assert::AreEqual(size_t(1), pghs.size());
             Assert::AreEqual(size_t(5), pghs[0].size());
@@ -214,22 +194,20 @@ namespace UnitTest1
 
         TEST_METHOD(parse_paragraphs_multiple_blank_lines)
         {
-            const char* str =
-                "f1: v1\n"
-                "f2: v2\n"
-                "\n"
-                "\n"
-                "f3: v3\n"
-                "f4: v4";
+            const char* str = "f1: v1\n"
+                              "f2: v2\n"
+                              "\n"
+                              "\n"
+                              "f3: v3\n"
+                              "f4: v4";
             auto pghs = vcpkg::Paragraphs::parse_paragraphs(str).value_or_exit(VCPKG_LINE_INFO);
             Assert::AreEqual(size_t(2), pghs.size());
         }
 
         TEST_METHOD(parse_paragraphs_empty_fields)
         {
-            const char* str =
-                "f1:\n"
-                "f2: ";
+            const char* str = "f1:\n"
+                              "f2: ";
             auto pghs = vcpkg::Paragraphs::parse_paragraphs(str).value_or_exit(VCPKG_LINE_INFO);
             Assert::AreEqual(size_t(1), pghs.size());
             Assert::AreEqual(size_t(2), pghs[0].size());
@@ -240,12 +218,11 @@ namespace UnitTest1
 
         TEST_METHOD(parse_paragraphs_multiline_fields)
         {
-            const char* str =
-                "f1: simple\n"
-                " f1\r\n"
-                "f2:\r\n"
-                " f2\r\n"
-                " continue\r\n";
+            const char* str = "f1: simple\n"
+                              " f1\r\n"
+                              "f2:\r\n"
+                              " f2\r\n"
+                              " continue\r\n";
             auto pghs = vcpkg::Paragraphs::parse_paragraphs(str).value_or_exit(VCPKG_LINE_INFO);
             Assert::AreEqual(size_t(1), pghs.size());
             Assert::AreEqual("simple\n f1", pghs[0]["f1"].c_str());
@@ -254,12 +231,11 @@ namespace UnitTest1
 
         TEST_METHOD(parse_paragraphs_crlfs)
         {
-            const char* str =
-                "f1: v1\r\n"
-                "f2: v2\r\n"
-                "\r\n"
-                "f3: v3\r\n"
-                "f4: v4";
+            const char* str = "f1: v1\r\n"
+                              "f2: v2\r\n"
+                              "\r\n"
+                              "f3: v3\r\n"
+                              "f4: v4";
             auto pghs = vcpkg::Paragraphs::parse_paragraphs(str).value_or_exit(VCPKG_LINE_INFO);
             Assert::AreEqual(size_t(2), pghs.size());
             Assert::AreEqual(size_t(2), pghs[0].size());
@@ -272,16 +248,15 @@ namespace UnitTest1
 
         TEST_METHOD(parse_paragraphs_comment)
         {
-            const char* str =
-                "f1: v1\r\n"
-                "#comment\r\n"
-                "f2: v2\r\n"
-                "#comment\r\n"
-                "\r\n"
-                "#comment\r\n"
-                "f3: v3\r\n"
-                "#comment\r\n"
-                "f4: v4";
+            const char* str = "f1: v1\r\n"
+                              "#comment\r\n"
+                              "f2: v2\r\n"
+                              "#comment\r\n"
+                              "\r\n"
+                              "#comment\r\n"
+                              "f3: v3\r\n"
+                              "#comment\r\n"
+                              "f4: v4";
             auto pghs = vcpkg::Paragraphs::parse_paragraphs(str).value_or_exit(VCPKG_LINE_INFO);
             Assert::AreEqual(size_t(2), pghs.size());
             Assert::AreEqual(size_t(2), pghs[0].size());
@@ -294,9 +269,8 @@ namespace UnitTest1
 
         TEST_METHOD(parse_comment_before_single_slashN)
         {
-            const char* str =
-                "f1: v1\r\n"
-                "#comment\n";
+            const char* str = "f1: v1\r\n"
+                              "#comment\n";
             auto pghs = vcpkg::Paragraphs::parse_paragraphs(str).value_or_exit(VCPKG_LINE_INFO);
             Assert::AreEqual(size_t(1), pghs[0].size());
             Assert::AreEqual("v1", pghs[0]["f1"].c_str());
@@ -360,16 +334,20 @@ namespace UnitTest1
 
         TEST_METHOD(package_spec_parse)
         {
-            vcpkg::Expected<vcpkg::PackageSpec> spec = vcpkg::PackageSpec::from_string("zlib", vcpkg::Triplet::X86_WINDOWS);
-            Assert::AreEqual(vcpkg::PackageSpecParseResult::SUCCESS, vcpkg::to_package_spec_parse_result(spec.error_code()));
+            vcpkg::Expected<vcpkg::PackageSpec> spec =
+                vcpkg::PackageSpec::from_string("zlib", vcpkg::Triplet::X86_WINDOWS);
+            Assert::AreEqual(vcpkg::PackageSpecParseResult::SUCCESS,
+                             vcpkg::to_package_spec_parse_result(spec.error_code()));
             Assert::AreEqual("zlib", spec.get()->name().c_str());
             Assert::AreEqual(vcpkg::Triplet::X86_WINDOWS.canonical_name(), spec.get()->triplet().canonical_name());
         }
 
         TEST_METHOD(package_spec_parse_with_arch)
         {
-            vcpkg::Expected<vcpkg::PackageSpec> spec = vcpkg::PackageSpec::from_string("zlib:x64-uwp", vcpkg::Triplet::X86_WINDOWS);
-            Assert::AreEqual(vcpkg::PackageSpecParseResult::SUCCESS, vcpkg::to_package_spec_parse_result(spec.error_code()));
+            vcpkg::Expected<vcpkg::PackageSpec> spec =
+                vcpkg::PackageSpec::from_string("zlib:x64-uwp", vcpkg::Triplet::X86_WINDOWS);
+            Assert::AreEqual(vcpkg::PackageSpecParseResult::SUCCESS,
+                             vcpkg::to_package_spec_parse_result(spec.error_code()));
             Assert::AreEqual("zlib", spec.get()->name().c_str());
             Assert::AreEqual(vcpkg::Triplet::X64_UWP.canonical_name(), spec.get()->triplet().canonical_name());
         }
@@ -393,5 +371,5 @@ namespace UnitTest1
         }
     };
 
-    TEST_CLASS(Metrics) { };
+    TEST_CLASS(Metrics){};
 }
diff --git a/toolsrc/src/vcpkg.cpp b/toolsrc/src/vcpkg.cpp
index e76e7087f..744d4d77f 100644
--- a/toolsrc/src/vcpkg.cpp
+++ b/toolsrc/src/vcpkg.cpp
@@ -1,19 +1,19 @@
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
 
-#include <fstream>
-#include <memory>
-#include <cassert>
-#include "vcpkg_Commands.h"
+#include "Paragraphs.h"
 #include "metrics.h"
-#include <Shlobj.h>
+#include "vcpkg_Chrono.h"
+#include "vcpkg_Commands.h"
 #include "vcpkg_Files.h"
-#include "vcpkg_System.h"
 #include "vcpkg_Input.h"
-#include "Paragraphs.h"
 #include "vcpkg_Strings.h"
-#include "vcpkg_Chrono.h"
+#include "vcpkg_System.h"
 #include "vcpkglib.h"
+#include <Shlobj.h>
+#include <cassert>
+#include <fstream>
+#include <memory>
 
 using namespace vcpkg;
 
@@ -52,14 +52,19 @@ static void inner(const VcpkgCmdArguments& args)
         }
         else
         {
-            vcpkg_root_dir = Files::get_real_filesystem().find_file_recursively_up(fs::stdfs::absolute(System::get_exe_path_of_current_process()), ".vcpkg-root");
+            vcpkg_root_dir = Files::get_real_filesystem().find_file_recursively_up(
+                fs::stdfs::absolute(System::get_exe_path_of_current_process()), ".vcpkg-root");
         }
     }
 
     Checks::check_exit(VCPKG_LINE_INFO, !vcpkg_root_dir.empty(), "Error: Could not detect vcpkg-root.");
 
     const Expected<VcpkgPaths> expected_paths = VcpkgPaths::create(vcpkg_root_dir);
-    Checks::check_exit(VCPKG_LINE_INFO, !expected_paths.error_code(), "Error: Invalid vcpkg root directory %s: %s", vcpkg_root_dir.string(), expected_paths.error_code().message());
+    Checks::check_exit(VCPKG_LINE_INFO,
+                       !expected_paths.error_code(),
+                       "Error: Invalid vcpkg root directory %s: %s",
+                       vcpkg_root_dir.string(),
+                       expected_paths.error_code().message());
     const VcpkgPaths paths = expected_paths.value_or_exit(VCPKG_LINE_INFO);
     int exit_code = _wchdir(paths.root.c_str());
     Checks::check_exit(VCPKG_LINE_INFO, exit_code == 0, "Changing the working dir failed");
@@ -76,7 +81,8 @@ static void inner(const VcpkgCmdArguments& args)
     }
     else
     {
-        const Optional<std::wstring> vcpkg_default_triplet_env = System::get_environmental_variable(L"VCPKG_DEFAULT_TRIPLET");
+        const Optional<std::wstring> vcpkg_default_triplet_env =
+            System::get_environmental_variable(L"VCPKG_DEFAULT_TRIPLET");
         if (auto v = vcpkg_default_triplet_env.get())
         {
             default_triplet = Triplet::from_canonical_name(Strings::utf16_to_utf8(*v));
@@ -103,8 +109,7 @@ static void loadConfig()
     {
         // Config path in AppDataLocal
         wchar_t* localappdatapath = nullptr;
-        if (S_OK != SHGetKnownFolderPath(FOLDERID_LocalAppData, 0, nullptr, &localappdatapath))
-            __fastfail(1);
+        if (S_OK != SHGetKnownFolderPath(FOLDERID_LocalAppData, 0, nullptr, &localappdatapath)) __fastfail(1);
         localappdata = localappdatapath;
         CoTaskMemFree(localappdatapath);
     }
@@ -117,8 +122,7 @@ static void loadConfig()
             const auto& pghs = *p_pghs;
 
             std::unordered_map<std::string, std::string> keys;
-            if (pghs.size() > 0)
-                keys = pghs[0];
+            if (pghs.size() > 0) keys = pghs[0];
 
             for (size_t x = 1; x < pghs.size(); ++x)
             {
@@ -135,7 +139,9 @@ static void loadConfig()
             }
         }
     }
-    catch (...) { }
+    catch (...)
+    {
+    }
 
     // config file not found, could not be read, or invalid
     std::string user_id, user_time;
@@ -147,16 +153,20 @@ static void loadConfig()
         auto& fs = Files::get_real_filesystem();
         fs.create_directory(localappdata / "vcpkg", ec);
         fs.write_contents(localappdata / "vcpkg" / "config",
-            Strings::format(
-                "User-Id: %s\n"
-                "User-Since: %s\n", user_id, user_time));
+                          Strings::format("User-Id: %s\n"
+                                          "User-Since: %s\n",
+                                          user_id,
+                                          user_time));
+    }
+    catch (...)
+    {
     }
-    catch (...) { }
 }
 
 static std::string trim_path_from_command_line(const std::string& full_command_line)
 {
-    Checks::check_exit(VCPKG_LINE_INFO, full_command_line.size() > 0, "Internal failure - cannot have empty command line");
+    Checks::check_exit(
+        VCPKG_LINE_INFO, full_command_line.size() > 0, "Internal failure - cannot have empty command line");
 
     if (full_command_line[0] == '"')
     {
@@ -178,17 +188,15 @@ static ElapsedTime g_timer;
 
 int wmain(const int argc, const wchar_t* const* const argv)
 {
-    if (argc == 0)
-        std::abort();
+    if (argc == 0) std::abort();
 
     g_timer = ElapsedTime::create_started();
-    atexit([]()
-        {
-            auto elapsed_us = g_timer.microseconds();
-            Metrics::track_metric("elapsed_us", elapsed_us);
-            g_debugging = false;
-            Metrics::flush();
-        });
+    atexit([]() {
+        auto elapsed_us = g_timer.microseconds();
+        Metrics::track_metric("elapsed_us", elapsed_us);
+        g_debugging = false;
+        Metrics::flush();
+    });
 
     Metrics::track_property("version", Commands::Version::version());
 
@@ -199,10 +207,8 @@ int wmain(const int argc, const wchar_t* const* const argv)
 
     const VcpkgCmdArguments args = VcpkgCmdArguments::create_from_command_line(argc, argv);
 
-    if (args.printmetrics != OptBoolC::UNSPECIFIED)
-        Metrics::set_print_metrics(args.printmetrics == OptBoolC::ENABLED);
-    if (args.sendmetrics != OptBoolC::UNSPECIFIED)
-        Metrics::set_send_metrics(args.sendmetrics == OptBoolC::ENABLED);
+    if (args.printmetrics != OptBoolC::UNSPECIFIED) Metrics::set_print_metrics(args.printmetrics == OptBoolC::ENABLED);
+    if (args.sendmetrics != OptBoolC::UNSPECIFIED) Metrics::set_send_metrics(args.sendmetrics == OptBoolC::ENABLED);
 
     if (args.debug != OptBoolC::UNSPECIFIED)
     {
@@ -232,18 +238,17 @@ int wmain(const int argc, const wchar_t* const* const argv)
     Metrics::track_property("error", exc_msg);
 
     fflush(stdout);
-    System::print(
-        "vcpkg.exe has crashed.\n"
-        "Please send an email to:\n"
-        "    %s\n"
-        "containing a brief summary of what you were trying to do and the following data blob:\n"
-        "\n"
-        "Version=%s\n"
-        "EXCEPTION='%s'\n"
-        "CMD=\n",
-        Commands::Contact::email(),
-        Commands::Version::version(),
-        exc_msg);
+    System::print("vcpkg.exe has crashed.\n"
+                  "Please send an email to:\n"
+                  "    %s\n"
+                  "containing a brief summary of what you were trying to do and the following data blob:\n"
+                  "\n"
+                  "Version=%s\n"
+                  "EXCEPTION='%s'\n"
+                  "CMD=\n",
+                  Commands::Contact::email(),
+                  Commands::Version::version(),
+                  exc_msg);
     fflush(stdout);
     for (int x = 0; x < argc; ++x)
         System::println("%s|", Strings::utf16_to_utf8(argv[x]));
diff --git a/toolsrc/src/vcpkg_metrics_uploader.cpp b/toolsrc/src/vcpkg_metrics_uploader.cpp
index d0fc5179c..38bf7ff9c 100644
--- a/toolsrc/src/vcpkg_metrics_uploader.cpp
+++ b/toolsrc/src/vcpkg_metrics_uploader.cpp
@@ -8,7 +8,7 @@ using namespace vcpkg;
 int WINAPI WinMain(_In_ HINSTANCE, _In_opt_ HINSTANCE, _In_ LPSTR, _In_ int)
 {
     int argCount;
-    LPWSTR * szArgList = CommandLineToArgvW(GetCommandLineW(), &argCount);
+    LPWSTR* szArgList = CommandLineToArgvW(GetCommandLineW(), &argCount);
 
     Checks::check_exit(VCPKG_LINE_INFO, argCount == 2, "Requires exactly one argument, the path to the payload file");
     Metrics::upload(Files::get_real_filesystem().read_contents(szArgList[1]).value_or_exit(VCPKG_LINE_INFO));