Run clang-foramt over tests and remaining cpp files

1 files changed, 74 insertions, 96 deletions

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){};
 }