*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

35 files changed, 3877 insertions, 3997 deletions

diff --git a/lldb/unittests/Core/BroadcasterTest.cpp b/lldb/unittests/Core/BroadcasterTest.cpp
index 5650f710620..cc6f2417897 100644
--- a/lldb/unittests/Core/BroadcasterTest.cpp
+++ b/lldb/unittests/Core/BroadcasterTest.cpp
@@ -18,55 +18,56 @@
 using namespace lldb;
 using namespace lldb_private;
 
-TEST(BroadcasterTest, BroadcastEvent)
-{
-    EventSP event_sp;
-    Broadcaster broadcaster(nullptr, "test-broadcaster");
+TEST(BroadcasterTest, BroadcastEvent) {
+  EventSP event_sp;
+  Broadcaster broadcaster(nullptr, "test-broadcaster");
 
-    // Create a listener, sign it up, make sure it recieves an event.
-    ListenerSP listener1_sp = Listener::MakeListener("test-listener1");
-    const uint32_t event_mask1 = 1;
-    EXPECT_EQ(event_mask1, listener1_sp->StartListeningForEvents(&broadcaster, event_mask1));
-    broadcaster.BroadcastEvent(event_mask1, nullptr);
-    EXPECT_TRUE(listener1_sp->GetNextEvent(event_sp));
-    EXPECT_EQ(event_mask1, event_sp->GetType());
+  // Create a listener, sign it up, make sure it recieves an event.
+  ListenerSP listener1_sp = Listener::MakeListener("test-listener1");
+  const uint32_t event_mask1 = 1;
+  EXPECT_EQ(event_mask1,
+            listener1_sp->StartListeningForEvents(&broadcaster, event_mask1));
+  broadcaster.BroadcastEvent(event_mask1, nullptr);
+  EXPECT_TRUE(listener1_sp->GetNextEvent(event_sp));
+  EXPECT_EQ(event_mask1, event_sp->GetType());
 
-    {
-        // Add one more listener, make sure it works as well.
-        ListenerSP listener2_sp = Listener::MakeListener("test-listener2");
-        const uint32_t event_mask2 = 1;
-        EXPECT_EQ(event_mask2, listener2_sp->StartListeningForEvents(&broadcaster, event_mask1 | event_mask2));
-        broadcaster.BroadcastEvent(event_mask2, nullptr);
-        EXPECT_TRUE(listener2_sp->GetNextEvent(event_sp));
-        EXPECT_EQ(event_mask2, event_sp->GetType());
+  {
+    // Add one more listener, make sure it works as well.
+    ListenerSP listener2_sp = Listener::MakeListener("test-listener2");
+    const uint32_t event_mask2 = 1;
+    EXPECT_EQ(event_mask2, listener2_sp->StartListeningForEvents(
+                               &broadcaster, event_mask1 | event_mask2));
+    broadcaster.BroadcastEvent(event_mask2, nullptr);
+    EXPECT_TRUE(listener2_sp->GetNextEvent(event_sp));
+    EXPECT_EQ(event_mask2, event_sp->GetType());
 
-        // Both listeners should get this event.
-        broadcaster.BroadcastEvent(event_mask1, nullptr);
-        EXPECT_TRUE(listener1_sp->GetNextEvent(event_sp));
-        EXPECT_EQ(event_mask1, event_sp->GetType());
-        EXPECT_TRUE(listener2_sp->GetNextEvent(event_sp));
-        EXPECT_EQ(event_mask2, event_sp->GetType());
-    }
-
-    // Now again only one listener should be active.
+    // Both listeners should get this event.
     broadcaster.BroadcastEvent(event_mask1, nullptr);
     EXPECT_TRUE(listener1_sp->GetNextEvent(event_sp));
     EXPECT_EQ(event_mask1, event_sp->GetType());
+    EXPECT_TRUE(listener2_sp->GetNextEvent(event_sp));
+    EXPECT_EQ(event_mask2, event_sp->GetType());
+  }
+
+  // Now again only one listener should be active.
+  broadcaster.BroadcastEvent(event_mask1, nullptr);
+  EXPECT_TRUE(listener1_sp->GetNextEvent(event_sp));
+  EXPECT_EQ(event_mask1, event_sp->GetType());
 }
 
-TEST(BroadcasterTest, EventTypeHasListeners)
-{
-    EventSP event_sp;
-    Broadcaster broadcaster(nullptr, "test-broadcaster");
+TEST(BroadcasterTest, EventTypeHasListeners) {
+  EventSP event_sp;
+  Broadcaster broadcaster(nullptr, "test-broadcaster");
 
-    const uint32_t event_mask = 1;
-    EXPECT_FALSE(broadcaster.EventTypeHasListeners(event_mask));
+  const uint32_t event_mask = 1;
+  EXPECT_FALSE(broadcaster.EventTypeHasListeners(event_mask));
 
-    {
-        ListenerSP listener_sp = Listener::MakeListener("test-listener");
-        EXPECT_EQ(event_mask, listener_sp->StartListeningForEvents(&broadcaster, event_mask));
-        EXPECT_TRUE(broadcaster.EventTypeHasListeners(event_mask));
-    }
+  {
+    ListenerSP listener_sp = Listener::MakeListener("test-listener");
+    EXPECT_EQ(event_mask,
+              listener_sp->StartListeningForEvents(&broadcaster, event_mask));
+    EXPECT_TRUE(broadcaster.EventTypeHasListeners(event_mask));
+  }
 
-    EXPECT_FALSE(broadcaster.EventTypeHasListeners(event_mask));
+  EXPECT_FALSE(broadcaster.EventTypeHasListeners(event_mask));
 }
diff --git a/lldb/unittests/Core/DataExtractorTest.cpp b/lldb/unittests/Core/DataExtractorTest.cpp
index 22438e59bea..d474e21dc0c 100644
--- a/lldb/unittests/Core/DataExtractorTest.cpp
+++ b/lldb/unittests/Core/DataExtractorTest.cpp
@@ -8,7 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 #if defined(_MSC_VER) && (_HAS_EXCEPTIONS == 0)
-// Workaround for MSVC standard library bug, which fails to include <thread> when
+// Workaround for MSVC standard library bug, which fails to include <thread>
+// when
 // exceptions are disabled.
 #include <eh.h>
 #endif
@@ -19,38 +20,39 @@
 
 using namespace lldb_private;
 
-TEST(DataExtractorTest, GetBitfield)
-{
-    uint8_t buffer[] = { 0x01, 0x23, 0x45, 0x67 };
-    DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle, sizeof(void *));
-    DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));
-
-    lldb::offset_t offset;
-
-    offset = 0;
-    ASSERT_EQ(buffer[1], LE.GetMaxU64Bitfield(&offset, sizeof(buffer), 8, 8));
-    offset = 0;
-    ASSERT_EQ(buffer[1], BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 8, 8));
-
-    offset = 0;
-    ASSERT_EQ(int8_t(buffer[1]), LE.GetMaxS64Bitfield(&offset, sizeof(buffer), 8, 8));
-    offset = 0;
-    ASSERT_EQ(int8_t(buffer[1]), BE.GetMaxS64Bitfield(&offset, sizeof(buffer), 8, 8));
+TEST(DataExtractorTest, GetBitfield) {
+  uint8_t buffer[] = {0x01, 0x23, 0x45, 0x67};
+  DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
+                   sizeof(void *));
+  DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));
+
+  lldb::offset_t offset;
+
+  offset = 0;
+  ASSERT_EQ(buffer[1], LE.GetMaxU64Bitfield(&offset, sizeof(buffer), 8, 8));
+  offset = 0;
+  ASSERT_EQ(buffer[1], BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 8, 8));
+
+  offset = 0;
+  ASSERT_EQ(int8_t(buffer[1]),
+            LE.GetMaxS64Bitfield(&offset, sizeof(buffer), 8, 8));
+  offset = 0;
+  ASSERT_EQ(int8_t(buffer[1]),
+            BE.GetMaxS64Bitfield(&offset, sizeof(buffer), 8, 8));
 }
 
-TEST(DataExtractorTest, PeekData)
-{
-    uint8_t buffer[] = { 0x01, 0x02, 0x03, 0x04 };
-    DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4);
+TEST(DataExtractorTest, PeekData) {
+  uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04};
+  DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4);
 
-    EXPECT_EQ(buffer + 0, E.PeekData(0, 0));
-    EXPECT_EQ(buffer + 0, E.PeekData(0, 4));
-    EXPECT_EQ(nullptr, E.PeekData(0, 5));
+  EXPECT_EQ(buffer + 0, E.PeekData(0, 0));
+  EXPECT_EQ(buffer + 0, E.PeekData(0, 4));
+  EXPECT_EQ(nullptr, E.PeekData(0, 5));
 
-    EXPECT_EQ(buffer + 2, E.PeekData(2, 0));
-    EXPECT_EQ(buffer + 2, E.PeekData(2, 2));
-    EXPECT_EQ(nullptr, E.PeekData(2, 3));
+  EXPECT_EQ(buffer + 2, E.PeekData(2, 0));
+  EXPECT_EQ(buffer + 2, E.PeekData(2, 2));
+  EXPECT_EQ(nullptr, E.PeekData(2, 3));
 
-    EXPECT_EQ(buffer + 4, E.PeekData(4, 0));
-    EXPECT_EQ(nullptr, E.PeekData(4, 1));
+  EXPECT_EQ(buffer + 4, E.PeekData(4, 0));
+  EXPECT_EQ(nullptr, E.PeekData(4, 1));
 }
diff --git a/lldb/unittests/Core/ScalarTest.cpp b/lldb/unittests/Core/ScalarTest.cpp
index adff5b0ce8e..b79854f97ae 100644
--- a/lldb/unittests/Core/ScalarTest.cpp
+++ b/lldb/unittests/Core/ScalarTest.cpp
@@ -8,135 +8,134 @@
 //===----------------------------------------------------------------------===//
 
 #if defined(_MSC_VER) && (_HAS_EXCEPTIONS == 0)
-// Workaround for MSVC standard library bug, which fails to include <thread> when
+// Workaround for MSVC standard library bug, which fails to include <thread>
+// when
 // exceptions are disabled.
 #include <eh.h>
 #endif
 
 #include "gtest/gtest.h"
 
+#include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Scalar.h"
-#include "lldb/Core/DataExtractor.h"
-#include "lldb/Host/Endian.h"
 #include "lldb/Core/StreamString.h"
+#include "lldb/Host/Endian.h"
 
 using namespace lldb_private;
 
-TEST(ScalarTest, RightShiftOperator)
-{
-    int a = 0x00001000;
-    int b = 0xFFFFFFFF;
-    int c = 4;
-    Scalar a_scalar(a);
-    Scalar b_scalar(b);
-    Scalar c_scalar(c);
-    ASSERT_EQ(a >> c, a_scalar >> c_scalar);
-    ASSERT_EQ(b >> c, b_scalar >> c_scalar);
+TEST(ScalarTest, RightShiftOperator) {
+  int a = 0x00001000;
+  int b = 0xFFFFFFFF;
+  int c = 4;
+  Scalar a_scalar(a);
+  Scalar b_scalar(b);
+  Scalar c_scalar(c);
+  ASSERT_EQ(a >> c, a_scalar >> c_scalar);
+  ASSERT_EQ(b >> c, b_scalar >> c_scalar);
 }
 
-TEST(ScalarTest, GetBytes)
-{
-    int a = 0x01020304;
-    long long b = 0x0102030405060708LL;
-    float c = 1234567.89e42;
-    double d = 1234567.89e42;
-    char e[16] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
-    char f[32] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-                   17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32 };
-    Scalar a_scalar(a);
-    Scalar b_scalar(b);
-    Scalar c_scalar(c);
-    Scalar d_scalar(d);
-    Scalar e_scalar;
-    Scalar f_scalar;
-    DataExtractor e_data(e, sizeof(e), endian::InlHostByteOrder(), sizeof(void *));
-    Error e_error = e_scalar.SetValueFromData(e_data, lldb::eEncodingUint, sizeof(e));
-    DataExtractor f_data(f, sizeof(f), endian::InlHostByteOrder(), sizeof(void *));
-    Error f_error = f_scalar.SetValueFromData(f_data, lldb::eEncodingUint, sizeof(f));
-    ASSERT_EQ(0, memcmp(&a, a_scalar.GetBytes(), sizeof(a)));
-    ASSERT_EQ(0, memcmp(&b, b_scalar.GetBytes(), sizeof(b)));
-    ASSERT_EQ(0, memcmp(&c, c_scalar.GetBytes(), sizeof(c)));
-    ASSERT_EQ(0, memcmp(&d, d_scalar.GetBytes(), sizeof(d)));
-    ASSERT_EQ(0, e_error.Fail());
-    ASSERT_EQ(0, memcmp(e, e_scalar.GetBytes(), sizeof(e)));
-    ASSERT_EQ(0, f_error.Fail());
-    ASSERT_EQ(0, memcmp(f, f_scalar.GetBytes(), sizeof(f)));
+TEST(ScalarTest, GetBytes) {
+  int a = 0x01020304;
+  long long b = 0x0102030405060708LL;
+  float c = 1234567.89e42;
+  double d = 1234567.89e42;
+  char e[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+  char f[32] = {1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
+                17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32};
+  Scalar a_scalar(a);
+  Scalar b_scalar(b);
+  Scalar c_scalar(c);
+  Scalar d_scalar(d);
+  Scalar e_scalar;
+  Scalar f_scalar;
+  DataExtractor e_data(e, sizeof(e), endian::InlHostByteOrder(),
+                       sizeof(void *));
+  Error e_error =
+      e_scalar.SetValueFromData(e_data, lldb::eEncodingUint, sizeof(e));
+  DataExtractor f_data(f, sizeof(f), endian::InlHostByteOrder(),
+                       sizeof(void *));
+  Error f_error =
+      f_scalar.SetValueFromData(f_data, lldb::eEncodingUint, sizeof(f));
+  ASSERT_EQ(0, memcmp(&a, a_scalar.GetBytes(), sizeof(a)));
+  ASSERT_EQ(0, memcmp(&b, b_scalar.GetBytes(), sizeof(b)));
+  ASSERT_EQ(0, memcmp(&c, c_scalar.GetBytes(), sizeof(c)));
+  ASSERT_EQ(0, memcmp(&d, d_scalar.GetBytes(), sizeof(d)));
+  ASSERT_EQ(0, e_error.Fail());
+  ASSERT_EQ(0, memcmp(e, e_scalar.GetBytes(), sizeof(e)));
+  ASSERT_EQ(0, f_error.Fail());
+  ASSERT_EQ(0, memcmp(f, f_scalar.GetBytes(), sizeof(f)));
 }
 
-TEST(ScalarTest, CastOperations)
-{
-    long long a = 0xf1f2f3f4f5f6f7f8LL;
-    Scalar a_scalar(a);
-    ASSERT_EQ((signed char)a, a_scalar.SChar());
-    ASSERT_EQ((unsigned char)a, a_scalar.UChar());
-    ASSERT_EQ((signed short)a, a_scalar.SShort());
-    ASSERT_EQ((unsigned short)a, a_scalar.UShort());
-    ASSERT_EQ((signed int)a, a_scalar.SInt());
-    ASSERT_EQ((unsigned int)a, a_scalar.UInt());
-    ASSERT_EQ((signed long)a, a_scalar.SLong());
-    ASSERT_EQ((unsigned long)a, a_scalar.ULong());
-    ASSERT_EQ((signed long long)a, a_scalar.SLongLong());
-    ASSERT_EQ((unsigned long long)a, a_scalar.ULongLong());
+TEST(ScalarTest, CastOperations) {
+  long long a = 0xf1f2f3f4f5f6f7f8LL;
+  Scalar a_scalar(a);
+  ASSERT_EQ((signed char)a, a_scalar.SChar());
+  ASSERT_EQ((unsigned char)a, a_scalar.UChar());
+  ASSERT_EQ((signed short)a, a_scalar.SShort());
+  ASSERT_EQ((unsigned short)a, a_scalar.UShort());
+  ASSERT_EQ((signed int)a, a_scalar.SInt());
+  ASSERT_EQ((unsigned int)a, a_scalar.UInt());
+  ASSERT_EQ((signed long)a, a_scalar.SLong());
+  ASSERT_EQ((unsigned long)a, a_scalar.ULong());
+  ASSERT_EQ((signed long long)a, a_scalar.SLongLong());
+  ASSERT_EQ((unsigned long long)a, a_scalar.ULongLong());
 }
 
-TEST(ScalarTest, ExtractBitfield)
-{
-    uint32_t len = sizeof(long long) * 8;
+TEST(ScalarTest, ExtractBitfield) {
+  uint32_t len = sizeof(long long) * 8;
 
-    long long a1 = 0xf1f2f3f4f5f6f7f8LL;
-    long long b1 = 0xff1f2f3f4f5f6f7fLL;
-    Scalar s_scalar(a1);
-    ASSERT_TRUE(s_scalar.ExtractBitfield(0, 0));
-    ASSERT_EQ(0, memcmp(&a1, s_scalar.GetBytes(), sizeof(a1)));
-    ASSERT_TRUE(s_scalar.ExtractBitfield(len, 0));
-    ASSERT_EQ(0, memcmp(&a1, s_scalar.GetBytes(), sizeof(a1)));
-    ASSERT_TRUE(s_scalar.ExtractBitfield(len - 4, 4));
-    ASSERT_EQ(0, memcmp(&b1, s_scalar.GetBytes(), sizeof(b1)));
+  long long a1 = 0xf1f2f3f4f5f6f7f8LL;
+  long long b1 = 0xff1f2f3f4f5f6f7fLL;
+  Scalar s_scalar(a1);
+  ASSERT_TRUE(s_scalar.ExtractBitfield(0, 0));
+  ASSERT_EQ(0, memcmp(&a1, s_scalar.GetBytes(), sizeof(a1)));
+  ASSERT_TRUE(s_scalar.ExtractBitfield(len, 0));
+  ASSERT_EQ(0, memcmp(&a1, s_scalar.GetBytes(), sizeof(a1)));
+  ASSERT_TRUE(s_scalar.ExtractBitfield(len - 4, 4));
+  ASSERT_EQ(0, memcmp(&b1, s_scalar.GetBytes(), sizeof(b1)));
 
-    unsigned long long a2 = 0xf1f2f3f4f5f6f7f8ULL;
-    unsigned long long b2 = 0x0f1f2f3f4f5f6f7fULL;
-    Scalar u_scalar(a2);
-    ASSERT_TRUE(u_scalar.ExtractBitfield(0, 0));
-    ASSERT_EQ(0, memcmp(&a2, u_scalar.GetBytes(), sizeof(a2)));
-    ASSERT_TRUE(u_scalar.ExtractBitfield(len, 0));
-    ASSERT_EQ(0, memcmp(&a2, u_scalar.GetBytes(), sizeof(a2)));
-    ASSERT_TRUE(u_scalar.ExtractBitfield(len - 4, 4));
-    ASSERT_EQ(0, memcmp(&b2, u_scalar.GetBytes(), sizeof(b2)));
+  unsigned long long a2 = 0xf1f2f3f4f5f6f7f8ULL;
+  unsigned long long b2 = 0x0f1f2f3f4f5f6f7fULL;
+  Scalar u_scalar(a2);
+  ASSERT_TRUE(u_scalar.ExtractBitfield(0, 0));
+  ASSERT_EQ(0, memcmp(&a2, u_scalar.GetBytes(), sizeof(a2)));
+  ASSERT_TRUE(u_scalar.ExtractBitfield(len, 0));
+  ASSERT_EQ(0, memcmp(&a2, u_scalar.GetBytes(), sizeof(a2)));
+  ASSERT_TRUE(u_scalar.ExtractBitfield(len - 4, 4));
+  ASSERT_EQ(0, memcmp(&b2, u_scalar.GetBytes(), sizeof(b2)));
 }
 
-template <typename T>
-static std::string
-ScalarGetValue(T value)
-{
-    StreamString stream;
-    Scalar(value).GetValue(&stream, false);
-    return stream.GetString();
+template <typename T> static std::string ScalarGetValue(T value) {
+  StreamString stream;
+  Scalar(value).GetValue(&stream, false);
+  return stream.GetString();
 }
 
-TEST(ScalarTest, GetValue)
-{
-    EXPECT_EQ("12345", ScalarGetValue<signed short>(12345));
-    EXPECT_EQ("-12345", ScalarGetValue<signed short>(-12345));
-    EXPECT_EQ("12345", ScalarGetValue<unsigned short>(12345));
-    EXPECT_EQ(std::to_string(std::numeric_limits<unsigned short>::max()),
-              ScalarGetValue(std::numeric_limits<unsigned short>::max()));
+TEST(ScalarTest, GetValue) {
+  EXPECT_EQ("12345", ScalarGetValue<signed short>(12345));
+  EXPECT_EQ("-12345", ScalarGetValue<signed short>(-12345));
+  EXPECT_EQ("12345", ScalarGetValue<unsigned short>(12345));
+  EXPECT_EQ(std::to_string(std::numeric_limits<unsigned short>::max()),
+            ScalarGetValue(std::numeric_limits<unsigned short>::max()));
 
-    EXPECT_EQ("12345", ScalarGetValue<signed int>(12345));
-    EXPECT_EQ("-12345", ScalarGetValue<signed int>(-12345));
-    EXPECT_EQ("12345", ScalarGetValue<unsigned int>(12345));
-    EXPECT_EQ(std::to_string(std::numeric_limits<unsigned int>::max()),
-              ScalarGetValue(std::numeric_limits<unsigned int>::max()));
+  EXPECT_EQ("12345", ScalarGetValue<signed int>(12345));
+  EXPECT_EQ("-12345", ScalarGetValue<signed int>(-12345));
+  EXPECT_EQ("12345", ScalarGetValue<unsigned int>(12345));
+  EXPECT_EQ(std::to_string(std::numeric_limits<unsigned int>::max()),
+            ScalarGetValue(std::numeric_limits<unsigned int>::max()));
 
-    EXPECT_EQ("12345678", ScalarGetValue<signed long>(12345678L));
-    EXPECT_EQ("-12345678", ScalarGetValue<signed long>(-12345678L));
-    EXPECT_EQ("12345678", ScalarGetValue<unsigned long>(12345678UL));
-    EXPECT_EQ(std::to_string(std::numeric_limits<unsigned long>::max()),
-              ScalarGetValue(std::numeric_limits<unsigned long>::max()));
+  EXPECT_EQ("12345678", ScalarGetValue<signed long>(12345678L));
+  EXPECT_EQ("-12345678", ScalarGetValue<signed long>(-12345678L));
+  EXPECT_EQ("12345678", ScalarGetValue<unsigned long>(12345678UL));
+  EXPECT_EQ(std::to_string(std::numeric_limits<unsigned long>::max()),
+            ScalarGetValue(std::numeric_limits<unsigned long>::max()));
 
-    EXPECT_EQ("1234567890123", ScalarGetValue<signed long long>(1234567890123LL));
-    EXPECT_EQ("-1234567890123", ScalarGetValue<signed long long>(-1234567890123LL));
-    EXPECT_EQ("1234567890123", ScalarGetValue<unsigned long long>(1234567890123ULL));
-    EXPECT_EQ(std::to_string(std::numeric_limits<unsigned long long>::max()),
-              ScalarGetValue(std::numeric_limits<unsigned long long>::max()));
+  EXPECT_EQ("1234567890123", ScalarGetValue<signed long long>(1234567890123LL));
+  EXPECT_EQ("-1234567890123",
+            ScalarGetValue<signed long long>(-1234567890123LL));
+  EXPECT_EQ("1234567890123",
+            ScalarGetValue<unsigned long long>(1234567890123ULL));
+  EXPECT_EQ(std::to_string(std::numeric_limits<unsigned long long>::max()),
+            ScalarGetValue(std::numeric_limits<unsigned long long>::max()));
 }
diff --git a/lldb/unittests/Editline/EditlineTest.cpp b/lldb/unittests/Editline/EditlineTest.cpp
index e2552ffdd3b..55dae525ddc 100644
--- a/lldb/unittests/Editline/EditlineTest.cpp
+++ b/lldb/unittests/Editline/EditlineTest.cpp
@@ -25,348 +25,289 @@
 #include "lldb/Host/Pipe.h"
 #include "lldb/Utility/PseudoTerminal.h"
 
-namespace
-{
-    const size_t TIMEOUT_MILLIS = 5000;
+namespace {
+const size_t TIMEOUT_MILLIS = 5000;
 }
 
-class FilePointer
-{
+class FilePointer {
 public:
+  FilePointer() = delete;
 
-    FilePointer () = delete;
+  FilePointer(const FilePointer &) = delete;
 
-    FilePointer (const FilePointer&) = delete;
+  FilePointer(FILE *file_p) : _file_p(file_p) {}
 
-    FilePointer (FILE *file_p)
-    : _file_p (file_p)
-    {
+  ~FilePointer() {
+    if (_file_p != nullptr) {
+      const int close_result = fclose(_file_p);
+      EXPECT_EQ(0, close_result);
     }
+  }
 
-    ~FilePointer ()
-    {
-        if (_file_p != nullptr)
-        {
-            const int close_result = fclose (_file_p);
-            EXPECT_EQ(0, close_result);
-        }
-    }
-
-    operator FILE* ()
-    {
-        return _file_p;
-    }
+  operator FILE *() { return _file_p; }
 
 private:
-
-    FILE *_file_p;
-
+  FILE *_file_p;
 };
 
 /**
  Wraps an Editline class, providing a simple way to feed
  input (as if from the keyboard) and receive output from Editline.
  */
-class EditlineAdapter
-{
+class EditlineAdapter {
 public:
+  EditlineAdapter();
 
-    EditlineAdapter ();
+  void CloseInput();
 
-    void
-    CloseInput ();
+  bool IsValid() const { return _editline_sp.get() != nullptr; }
 
-    bool
-    IsValid () const
-    {
-        return _editline_sp.get () != nullptr;
-    }
+  lldb_private::Editline &GetEditline() { return *_editline_sp; }
 
-    lldb_private::Editline&
-    GetEditline ()
-    {
-        return *_editline_sp;
-    }
+  bool SendLine(const std::string &line);
 
-    bool
-    SendLine (const std::string &line);
+  bool SendLines(const std::vector<std::string> &lines);
 
-    bool
-    SendLines (const std::vector<std::string> &lines);
+  bool GetLine(std::string &line, bool &interrupted, size_t timeout_millis);
 
-    bool
-    GetLine (std::string &line, bool &interrupted, size_t timeout_millis);
+  bool GetLines(lldb_private::StringList &lines, bool &interrupted,
+                size_t timeout_millis);
 
-    bool
-    GetLines (lldb_private::StringList &lines, bool &interrupted, size_t timeout_millis);
-
-    void
-    ConsumeAllOutput ();
+  void ConsumeAllOutput();
 
 private:
+  static bool IsInputComplete(lldb_private::Editline *editline,
+                              lldb_private::StringList &lines, void *baton);
 
-    static bool
-    IsInputComplete (
-        lldb_private::Editline * editline,
-        lldb_private::StringList & lines,
-        void * baton);
-
-    std::unique_ptr<lldb_private::Editline> _editline_sp;
+  std::unique_ptr<lldb_private::Editline> _editline_sp;
 
-    lldb_utility::PseudoTerminal _pty;
-    int _pty_master_fd;
-    int _pty_slave_fd;
+  lldb_utility::PseudoTerminal _pty;
+  int _pty_master_fd;
+  int _pty_slave_fd;
 
-    std::unique_ptr<FilePointer> _el_slave_file;
+  std::unique_ptr<FilePointer> _el_slave_file;
 };
 
-EditlineAdapter::EditlineAdapter () :
-    _editline_sp (),
-    _pty (),
-    _pty_master_fd (-1),
-    _pty_slave_fd (-1),
-    _el_slave_file ()
-{
-    lldb_private::Error error;
-
-    // Open the first master pty available.
-    char error_string[256];
-    error_string[0] = '\0';
-    if (!_pty.OpenFirstAvailableMaster (O_RDWR, error_string, sizeof (error_string)))
-    {
-        fprintf(stderr, "failed to open first available master pty: '%s'\n", error_string);
-        return;
-    }
-
-    // Grab the master fd.  This is a file descriptor we will:
-    // (1) write to when we want to send input to editline.
-    // (2) read from when we want to see what editline sends back.
-    _pty_master_fd = _pty.GetMasterFileDescriptor();
-
-    // Open the corresponding slave pty.
-    if (!_pty.OpenSlave (O_RDWR, error_string, sizeof (error_string)))
-    {
-        fprintf(stderr, "failed to open slave pty: '%s'\n", error_string);
-        return;
-    }
-    _pty_slave_fd = _pty.GetSlaveFileDescriptor();
+EditlineAdapter::EditlineAdapter()
+    : _editline_sp(), _pty(), _pty_master_fd(-1), _pty_slave_fd(-1),
+      _el_slave_file() {
+  lldb_private::Error error;
+
+  // Open the first master pty available.
+  char error_string[256];
+  error_string[0] = '\0';
+  if (!_pty.OpenFirstAvailableMaster(O_RDWR, error_string,
+                                     sizeof(error_string))) {
+    fprintf(stderr, "failed to open first available master pty: '%s'\n",
+            error_string);
+    return;
+  }
+
+  // Grab the master fd.  This is a file descriptor we will:
+  // (1) write to when we want to send input to editline.
+  // (2) read from when we want to see what editline sends back.
+  _pty_master_fd = _pty.GetMasterFileDescriptor();
+
+  // Open the corresponding slave pty.
+  if (!_pty.OpenSlave(O_RDWR, error_string, sizeof(error_string))) {
+    fprintf(stderr, "failed to open slave pty: '%s'\n", error_string);
+    return;
+  }
+  _pty_slave_fd = _pty.GetSlaveFileDescriptor();
+
+  _el_slave_file.reset(new FilePointer(fdopen(_pty_slave_fd, "rw")));
+  EXPECT_FALSE(nullptr == *_el_slave_file);
+  if (*_el_slave_file == nullptr)
+    return;
+
+  // Create an Editline instance.
+  _editline_sp.reset(new lldb_private::Editline("gtest editor", *_el_slave_file,
+                                                *_el_slave_file,
+                                                *_el_slave_file, false));
+  _editline_sp->SetPrompt("> ");
+
+  // Hookup our input complete callback.
+  _editline_sp->SetIsInputCompleteCallback(IsInputComplete, this);
+}
 
-    _el_slave_file.reset (new FilePointer (fdopen (_pty_slave_fd, "rw")));
-    EXPECT_FALSE (nullptr == *_el_slave_file);
-    if (*_el_slave_file == nullptr)
-        return;
+void EditlineAdapter::CloseInput() {
+  if (_el_slave_file != nullptr)
+    _el_slave_file.reset(nullptr);
+}
 
-    // Create an Editline instance.
-    _editline_sp.reset (new lldb_private::Editline("gtest editor", *_el_slave_file, *_el_slave_file, *_el_slave_file, false));
-    _editline_sp->SetPrompt ("> ");
+bool EditlineAdapter::SendLine(const std::string &line) {
+  // Ensure we're valid before proceeding.
+  if (!IsValid())
+    return false;
 
-    // Hookup our input complete callback.
-    _editline_sp->SetIsInputCompleteCallback(IsInputComplete, this);
-}
+  // Write the line out to the pipe connected to editline's input.
+  ssize_t input_bytes_written =
+      ::write(_pty_master_fd, line.c_str(),
+              line.length() * sizeof(std::string::value_type));
 
-void
-EditlineAdapter::CloseInput ()
-{
-    if (_el_slave_file != nullptr)
-        _el_slave_file.reset (nullptr);
-}
+  const char *eoln = "\n";
+  const size_t eoln_length = strlen(eoln);
+  input_bytes_written =
+      ::write(_pty_master_fd, eoln, eoln_length * sizeof(char));
 
-bool
-EditlineAdapter::SendLine (const std::string &line)
-{
-    // Ensure we're valid before proceeding.
-    if (!IsValid ())
-        return false;
-
-    // Write the line out to the pipe connected to editline's input.
-    ssize_t input_bytes_written =
-        ::write (_pty_master_fd,
-                 line.c_str(),
-                 line.length() * sizeof (std::string::value_type));
-
-    const char *eoln = "\n";
-    const size_t eoln_length = strlen(eoln);
-    input_bytes_written =
-        ::write (_pty_master_fd,
-                 eoln,
-                 eoln_length * sizeof (char));
-
-    EXPECT_NE(-1, input_bytes_written) << strerror(errno);
-    EXPECT_EQ (eoln_length * sizeof (char), size_t(input_bytes_written));
-    return eoln_length * sizeof (char) == size_t(input_bytes_written);
+  EXPECT_NE(-1, input_bytes_written) << strerror(errno);
+  EXPECT_EQ(eoln_length * sizeof(char), size_t(input_bytes_written));
+  return eoln_length * sizeof(char) == size_t(input_bytes_written);
 }
 
-bool
-EditlineAdapter::SendLines (const std::vector<std::string> &lines)
-{
-    for (auto &line : lines)
-    {
+bool EditlineAdapter::SendLines(const std::vector<std::string> &lines) {
+  for (auto &line : lines) {
 #if EDITLINE_TEST_DUMP_OUTPUT
-        printf ("<stdin> sending line \"%s\"\n", line.c_str());
+    printf("<stdin> sending line \"%s\"\n", line.c_str());
 #endif
-        if (!SendLine (line))
-            return false;
-    }
-    return true;
+    if (!SendLine(line))
+      return false;
+  }
+  return true;
 }
 
 // We ignore the timeout for now.
-bool
-EditlineAdapter::GetLine (std::string &line, bool &interrupted, size_t /* timeout_millis */)
-{
-    // Ensure we're valid before proceeding.
-    if (!IsValid ())
-        return false;
-
-    _editline_sp->GetLine (line, interrupted);
-    return true;
+bool EditlineAdapter::GetLine(std::string &line, bool &interrupted,
+                              size_t /* timeout_millis */) {
+  // Ensure we're valid before proceeding.
+  if (!IsValid())
+    return false;
+
+  _editline_sp->GetLine(line, interrupted);
+  return true;
 }
 
-bool
-EditlineAdapter::GetLines (lldb_private::StringList &lines, bool &interrupted, size_t /* timeout_millis */)
-{
-    // Ensure we're valid before proceeding.
-    if (!IsValid ())
-        return false;
-    
-    _editline_sp->GetLines (1, lines, interrupted);
-    return true;
+bool EditlineAdapter::GetLines(lldb_private::StringList &lines,
+                               bool &interrupted, size_t /* timeout_millis */) {
+  // Ensure we're valid before proceeding.
+  if (!IsValid())
+    return false;
+
+  _editline_sp->GetLines(1, lines, interrupted);
+  return true;
 }
 
-bool
-EditlineAdapter::IsInputComplete (
-        lldb_private::Editline * editline,
-        lldb_private::StringList & lines,
-        void * baton)
-{
-    // We'll call ourselves complete if we've received a balanced set of braces.
-    int start_block_count = 0;
-    int brace_balance = 0;
-
-    for (size_t i = 0; i < lines.GetSize (); ++i)
-    {
-        for (auto ch : lines[i])
-        {
-            if (ch == '{')
-            {
-                ++start_block_count;
-                ++brace_balance;
-            }
-            else if (ch == '}')
-                --brace_balance;
-        }
+bool EditlineAdapter::IsInputComplete(lldb_private::Editline *editline,
+                                      lldb_private::StringList &lines,
+                                      void *baton) {
+  // We'll call ourselves complete if we've received a balanced set of braces.
+  int start_block_count = 0;
+  int brace_balance = 0;
+
+  for (size_t i = 0; i < lines.GetSize(); ++i) {
+    for (auto ch : lines[i]) {
+      if (ch == '{') {
+        ++start_block_count;
+        ++brace_balance;
+      } else if (ch == '}')
+        --brace_balance;
     }
+  }
 
-    return (start_block_count > 0) && (brace_balance == 0);
+  return (start_block_count > 0) && (brace_balance == 0);
 }
 
-void
-EditlineAdapter::ConsumeAllOutput ()
-{
-    FilePointer output_file (fdopen (_pty_master_fd, "r"));
+void EditlineAdapter::ConsumeAllOutput() {
+  FilePointer output_file(fdopen(_pty_master_fd, "r"));
 
-    int ch;
-    while ((ch = fgetc(output_file)) != EOF)
-    {
+  int ch;
+  while ((ch = fgetc(output_file)) != EOF) {
 #if EDITLINE_TEST_DUMP_OUTPUT
-        char display_str[] = { 0, 0, 0 };
-        switch (ch)
-        {
-            case '\t':
-                display_str[0] = '\\';
-                display_str[1] = 't';
-                break;
-            case '\n':
-                display_str[0] = '\\';
-                display_str[1] = 'n';
-                break;
-            case '\r':
-                display_str[0] = '\\';
-                display_str[1] = 'r';
-                break;
-            default:
-                display_str[0] = ch;
-                break;
-        }
-        printf ("<stdout> 0x%02x (%03d) (%s)\n", ch, ch, display_str);
-        // putc(ch, stdout);
-#endif
+    char display_str[] = {0, 0, 0};
+    switch (ch) {
+    case '\t':
+      display_str[0] = '\\';
+      display_str[1] = 't';
+      break;
+    case '\n':
+      display_str[0] = '\\';
+      display_str[1] = 'n';
+      break;
+    case '\r':
+      display_str[0] = '\\';
+      display_str[1] = 'r';
+      break;
+    default:
+      display_str[0] = ch;
+      break;
     }
+    printf("<stdout> 0x%02x (%03d) (%s)\n", ch, ch, display_str);
+// putc(ch, stdout);
+#endif
+  }
 }
 
-class EditlineTestFixture : public ::testing::Test
-{
+class EditlineTestFixture : public ::testing::Test {
 private:
-    EditlineAdapter _el_adapter;
-    std::shared_ptr<std::thread> _sp_output_thread;
+  EditlineAdapter _el_adapter;
+  std::shared_ptr<std::thread> _sp_output_thread;
 
 public:
-    void SetUp()
-    {
-        // We need a TERM set properly for editline to work as expected.
-        setenv("TERM", "vt100", 1);
-
-        // Validate the editline adapter.
-        EXPECT_TRUE(_el_adapter.IsValid());
-        if (!_el_adapter.IsValid())
-            return;
-
-        // Dump output.
-        _sp_output_thread.reset(new std::thread([&] { _el_adapter.ConsumeAllOutput(); }));
-    }
-
-    void TearDown()
-    {
-        _el_adapter.CloseInput();
-        if (_sp_output_thread)
-            _sp_output_thread->join();
-    }
-
-    EditlineAdapter &GetEditlineAdapter() { return _el_adapter; }
+  void SetUp() {
+    // We need a TERM set properly for editline to work as expected.
+    setenv("TERM", "vt100", 1);
+
+    // Validate the editline adapter.
+    EXPECT_TRUE(_el_adapter.IsValid());
+    if (!_el_adapter.IsValid())
+      return;
+
+    // Dump output.
+    _sp_output_thread.reset(
+        new std::thread([&] { _el_adapter.ConsumeAllOutput(); }));
+  }
+
+  void TearDown() {
+    _el_adapter.CloseInput();
+    if (_sp_output_thread)
+      _sp_output_thread->join();
+  }
+
+  EditlineAdapter &GetEditlineAdapter() { return _el_adapter; }
 };
 
-TEST_F(EditlineTestFixture, EditlineReceivesSingleLineText)
-{
-    // Send it some text via our virtual keyboard.
-    const std::string input_text ("Hello, world");
-    EXPECT_TRUE(GetEditlineAdapter().SendLine(input_text));
+TEST_F(EditlineTestFixture, EditlineReceivesSingleLineText) {
+  // Send it some text via our virtual keyboard.
+  const std::string input_text("Hello, world");
+  EXPECT_TRUE(GetEditlineAdapter().SendLine(input_text));
 
-    // Verify editline sees what we put in.
-    std::string el_reported_line;
-    bool input_interrupted = false;
-    const bool received_line = GetEditlineAdapter().GetLine(el_reported_line, input_interrupted, TIMEOUT_MILLIS);
+  // Verify editline sees what we put in.
+  std::string el_reported_line;
+  bool input_interrupted = false;
+  const bool received_line = GetEditlineAdapter().GetLine(
+      el_reported_line, input_interrupted, TIMEOUT_MILLIS);
 
-    EXPECT_TRUE (received_line);
-    EXPECT_FALSE (input_interrupted);
-    EXPECT_EQ (input_text, el_reported_line);
+  EXPECT_TRUE(received_line);
+  EXPECT_FALSE(input_interrupted);
+  EXPECT_EQ(input_text, el_reported_line);
 }
 
-TEST_F(EditlineTestFixture, EditlineReceivesMultiLineText)
-{
-    // Send it some text via our virtual keyboard.
-    std::vector<std::string> input_lines;
-    input_lines.push_back ("int foo()");
-    input_lines.push_back ("{");
-    input_lines.push_back ("printf(\"Hello, world\");");
-    input_lines.push_back ("}");
-    input_lines.push_back ("");
-
-    EXPECT_TRUE(GetEditlineAdapter().SendLines(input_lines));
-
-    // Verify editline sees what we put in.
-    lldb_private::StringList el_reported_lines;
-    bool input_interrupted = false;
-
-    EXPECT_TRUE(GetEditlineAdapter().GetLines(el_reported_lines, input_interrupted, TIMEOUT_MILLIS));
-    EXPECT_FALSE (input_interrupted);
-
-    // Without any auto indentation support, our output should directly match our input.
-    EXPECT_EQ (input_lines.size (), el_reported_lines.GetSize ());
-    if (input_lines.size () == el_reported_lines.GetSize ())
-    {
-        for (size_t i = 0; i < input_lines.size(); ++i)
-            EXPECT_EQ (input_lines[i], el_reported_lines[i]);
-    }
+TEST_F(EditlineTestFixture, EditlineReceivesMultiLineText) {
+  // Send it some text via our virtual keyboard.
+  std::vector<std::string> input_lines;
+  input_lines.push_back("int foo()");
+  input_lines.push_back("{");
+  input_lines.push_back("printf(\"Hello, world\");");
+  input_lines.push_back("}");
+  input_lines.push_back("");
+
+  EXPECT_TRUE(GetEditlineAdapter().SendLines(input_lines));
+
+  // Verify editline sees what we put in.
+  lldb_private::StringList el_reported_lines;
+  bool input_interrupted = false;
+
+  EXPECT_TRUE(GetEditlineAdapter().GetLines(el_reported_lines,
+                                            input_interrupted, TIMEOUT_MILLIS));
+  EXPECT_FALSE(input_interrupted);
+
+  // Without any auto indentation support, our output should directly match our
+  // input.
+  EXPECT_EQ(input_lines.size(), el_reported_lines.GetSize());
+  if (input_lines.size() == el_reported_lines.GetSize()) {
+    for (size_t i = 0; i < input_lines.size(); ++i)
+      EXPECT_EQ(input_lines[i], el_reported_lines[i]);
+  }
 }
 
 #endif
diff --git a/lldb/unittests/Expression/GoParserTest.cpp b/lldb/unittests/Expression/GoParserTest.cpp
index 76483979f35..de489e43ef2 100644
--- a/lldb/unittests/Expression/GoParserTest.cpp
+++ b/lldb/unittests/Expression/GoParserTest.cpp
@@ -1,4 +1,5 @@
-//===-- GoParserTest.cpp ------------------------------------------*- C++ -*-===//
+//===-- GoParserTest.cpp ------------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -8,7 +9,8 @@
 //===----------------------------------------------------------------------===//
 
 #if defined(_MSC_VER) && (_HAS_EXCEPTIONS == 0)
-// Workaround for MSVC standard library bug, which fails to include <thread> when
+// Workaround for MSVC standard library bug, which fails to include <thread>
+// when
 // exceptions are disabled.
 #include <eh.h>
 #endif
@@ -17,234 +19,262 @@
 
 #include "gtest/gtest.h"
 
-#include "lldb/Core/Error.h"
 #include "Plugins/ExpressionParser/Go/GoParser.h"
+#include "lldb/Core/Error.h"
 
 using namespace lldb_private;
 
-namespace
-{
-struct ASTPrinter
-{
-    ASTPrinter(GoASTNode *n) { (*this)(n); }
-
-    void
-    operator()(GoASTNode *n)
-    {
-        if (n == nullptr)
-        {
-            m_stream << "nil ";
-            return;
-        }
-        m_stream << "(" << n->GetKindName() << " ";
-        n->WalkChildren(*this);
-        if (auto *nn = llvm::dyn_cast<GoASTAssignStmt>(n))
-            m_stream << nn->GetDefine() << " ";
-        if (auto *nn = llvm::dyn_cast<GoASTBasicLit>(n))
-            m_stream << nn->GetValue().m_value.str() << " ";
-        if (auto *nn = llvm::dyn_cast<GoASTBinaryExpr>(n))
-            m_stream << GoLexer::LookupToken(nn->GetOp()).str() << " ";
-        if (auto *nn = llvm::dyn_cast<GoASTIdent>(n))
-            m_stream << nn->GetName().m_value.str() << " ";
-        if (auto *nn = llvm::dyn_cast<GoASTBranchStmt>(n))
-            m_stream << GoLexer::LookupToken(nn->GetTok()).str() << " ";
-        if (auto *nn = llvm::dyn_cast<GoASTCallExpr>(n))
-            m_stream << (nn->GetEllipsis() ? "..." : "") << " ";
-        if (auto *nn = llvm::dyn_cast<GoASTChanType>(n))
-            m_stream << nn->GetDir() << " ";
-        if (auto *nn = llvm::dyn_cast<GoASTGenDecl>(n))
-            m_stream << GoLexer::LookupToken(nn->GetTok()).str() << " ";
-        if (auto *nn = llvm::dyn_cast<GoASTIncDecStmt>(n))
-            m_stream << GoLexer::LookupToken(nn->GetTok()).str() << " ";
-        if (auto *nn = llvm::dyn_cast<GoASTRangeStmt>(n))
-            m_stream << nn->GetDefine() << " ";
-        if (auto *nn = llvm::dyn_cast<GoASTSliceExpr>(n))
-            m_stream << nn->GetSlice3() << " ";
-        if (auto *nn = llvm::dyn_cast<GoASTUnaryExpr>(n))
-            m_stream << GoLexer::LookupToken(nn->GetOp()).str() << " ";
-        m_stream << ") ";
-    }
+namespace {
+struct ASTPrinter {
+  ASTPrinter(GoASTNode *n) { (*this)(n); }
 
-    const std::string
-    str() const
-    {
-        return m_stream.str();
+  void operator()(GoASTNode *n) {
+    if (n == nullptr) {
+      m_stream << "nil ";
+      return;
     }
-    std::stringstream m_stream;
+    m_stream << "(" << n->GetKindName() << " ";
+    n->WalkChildren(*this);
+    if (auto *nn = llvm::dyn_cast<GoASTAssignStmt>(n))
+      m_stream << nn->GetDefine() << " ";
+    if (auto *nn = llvm::dyn_cast<GoASTBasicLit>(n))
+      m_stream << nn->GetValue().m_value.str() << " ";
+    if (auto *nn = llvm::dyn_cast<GoASTBinaryExpr>(n))
+      m_stream << GoLexer::LookupToken(nn->GetOp()).str() << " ";
+    if (auto *nn = llvm::dyn_cast<GoASTIdent>(n))
+      m_stream << nn->GetName().m_value.str() << " ";
+    if (auto *nn = llvm::dyn_cast<GoASTBranchStmt>(n))
+      m_stream << GoLexer::LookupToken(nn->GetTok()).str() << " ";
+    if (auto *nn = llvm::dyn_cast<GoASTCallExpr>(n))
+      m_stream << (nn->GetEllipsis() ? "..." : "") << " ";
+    if (auto *nn = llvm::dyn_cast<GoASTChanType>(n))
+      m_stream << nn->GetDir() << " ";
+    if (auto *nn = llvm::dyn_cast<GoASTGenDecl>(n))
+      m_stream << GoLexer::LookupToken(nn->GetTok()).str() << " ";
+    if (auto *nn = llvm::dyn_cast<GoASTIncDecStmt>(n))
+      m_stream << GoLexer::LookupToken(nn->GetTok()).str() << " ";
+    if (auto *nn = llvm::dyn_cast<GoASTRangeStmt>(n))
+      m_stream << nn->GetDefine() << " ";
+    if (auto *nn = llvm::dyn_cast<GoASTSliceExpr>(n))
+      m_stream << nn->GetSlice3() << " ";
+    if (auto *nn = llvm::dyn_cast<GoASTUnaryExpr>(n))
+      m_stream << GoLexer::LookupToken(nn->GetOp()).str() << " ";
+    m_stream << ") ";
+  }
+
+  const std::string str() const { return m_stream.str(); }
+  std::stringstream m_stream;
 };
 
-testing::AssertionResult
-CheckStatement(const char *_s, const char *c_expr, const char *sexpr, const char *code)
-{
-    GoParser parser(code);
-    std::unique_ptr<GoASTStmt> stmt(parser.Statement());
-    if (parser.Failed() || !stmt)
-    {
-        Error err;
-        parser.GetError(err);
-        return testing::AssertionFailure() << "Error parsing " << c_expr << "\n\t" << err.AsCString();
-    }
-    std::string actual_sexpr = ASTPrinter(stmt.get()).str();
-    if (actual_sexpr == sexpr)
-        return testing::AssertionSuccess();
-    return testing::AssertionFailure() << "Parsing: " << c_expr << "\nExpected: " << sexpr
-                                       << "\nGot:      " << actual_sexpr;
+testing::AssertionResult CheckStatement(const char *_s, const char *c_expr,
+                                        const char *sexpr, const char *code) {
+  GoParser parser(code);
+  std::unique_ptr<GoASTStmt> stmt(parser.Statement());
+  if (parser.Failed() || !stmt) {
+    Error err;
+    parser.GetError(err);
+    return testing::AssertionFailure() << "Error parsing " << c_expr << "\n\t"
+                                       << err.AsCString();
+  }
+  std::string actual_sexpr = ASTPrinter(stmt.get()).str();
+  if (actual_sexpr == sexpr)
+    return testing::AssertionSuccess();
+  return testing::AssertionFailure() << "Parsing: " << c_expr
+                                     << "\nExpected: " << sexpr
+                                     << "\nGot:      " << actual_sexpr;
 }
 } // namespace
 
 #define EXPECT_PARSE(s, c) EXPECT_PRED_FORMAT2(CheckStatement, s, c)
 
-TEST(GoParserTest, ParseBasicLiterals)
-{
-    EXPECT_PARSE("(ExprStmt (BasicLit 0 ) ) ", "0");
-    EXPECT_PARSE("(ExprStmt (BasicLit 42 ) ) ", "42");
-    EXPECT_PARSE("(ExprStmt (BasicLit 0600 ) ) ", "0600");
-    EXPECT_PARSE("(ExprStmt (BasicLit 0xBadFace ) ) ", "0xBadFace");
-    EXPECT_PARSE("(ExprStmt (BasicLit 170141183460469231731687303715884105727 ) ) ",
-                 "170141183460469231731687303715884105727");
-
-    EXPECT_PARSE("(ExprStmt (BasicLit 0. ) ) ", "0.");
-    EXPECT_PARSE("(ExprStmt (BasicLit 72.40 ) ) ", "72.40");
-    EXPECT_PARSE("(ExprStmt (BasicLit 072.40 ) ) ", "072.40");
-    EXPECT_PARSE("(ExprStmt (BasicLit 2.71828 ) ) ", "2.71828");
-    EXPECT_PARSE("(ExprStmt (BasicLit 1.e+0 ) ) ", "1.e+0");
-    EXPECT_PARSE("(ExprStmt (BasicLit 6.67428e-11 ) ) ", "6.67428e-11");
-    EXPECT_PARSE("(ExprStmt (BasicLit 1E6 ) ) ", "1E6");
-    EXPECT_PARSE("(ExprStmt (BasicLit .12345E+6 ) ) ", ".12345E+6");
-
-    EXPECT_PARSE("(ExprStmt (BasicLit 0i ) ) ", "0i");
-    EXPECT_PARSE("(ExprStmt (BasicLit 011i ) ) ", "011i");
-    EXPECT_PARSE("(ExprStmt (BasicLit 0.i ) ) ", "0.i");
-    EXPECT_PARSE("(ExprStmt (BasicLit 2.71828i ) ) ", "2.71828i");
-    EXPECT_PARSE("(ExprStmt (BasicLit 6.67428e-11i ) ) ", "6.67428e-11i");
-    EXPECT_PARSE("(ExprStmt (BasicLit 1E6i ) ) ", "1E6i");
-    EXPECT_PARSE("(ExprStmt (BasicLit .12345E+6i ) ) ", ".12345E+6i");
-
-    EXPECT_PARSE("(ExprStmt (BasicLit 'a' ) ) ", "'a'");
-    EXPECT_PARSE("(ExprStmt (BasicLit '本' ) ) ", "'本'");
-    EXPECT_PARSE("(ExprStmt (BasicLit \"abc\" ) ) ", "\"abc\"");
-    EXPECT_PARSE("(ExprStmt (BasicLit `abc` ) ) ", "`abc`");
-    EXPECT_PARSE("(ExprStmt (BasicLit `ab\nc` ) ) ", "`ab\nc`");
+TEST(GoParserTest, ParseBasicLiterals) {
+  EXPECT_PARSE("(ExprStmt (BasicLit 0 ) ) ", "0");
+  EXPECT_PARSE("(ExprStmt (BasicLit 42 ) ) ", "42");
+  EXPECT_PARSE("(ExprStmt (BasicLit 0600 ) ) ", "0600");
+  EXPECT_PARSE("(ExprStmt (BasicLit 0xBadFace ) ) ", "0xBadFace");
+  EXPECT_PARSE(
+      "(ExprStmt (BasicLit 170141183460469231731687303715884105727 ) ) ",
+      "170141183460469231731687303715884105727");
+
+  EXPECT_PARSE("(ExprStmt (BasicLit 0. ) ) ", "0.");
+  EXPECT_PARSE("(ExprStmt (BasicLit 72.40 ) ) ", "72.40");
+  EXPECT_PARSE("(ExprStmt (BasicLit 072.40 ) ) ", "072.40");
+  EXPECT_PARSE("(ExprStmt (BasicLit 2.71828 ) ) ", "2.71828");
+  EXPECT_PARSE("(ExprStmt (BasicLit 1.e+0 ) ) ", "1.e+0");
+  EXPECT_PARSE("(ExprStmt (BasicLit 6.67428e-11 ) ) ", "6.67428e-11");
+  EXPECT_PARSE("(ExprStmt (BasicLit 1E6 ) ) ", "1E6");
+  EXPECT_PARSE("(ExprStmt (BasicLit .12345E+6 ) ) ", ".12345E+6");
+
+  EXPECT_PARSE("(ExprStmt (BasicLit 0i ) ) ", "0i");
+  EXPECT_PARSE("(ExprStmt (BasicLit 011i ) ) ", "011i");
+  EXPECT_PARSE("(ExprStmt (BasicLit 0.i ) ) ", "0.i");
+  EXPECT_PARSE("(ExprStmt (BasicLit 2.71828i ) ) ", "2.71828i");
+  EXPECT_PARSE("(ExprStmt (BasicLit 6.67428e-11i ) ) ", "6.67428e-11i");
+  EXPECT_PARSE("(ExprStmt (BasicLit 1E6i ) ) ", "1E6i");
+  EXPECT_PARSE("(ExprStmt (BasicLit .12345E+6i ) ) ", ".12345E+6i");
+
+  EXPECT_PARSE("(ExprStmt (BasicLit 'a' ) ) ", "'a'");
+  EXPECT_PARSE("(ExprStmt (BasicLit '本' ) ) ", "'本'");
+  EXPECT_PARSE("(ExprStmt (BasicLit \"abc\" ) ) ", "\"abc\"");
+  EXPECT_PARSE("(ExprStmt (BasicLit `abc` ) ) ", "`abc`");
+  EXPECT_PARSE("(ExprStmt (BasicLit `ab\nc` ) ) ", "`ab\nc`");
 }
 
-TEST(GoParserTest, ParseOperand)
-{
-    EXPECT_PARSE("(ExprStmt (Ident a ) ) ", "a");
-    EXPECT_PARSE("(ExprStmt (Ident _x9 ) ) ", "_x9");
-    EXPECT_PARSE("(ExprStmt (Ident ThisVariableIsExported ) ) ", "ThisVariableIsExported");
-    EXPECT_PARSE("(ExprStmt (Ident αβ ) ) ", "αβ");
+TEST(GoParserTest, ParseOperand) {
+  EXPECT_PARSE("(ExprStmt (Ident a ) ) ", "a");
+  EXPECT_PARSE("(ExprStmt (Ident _x9 ) ) ", "_x9");
+  EXPECT_PARSE("(ExprStmt (Ident ThisVariableIsExported ) ) ",
+               "ThisVariableIsExported");
+  EXPECT_PARSE("(ExprStmt (Ident αβ ) ) ", "αβ");
 
-    EXPECT_PARSE("(ExprStmt (SelectorExpr (Ident math ) (Ident Sin ) ) ) ", "math.Sin");
+  EXPECT_PARSE("(ExprStmt (SelectorExpr (Ident math ) (Ident Sin ) ) ) ",
+               "math.Sin");
 }
 
-TEST(GoParserTest, ParseCompositeLiterals)
-{
-    EXPECT_PARSE("(ExprStmt (CompositeLit (Ident Point3D ) ) ) ", "Point3D{}");
-    EXPECT_PARSE("(ExprStmt (CompositeLit (Ident Line ) (Ident origin ) (CompositeLit (Ident Point3D ) (KeyValueExpr "
-                 "(Ident y ) (UnaryExpr (BasicLit 4 ) - ) ) (KeyValueExpr (Ident z ) (BasicLit 12.3 ) ) ) ) ) ",
-                 "Line{origin, Point3D{y: -4, z: 12.3}}");
-    EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType (BasicLit 10 ) (Ident string ) ) ) ) ", "[10]string{}");
-    EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType (BasicLit 6 ) (Ident int ) ) (BasicLit 1 ) (BasicLit 2 ) "
-                 "(BasicLit 3 ) (BasicLit 5 ) ) ) ",
-                 "[6]int {1, 2, 3, 5}");
-    EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType nil (Ident int ) ) (BasicLit 2 ) (BasicLit 3 ) (BasicLit 5 ) "
-                 "(BasicLit 7 ) (BasicLit 9 ) (BasicLit 2147483647 ) ) ) ",
-                 "[]int{2, 3, 5, 7, 9, 2147483647}");
-    EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType (BasicLit 128 ) (Ident bool ) ) (KeyValueExpr (BasicLit 'a' ) "
-                 "(Ident true ) ) (KeyValueExpr (BasicLit 'e' ) (Ident true ) ) (KeyValueExpr (BasicLit 'i' ) (Ident "
-                 "true ) ) (KeyValueExpr (BasicLit 'o' ) (Ident true ) ) (KeyValueExpr (BasicLit 'u' ) (Ident true ) ) "
-                 "(KeyValueExpr (BasicLit 'y' ) (Ident true ) ) ) ) ",
-                 "[128]bool{'a': true, 'e': true, 'i': true, 'o': true, 'u': true, 'y': true}");
-    EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType (BasicLit 10 ) (Ident float32 ) ) (UnaryExpr (BasicLit 1 ) - ) "
-                 "(KeyValueExpr (BasicLit 4 ) (UnaryExpr (BasicLit 0.1 ) - ) ) (UnaryExpr (BasicLit 0.1 ) - ) "
-                 "(KeyValueExpr (BasicLit 9 ) (UnaryExpr (BasicLit 1 ) - ) ) ) ) ",
-                 "[10]float32{-1, 4: -0.1, -0.1, 9: -1}");
+TEST(GoParserTest, ParseCompositeLiterals) {
+  EXPECT_PARSE("(ExprStmt (CompositeLit (Ident Point3D ) ) ) ", "Point3D{}");
+  EXPECT_PARSE("(ExprStmt (CompositeLit (Ident Line ) (Ident origin ) "
+               "(CompositeLit (Ident Point3D ) (KeyValueExpr "
+               "(Ident y ) (UnaryExpr (BasicLit 4 ) - ) ) (KeyValueExpr (Ident "
+               "z ) (BasicLit 12.3 ) ) ) ) ) ",
+               "Line{origin, Point3D{y: -4, z: 12.3}}");
+  EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType (BasicLit 10 ) (Ident "
+               "string ) ) ) ) ",
+               "[10]string{}");
+  EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType (BasicLit 6 ) (Ident int ) "
+               ") (BasicLit 1 ) (BasicLit 2 ) "
+               "(BasicLit 3 ) (BasicLit 5 ) ) ) ",
+               "[6]int {1, 2, 3, 5}");
+  EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType nil (Ident int ) ) "
+               "(BasicLit 2 ) (BasicLit 3 ) (BasicLit 5 ) "
+               "(BasicLit 7 ) (BasicLit 9 ) (BasicLit 2147483647 ) ) ) ",
+               "[]int{2, 3, 5, 7, 9, 2147483647}");
+  EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType (BasicLit 128 ) (Ident bool "
+               ") ) (KeyValueExpr (BasicLit 'a' ) "
+               "(Ident true ) ) (KeyValueExpr (BasicLit 'e' ) (Ident true ) ) "
+               "(KeyValueExpr (BasicLit 'i' ) (Ident "
+               "true ) ) (KeyValueExpr (BasicLit 'o' ) (Ident true ) ) "
+               "(KeyValueExpr (BasicLit 'u' ) (Ident true ) ) "
+               "(KeyValueExpr (BasicLit 'y' ) (Ident true ) ) ) ) ",
+               "[128]bool{'a': true, 'e': true, 'i': true, 'o': true, 'u': "
+               "true, 'y': true}");
+  EXPECT_PARSE(
+      "(ExprStmt (CompositeLit (ArrayType (BasicLit 10 ) (Ident float32 ) ) "
+      "(UnaryExpr (BasicLit 1 ) - ) "
+      "(KeyValueExpr (BasicLit 4 ) (UnaryExpr (BasicLit 0.1 ) - ) ) (UnaryExpr "
+      "(BasicLit 0.1 ) - ) "
+      "(KeyValueExpr (BasicLit 9 ) (UnaryExpr (BasicLit 1 ) - ) ) ) ) ",
+      "[10]float32{-1, 4: -0.1, -0.1, 9: -1}");
 }
 
-TEST(GoParserTest, ParseEllipsisArray)
-{
-    EXPECT_PARSE(
-        "(ExprStmt (CompositeLit (ArrayType (Ellipsis nil ) (Ident string ) ) (BasicLit `Sat` ) (BasicLit `Sun` ) ) ) ",
-        "[...]string {`Sat`, `Sun`}");
-    EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType (Ellipsis nil ) (Ident Point ) ) (CompositeLit nil (BasicLit 1.5 "
-                 ") (UnaryExpr (BasicLit 3.5 ) - ) ) (CompositeLit nil (BasicLit 0 ) (BasicLit 0 ) ) ) ) ",
-                 "[...]Point{{1.5, -3.5}, {0, 0}}");
+TEST(GoParserTest, ParseEllipsisArray) {
+  EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType (Ellipsis nil ) (Ident "
+               "string ) ) (BasicLit `Sat` ) (BasicLit `Sun` ) ) ) ",
+               "[...]string {`Sat`, `Sun`}");
+  EXPECT_PARSE("(ExprStmt (CompositeLit (ArrayType (Ellipsis nil ) (Ident "
+               "Point ) ) (CompositeLit nil (BasicLit 1.5 "
+               ") (UnaryExpr (BasicLit 3.5 ) - ) ) (CompositeLit nil (BasicLit "
+               "0 ) (BasicLit 0 ) ) ) ) ",
+               "[...]Point{{1.5, -3.5}, {0, 0}}");
 }
 
-TEST(GoParserTest, ParseMap)
-{
-    EXPECT_PARSE("(ExprStmt (CompositeLit (MapType (Ident string ) (Ident float32 ) ) (KeyValueExpr (BasicLit `C0` ) "
-                 "(BasicLit 16.35 ) ) (KeyValueExpr (BasicLit `D0` ) (BasicLit 18.35 ) ) ) ) ",
-                 "map[string]float32{`C0`: 16.35, `D0`: 18.35, }");
+TEST(GoParserTest, ParseMap) {
+  EXPECT_PARSE("(ExprStmt (CompositeLit (MapType (Ident string ) (Ident "
+               "float32 ) ) (KeyValueExpr (BasicLit `C0` ) "
+               "(BasicLit 16.35 ) ) (KeyValueExpr (BasicLit `D0` ) (BasicLit "
+               "18.35 ) ) ) ) ",
+               "map[string]float32{`C0`: 16.35, `D0`: 18.35, }");
 }
 
-TEST(GoParserTest, UnaryExpr)
-{
-    EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) + ) ) ", "+x");
-    EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) - ) ) ", "-x");
-    EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) ! ) ) ", "!x");
-    EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) ^ ) ) ", "^x");
-    EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) & ) ) ", "&x");
-    EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) <- ) ) ", "<-x");
-    EXPECT_PARSE("(ExprStmt (StarExpr (Ident x ) ) ) ", "*x");
+TEST(GoParserTest, UnaryExpr) {
+  EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) + ) ) ", "+x");
+  EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) - ) ) ", "-x");
+  EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) ! ) ) ", "!x");
+  EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) ^ ) ) ", "^x");
+  EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) & ) ) ", "&x");
+  EXPECT_PARSE("(ExprStmt (UnaryExpr (Ident x ) <- ) ) ", "<-x");
+  EXPECT_PARSE("(ExprStmt (StarExpr (Ident x ) ) ) ", "*x");
 }
 
-TEST(GoParserTest, BinaryExpr)
-{
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) || ) ) ", "a || b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) && ) ) ", "a && b");
-
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) == ) ) ", "a == b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) != ) ) ", "a != b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) < ) ) ", "a < b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) <= ) ) ", "a <= b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) > ) ) ", "a > b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) >= ) ) ", "a >= b");
-
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) + ) ) ", "a + b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) - ) ) ", "a - b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) | ) ) ", "a | b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) ^ ) ) ", "a ^ b");
-
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) * ) ) ", "a * b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) / ) ) ", "a / b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) % ) ) ", "a % b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) << ) ) ", "a << b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) >> ) ) ", "a >> b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) & ) ) ", "a & b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) &^ ) ) ", "a &^ b");
-
-    EXPECT_PARSE(
-        "(ExprStmt (BinaryExpr (BasicLit 23 ) (BinaryExpr (BasicLit 3 ) (IndexExpr (Ident x ) (Ident i ) ) * ) + ) ) ",
-        "23 + 3*x[i]");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (UnaryExpr (UnaryExpr (Ident a ) + ) + ) + ) ) ", "a + + + a");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (UnaryExpr (Ident a ) ^ ) (Ident b ) >> ) ) ", "^a >> b");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (CallExpr (Ident f )  ) (CallExpr (Ident g )  ) || ) ) ", "f() || g()");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (BinaryExpr (Ident x ) (BinaryExpr (Ident y ) (BasicLit 1 ) + ) == ) "
-                 "(BinaryExpr (UnaryExpr (Ident chanPtr ) <- ) (BasicLit 0 ) > ) && ) ) ",
-                 "x == y+1 && <-chanPtr > 0");
+TEST(GoParserTest, BinaryExpr) {
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) || ) ) ", "a || b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) && ) ) ", "a && b");
+
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) == ) ) ", "a == b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) != ) ) ", "a != b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) < ) ) ", "a < b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) <= ) ) ", "a <= b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) > ) ) ", "a > b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) >= ) ) ", "a >= b");
+
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) + ) ) ", "a + b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) - ) ) ", "a - b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) | ) ) ", "a | b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) ^ ) ) ", "a ^ b");
+
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) * ) ) ", "a * b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) / ) ) ", "a / b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) % ) ) ", "a % b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) << ) ) ", "a << b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) >> ) ) ", "a >> b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) & ) ) ", "a & b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (Ident b ) &^ ) ) ", "a &^ b");
+
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (BasicLit 23 ) (BinaryExpr (BasicLit 3 ) "
+               "(IndexExpr (Ident x ) (Ident i ) ) * ) + ) ) ",
+               "23 + 3*x[i]");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident a ) (UnaryExpr (UnaryExpr (Ident "
+               "a ) + ) + ) + ) ) ",
+               "a + + + a");
+  EXPECT_PARSE(
+      "(ExprStmt (BinaryExpr (UnaryExpr (Ident a ) ^ ) (Ident b ) >> ) ) ",
+      "^a >> b");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (CallExpr (Ident f )  ) (CallExpr (Ident "
+               "g )  ) || ) ) ",
+               "f() || g()");
+  EXPECT_PARSE(
+      "(ExprStmt (BinaryExpr (BinaryExpr (Ident x ) (BinaryExpr (Ident y ) "
+      "(BasicLit 1 ) + ) == ) "
+      "(BinaryExpr (UnaryExpr (Ident chanPtr ) <- ) (BasicLit 0 ) > ) && ) ) ",
+      "x == y+1 && <-chanPtr > 0");
 }
 
-TEST(GoParserTest, PrimaryExpr)
-{
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident x ) (CallExpr (Ident f )  ) <= ) ) ", "x <= f()");
-    EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident s ) (BasicLit `.txt` ) + ) ) ", "(s + `.txt`)");
-    EXPECT_PARSE("(ExprStmt (CallExpr (Ident f ) (BasicLit 3.1415 ) (Ident true )  ) ) ", "f(3.1415, true)");
-    EXPECT_PARSE("(ExprStmt (CallExpr (Ident f ) (BasicLit 3.1415 ) (Ident a ) ... ) ) ", "f(3.1415, a...)");
-    EXPECT_PARSE("(ExprStmt (IndexExpr (Ident m ) (BasicLit '1' ) ) ) ", "m['1']");
-    EXPECT_PARSE("(ExprStmt (SliceExpr (Ident s ) (Ident i ) (BinaryExpr (Ident j ) (BasicLit 1 ) + ) nil 0 ) ) ",
-                 "s[i : j + 1]");
-    EXPECT_PARSE("(ExprStmt (SelectorExpr (Ident obj ) (Ident color ) ) ) ", "obj.color");
-    EXPECT_PARSE("(ExprStmt (CallExpr (SelectorExpr (IndexExpr (SelectorExpr (Ident f ) (Ident p ) ) (Ident i ) ) "
-                 "(Ident x ) )  ) ) ",
-                 "f.p[i].x()");
+TEST(GoParserTest, PrimaryExpr) {
+  EXPECT_PARSE(
+      "(ExprStmt (BinaryExpr (Ident x ) (CallExpr (Ident f )  ) <= ) ) ",
+      "x <= f()");
+  EXPECT_PARSE("(ExprStmt (BinaryExpr (Ident s ) (BasicLit `.txt` ) + ) ) ",
+               "(s + `.txt`)");
+  EXPECT_PARSE(
+      "(ExprStmt (CallExpr (Ident f ) (BasicLit 3.1415 ) (Ident true )  ) ) ",
+      "f(3.1415, true)");
+  EXPECT_PARSE(
+      "(ExprStmt (CallExpr (Ident f ) (BasicLit 3.1415 ) (Ident a ) ... ) ) ",
+      "f(3.1415, a...)");
+  EXPECT_PARSE("(ExprStmt (IndexExpr (Ident m ) (BasicLit '1' ) ) ) ",
+               "m['1']");
+  EXPECT_PARSE("(ExprStmt (SliceExpr (Ident s ) (Ident i ) (BinaryExpr (Ident "
+               "j ) (BasicLit 1 ) + ) nil 0 ) ) ",
+               "s[i : j + 1]");
+  EXPECT_PARSE("(ExprStmt (SelectorExpr (Ident obj ) (Ident color ) ) ) ",
+               "obj.color");
+  EXPECT_PARSE("(ExprStmt (CallExpr (SelectorExpr (IndexExpr (SelectorExpr "
+               "(Ident f ) (Ident p ) ) (Ident i ) ) "
+               "(Ident x ) )  ) ) ",
+               "f.p[i].x()");
 }
 
-TEST(GoParserTest, Conversions)
-{
-    EXPECT_PARSE("(ExprStmt (StarExpr (CallExpr (Ident Point ) (Ident p )  ) ) ) ", "*Point(p)");
-    EXPECT_PARSE("(ExprStmt (CallExpr (StarExpr (Ident Point ) ) (Ident p )  ) ) ", "(*Point)(p)");
-    EXPECT_PARSE("(ExprStmt (UnaryExpr (CallExpr (ChanType (Ident int ) 0 ) (Ident c )  ) <- ) ) ", "<-chan int(c)");
-    EXPECT_PARSE("(ExprStmt (TypeAssertExpr (Ident y ) (SelectorExpr (Ident io ) (Ident Reader ) ) ) ) ",
-                 "y.(io.Reader)");
+TEST(GoParserTest, Conversions) {
+  EXPECT_PARSE(
+      "(ExprStmt (StarExpr (CallExpr (Ident Point ) (Ident p )  ) ) ) ",
+      "*Point(p)");
+  EXPECT_PARSE(
+      "(ExprStmt (CallExpr (StarExpr (Ident Point ) ) (Ident p )  ) ) ",
+      "(*Point)(p)");
+  EXPECT_PARSE("(ExprStmt (UnaryExpr (CallExpr (ChanType (Ident int ) 0 ) "
+               "(Ident c )  ) <- ) ) ",
+               "<-chan int(c)");
+  EXPECT_PARSE("(ExprStmt (TypeAssertExpr (Ident y ) (SelectorExpr (Ident io ) "
+               "(Ident Reader ) ) ) ) ",
+               "y.(io.Reader)");
 }
diff --git a/lldb/unittests/Host/FileSpecTest.cpp b/lldb/unittests/Host/FileSpecTest.cpp
index 522f4bc69ea..765dd9e0b5b 100644
--- a/lldb/unittests/Host/FileSpecTest.cpp
+++ b/lldb/unittests/Host/FileSpecTest.cpp
@@ -13,105 +13,115 @@
 
 using namespace lldb_private;
 
-TEST(FileSpecTest, FileAndDirectoryComponents)
-{
-    FileSpec fs_posix("/foo/bar", false, FileSpec::ePathSyntaxPosix);
-    EXPECT_STREQ("/foo/bar", fs_posix.GetCString());
-    EXPECT_STREQ("/foo", fs_posix.GetDirectory().GetCString());
-    EXPECT_STREQ("bar", fs_posix.GetFilename().GetCString());
-
-    FileSpec fs_windows("F:\\bar", false, FileSpec::ePathSyntaxWindows);
-    EXPECT_STREQ("F:\\bar", fs_windows.GetCString());
-    // EXPECT_STREQ("F:\\", fs_windows.GetDirectory().GetCString()); // It returns "F:/"
-    EXPECT_STREQ("bar", fs_windows.GetFilename().GetCString());
-
-    FileSpec fs_posix_root("/", false, FileSpec::ePathSyntaxPosix);
-    EXPECT_STREQ("/", fs_posix_root.GetCString());
-    EXPECT_EQ(nullptr, fs_posix_root.GetDirectory().GetCString());
-    EXPECT_STREQ("/", fs_posix_root.GetFilename().GetCString());
-
-    FileSpec fs_windows_drive("F:", false, FileSpec::ePathSyntaxWindows);
-    EXPECT_STREQ("F:", fs_windows_drive.GetCString());
-    EXPECT_EQ(nullptr, fs_windows_drive.GetDirectory().GetCString());
-    EXPECT_STREQ("F:", fs_windows_drive.GetFilename().GetCString());
-
-    FileSpec fs_windows_root("F:\\", false, FileSpec::ePathSyntaxWindows);
-    EXPECT_STREQ("F:\\", fs_windows_root.GetCString());
-    EXPECT_STREQ("F:", fs_windows_root.GetDirectory().GetCString());
-    // EXPECT_STREQ("\\", fs_windows_root.GetFilename().GetCString()); // It returns "/"
-
-    FileSpec fs_posix_long("/foo/bar/baz", false, FileSpec::ePathSyntaxPosix);
-    EXPECT_STREQ("/foo/bar/baz", fs_posix_long.GetCString());
-    EXPECT_STREQ("/foo/bar", fs_posix_long.GetDirectory().GetCString());
-    EXPECT_STREQ("baz", fs_posix_long.GetFilename().GetCString());
-
-    FileSpec fs_windows_long("F:\\bar\\baz", false, FileSpec::ePathSyntaxWindows);
-    EXPECT_STREQ("F:\\bar\\baz", fs_windows_long.GetCString());
-    // EXPECT_STREQ("F:\\bar", fs_windows_long.GetDirectory().GetCString()); // It returns "F:/bar"
-    EXPECT_STREQ("baz", fs_windows_long.GetFilename().GetCString());
-
-    FileSpec fs_posix_trailing_slash("/foo/bar/", false, FileSpec::ePathSyntaxPosix);
-    EXPECT_STREQ("/foo/bar/.", fs_posix_trailing_slash.GetCString());
-    EXPECT_STREQ("/foo/bar", fs_posix_trailing_slash.GetDirectory().GetCString());
-    EXPECT_STREQ(".", fs_posix_trailing_slash.GetFilename().GetCString());
-
-    FileSpec fs_windows_trailing_slash("F:\\bar\\", false, FileSpec::ePathSyntaxWindows);
-    EXPECT_STREQ("F:\\bar\\.", fs_windows_trailing_slash.GetCString());
-    // EXPECT_STREQ("F:\\bar", fs_windows_trailing_slash.GetDirectory().GetCString()); // It returns "F:/bar"
-    EXPECT_STREQ(".", fs_windows_trailing_slash.GetFilename().GetCString());
+TEST(FileSpecTest, FileAndDirectoryComponents) {
+  FileSpec fs_posix("/foo/bar", false, FileSpec::ePathSyntaxPosix);
+  EXPECT_STREQ("/foo/bar", fs_posix.GetCString());
+  EXPECT_STREQ("/foo", fs_posix.GetDirectory().GetCString());
+  EXPECT_STREQ("bar", fs_posix.GetFilename().GetCString());
+
+  FileSpec fs_windows("F:\\bar", false, FileSpec::ePathSyntaxWindows);
+  EXPECT_STREQ("F:\\bar", fs_windows.GetCString());
+  // EXPECT_STREQ("F:\\", fs_windows.GetDirectory().GetCString()); // It returns
+  // "F:/"
+  EXPECT_STREQ("bar", fs_windows.GetFilename().GetCString());
+
+  FileSpec fs_posix_root("/", false, FileSpec::ePathSyntaxPosix);
+  EXPECT_STREQ("/", fs_posix_root.GetCString());
+  EXPECT_EQ(nullptr, fs_posix_root.GetDirectory().GetCString());
+  EXPECT_STREQ("/", fs_posix_root.GetFilename().GetCString());
+
+  FileSpec fs_windows_drive("F:", false, FileSpec::ePathSyntaxWindows);
+  EXPECT_STREQ("F:", fs_windows_drive.GetCString());
+  EXPECT_EQ(nullptr, fs_windows_drive.GetDirectory().GetCString());
+  EXPECT_STREQ("F:", fs_windows_drive.GetFilename().GetCString());
+
+  FileSpec fs_windows_root("F:\\", false, FileSpec::ePathSyntaxWindows);
+  EXPECT_STREQ("F:\\", fs_windows_root.GetCString());
+  EXPECT_STREQ("F:", fs_windows_root.GetDirectory().GetCString());
+  // EXPECT_STREQ("\\", fs_windows_root.GetFilename().GetCString()); // It
+  // returns "/"
+
+  FileSpec fs_posix_long("/foo/bar/baz", false, FileSpec::ePathSyntaxPosix);
+  EXPECT_STREQ("/foo/bar/baz", fs_posix_long.GetCString());
+  EXPECT_STREQ("/foo/bar", fs_posix_long.GetDirectory().GetCString());
+  EXPECT_STREQ("baz", fs_posix_long.GetFilename().GetCString());
+
+  FileSpec fs_windows_long("F:\\bar\\baz", false, FileSpec::ePathSyntaxWindows);
+  EXPECT_STREQ("F:\\bar\\baz", fs_windows_long.GetCString());
+  // EXPECT_STREQ("F:\\bar", fs_windows_long.GetDirectory().GetCString()); // It
+  // returns "F:/bar"
+  EXPECT_STREQ("baz", fs_windows_long.GetFilename().GetCString());
+
+  FileSpec fs_posix_trailing_slash("/foo/bar/", false,
+                                   FileSpec::ePathSyntaxPosix);
+  EXPECT_STREQ("/foo/bar/.", fs_posix_trailing_slash.GetCString());
+  EXPECT_STREQ("/foo/bar", fs_posix_trailing_slash.GetDirectory().GetCString());
+  EXPECT_STREQ(".", fs_posix_trailing_slash.GetFilename().GetCString());
+
+  FileSpec fs_windows_trailing_slash("F:\\bar\\", false,
+                                     FileSpec::ePathSyntaxWindows);
+  EXPECT_STREQ("F:\\bar\\.", fs_windows_trailing_slash.GetCString());
+  // EXPECT_STREQ("F:\\bar",
+  // fs_windows_trailing_slash.GetDirectory().GetCString()); // It returns
+  // "F:/bar"
+  EXPECT_STREQ(".", fs_windows_trailing_slash.GetFilename().GetCString());
 }
 
-TEST(FileSpecTest, AppendPathComponent)
-{
-    FileSpec fs_posix("/foo", false, FileSpec::ePathSyntaxPosix);
-    fs_posix.AppendPathComponent("bar");
-    EXPECT_STREQ("/foo/bar", fs_posix.GetCString());
-    EXPECT_STREQ("/foo", fs_posix.GetDirectory().GetCString());
-    EXPECT_STREQ("bar", fs_posix.GetFilename().GetCString());
-
-    FileSpec fs_posix_2("/foo", false, FileSpec::ePathSyntaxPosix);
-    fs_posix_2.AppendPathComponent("//bar/baz");
-    EXPECT_STREQ("/foo/bar/baz", fs_posix_2.GetCString());
-    EXPECT_STREQ("/foo/bar", fs_posix_2.GetDirectory().GetCString());
-    EXPECT_STREQ("baz", fs_posix_2.GetFilename().GetCString());
-
-    FileSpec fs_windows("F:\\bar", false, FileSpec::ePathSyntaxWindows);
-    fs_windows.AppendPathComponent("baz");
-    EXPECT_STREQ("F:\\bar\\baz", fs_windows.GetCString());
-    // EXPECT_STREQ("F:\\bar", fs_windows.GetDirectory().GetCString()); // It returns "F:/bar"
-    EXPECT_STREQ("baz", fs_windows.GetFilename().GetCString());
-
-    FileSpec fs_posix_root("/", false, FileSpec::ePathSyntaxPosix);
-    fs_posix_root.AppendPathComponent("bar");
-    EXPECT_STREQ("/bar", fs_posix_root.GetCString());
-    EXPECT_STREQ("/", fs_posix_root.GetDirectory().GetCString());
-    EXPECT_STREQ("bar", fs_posix_root.GetFilename().GetCString());
-
-    FileSpec fs_windows_root("F:\\", false, FileSpec::ePathSyntaxWindows);
-    fs_windows_root.AppendPathComponent("bar");
-    EXPECT_STREQ("F:\\bar", fs_windows_root.GetCString());
-    // EXPECT_STREQ("F:\\", fs_windows_root.GetDirectory().GetCString()); // It returns "F:/"
-    EXPECT_STREQ("bar", fs_windows_root.GetFilename().GetCString());
+TEST(FileSpecTest, AppendPathComponent) {
+  FileSpec fs_posix("/foo", false, FileSpec::ePathSyntaxPosix);
+  fs_posix.AppendPathComponent("bar");
+  EXPECT_STREQ("/foo/bar", fs_posix.GetCString());
+  EXPECT_STREQ("/foo", fs_posix.GetDirectory().GetCString());
+  EXPECT_STREQ("bar", fs_posix.GetFilename().GetCString());
+
+  FileSpec fs_posix_2("/foo", false, FileSpec::ePathSyntaxPosix);
+  fs_posix_2.AppendPathComponent("//bar/baz");
+  EXPECT_STREQ("/foo/bar/baz", fs_posix_2.GetCString());
+  EXPECT_STREQ("/foo/bar", fs_posix_2.GetDirectory().GetCString());
+  EXPECT_STREQ("baz", fs_posix_2.GetFilename().GetCString());
+
+  FileSpec fs_windows("F:\\bar", false, FileSpec::ePathSyntaxWindows);
+  fs_windows.AppendPathComponent("baz");
+  EXPECT_STREQ("F:\\bar\\baz", fs_windows.GetCString());
+  // EXPECT_STREQ("F:\\bar", fs_windows.GetDirectory().GetCString()); // It
+  // returns "F:/bar"
+  EXPECT_STREQ("baz", fs_windows.GetFilename().GetCString());
+
+  FileSpec fs_posix_root("/", false, FileSpec::ePathSyntaxPosix);
+  fs_posix_root.AppendPathComponent("bar");
+  EXPECT_STREQ("/bar", fs_posix_root.GetCString());
+  EXPECT_STREQ("/", fs_posix_root.GetDirectory().GetCString());
+  EXPECT_STREQ("bar", fs_posix_root.GetFilename().GetCString());
+
+  FileSpec fs_windows_root("F:\\", false, FileSpec::ePathSyntaxWindows);
+  fs_windows_root.AppendPathComponent("bar");
+  EXPECT_STREQ("F:\\bar", fs_windows_root.GetCString());
+  // EXPECT_STREQ("F:\\", fs_windows_root.GetDirectory().GetCString()); // It
+  // returns "F:/"
+  EXPECT_STREQ("bar", fs_windows_root.GetFilename().GetCString());
 }
 
-TEST(FileSpecTest, CopyByAppendingPathComponent)
-{
-    FileSpec fs = FileSpec("/foo", false, FileSpec::ePathSyntaxPosix).CopyByAppendingPathComponent("bar");
-    EXPECT_STREQ("/foo/bar", fs.GetCString());
-    EXPECT_STREQ("/foo", fs.GetDirectory().GetCString());
-    EXPECT_STREQ("bar", fs.GetFilename().GetCString());
+TEST(FileSpecTest, CopyByAppendingPathComponent) {
+  FileSpec fs = FileSpec("/foo", false, FileSpec::ePathSyntaxPosix)
+                    .CopyByAppendingPathComponent("bar");
+  EXPECT_STREQ("/foo/bar", fs.GetCString());
+  EXPECT_STREQ("/foo", fs.GetDirectory().GetCString());
+  EXPECT_STREQ("bar", fs.GetFilename().GetCString());
 }
 
-TEST(FileSpecTest, Equal)
-{
-    FileSpec backward("C:\\foo\\bar", false, FileSpec::ePathSyntaxWindows);
-    FileSpec forward("C:/foo/bar", false, FileSpec::ePathSyntaxWindows);
-    EXPECT_EQ(forward, backward);
-
-    const bool full_match = true;
-    const bool remove_backup_dots = true;
-    EXPECT_TRUE(FileSpec::Equal(forward, backward, full_match, remove_backup_dots));
-    EXPECT_TRUE(FileSpec::Equal(forward, backward, full_match, !remove_backup_dots));
-    EXPECT_TRUE(FileSpec::Equal(forward, backward, !full_match, remove_backup_dots));
-    EXPECT_TRUE(FileSpec::Equal(forward, backward, !full_match, !remove_backup_dots));
+TEST(FileSpecTest, Equal) {
+  FileSpec backward("C:\\foo\\bar", false, FileSpec::ePathSyntaxWindows);
+  FileSpec forward("C:/foo/bar", false, FileSpec::ePathSyntaxWindows);
+  EXPECT_EQ(forward, backward);
+
+  const bool full_match = true;
+  const bool remove_backup_dots = true;
+  EXPECT_TRUE(
+      FileSpec::Equal(forward, backward, full_match, remove_backup_dots));
+  EXPECT_TRUE(
+      FileSpec::Equal(forward, backward, full_match, !remove_backup_dots));
+  EXPECT_TRUE(
+      FileSpec::Equal(forward, backward, !full_match, remove_backup_dots));
+  EXPECT_TRUE(
+      FileSpec::Equal(forward, backward, !full_match, !remove_backup_dots));
 }
diff --git a/lldb/unittests/Host/SocketAddressTest.cpp b/lldb/unittests/Host/SocketAddressTest.cpp
index 6b27e04ce70..3c18137ac06 100644
--- a/lldb/unittests/Host/SocketAddressTest.cpp
+++ b/lldb/unittests/Host/SocketAddressTest.cpp
@@ -7,68 +7,64 @@
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "gtest/gtest.h"
 
 #include "lldb/Host/SocketAddress.h"
 
-namespace
-{
-    class SocketAddressTest: public ::testing::Test
-    {
-    };
+namespace {
+class SocketAddressTest : public ::testing::Test {};
 }
 
 using namespace lldb_private;
 
-TEST_F (SocketAddressTest, Set)
-{
-    SocketAddress sa;
-    ASSERT_TRUE (sa.SetToLocalhost (AF_INET, 1138));
-    ASSERT_STREQ ("127.0.0.1", sa.GetIPAddress ().c_str ());
-    ASSERT_EQ (1138, sa.GetPort ());
+TEST_F(SocketAddressTest, Set) {
+  SocketAddress sa;
+  ASSERT_TRUE(sa.SetToLocalhost(AF_INET, 1138));
+  ASSERT_STREQ("127.0.0.1", sa.GetIPAddress().c_str());
+  ASSERT_EQ(1138, sa.GetPort());
 
-    ASSERT_TRUE (sa.SetToAnyAddress (AF_INET, 0));
-    ASSERT_STREQ ("0.0.0.0", sa.GetIPAddress ().c_str ());
-    ASSERT_EQ (0, sa.GetPort ());
+  ASSERT_TRUE(sa.SetToAnyAddress(AF_INET, 0));
+  ASSERT_STREQ("0.0.0.0", sa.GetIPAddress().c_str());
+  ASSERT_EQ(0, sa.GetPort());
 
-    ASSERT_TRUE (sa.SetToLocalhost (AF_INET6, 1139));
-    ASSERT_TRUE(sa.GetIPAddress() == "::1" || sa.GetIPAddress() == "0:0:0:0:0:0:0:1") << "Address was: "
-                                                                                      << sa.GetIPAddress();
-    ASSERT_EQ (1139, sa.GetPort ());
+  ASSERT_TRUE(sa.SetToLocalhost(AF_INET6, 1139));
+  ASSERT_TRUE(sa.GetIPAddress() == "::1" ||
+              sa.GetIPAddress() == "0:0:0:0:0:0:0:1")
+      << "Address was: " << sa.GetIPAddress();
+  ASSERT_EQ(1139, sa.GetPort());
 }
 
 #ifdef _WIN32
 
 // we need to test our inet_ntop implementation for Windows XP
-const char* inet_ntop (int af, const void * src,
-                        char * dst, socklen_t size);
+const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
 
-TEST_F (SocketAddressTest, inet_ntop)
-{
-    const uint8_t address4[4] = {255, 0, 1, 100};
-    const uint8_t address6[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 255, 0};
-   
-    char buffer[INET6_ADDRSTRLEN];
-    memset (buffer, 'x', sizeof (buffer));
-    EXPECT_STREQ ("1:203:405:607:809:a0b:c0d:ff00", inet_ntop (AF_INET6, address6, buffer, sizeof (buffer)));
-    memset (buffer, 'x', sizeof (buffer));
-    EXPECT_STREQ ("1:203:405:607:809:a0b:c0d:ff00", inet_ntop (AF_INET6, address6, buffer, 31));
-    memset (buffer, 'x', sizeof (buffer));
-    EXPECT_STREQ (nullptr, inet_ntop (AF_INET6, address6, buffer, 0));
-    memset (buffer, 'x', sizeof (buffer));
-    EXPECT_STREQ (nullptr, inet_ntop (AF_INET6, address6, buffer, 30));
-    
-    memset (buffer, 'x', sizeof (buffer));
-    EXPECT_STREQ ("255.0.1.100", inet_ntop (AF_INET, address4, buffer, sizeof (buffer)));
-    memset (buffer, 'x', sizeof (buffer));
-    EXPECT_STREQ ("255.0.1.100", inet_ntop (AF_INET, address4, buffer, 12));
-    memset (buffer, 'x', sizeof (buffer));
-    EXPECT_STREQ (nullptr, inet_ntop (AF_INET, address4, buffer, 0));
-    memset (buffer, 'x', sizeof (buffer));
-    EXPECT_STREQ (nullptr, inet_ntop (AF_INET, address4, buffer, 11));
-}
+TEST_F(SocketAddressTest, inet_ntop) {
+  const uint8_t address4[4] = {255, 0, 1, 100};
+  const uint8_t address6[16] = {0, 1, 2,  3,  4,  5,  6,   7,
+                                8, 9, 10, 11, 12, 13, 255, 0};
 
-#endif
+  char buffer[INET6_ADDRSTRLEN];
+  memset(buffer, 'x', sizeof(buffer));
+  EXPECT_STREQ("1:203:405:607:809:a0b:c0d:ff00",
+               inet_ntop(AF_INET6, address6, buffer, sizeof(buffer)));
+  memset(buffer, 'x', sizeof(buffer));
+  EXPECT_STREQ("1:203:405:607:809:a0b:c0d:ff00",
+               inet_ntop(AF_INET6, address6, buffer, 31));
+  memset(buffer, 'x', sizeof(buffer));
+  EXPECT_STREQ(nullptr, inet_ntop(AF_INET6, address6, buffer, 0));
+  memset(buffer, 'x', sizeof(buffer));
+  EXPECT_STREQ(nullptr, inet_ntop(AF_INET6, address6, buffer, 30));
 
+  memset(buffer, 'x', sizeof(buffer));
+  EXPECT_STREQ("255.0.1.100",
+               inet_ntop(AF_INET, address4, buffer, sizeof(buffer)));
+  memset(buffer, 'x', sizeof(buffer));
+  EXPECT_STREQ("255.0.1.100", inet_ntop(AF_INET, address4, buffer, 12));
+  memset(buffer, 'x', sizeof(buffer));
+  EXPECT_STREQ(nullptr, inet_ntop(AF_INET, address4, buffer, 0));
+  memset(buffer, 'x', sizeof(buffer));
+  EXPECT_STREQ(nullptr, inet_ntop(AF_INET, address4, buffer, 11));
+}
 
+#endif
diff --git a/lldb/unittests/Host/SocketTest.cpp b/lldb/unittests/Host/SocketTest.cpp
index e3e52274476..b7ecf190b59 100644
--- a/lldb/unittests/Host/SocketTest.cpp
+++ b/lldb/unittests/Host/SocketTest.cpp
@@ -8,7 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 #if defined(_MSC_VER) && (_HAS_EXCEPTIONS == 0)
-// Workaround for MSVC standard library bug, which fails to include <thread> when
+// Workaround for MSVC standard library bug, which fails to include <thread>
+// when
 // exceptions are disabled.
 #include <eh.h>
 #endif
@@ -30,182 +31,189 @@
 
 using namespace lldb_private;
 
-class SocketTest : public testing::Test
-{
-  public:
-    void
-    SetUp() override
-    {
+class SocketTest : public testing::Test {
+public:
+  void SetUp() override {
 #if defined(_MSC_VER)
-        WSADATA data;
-        ::WSAStartup(MAKEWORD(2, 2), &data);
+    WSADATA data;
+    ::WSAStartup(MAKEWORD(2, 2), &data);
 #endif
-    }
+  }
 
-    void
-    TearDown() override
-    {
+  void TearDown() override {
 #if defined(_MSC_VER)
-        ::WSACleanup();
+    ::WSACleanup();
 #endif
-    }
-
-  protected:
-    static void
-    AcceptThread(Socket *listen_socket, const char *listen_remote_address, bool child_processes_inherit,
-                 Socket **accept_socket, Error *error)
-    {
-        *error = listen_socket->Accept(listen_remote_address, child_processes_inherit, *accept_socket);
-    }
-
-    template<typename SocketType>
-    void
-    CreateConnectedSockets(const char *listen_remote_address, const std::function<std::string(const SocketType&)> &get_connect_addr, std::unique_ptr<SocketType> *a_up, std::unique_ptr<SocketType> *b_up)
-    {
-        bool child_processes_inherit = false;
-        Error error;
-        std::unique_ptr<SocketType> listen_socket_up(new SocketType(child_processes_inherit, error));
-        EXPECT_FALSE(error.Fail());
-        error = listen_socket_up->Listen(listen_remote_address, 5);
-        EXPECT_FALSE(error.Fail());
-        EXPECT_TRUE(listen_socket_up->IsValid());
-
-        Error accept_error;
-        Socket *accept_socket;
-        std::thread accept_thread(AcceptThread, listen_socket_up.get(), listen_remote_address, child_processes_inherit,
-                                  &accept_socket, &accept_error);
-
-        std::string connect_remote_address = get_connect_addr(*listen_socket_up);
-        std::unique_ptr<SocketType> connect_socket_up(new SocketType(child_processes_inherit, error));
-        EXPECT_FALSE(error.Fail());
-        error = connect_socket_up->Connect(connect_remote_address.c_str());
-        EXPECT_FALSE(error.Fail());
-        EXPECT_TRUE(connect_socket_up->IsValid());
-
-        a_up->swap(connect_socket_up);
-        EXPECT_TRUE(error.Success());
-        EXPECT_NE(nullptr, a_up->get());
-        EXPECT_TRUE((*a_up)->IsValid());
-
-        accept_thread.join();
-        b_up->reset(static_cast<SocketType*>(accept_socket));
-        EXPECT_TRUE(accept_error.Success());
-        EXPECT_NE(nullptr, b_up->get());
-        EXPECT_TRUE((*b_up)->IsValid());
-
-        listen_socket_up.reset();
-    }
-};
-
-TEST_F (SocketTest, DecodeHostAndPort)
-{
-    std::string host_str;
-    std::string port_str;
-    int32_t port;
+  }
+
+protected:
+  static void AcceptThread(Socket *listen_socket,
+                           const char *listen_remote_address,
+                           bool child_processes_inherit, Socket **accept_socket,
+                           Error *error) {
+    *error = listen_socket->Accept(listen_remote_address,
+                                   child_processes_inherit, *accept_socket);
+  }
+
+  template <typename SocketType>
+  void CreateConnectedSockets(
+      const char *listen_remote_address,
+      const std::function<std::string(const SocketType &)> &get_connect_addr,
+      std::unique_ptr<SocketType> *a_up, std::unique_ptr<SocketType> *b_up) {
+    bool child_processes_inherit = false;
     Error error;
-    EXPECT_TRUE (Socket::DecodeHostAndPort ("localhost:1138", host_str, port_str, port, &error));
-    EXPECT_STREQ ("localhost", host_str.c_str ());
-    EXPECT_STREQ ("1138", port_str.c_str ());
-    EXPECT_EQ (1138, port);
-    EXPECT_TRUE (error.Success ());
-    
-    EXPECT_FALSE (Socket::DecodeHostAndPort ("google.com:65536", host_str, port_str, port, &error));
-    EXPECT_TRUE (error.Fail ());
-    EXPECT_STREQ ("invalid host:port specification: 'google.com:65536'", error.AsCString ());
-    
-    EXPECT_FALSE (Socket::DecodeHostAndPort ("google.com:-1138", host_str, port_str, port, &error));
-    EXPECT_TRUE (error.Fail ());
-    EXPECT_STREQ ("invalid host:port specification: 'google.com:-1138'", error.AsCString ());
-
-    EXPECT_FALSE(Socket::DecodeHostAndPort("google.com:65536", host_str, port_str, port, &error));
-    EXPECT_TRUE(error.Fail());
-    EXPECT_STREQ("invalid host:port specification: 'google.com:65536'", error.AsCString());
-
-    EXPECT_TRUE (Socket::DecodeHostAndPort ("12345", host_str, port_str, port, &error));
-    EXPECT_STREQ ("", host_str.c_str ());
-    EXPECT_STREQ ("12345", port_str.c_str ());
-    EXPECT_EQ (12345, port);
-    EXPECT_TRUE (error.Success ());
-    
-    EXPECT_TRUE (Socket::DecodeHostAndPort ("*:0", host_str, port_str, port, &error));
-    EXPECT_STREQ ("*", host_str.c_str ());
-    EXPECT_STREQ ("0", port_str.c_str ());
-    EXPECT_EQ (0, port);
-    EXPECT_TRUE (error.Success ());
-
-    EXPECT_TRUE(Socket::DecodeHostAndPort("*:65535", host_str, port_str, port, &error));
-    EXPECT_STREQ("*", host_str.c_str());
-    EXPECT_STREQ("65535", port_str.c_str());
-    EXPECT_EQ(65535, port);
+    std::unique_ptr<SocketType> listen_socket_up(
+        new SocketType(child_processes_inherit, error));
+    EXPECT_FALSE(error.Fail());
+    error = listen_socket_up->Listen(listen_remote_address, 5);
+    EXPECT_FALSE(error.Fail());
+    EXPECT_TRUE(listen_socket_up->IsValid());
+
+    Error accept_error;
+    Socket *accept_socket;
+    std::thread accept_thread(AcceptThread, listen_socket_up.get(),
+                              listen_remote_address, child_processes_inherit,
+                              &accept_socket, &accept_error);
+
+    std::string connect_remote_address = get_connect_addr(*listen_socket_up);
+    std::unique_ptr<SocketType> connect_socket_up(
+        new SocketType(child_processes_inherit, error));
+    EXPECT_FALSE(error.Fail());
+    error = connect_socket_up->Connect(connect_remote_address.c_str());
+    EXPECT_FALSE(error.Fail());
+    EXPECT_TRUE(connect_socket_up->IsValid());
+
+    a_up->swap(connect_socket_up);
     EXPECT_TRUE(error.Success());
+    EXPECT_NE(nullptr, a_up->get());
+    EXPECT_TRUE((*a_up)->IsValid());
+
+    accept_thread.join();
+    b_up->reset(static_cast<SocketType *>(accept_socket));
+    EXPECT_TRUE(accept_error.Success());
+    EXPECT_NE(nullptr, b_up->get());
+    EXPECT_TRUE((*b_up)->IsValid());
+
+    listen_socket_up.reset();
+  }
+};
+
+TEST_F(SocketTest, DecodeHostAndPort) {
+  std::string host_str;
+  std::string port_str;
+  int32_t port;
+  Error error;
+  EXPECT_TRUE(Socket::DecodeHostAndPort("localhost:1138", host_str, port_str,
+                                        port, &error));
+  EXPECT_STREQ("localhost", host_str.c_str());
+  EXPECT_STREQ("1138", port_str.c_str());
+  EXPECT_EQ(1138, port);
+  EXPECT_TRUE(error.Success());
+
+  EXPECT_FALSE(Socket::DecodeHostAndPort("google.com:65536", host_str, port_str,
+                                         port, &error));
+  EXPECT_TRUE(error.Fail());
+  EXPECT_STREQ("invalid host:port specification: 'google.com:65536'",
+               error.AsCString());
+
+  EXPECT_FALSE(Socket::DecodeHostAndPort("google.com:-1138", host_str, port_str,
+                                         port, &error));
+  EXPECT_TRUE(error.Fail());
+  EXPECT_STREQ("invalid host:port specification: 'google.com:-1138'",
+               error.AsCString());
+
+  EXPECT_FALSE(Socket::DecodeHostAndPort("google.com:65536", host_str, port_str,
+                                         port, &error));
+  EXPECT_TRUE(error.Fail());
+  EXPECT_STREQ("invalid host:port specification: 'google.com:65536'",
+               error.AsCString());
+
+  EXPECT_TRUE(
+      Socket::DecodeHostAndPort("12345", host_str, port_str, port, &error));
+  EXPECT_STREQ("", host_str.c_str());
+  EXPECT_STREQ("12345", port_str.c_str());
+  EXPECT_EQ(12345, port);
+  EXPECT_TRUE(error.Success());
+
+  EXPECT_TRUE(
+      Socket::DecodeHostAndPort("*:0", host_str, port_str, port, &error));
+  EXPECT_STREQ("*", host_str.c_str());
+  EXPECT_STREQ("0", port_str.c_str());
+  EXPECT_EQ(0, port);
+  EXPECT_TRUE(error.Success());
+
+  EXPECT_TRUE(
+      Socket::DecodeHostAndPort("*:65535", host_str, port_str, port, &error));
+  EXPECT_STREQ("*", host_str.c_str());
+  EXPECT_STREQ("65535", port_str.c_str());
+  EXPECT_EQ(65535, port);
+  EXPECT_TRUE(error.Success());
 }
 
 #ifndef LLDB_DISABLE_POSIX
-TEST_F (SocketTest, DomainListenConnectAccept)
-{
-    char* file_name_str = tempnam(nullptr, nullptr);
-    EXPECT_NE (nullptr, file_name_str);
-    const std::string file_name(file_name_str);
-    free(file_name_str);
-
-    std::unique_ptr<DomainSocket> socket_a_up;
-    std::unique_ptr<DomainSocket> socket_b_up;
-    CreateConnectedSockets<DomainSocket>(file_name.c_str(),
-                                      [=](const DomainSocket &)
-                                      {
-                                          return file_name;
-                                      },
-                                      &socket_a_up, &socket_b_up);
+TEST_F(SocketTest, DomainListenConnectAccept) {
+  char *file_name_str = tempnam(nullptr, nullptr);
+  EXPECT_NE(nullptr, file_name_str);
+  const std::string file_name(file_name_str);
+  free(file_name_str);
+
+  std::unique_ptr<DomainSocket> socket_a_up;
+  std::unique_ptr<DomainSocket> socket_b_up;
+  CreateConnectedSockets<DomainSocket>(
+      file_name.c_str(), [=](const DomainSocket &) { return file_name; },
+      &socket_a_up, &socket_b_up);
 }
 #endif
 
-TEST_F (SocketTest, TCPListen0ConnectAccept)
-{
-    std::unique_ptr<TCPSocket> socket_a_up;
-    std::unique_ptr<TCPSocket> socket_b_up;
-    CreateConnectedSockets<TCPSocket>("127.0.0.1:0",
-                                      [=](const TCPSocket &s)
-                                      {
-                                          char connect_remote_address[64];
-                                          snprintf(connect_remote_address, sizeof(connect_remote_address), "localhost:%u", s.GetLocalPortNumber());
-                                          return std::string(connect_remote_address);
-                                      },
-                                      &socket_a_up, &socket_b_up);
+TEST_F(SocketTest, TCPListen0ConnectAccept) {
+  std::unique_ptr<TCPSocket> socket_a_up;
+  std::unique_ptr<TCPSocket> socket_b_up;
+  CreateConnectedSockets<TCPSocket>(
+      "127.0.0.1:0",
+      [=](const TCPSocket &s) {
+        char connect_remote_address[64];
+        snprintf(connect_remote_address, sizeof(connect_remote_address),
+                 "localhost:%u", s.GetLocalPortNumber());
+        return std::string(connect_remote_address);
+      },
+      &socket_a_up, &socket_b_up);
 }
 
-TEST_F (SocketTest, TCPGetAddress)
-{
-    std::unique_ptr<TCPSocket> socket_a_up;
-    std::unique_ptr<TCPSocket> socket_b_up;
-    CreateConnectedSockets<TCPSocket>("127.0.0.1:0",
-                                      [=](const TCPSocket &s)
-                                      {
-                                          char connect_remote_address[64];
-                                          snprintf(connect_remote_address, sizeof(connect_remote_address), "localhost:%u", s.GetLocalPortNumber());
-                                          return std::string(connect_remote_address);
-                                      },
-                                      &socket_a_up,
-                                      &socket_b_up);
-
-    EXPECT_EQ (socket_a_up->GetLocalPortNumber (), socket_b_up->GetRemotePortNumber ());
-    EXPECT_EQ (socket_b_up->GetLocalPortNumber (), socket_a_up->GetRemotePortNumber ());
-    EXPECT_NE (socket_a_up->GetLocalPortNumber (), socket_b_up->GetLocalPortNumber ());
-    EXPECT_STREQ ("127.0.0.1", socket_a_up->GetRemoteIPAddress ().c_str ());
-    EXPECT_STREQ ("127.0.0.1", socket_b_up->GetRemoteIPAddress ().c_str ());
+TEST_F(SocketTest, TCPGetAddress) {
+  std::unique_ptr<TCPSocket> socket_a_up;
+  std::unique_ptr<TCPSocket> socket_b_up;
+  CreateConnectedSockets<TCPSocket>(
+      "127.0.0.1:0",
+      [=](const TCPSocket &s) {
+        char connect_remote_address[64];
+        snprintf(connect_remote_address, sizeof(connect_remote_address),
+                 "localhost:%u", s.GetLocalPortNumber());
+        return std::string(connect_remote_address);
+      },
+      &socket_a_up, &socket_b_up);
+
+  EXPECT_EQ(socket_a_up->GetLocalPortNumber(),
+            socket_b_up->GetRemotePortNumber());
+  EXPECT_EQ(socket_b_up->GetLocalPortNumber(),
+            socket_a_up->GetRemotePortNumber());
+  EXPECT_NE(socket_a_up->GetLocalPortNumber(),
+            socket_b_up->GetLocalPortNumber());
+  EXPECT_STREQ("127.0.0.1", socket_a_up->GetRemoteIPAddress().c_str());
+  EXPECT_STREQ("127.0.0.1", socket_b_up->GetRemoteIPAddress().c_str());
 }
 
-TEST_F (SocketTest, UDPConnect)
-{
-    Socket* socket_a;
-    Socket* socket_b;
+TEST_F(SocketTest, UDPConnect) {
+  Socket *socket_a;
+  Socket *socket_b;
+
+  bool child_processes_inherit = false;
+  auto error = UDPSocket::Connect("127.0.0.1:0", child_processes_inherit,
+                                  socket_a, socket_b);
 
-    bool child_processes_inherit = false;    
-    auto error = UDPSocket::Connect("127.0.0.1:0", child_processes_inherit, socket_a, socket_b);
-   
-    std::unique_ptr<Socket> a_up(socket_a);
-    std::unique_ptr<Socket> b_up(socket_b);
+  std::unique_ptr<Socket> a_up(socket_a);
+  std::unique_ptr<Socket> b_up(socket_b);
 
-    EXPECT_TRUE(error.Success ());
-    EXPECT_TRUE(a_up->IsValid());
-    EXPECT_TRUE(b_up->IsValid());
+  EXPECT_TRUE(error.Success());
+  EXPECT_TRUE(a_up->IsValid());
+  EXPECT_TRUE(b_up->IsValid());
 }
diff --git a/lldb/unittests/Host/SymbolsTest.cpp b/lldb/unittests/Host/SymbolsTest.cpp
index cb59b2c5653..ba100bdb507 100644
--- a/lldb/unittests/Host/SymbolsTest.cpp
+++ b/lldb/unittests/Host/SymbolsTest.cpp
@@ -7,24 +7,25 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "gtest/gtest.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Core/ModuleSpec.h"
+#include "gtest/gtest.h"
 
 using namespace lldb_private;
 
-TEST(SymbolsTest, LocateExecutableSymbolFileForUnknownExecutableAndUnknownSymbolFile)
-{
-    ModuleSpec module_spec;
-    FileSpec symbol_file_spec = Symbols::LocateExecutableSymbolFile(module_spec);
-    EXPECT_TRUE(symbol_file_spec.GetFilename().IsEmpty());
+TEST(SymbolsTest,
+     LocateExecutableSymbolFileForUnknownExecutableAndUnknownSymbolFile) {
+  ModuleSpec module_spec;
+  FileSpec symbol_file_spec = Symbols::LocateExecutableSymbolFile(module_spec);
+  EXPECT_TRUE(symbol_file_spec.GetFilename().IsEmpty());
 }
 
-TEST(SymbolsTest, LocateExecutableSymbolFileForUnknownExecutableAndMissingSymbolFile)
-{
-    ModuleSpec module_spec;
-    // using a GUID here because the symbol file shouldn't actually exist on disk
-    module_spec.GetSymbolFileSpec().SetFile("4A524676-B24B-4F4E-968A-551D465EBAF1.so", false);
-    FileSpec symbol_file_spec = Symbols::LocateExecutableSymbolFile(module_spec);
-    EXPECT_TRUE(symbol_file_spec.GetFilename().IsEmpty());
+TEST(SymbolsTest,
+     LocateExecutableSymbolFileForUnknownExecutableAndMissingSymbolFile) {
+  ModuleSpec module_spec;
+  // using a GUID here because the symbol file shouldn't actually exist on disk
+  module_spec.GetSymbolFileSpec().SetFile(
+      "4A524676-B24B-4F4E-968A-551D465EBAF1.so", false);
+  FileSpec symbol_file_spec = Symbols::LocateExecutableSymbolFile(module_spec);
+  EXPECT_TRUE(symbol_file_spec.GetFilename().IsEmpty());
 }
diff --git a/lldb/unittests/Interpreter/TestArgs.cpp b/lldb/unittests/Interpreter/TestArgs.cpp
index e2cf1c4d4a0..a14b8428aef 100644
--- a/lldb/unittests/Interpreter/TestArgs.cpp
+++ b/lldb/unittests/Interpreter/TestArgs.cpp
@@ -13,58 +13,52 @@
 
 using namespace lldb_private;
 
-TEST(ArgsTest, TestSingleArg)
-{
-    Args args;
-    args.SetCommandString("arg");
-    EXPECT_EQ(1u, args.GetArgumentCount());
-    EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg");
+TEST(ArgsTest, TestSingleArg) {
+  Args args;
+  args.SetCommandString("arg");
+  EXPECT_EQ(1u, args.GetArgumentCount());
+  EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg");
 }
 
-TEST(ArgsTest, TestSingleQuotedArgWithSpace)
-{
-    Args args;
-    args.SetCommandString("\"arg with space\"");
-    EXPECT_EQ(1u, args.GetArgumentCount());
-    EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg with space");
+TEST(ArgsTest, TestSingleQuotedArgWithSpace) {
+  Args args;
+  args.SetCommandString("\"arg with space\"");
+  EXPECT_EQ(1u, args.GetArgumentCount());
+  EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg with space");
 }
 
-TEST(ArgsTest, TestSingleArgWithQuotedSpace)
-{
-    Args args;
-    args.SetCommandString("arg\\ with\\ space");
-    EXPECT_EQ(1u, args.GetArgumentCount());
-    EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg with space");
+TEST(ArgsTest, TestSingleArgWithQuotedSpace) {
+  Args args;
+  args.SetCommandString("arg\\ with\\ space");
+  EXPECT_EQ(1u, args.GetArgumentCount());
+  EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg with space");
 }
 
-TEST(ArgsTest, TestMultipleArgs)
-{
-    Args args;
-    args.SetCommandString("this has multiple args");
-    EXPECT_EQ(4u, args.GetArgumentCount());
-    EXPECT_STREQ(args.GetArgumentAtIndex(0), "this");
-    EXPECT_STREQ(args.GetArgumentAtIndex(1), "has");
-    EXPECT_STREQ(args.GetArgumentAtIndex(2), "multiple");
-    EXPECT_STREQ(args.GetArgumentAtIndex(3), "args");
+TEST(ArgsTest, TestMultipleArgs) {
+  Args args;
+  args.SetCommandString("this has multiple args");
+  EXPECT_EQ(4u, args.GetArgumentCount());
+  EXPECT_STREQ(args.GetArgumentAtIndex(0), "this");
+  EXPECT_STREQ(args.GetArgumentAtIndex(1), "has");
+  EXPECT_STREQ(args.GetArgumentAtIndex(2), "multiple");
+  EXPECT_STREQ(args.GetArgumentAtIndex(3), "args");
 }
 
-TEST(ArgsTest, TestOverwriteArgs)
-{
-    Args args;
-    args.SetCommandString("this has multiple args");
-    EXPECT_EQ(4u, args.GetArgumentCount());
-    args.SetCommandString("arg");
-    EXPECT_EQ(1u, args.GetArgumentCount());
-    EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg");
+TEST(ArgsTest, TestOverwriteArgs) {
+  Args args;
+  args.SetCommandString("this has multiple args");
+  EXPECT_EQ(4u, args.GetArgumentCount());
+  args.SetCommandString("arg");
+  EXPECT_EQ(1u, args.GetArgumentCount());
+  EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg");
 }
 
-TEST(ArgsTest, TestAppendArg)
-{
-    Args args;
-    args.SetCommandString("first_arg");
-    EXPECT_EQ(1u, args.GetArgumentCount());
-    args.AppendArgument("second_arg");
-    EXPECT_EQ(2u, args.GetArgumentCount());
-    EXPECT_STREQ(args.GetArgumentAtIndex(0), "first_arg");
-    EXPECT_STREQ(args.GetArgumentAtIndex(1), "second_arg");
+TEST(ArgsTest, TestAppendArg) {
+  Args args;
+  args.SetCommandString("first_arg");
+  EXPECT_EQ(1u, args.GetArgumentCount());
+  args.AppendArgument("second_arg");
+  EXPECT_EQ(2u, args.GetArgumentCount());
+  EXPECT_STREQ(args.GetArgumentAtIndex(0), "first_arg");
+  EXPECT_STREQ(args.GetArgumentAtIndex(1), "second_arg");
 }
diff --git a/lldb/unittests/Language/CPlusPlus/CPlusPlusLanguageTest.cpp b/lldb/unittests/Language/CPlusPlus/CPlusPlusLanguageTest.cpp
index 8b3cd50bbbf..26de31d52a3 100644
--- a/lldb/unittests/Language/CPlusPlus/CPlusPlusLanguageTest.cpp
+++ b/lldb/unittests/Language/CPlusPlus/CPlusPlusLanguageTest.cpp
@@ -13,29 +13,28 @@
 
 using namespace lldb_private;
 
-TEST(CPlusPlusLanguage, MethodName)
-{
-    struct TestCase {
-        std::string input;
-        std::string context, basename, arguments, qualifiers, scope_qualified_name;
-    };
+TEST(CPlusPlusLanguage, MethodName) {
+  struct TestCase {
+    std::string input;
+    std::string context, basename, arguments, qualifiers, scope_qualified_name;
+  };
 
-    TestCase test_cases[] = {{"foo::bar(baz)", "foo", "bar", "(baz)", "", "foo::bar"},
-                             {"std::basic_ostream<char, std::char_traits<char> >& "
-                              "std::operator<<<std::char_traits<char> >"
-                              "(std::basic_ostream<char, std::char_traits<char> >&, char const*)",
-                              "std", "operator<<<std::char_traits<char> >",
-                              "(std::basic_ostream<char, std::char_traits<char> >&, char const*)", "",
-                              "std::operator<<<std::char_traits<char> >"}};
+  TestCase test_cases[] = {
+      {"foo::bar(baz)", "foo", "bar", "(baz)", "", "foo::bar"},
+      {"std::basic_ostream<char, std::char_traits<char> >& "
+       "std::operator<<<std::char_traits<char> >"
+       "(std::basic_ostream<char, std::char_traits<char> >&, char const*)",
+       "std", "operator<<<std::char_traits<char> >",
+       "(std::basic_ostream<char, std::char_traits<char> >&, char const*)", "",
+       "std::operator<<<std::char_traits<char> >"}};
 
-    for (const auto &test: test_cases)
-    {
-        CPlusPlusLanguage::MethodName method(ConstString(test.input));
-        EXPECT_TRUE(method.IsValid());
-        EXPECT_EQ(test.context, method.GetContext());
-        EXPECT_EQ(test.basename, method.GetBasename());
-        EXPECT_EQ(test.arguments, method.GetArguments());
-        EXPECT_EQ(test.qualifiers, method.GetQualifiers());
-        EXPECT_EQ(test.scope_qualified_name, method.GetScopeQualifiedName());
-    }
+  for (const auto &test : test_cases) {
+    CPlusPlusLanguage::MethodName method(ConstString(test.input));
+    EXPECT_TRUE(method.IsValid());
+    EXPECT_EQ(test.context, method.GetContext());
+    EXPECT_EQ(test.basename, method.GetBasename());
+    EXPECT_EQ(test.arguments, method.GetArguments());
+    EXPECT_EQ(test.qualifiers, method.GetQualifiers());
+    EXPECT_EQ(test.scope_qualified_name, method.GetScopeQualifiedName());
+  }
 }
diff --git a/lldb/unittests/Process/gdb-remote/GDBRemoteClientBaseTest.cpp b/lldb/unittests/Process/gdb-remote/GDBRemoteClientBaseTest.cpp
index 6b56e5c506e..60397943a0e 100644
--- a/lldb/unittests/Process/gdb-remote/GDBRemoteClientBaseTest.cpp
+++ b/lldb/unittests/Process/gdb-remote/GDBRemoteClientBaseTest.cpp
@@ -8,7 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 #if defined(_MSC_VER) && (_HAS_EXCEPTIONS == 0)
-// Workaround for MSVC standard library bug, which fails to include <thread> when
+// Workaround for MSVC standard library bug, which fails to include <thread>
+// when
 // exceptions are disabled.
 #include <eh.h>
 #endif
@@ -28,338 +29,320 @@ using namespace lldb_private;
 using namespace lldb;
 typedef GDBRemoteCommunication::PacketResult PacketResult;
 
-namespace
-{
-
-struct MockDelegate : public GDBRemoteClientBase::ContinueDelegate
-{
-    std::string output;
-    std::string misc_data;
-    unsigned stop_reply_called = 0;
-
-    void
-    HandleAsyncStdout(llvm::StringRef out)
-    {
-        output += out;
-    }
-    void
-    HandleAsyncMisc(llvm::StringRef data)
-    {
-        misc_data += data;
-    }
-    void
-    HandleStopReply()
-    {
-        ++stop_reply_called;
-    }
-
-    bool
-    HandleAsyncStructuredData(const StructuredData::ObjectSP
-                              &object_sp)
-    {
-        // TODO work in a test here after I fix the gtest breakage.
-        return true;
-    }
+namespace {
 
+struct MockDelegate : public GDBRemoteClientBase::ContinueDelegate {
+  std::string output;
+  std::string misc_data;
+  unsigned stop_reply_called = 0;
+
+  void HandleAsyncStdout(llvm::StringRef out) { output += out; }
+  void HandleAsyncMisc(llvm::StringRef data) { misc_data += data; }
+  void HandleStopReply() { ++stop_reply_called; }
+
+  bool HandleAsyncStructuredData(const StructuredData::ObjectSP &object_sp) {
+    // TODO work in a test here after I fix the gtest breakage.
+    return true;
+  }
 };
 
-struct TestClient : public GDBRemoteClientBase
-{
-    TestClient() : GDBRemoteClientBase("test.client", "test.client.listener") { m_send_acks = false; }
+struct TestClient : public GDBRemoteClientBase {
+  TestClient() : GDBRemoteClientBase("test.client", "test.client.listener") {
+    m_send_acks = false;
+  }
 };
 
-struct ContinueFixture
-{
-    MockDelegate delegate;
-    TestClient client;
-    MockServer server;
-    ListenerSP listener_sp;
-
-    ContinueFixture();
-
-    StateType
-    SendCPacket(StringExtractorGDBRemote &response)
-    {
-        return client.SendContinuePacketAndWaitForResponse(delegate, LinuxSignals(), "c", response);
-    }
-
-    void
-    WaitForRunEvent()
-    {
-        EventSP event_sp;
-        listener_sp->WaitForEventForBroadcasterWithType(std::chrono::microseconds(0), &client,
-                                                        TestClient::eBroadcastBitRunPacketSent, event_sp);
-    }
+struct ContinueFixture {
+  MockDelegate delegate;
+  TestClient client;
+  MockServer server;
+  ListenerSP listener_sp;
+
+  ContinueFixture();
+
+  StateType SendCPacket(StringExtractorGDBRemote &response) {
+    return client.SendContinuePacketAndWaitForResponse(delegate, LinuxSignals(),
+                                                       "c", response);
+  }
+
+  void WaitForRunEvent() {
+    EventSP event_sp;
+    listener_sp->WaitForEventForBroadcasterWithType(
+        std::chrono::microseconds(0), &client,
+        TestClient::eBroadcastBitRunPacketSent, event_sp);
+  }
 };
 
-ContinueFixture::ContinueFixture() : listener_sp(Listener::MakeListener("listener"))
-{
-    Connect(client, server);
-    listener_sp->StartListeningForEvents(&client, TestClient::eBroadcastBitRunPacketSent);
+ContinueFixture::ContinueFixture()
+    : listener_sp(Listener::MakeListener("listener")) {
+  Connect(client, server);
+  listener_sp->StartListeningForEvents(&client,
+                                       TestClient::eBroadcastBitRunPacketSent);
 }
 
 } // end anonymous namespace
 
-class GDBRemoteClientBaseTest : public GDBRemoteTest
-{
-};
-
-TEST_F(GDBRemoteClientBaseTest, SendContinueAndWait)
-{
-    StringExtractorGDBRemote response;
-    ContinueFixture fix;
-    if (HasFailure())
-        return;
-
-    // Continue. The inferior will stop with a signal.
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T01"));
-    ASSERT_EQ(eStateStopped, fix.SendCPacket(response));
-    ASSERT_EQ("T01", response.GetStringRef());
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("c", response.GetStringRef());
-
-    // Continue. The inferior will exit.
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("W01"));
-    ASSERT_EQ(eStateExited, fix.SendCPacket(response));
-    ASSERT_EQ("W01", response.GetStringRef());
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("c", response.GetStringRef());
-
-    // Continue. The inferior will get killed.
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("X01"));
-    ASSERT_EQ(eStateExited, fix.SendCPacket(response));
-    ASSERT_EQ("X01", response.GetStringRef());
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("c", response.GetStringRef());
+class GDBRemoteClientBaseTest : public GDBRemoteTest {};
+
+TEST_F(GDBRemoteClientBaseTest, SendContinueAndWait) {
+  StringExtractorGDBRemote response;
+  ContinueFixture fix;
+  if (HasFailure())
+    return;
+
+  // Continue. The inferior will stop with a signal.
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T01"));
+  ASSERT_EQ(eStateStopped, fix.SendCPacket(response));
+  ASSERT_EQ("T01", response.GetStringRef());
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("c", response.GetStringRef());
+
+  // Continue. The inferior will exit.
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("W01"));
+  ASSERT_EQ(eStateExited, fix.SendCPacket(response));
+  ASSERT_EQ("W01", response.GetStringRef());
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("c", response.GetStringRef());
+
+  // Continue. The inferior will get killed.
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("X01"));
+  ASSERT_EQ(eStateExited, fix.SendCPacket(response));
+  ASSERT_EQ("X01", response.GetStringRef());
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("c", response.GetStringRef());
 }
 
-TEST_F(GDBRemoteClientBaseTest, SendContinueAndAsyncSignal)
-{
-    StringExtractorGDBRemote continue_response, response;
-    ContinueFixture fix;
-    if (HasFailure())
-        return;
-
-    // SendAsyncSignal should do nothing when we are not running.
-    ASSERT_FALSE(fix.client.SendAsyncSignal(0x47));
-
-    // Continue. After the run packet is sent, send an async signal.
-    std::future<StateType> continue_state =
-        std::async(std::launch::async, [&] { return fix.SendCPacket(continue_response); });
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("c", response.GetStringRef());
-    fix.WaitForRunEvent();
-
-    std::future<bool> async_result = std::async(std::launch::async, [&] { return fix.client.SendAsyncSignal(0x47); });
-
-    // First we'll get interrupted.
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("\x03", response.GetStringRef());
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T13"));
-
-    // Then we get the signal packet.
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("C47", response.GetStringRef());
-    ASSERT_TRUE(async_result.get());
-
-    // And we report back a signal stop.
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T47"));
-    ASSERT_EQ(eStateStopped, continue_state.get());
-    ASSERT_EQ("T47", continue_response.GetStringRef());
+TEST_F(GDBRemoteClientBaseTest, SendContinueAndAsyncSignal) {
+  StringExtractorGDBRemote continue_response, response;
+  ContinueFixture fix;
+  if (HasFailure())
+    return;
+
+  // SendAsyncSignal should do nothing when we are not running.
+  ASSERT_FALSE(fix.client.SendAsyncSignal(0x47));
+
+  // Continue. After the run packet is sent, send an async signal.
+  std::future<StateType> continue_state = std::async(
+      std::launch::async, [&] { return fix.SendCPacket(continue_response); });
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("c", response.GetStringRef());
+  fix.WaitForRunEvent();
+
+  std::future<bool> async_result = std::async(
+      std::launch::async, [&] { return fix.client.SendAsyncSignal(0x47); });
+
+  // First we'll get interrupted.
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("\x03", response.GetStringRef());
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T13"));
+
+  // Then we get the signal packet.
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("C47", response.GetStringRef());
+  ASSERT_TRUE(async_result.get());
+
+  // And we report back a signal stop.
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T47"));
+  ASSERT_EQ(eStateStopped, continue_state.get());
+  ASSERT_EQ("T47", continue_response.GetStringRef());
 }
 
-TEST_F(GDBRemoteClientBaseTest, SendContinueAndAsyncPacket)
-{
-    StringExtractorGDBRemote continue_response, async_response, response;
-    const bool send_async = true;
-    ContinueFixture fix;
-    if (HasFailure())
-        return;
-
-    // Continue. After the run packet is sent, send an async packet.
-    std::future<StateType> continue_state =
-        std::async(std::launch::async, [&] { return fix.SendCPacket(continue_response); });
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("c", response.GetStringRef());
-    fix.WaitForRunEvent();
-
-    // Sending without async enabled should fail.
-    ASSERT_EQ(PacketResult::ErrorSendFailed, fix.client.SendPacketAndWaitForResponse("qTest1", response, !send_async));
-
-    std::future<PacketResult> async_result = std::async(std::launch::async, [&] {
-        return fix.client.SendPacketAndWaitForResponse("qTest2", async_response, send_async);
-    });
-
-    // First we'll get interrupted.
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("\x03", response.GetStringRef());
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T13"));
-
-    // Then we get the async packet.
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("qTest2", response.GetStringRef());
-
-    // Send the response and receive it.
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("QTest2"));
-    ASSERT_EQ(PacketResult::Success, async_result.get());
-    ASSERT_EQ("QTest2", async_response.GetStringRef());
-
-    // And we get resumed again.
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("c", response.GetStringRef());
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T01"));
-    ASSERT_EQ(eStateStopped, continue_state.get());
-    ASSERT_EQ("T01", continue_response.GetStringRef());
+TEST_F(GDBRemoteClientBaseTest, SendContinueAndAsyncPacket) {
+  StringExtractorGDBRemote continue_response, async_response, response;
+  const bool send_async = true;
+  ContinueFixture fix;
+  if (HasFailure())
+    return;
+
+  // Continue. After the run packet is sent, send an async packet.
+  std::future<StateType> continue_state = std::async(
+      std::launch::async, [&] { return fix.SendCPacket(continue_response); });
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("c", response.GetStringRef());
+  fix.WaitForRunEvent();
+
+  // Sending without async enabled should fail.
+  ASSERT_EQ(
+      PacketResult::ErrorSendFailed,
+      fix.client.SendPacketAndWaitForResponse("qTest1", response, !send_async));
+
+  std::future<PacketResult> async_result = std::async(std::launch::async, [&] {
+    return fix.client.SendPacketAndWaitForResponse("qTest2", async_response,
+                                                   send_async);
+  });
+
+  // First we'll get interrupted.
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("\x03", response.GetStringRef());
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T13"));
+
+  // Then we get the async packet.
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("qTest2", response.GetStringRef());
+
+  // Send the response and receive it.
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("QTest2"));
+  ASSERT_EQ(PacketResult::Success, async_result.get());
+  ASSERT_EQ("QTest2", async_response.GetStringRef());
+
+  // And we get resumed again.
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("c", response.GetStringRef());
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T01"));
+  ASSERT_EQ(eStateStopped, continue_state.get());
+  ASSERT_EQ("T01", continue_response.GetStringRef());
 }
 
-TEST_F(GDBRemoteClientBaseTest, SendContinueAndInterrupt)
-{
-    StringExtractorGDBRemote continue_response, response;
-    ContinueFixture fix;
-    if (HasFailure())
-        return;
-
-    // Interrupt should do nothing when we're not running.
-    ASSERT_FALSE(fix.client.Interrupt());
-
-    // Continue. After the run packet is sent, send an interrupt.
-    std::future<StateType> continue_state =
-        std::async(std::launch::async, [&] { return fix.SendCPacket(continue_response); });
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("c", response.GetStringRef());
-    fix.WaitForRunEvent();
-
-    std::future<bool> async_result = std::async(std::launch::async, [&] { return fix.client.Interrupt(); });
-
-    // We get interrupted.
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("\x03", response.GetStringRef());
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T13"));
-
-    // And that's it.
-    ASSERT_EQ(eStateStopped, continue_state.get());
-    ASSERT_EQ("T13", continue_response.GetStringRef());
-    ASSERT_TRUE(async_result.get());
+TEST_F(GDBRemoteClientBaseTest, SendContinueAndInterrupt) {
+  StringExtractorGDBRemote continue_response, response;
+  ContinueFixture fix;
+  if (HasFailure())
+    return;
+
+  // Interrupt should do nothing when we're not running.
+  ASSERT_FALSE(fix.client.Interrupt());
+
+  // Continue. After the run packet is sent, send an interrupt.
+  std::future<StateType> continue_state = std::async(
+      std::launch::async, [&] { return fix.SendCPacket(continue_response); });
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("c", response.GetStringRef());
+  fix.WaitForRunEvent();
+
+  std::future<bool> async_result =
+      std::async(std::launch::async, [&] { return fix.client.Interrupt(); });
+
+  // We get interrupted.
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("\x03", response.GetStringRef());
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T13"));
+
+  // And that's it.
+  ASSERT_EQ(eStateStopped, continue_state.get());
+  ASSERT_EQ("T13", continue_response.GetStringRef());
+  ASSERT_TRUE(async_result.get());
 }
 
-TEST_F(GDBRemoteClientBaseTest, SendContinueAndLateInterrupt)
-{
-    StringExtractorGDBRemote continue_response, response;
-    ContinueFixture fix;
-    if (HasFailure())
-        return;
-
-    // Continue. After the run packet is sent, send an interrupt.
-    std::future<StateType> continue_state =
-        std::async(std::launch::async, [&] { return fix.SendCPacket(continue_response); });
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("c", response.GetStringRef());
-    fix.WaitForRunEvent();
-
-    std::future<bool> async_result = std::async(std::launch::async, [&] { return fix.client.Interrupt(); });
-
-    // However, the target stops due to a different reason than the original interrupt.
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("\x03", response.GetStringRef());
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T01"));
-    ASSERT_EQ(eStateStopped, continue_state.get());
-    ASSERT_EQ("T01", continue_response.GetStringRef());
-    ASSERT_TRUE(async_result.get());
-
-    // The subsequent continue packet should work normally.
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T01"));
-    ASSERT_EQ(eStateStopped, fix.SendCPacket(response));
-    ASSERT_EQ("T01", response.GetStringRef());
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("c", response.GetStringRef());
+TEST_F(GDBRemoteClientBaseTest, SendContinueAndLateInterrupt) {
+  StringExtractorGDBRemote continue_response, response;
+  ContinueFixture fix;
+  if (HasFailure())
+    return;
+
+  // Continue. After the run packet is sent, send an interrupt.
+  std::future<StateType> continue_state = std::async(
+      std::launch::async, [&] { return fix.SendCPacket(continue_response); });
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("c", response.GetStringRef());
+  fix.WaitForRunEvent();
+
+  std::future<bool> async_result =
+      std::async(std::launch::async, [&] { return fix.client.Interrupt(); });
+
+  // However, the target stops due to a different reason than the original
+  // interrupt.
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("\x03", response.GetStringRef());
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T01"));
+  ASSERT_EQ(eStateStopped, continue_state.get());
+  ASSERT_EQ("T01", continue_response.GetStringRef());
+  ASSERT_TRUE(async_result.get());
+
+  // The subsequent continue packet should work normally.
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T01"));
+  ASSERT_EQ(eStateStopped, fix.SendCPacket(response));
+  ASSERT_EQ("T01", response.GetStringRef());
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("c", response.GetStringRef());
 }
 
-TEST_F(GDBRemoteClientBaseTest, SendContinueAndInterrupt2PacketBug)
-{
-    StringExtractorGDBRemote continue_response, async_response, response;
-    const bool send_async = true;
-    ContinueFixture fix;
-    if (HasFailure())
-        return;
-
-    // Interrupt should do nothing when we're not running.
-    ASSERT_FALSE(fix.client.Interrupt());
-
-    // Continue. After the run packet is sent, send an async signal.
-    std::future<StateType> continue_state =
-        std::async(std::launch::async, [&] { return fix.SendCPacket(continue_response); });
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("c", response.GetStringRef());
-    fix.WaitForRunEvent();
-
-    std::future<bool> interrupt_result = std::async(std::launch::async, [&] { return fix.client.Interrupt(); });
-
-    // We get interrupted. We'll send two packets to simulate a buggy stub.
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("\x03", response.GetStringRef());
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T13"));
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T13"));
-
-    // We should stop.
-    ASSERT_EQ(eStateStopped, continue_state.get());
-    ASSERT_EQ("T13", continue_response.GetStringRef());
-    ASSERT_TRUE(interrupt_result.get());
-
-    // Packet stream should remain synchronized.
-    std::future<PacketResult> send_result = std::async(std::launch::async, [&] {
-        return fix.client.SendPacketAndWaitForResponse("qTest", async_response, !send_async);
-    });
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("qTest", response.GetStringRef());
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("QTest"));
-    ASSERT_EQ(PacketResult::Success, send_result.get());
-    ASSERT_EQ("QTest", async_response.GetStringRef());
+TEST_F(GDBRemoteClientBaseTest, SendContinueAndInterrupt2PacketBug) {
+  StringExtractorGDBRemote continue_response, async_response, response;
+  const bool send_async = true;
+  ContinueFixture fix;
+  if (HasFailure())
+    return;
+
+  // Interrupt should do nothing when we're not running.
+  ASSERT_FALSE(fix.client.Interrupt());
+
+  // Continue. After the run packet is sent, send an async signal.
+  std::future<StateType> continue_state = std::async(
+      std::launch::async, [&] { return fix.SendCPacket(continue_response); });
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("c", response.GetStringRef());
+  fix.WaitForRunEvent();
+
+  std::future<bool> interrupt_result =
+      std::async(std::launch::async, [&] { return fix.client.Interrupt(); });
+
+  // We get interrupted. We'll send two packets to simulate a buggy stub.
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("\x03", response.GetStringRef());
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T13"));
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T13"));
+
+  // We should stop.
+  ASSERT_EQ(eStateStopped, continue_state.get());
+  ASSERT_EQ("T13", continue_response.GetStringRef());
+  ASSERT_TRUE(interrupt_result.get());
+
+  // Packet stream should remain synchronized.
+  std::future<PacketResult> send_result = std::async(std::launch::async, [&] {
+    return fix.client.SendPacketAndWaitForResponse("qTest", async_response,
+                                                   !send_async);
+  });
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("qTest", response.GetStringRef());
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("QTest"));
+  ASSERT_EQ(PacketResult::Success, send_result.get());
+  ASSERT_EQ("QTest", async_response.GetStringRef());
 }
 
-TEST_F(GDBRemoteClientBaseTest, SendContinueDelegateInterface)
-{
-    StringExtractorGDBRemote response;
-    ContinueFixture fix;
-    if (HasFailure())
-        return;
-
-    // Continue. We'll have the server send a bunch of async packets before it stops.
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("O4142"));
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("Apro"));
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("O4344"));
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("Afile"));
-    ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T01"));
-    ASSERT_EQ(eStateStopped, fix.SendCPacket(response));
-    ASSERT_EQ("T01", response.GetStringRef());
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("c", response.GetStringRef());
-
-    EXPECT_EQ("ABCD", fix.delegate.output);
-    EXPECT_EQ("profile", fix.delegate.misc_data);
-    EXPECT_EQ(1u, fix.delegate.stop_reply_called);
+TEST_F(GDBRemoteClientBaseTest, SendContinueDelegateInterface) {
+  StringExtractorGDBRemote response;
+  ContinueFixture fix;
+  if (HasFailure())
+    return;
+
+  // Continue. We'll have the server send a bunch of async packets before it
+  // stops.
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("O4142"));
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("Apro"));
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("O4344"));
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("Afile"));
+  ASSERT_EQ(PacketResult::Success, fix.server.SendPacket("T01"));
+  ASSERT_EQ(eStateStopped, fix.SendCPacket(response));
+  ASSERT_EQ("T01", response.GetStringRef());
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("c", response.GetStringRef());
+
+  EXPECT_EQ("ABCD", fix.delegate.output);
+  EXPECT_EQ("profile", fix.delegate.misc_data);
+  EXPECT_EQ(1u, fix.delegate.stop_reply_called);
 }
 
-TEST_F(GDBRemoteClientBaseTest, InterruptNoResponse)
-{
-    StringExtractorGDBRemote continue_response, response;
-    ContinueFixture fix;
-    if (HasFailure())
-        return;
-
-    // Continue. After the run packet is sent, send an interrupt.
-    std::future<StateType> continue_state =
-        std::async(std::launch::async, [&] { return fix.SendCPacket(continue_response); });
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("c", response.GetStringRef());
-    fix.WaitForRunEvent();
-
-    std::future<bool> async_result = std::async(std::launch::async, [&] { return fix.client.Interrupt(); });
-
-    // We get interrupted, but we don't send a stop packet.
-    ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
-    ASSERT_EQ("\x03", response.GetStringRef());
-
-    // The functions should still terminate (after a timeout).
-    ASSERT_TRUE(async_result.get());
-    ASSERT_EQ(eStateInvalid, continue_state.get());
+TEST_F(GDBRemoteClientBaseTest, InterruptNoResponse) {
+  StringExtractorGDBRemote continue_response, response;
+  ContinueFixture fix;
+  if (HasFailure())
+    return;
+
+  // Continue. After the run packet is sent, send an interrupt.
+  std::future<StateType> continue_state = std::async(
+      std::launch::async, [&] { return fix.SendCPacket(continue_response); });
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("c", response.GetStringRef());
+  fix.WaitForRunEvent();
+
+  std::future<bool> async_result =
+      std::async(std::launch::async, [&] { return fix.client.Interrupt(); });
+
+  // We get interrupted, but we don't send a stop packet.
+  ASSERT_EQ(PacketResult::Success, fix.server.GetPacket(response));
+  ASSERT_EQ("\x03", response.GetStringRef());
+
+  // The functions should still terminate (after a timeout).
+  ASSERT_TRUE(async_result.get());
+  ASSERT_EQ(eStateInvalid, continue_state.get());
 }
diff --git a/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp b/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp
index 0b1f60d33d0..d74ac66e15d 100644
--- a/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp
+++ b/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp
@@ -8,7 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 #if defined(_MSC_VER) && (_HAS_EXCEPTIONS == 0)
-// Workaround for MSVC standard library bug, which fails to include <thread> when
+// Workaround for MSVC standard library bug, which fails to include <thread>
+// when
 // exceptions are disabled.
 #include <eh.h>
 #endif
@@ -26,159 +27,162 @@ using namespace lldb_private::process_gdb_remote;
 using namespace lldb_private;
 using namespace lldb;
 
-namespace
-{
+namespace {
 
 typedef GDBRemoteCommunication::PacketResult PacketResult;
 
-struct TestClient : public GDBRemoteCommunicationClient
-{
-    TestClient() { m_send_acks = false; }
+struct TestClient : public GDBRemoteCommunicationClient {
+  TestClient() { m_send_acks = false; }
 };
 
-void
-Handle_QThreadSuffixSupported(MockServer &server, bool supported)
-{
-    StringExtractorGDBRemote request;
-    ASSERT_EQ(PacketResult::Success, server.GetPacket(request));
-    ASSERT_EQ("QThreadSuffixSupported", request.GetStringRef());
-    if (supported)
-        ASSERT_EQ(PacketResult::Success, server.SendOKResponse());
-    else
-        ASSERT_EQ(PacketResult::Success, server.SendUnimplementedResponse(nullptr));
+void Handle_QThreadSuffixSupported(MockServer &server, bool supported) {
+  StringExtractorGDBRemote request;
+  ASSERT_EQ(PacketResult::Success, server.GetPacket(request));
+  ASSERT_EQ("QThreadSuffixSupported", request.GetStringRef());
+  if (supported)
+    ASSERT_EQ(PacketResult::Success, server.SendOKResponse());
+  else
+    ASSERT_EQ(PacketResult::Success, server.SendUnimplementedResponse(nullptr));
 }
 
-void
-HandlePacket(MockServer &server, llvm::StringRef expected, llvm::StringRef response)
-{
-    StringExtractorGDBRemote request;
-    ASSERT_EQ(PacketResult::Success, server.GetPacket(request));
-    ASSERT_EQ(expected, request.GetStringRef());
-    ASSERT_EQ(PacketResult::Success, server.SendPacket(response));
+void HandlePacket(MockServer &server, llvm::StringRef expected,
+                  llvm::StringRef response) {
+  StringExtractorGDBRemote request;
+  ASSERT_EQ(PacketResult::Success, server.GetPacket(request));
+  ASSERT_EQ(expected, request.GetStringRef());
+  ASSERT_EQ(PacketResult::Success, server.SendPacket(response));
 }
 
-uint8_t all_registers[] = {'@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O'};
+uint8_t all_registers[] = {'@', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
+                           'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O'};
 std::string all_registers_hex = "404142434445464748494a4b4c4d4e4f";
 uint8_t one_register[] = {'A', 'B', 'C', 'D'};
 std::string one_register_hex = "41424344";
 
 } // end anonymous namespace
 
-class GDBRemoteCommunicationClientTest : public GDBRemoteTest
-{
-};
+class GDBRemoteCommunicationClientTest : public GDBRemoteTest {};
 
-TEST_F(GDBRemoteCommunicationClientTest, WriteRegister)
-{
-    TestClient client;
-    MockServer server;
-    Connect(client, server);
-    if (HasFailure())
-        return;
+TEST_F(GDBRemoteCommunicationClientTest, WriteRegister) {
+  TestClient client;
+  MockServer server;
+  Connect(client, server);
+  if (HasFailure())
+    return;
 
-    const lldb::tid_t tid = 0x47;
-    const uint32_t reg_num = 4;
-    std::future<bool> write_result =
-        std::async(std::launch::async, [&] { return client.WriteRegister(tid, reg_num, one_register); });
+  const lldb::tid_t tid = 0x47;
+  const uint32_t reg_num = 4;
+  std::future<bool> write_result = std::async(std::launch::async, [&] {
+    return client.WriteRegister(tid, reg_num, one_register);
+  });
 
-    Handle_QThreadSuffixSupported(server, true);
+  Handle_QThreadSuffixSupported(server, true);
 
-    HandlePacket(server, "P4=" + one_register_hex + ";thread:0047;", "OK");
-    ASSERT_TRUE(write_result.get());
+  HandlePacket(server, "P4=" + one_register_hex + ";thread:0047;", "OK");
+  ASSERT_TRUE(write_result.get());
 
-    write_result = std::async(std::launch::async, [&] { return client.WriteAllRegisters(tid, all_registers); });
+  write_result = std::async(std::launch::async, [&] {
+    return client.WriteAllRegisters(tid, all_registers);
+  });
 
-    HandlePacket(server, "G" + all_registers_hex + ";thread:0047;", "OK");
-    ASSERT_TRUE(write_result.get());
+  HandlePacket(server, "G" + all_registers_hex + ";thread:0047;", "OK");
+  ASSERT_TRUE(write_result.get());
 }
 
-TEST_F(GDBRemoteCommunicationClientTest, WriteRegisterNoSuffix)
-{
-    TestClient client;
-    MockServer server;
-    Connect(client, server);
-    if (HasFailure())
-        return;
-
-    const lldb::tid_t tid = 0x47;
-    const uint32_t reg_num = 4;
-    std::future<bool> write_result =
-        std::async(std::launch::async, [&] { return client.WriteRegister(tid, reg_num, one_register); });
-
-    Handle_QThreadSuffixSupported(server, false);
-    HandlePacket(server, "Hg47", "OK");
-    HandlePacket(server, "P4=" + one_register_hex, "OK");
-    ASSERT_TRUE(write_result.get());
-
-    write_result = std::async(std::launch::async, [&] { return client.WriteAllRegisters(tid, all_registers); });
-
-    HandlePacket(server, "G" + all_registers_hex, "OK");
-    ASSERT_TRUE(write_result.get());
+TEST_F(GDBRemoteCommunicationClientTest, WriteRegisterNoSuffix) {
+  TestClient client;
+  MockServer server;
+  Connect(client, server);
+  if (HasFailure())
+    return;
+
+  const lldb::tid_t tid = 0x47;
+  const uint32_t reg_num = 4;
+  std::future<bool> write_result = std::async(std::launch::async, [&] {
+    return client.WriteRegister(tid, reg_num, one_register);
+  });
+
+  Handle_QThreadSuffixSupported(server, false);
+  HandlePacket(server, "Hg47", "OK");
+  HandlePacket(server, "P4=" + one_register_hex, "OK");
+  ASSERT_TRUE(write_result.get());
+
+  write_result = std::async(std::launch::async, [&] {
+    return client.WriteAllRegisters(tid, all_registers);
+  });
+
+  HandlePacket(server, "G" + all_registers_hex, "OK");
+  ASSERT_TRUE(write_result.get());
 }
 
-TEST_F(GDBRemoteCommunicationClientTest, ReadRegister)
-{
-    TestClient client;
-    MockServer server;
-    Connect(client, server);
-    if (HasFailure())
-        return;
-
-    const lldb::tid_t tid = 0x47;
-    const uint32_t reg_num = 4;
-    std::future<bool> async_result = std::async(std::launch::async, [&] { return client.GetpPacketSupported(tid); });
-    Handle_QThreadSuffixSupported(server, true);
-    HandlePacket(server, "p0;thread:0047;", one_register_hex);
-    ASSERT_TRUE(async_result.get());
-
-    std::future<DataBufferSP> read_result =
-        std::async(std::launch::async, [&] { return client.ReadRegister(tid, reg_num); });
-    HandlePacket(server, "p4;thread:0047;", "41424344");
-    auto buffer_sp = read_result.get();
-    ASSERT_TRUE(bool(buffer_sp));
-    ASSERT_EQ(0, memcmp(buffer_sp->GetBytes(), one_register, sizeof one_register));
-
-    read_result = std::async(std::launch::async, [&] { return client.ReadAllRegisters(tid); });
-    HandlePacket(server, "g;thread:0047;", all_registers_hex);
-    buffer_sp = read_result.get();
-    ASSERT_TRUE(bool(buffer_sp));
-    ASSERT_EQ(0, memcmp(buffer_sp->GetBytes(), all_registers, sizeof all_registers));
+TEST_F(GDBRemoteCommunicationClientTest, ReadRegister) {
+  TestClient client;
+  MockServer server;
+  Connect(client, server);
+  if (HasFailure())
+    return;
+
+  const lldb::tid_t tid = 0x47;
+  const uint32_t reg_num = 4;
+  std::future<bool> async_result = std::async(
+      std::launch::async, [&] { return client.GetpPacketSupported(tid); });
+  Handle_QThreadSuffixSupported(server, true);
+  HandlePacket(server, "p0;thread:0047;", one_register_hex);
+  ASSERT_TRUE(async_result.get());
+
+  std::future<DataBufferSP> read_result = std::async(
+      std::launch::async, [&] { return client.ReadRegister(tid, reg_num); });
+  HandlePacket(server, "p4;thread:0047;", "41424344");
+  auto buffer_sp = read_result.get();
+  ASSERT_TRUE(bool(buffer_sp));
+  ASSERT_EQ(0,
+            memcmp(buffer_sp->GetBytes(), one_register, sizeof one_register));
+
+  read_result = std::async(std::launch::async,
+                           [&] { return client.ReadAllRegisters(tid); });
+  HandlePacket(server, "g;thread:0047;", all_registers_hex);
+  buffer_sp = read_result.get();
+  ASSERT_TRUE(bool(buffer_sp));
+  ASSERT_EQ(0,
+            memcmp(buffer_sp->GetBytes(), all_registers, sizeof all_registers));
 }
 
-TEST_F(GDBRemoteCommunicationClientTest, SaveRestoreRegistersNoSuffix)
-{
-    TestClient client;
-    MockServer server;
-    Connect(client, server);
-    if (HasFailure())
-        return;
-
-    const lldb::tid_t tid = 0x47;
-    uint32_t save_id;
-    std::future<bool> async_result =
-        std::async(std::launch::async, [&] { return client.SaveRegisterState(tid, save_id); });
-    Handle_QThreadSuffixSupported(server, false);
-    HandlePacket(server, "Hg47", "OK");
-    HandlePacket(server, "QSaveRegisterState", "1");
-    ASSERT_TRUE(async_result.get());
-    EXPECT_EQ(1u, save_id);
-
-    async_result = std::async(std::launch::async, [&] { return client.RestoreRegisterState(tid, save_id); });
-    HandlePacket(server, "QRestoreRegisterState:1", "OK");
-    ASSERT_TRUE(async_result.get());
+TEST_F(GDBRemoteCommunicationClientTest, SaveRestoreRegistersNoSuffix) {
+  TestClient client;
+  MockServer server;
+  Connect(client, server);
+  if (HasFailure())
+    return;
+
+  const lldb::tid_t tid = 0x47;
+  uint32_t save_id;
+  std::future<bool> async_result = std::async(std::launch::async, [&] {
+    return client.SaveRegisterState(tid, save_id);
+  });
+  Handle_QThreadSuffixSupported(server, false);
+  HandlePacket(server, "Hg47", "OK");
+  HandlePacket(server, "QSaveRegisterState", "1");
+  ASSERT_TRUE(async_result.get());
+  EXPECT_EQ(1u, save_id);
+
+  async_result = std::async(std::launch::async, [&] {
+    return client.RestoreRegisterState(tid, save_id);
+  });
+  HandlePacket(server, "QRestoreRegisterState:1", "OK");
+  ASSERT_TRUE(async_result.get());
 }
 
-TEST_F(GDBRemoteCommunicationClientTest, SyncThreadState)
-{
-    TestClient client;
-    MockServer server;
-    Connect(client, server);
-    if (HasFailure())
-        return;
-
-    const lldb::tid_t tid = 0x47;
-    std::future<bool> async_result = std::async(std::launch::async, [&] { return client.SyncThreadState(tid); });
-    HandlePacket(server, "qSyncThreadStateSupported", "OK");
-    HandlePacket(server, "QSyncThreadState:0047;", "OK");
-    ASSERT_TRUE(async_result.get());
+TEST_F(GDBRemoteCommunicationClientTest, SyncThreadState) {
+  TestClient client;
+  MockServer server;
+  Connect(client, server);
+  if (HasFailure())
+    return;
+
+  const lldb::tid_t tid = 0x47;
+  std::future<bool> async_result = std::async(
+      std::launch::async, [&] { return client.SyncThreadState(tid); });
+  HandlePacket(server, "qSyncThreadStateSupported", "OK");
+  HandlePacket(server, "QSyncThreadState:0047;", "OK");
+  ASSERT_TRUE(async_result.get());
 }
diff --git a/lldb/unittests/Process/gdb-remote/GDBRemoteTestUtils.cpp b/lldb/unittests/Process/gdb-remote/GDBRemoteTestUtils.cpp
index 3aee52e5332..58cc9f50586 100644
--- a/lldb/unittests/Process/gdb-remote/GDBRemoteTestUtils.cpp
+++ b/lldb/unittests/Process/gdb-remote/GDBRemoteTestUtils.cpp
@@ -8,7 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 #if defined(_MSC_VER) && (_HAS_EXCEPTIONS == 0)
-// Workaround for MSVC standard library bug, which fails to include <thread> when
+// Workaround for MSVC standard library bug, which fails to include <thread>
+// when
 // exceptions are disabled.
 #include <eh.h>
 #endif
@@ -20,53 +21,48 @@
 
 #include <future>
 
-namespace lldb_private
-{
-namespace process_gdb_remote
-{
+namespace lldb_private {
+namespace process_gdb_remote {
 
-void
-GDBRemoteTest::SetUpTestCase()
-{
+void GDBRemoteTest::SetUpTestCase() {
 #if defined(_MSC_VER)
-    WSADATA data;
-    ::WSAStartup(MAKEWORD(2, 2), &data);
+  WSADATA data;
+  ::WSAStartup(MAKEWORD(2, 2), &data);
 #endif
 }
 
-void
-GDBRemoteTest::TearDownTestCase()
-{
+void GDBRemoteTest::TearDownTestCase() {
 #if defined(_MSC_VER)
-    ::WSACleanup();
+  ::WSACleanup();
 #endif
 }
 
-void
-Connect(GDBRemoteCommunication &client, GDBRemoteCommunication &server)
-{
-    bool child_processes_inherit = false;
-    Error error;
-    TCPSocket listen_socket(child_processes_inherit, error);
-    ASSERT_FALSE(error.Fail());
-    error = listen_socket.Listen("127.0.0.1:0", 5);
-    ASSERT_FALSE(error.Fail());
+void Connect(GDBRemoteCommunication &client, GDBRemoteCommunication &server) {
+  bool child_processes_inherit = false;
+  Error error;
+  TCPSocket listen_socket(child_processes_inherit, error);
+  ASSERT_FALSE(error.Fail());
+  error = listen_socket.Listen("127.0.0.1:0", 5);
+  ASSERT_FALSE(error.Fail());
 
-    Socket *accept_socket;
-    std::future<Error> accept_error = std::async(std::launch::async, [&] {
-        return listen_socket.Accept("127.0.0.1:0", child_processes_inherit, accept_socket);
-    });
+  Socket *accept_socket;
+  std::future<Error> accept_error = std::async(std::launch::async, [&] {
+    return listen_socket.Accept("127.0.0.1:0", child_processes_inherit,
+                                accept_socket);
+  });
 
-    char connect_remote_address[64];
-    snprintf(connect_remote_address, sizeof(connect_remote_address), "connect://localhost:%u",
-             listen_socket.GetLocalPortNumber());
+  char connect_remote_address[64];
+  snprintf(connect_remote_address, sizeof(connect_remote_address),
+           "connect://localhost:%u", listen_socket.GetLocalPortNumber());
 
-    std::unique_ptr<ConnectionFileDescriptor> conn_ap(new ConnectionFileDescriptor());
-    ASSERT_EQ(conn_ap->Connect(connect_remote_address, nullptr), lldb::eConnectionStatusSuccess);
+  std::unique_ptr<ConnectionFileDescriptor> conn_ap(
+      new ConnectionFileDescriptor());
+  ASSERT_EQ(conn_ap->Connect(connect_remote_address, nullptr),
+            lldb::eConnectionStatusSuccess);
 
-    client.SetConnection(conn_ap.release());
-    ASSERT_TRUE(accept_error.get().Success());
-    server.SetConnection(new ConnectionFileDescriptor(accept_socket));
+  client.SetConnection(conn_ap.release());
+  ASSERT_TRUE(accept_error.get().Success());
+  server.SetConnection(new ConnectionFileDescriptor(accept_socket));
 }
 
 } // namespace process_gdb_remote
diff --git a/lldb/unittests/Process/gdb-remote/GDBRemoteTestUtils.h b/lldb/unittests/Process/gdb-remote/GDBRemoteTestUtils.h
index 6ceeccfaf81..2aad2ae4972 100644
--- a/lldb/unittests/Process/gdb-remote/GDBRemoteTestUtils.h
+++ b/lldb/unittests/Process/gdb-remote/GDBRemoteTestUtils.h
@@ -9,47 +9,40 @@
 #ifndef lldb_unittests_Process_gdb_remote_GDBRemoteTestUtils_h
 #define lldb_unittests_Process_gdb_remote_GDBRemoteTestUtils_h
 
-#include "gtest/gtest.h"
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.h"
+#include "gtest/gtest.h"
 
-namespace lldb_private
-{
-namespace process_gdb_remote
-{
+namespace lldb_private {
+namespace process_gdb_remote {
 
-class GDBRemoteTest : public testing::Test
-{
+class GDBRemoteTest : public testing::Test {
 public:
-    static void
-    SetUpTestCase();
+  static void SetUpTestCase();
 
-    static void
-    TearDownTestCase();
+  static void TearDownTestCase();
 };
 
-void
-Connect(GDBRemoteCommunication &client, GDBRemoteCommunication &server);
-
-struct MockServer : public GDBRemoteCommunicationServer
-{
-    MockServer() : GDBRemoteCommunicationServer("mock-server", "mock-server.listener") { m_send_acks = false; }
-
-    PacketResult
-    SendPacket(llvm::StringRef payload)
-    {
-        return GDBRemoteCommunicationServer::SendPacketNoLock(payload);
-    }
-
-    PacketResult
-    GetPacket(StringExtractorGDBRemote &response)
-    {
-        const unsigned timeout_usec = 1000000; // 1s
-        const bool sync_on_timeout = false;
-        return WaitForPacketWithTimeoutMicroSecondsNoLock(response, timeout_usec, sync_on_timeout);
-    }
-
-    using GDBRemoteCommunicationServer::SendOKResponse;
-    using GDBRemoteCommunicationServer::SendUnimplementedResponse;
+void Connect(GDBRemoteCommunication &client, GDBRemoteCommunication &server);
+
+struct MockServer : public GDBRemoteCommunicationServer {
+  MockServer()
+      : GDBRemoteCommunicationServer("mock-server", "mock-server.listener") {
+    m_send_acks = false;
+  }
+
+  PacketResult SendPacket(llvm::StringRef payload) {
+    return GDBRemoteCommunicationServer::SendPacketNoLock(payload);
+  }
+
+  PacketResult GetPacket(StringExtractorGDBRemote &response) {
+    const unsigned timeout_usec = 1000000; // 1s
+    const bool sync_on_timeout = false;
+    return WaitForPacketWithTimeoutMicroSecondsNoLock(response, timeout_usec,
+                                                      sync_on_timeout);
+  }
+
+  using GDBRemoteCommunicationServer::SendOKResponse;
+  using GDBRemoteCommunicationServer::SendUnimplementedResponse;
 };
 
 } // namespace process_gdb_remote
diff --git a/lldb/unittests/Process/minidump/Inputs/linux-x86_64.cpp b/lldb/unittests/Process/minidump/Inputs/linux-x86_64.cpp
index 9974a50310f..827fe67b503 100644
--- a/lldb/unittests/Process/minidump/Inputs/linux-x86_64.cpp
+++ b/lldb/unittests/Process/minidump/Inputs/linux-x86_64.cpp
@@ -7,19 +7,22 @@
 
 #include "client/linux/handler/exception_handler.h"
 
-
-static bool dumpCallback(const google_breakpad::MinidumpDescriptor& descriptor,
-void* context, bool succeeded) {
-    printf("Dump path: %s\n", descriptor.path());
-    return succeeded;
+static bool dumpCallback(const google_breakpad::MinidumpDescriptor &descriptor,
+                         void *context, bool succeeded) {
+  printf("Dump path: %s\n", descriptor.path());
+  return succeeded;
 }
 
-void crash() { volatile int* a = (int*)(NULL); *a = 1; }
+void crash() {
+  volatile int *a = (int *)(NULL);
+  *a = 1;
+}
 
-int main(int argc, char* argv[]) {
-    google_breakpad::MinidumpDescriptor descriptor("/tmp");
-    google_breakpad::ExceptionHandler eh(descriptor, NULL, dumpCallback, NULL, true, -1);
-    printf("pid: %d\n", getpid());
-    crash();
-    return 0;
+int main(int argc, char *argv[]) {
+  google_breakpad::MinidumpDescriptor descriptor("/tmp");
+  google_breakpad::ExceptionHandler eh(descriptor, NULL, dumpCallback, NULL,
+                                       true, -1);
+  printf("pid: %d\n", getpid());
+  crash();
+  return 0;
 }
diff --git a/lldb/unittests/Process/minidump/MinidumpParserTest.cpp b/lldb/unittests/Process/minidump/MinidumpParserTest.cpp
index 753d631f747..3c273fb4a8e 100644
--- a/lldb/unittests/Process/minidump/MinidumpParserTest.cpp
+++ b/lldb/unittests/Process/minidump/MinidumpParserTest.cpp
@@ -32,66 +32,60 @@ extern const char *TestMainArgv0;
 using namespace lldb_private;
 using namespace minidump;
 
-class MinidumpParserTest : public testing::Test
-{
+class MinidumpParserTest : public testing::Test {
 public:
-    void
-    SetUp() override
-    {
-        llvm::StringRef dmp_folder = llvm::sys::path::parent_path(TestMainArgv0);
-        inputs_folder = dmp_folder;
-        llvm::sys::path::append(inputs_folder, "Inputs");
-    }
-
-    void
-    SetUpData(const char *minidump_filename, size_t load_size = SIZE_MAX)
-    {
-        llvm::SmallString<128> filename = inputs_folder;
-        llvm::sys::path::append(filename, minidump_filename);
-        FileSpec minidump_file(filename.c_str(), false);
-        lldb::DataBufferSP data_sp(minidump_file.MemoryMapFileContents(0, load_size));
-        llvm::Optional<MinidumpParser> optional_parser = MinidumpParser::Create(data_sp);
-        ASSERT_TRUE(optional_parser.hasValue());
-        parser.reset(new MinidumpParser(optional_parser.getValue()));
-        ASSERT_GT(parser->GetByteSize(), 0UL);
-    }
-
-    llvm::SmallString<128> inputs_folder;
-    std::unique_ptr<MinidumpParser> parser;
+  void SetUp() override {
+    llvm::StringRef dmp_folder = llvm::sys::path::parent_path(TestMainArgv0);
+    inputs_folder = dmp_folder;
+    llvm::sys::path::append(inputs_folder, "Inputs");
+  }
+
+  void SetUpData(const char *minidump_filename, size_t load_size = SIZE_MAX) {
+    llvm::SmallString<128> filename = inputs_folder;
+    llvm::sys::path::append(filename, minidump_filename);
+    FileSpec minidump_file(filename.c_str(), false);
+    lldb::DataBufferSP data_sp(
+        minidump_file.MemoryMapFileContents(0, load_size));
+    llvm::Optional<MinidumpParser> optional_parser =
+        MinidumpParser::Create(data_sp);
+    ASSERT_TRUE(optional_parser.hasValue());
+    parser.reset(new MinidumpParser(optional_parser.getValue()));
+    ASSERT_GT(parser->GetByteSize(), 0UL);
+  }
+
+  llvm::SmallString<128> inputs_folder;
+  std::unique_ptr<MinidumpParser> parser;
 };
 
-TEST_F(MinidumpParserTest, GetThreads)
-{
-    SetUpData("linux-x86_64.dmp");
-    llvm::Optional<std::vector<const MinidumpThread *>> thread_list;
+TEST_F(MinidumpParserTest, GetThreads) {
+  SetUpData("linux-x86_64.dmp");
+  llvm::Optional<std::vector<const MinidumpThread *>> thread_list;
 
-    thread_list = parser->GetThreads();
-    ASSERT_TRUE(thread_list.hasValue());
-    ASSERT_EQ(1UL, thread_list->size());
+  thread_list = parser->GetThreads();
+  ASSERT_TRUE(thread_list.hasValue());
+  ASSERT_EQ(1UL, thread_list->size());
 
-    const MinidumpThread *thread = thread_list.getValue()[0];
-    ASSERT_EQ(16001UL, thread->thread_id);
+  const MinidumpThread *thread = thread_list.getValue()[0];
+  ASSERT_EQ(16001UL, thread->thread_id);
 }
 
-TEST_F(MinidumpParserTest, GetThreadsTruncatedFile)
-{
-    SetUpData("linux-x86_64.dmp", 200);
-    llvm::Optional<std::vector<const MinidumpThread *>> thread_list;
+TEST_F(MinidumpParserTest, GetThreadsTruncatedFile) {
+  SetUpData("linux-x86_64.dmp", 200);
+  llvm::Optional<std::vector<const MinidumpThread *>> thread_list;
 
-    thread_list = parser->GetThreads();
-    ASSERT_FALSE(thread_list.hasValue());
+  thread_list = parser->GetThreads();
+  ASSERT_FALSE(thread_list.hasValue());
 }
 
-TEST_F(MinidumpParserTest, GetArchitecture)
-{
-    SetUpData("linux-x86_64.dmp");
-    ASSERT_EQ(llvm::Triple::ArchType::x86_64, parser->GetArchitecture().GetTriple().getArch());
+TEST_F(MinidumpParserTest, GetArchitecture) {
+  SetUpData("linux-x86_64.dmp");
+  ASSERT_EQ(llvm::Triple::ArchType::x86_64,
+            parser->GetArchitecture().GetTriple().getArch());
 }
 
-TEST_F(MinidumpParserTest, GetMiscInfo)
-{
-    SetUpData("linux-x86_64.dmp");
-    const MinidumpMiscInfo *misc_info = parser->GetMiscInfo();
-    ASSERT_EQ(nullptr, misc_info);
-    // linux breakpad generated minidump files don't have misc info stream
+TEST_F(MinidumpParserTest, GetMiscInfo) {
+  SetUpData("linux-x86_64.dmp");
+  const MinidumpMiscInfo *misc_info = parser->GetMiscInfo();
+  ASSERT_EQ(nullptr, misc_info);
+  // linux breakpad generated minidump files don't have misc info stream
 }
diff --git a/lldb/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp b/lldb/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp
index efd169e686d..590b143ec7a 100644
--- a/lldb/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp
+++ b/lldb/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp
@@ -7,615 +7,593 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "gtest/gtest.h"
 #include "Plugins/ScriptInterpreter/Python/lldb-python.h"
+#include "gtest/gtest.h"
 
+#include "Plugins/ScriptInterpreter/Python/PythonDataObjects.h"
+#include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
-#include "Plugins/ScriptInterpreter/Python/PythonDataObjects.h"
-#include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
 
 #include "PythonTestSuite.h"
 
 using namespace lldb_private;
 
-class PythonDataObjectsTest : public PythonTestSuite
-{
-  public:
-    void
-    SetUp() override
-    {
-        PythonTestSuite::SetUp();
-
-        PythonString sys_module("sys");
-        m_sys_module.Reset(PyRefType::Owned, PyImport_Import(sys_module.get()));
-        m_main_module = PythonModule::MainModule();
-        m_builtins_module = PythonModule::BuiltinsModule();
-    }
-
-    void
-    TearDown() override
-    {
-        m_sys_module.Reset();
-        m_main_module.Reset();
-        m_builtins_module.Reset();
-
-        PythonTestSuite::TearDown();
-    }
-
-  protected:
-    PythonModule m_sys_module;
-    PythonModule m_main_module;
-    PythonModule m_builtins_module;
+class PythonDataObjectsTest : public PythonTestSuite {
+public:
+  void SetUp() override {
+    PythonTestSuite::SetUp();
+
+    PythonString sys_module("sys");
+    m_sys_module.Reset(PyRefType::Owned, PyImport_Import(sys_module.get()));
+    m_main_module = PythonModule::MainModule();
+    m_builtins_module = PythonModule::BuiltinsModule();
+  }
+
+  void TearDown() override {
+    m_sys_module.Reset();
+    m_main_module.Reset();
+    m_builtins_module.Reset();
+
+    PythonTestSuite::TearDown();
+  }
+
+protected:
+  PythonModule m_sys_module;
+  PythonModule m_main_module;
+  PythonModule m_builtins_module;
 };
 
-TEST_F(PythonDataObjectsTest, TestOwnedReferences)
-{
-    // After creating a new object, the refcount should be >= 1
-    PyObject *obj = PyLong_FromLong(3);
-    Py_ssize_t original_refcnt = obj->ob_refcnt;
-    EXPECT_LE(1, original_refcnt);
+TEST_F(PythonDataObjectsTest, TestOwnedReferences) {
+  // After creating a new object, the refcount should be >= 1
+  PyObject *obj = PyLong_FromLong(3);
+  Py_ssize_t original_refcnt = obj->ob_refcnt;
+  EXPECT_LE(1, original_refcnt);
 
-    // If we take an owned reference, the refcount should be the same
-    PythonObject owned_long(PyRefType::Owned, obj);
-    EXPECT_EQ(original_refcnt, owned_long.get()->ob_refcnt);
+  // If we take an owned reference, the refcount should be the same
+  PythonObject owned_long(PyRefType::Owned, obj);
+  EXPECT_EQ(original_refcnt, owned_long.get()->ob_refcnt);
 
-    // Take another reference and verify that the refcount increases by 1
-    PythonObject strong_ref(owned_long);
-    EXPECT_EQ(original_refcnt + 1, strong_ref.get()->ob_refcnt);
+  // Take another reference and verify that the refcount increases by 1
+  PythonObject strong_ref(owned_long);
+  EXPECT_EQ(original_refcnt + 1, strong_ref.get()->ob_refcnt);
 
-    // If we reset the first one, the refcount should be the original value.
-    owned_long.Reset();
-    EXPECT_EQ(original_refcnt, strong_ref.get()->ob_refcnt);
+  // If we reset the first one, the refcount should be the original value.
+  owned_long.Reset();
+  EXPECT_EQ(original_refcnt, strong_ref.get()->ob_refcnt);
 }
 
-TEST_F(PythonDataObjectsTest, TestResetting)
-{
-    PythonDictionary dict(PyInitialValue::Empty);
+TEST_F(PythonDataObjectsTest, TestResetting) {
+  PythonDictionary dict(PyInitialValue::Empty);
 
-    PyObject *new_dict = PyDict_New();
-    dict.Reset(PyRefType::Owned, new_dict);
-    EXPECT_EQ(new_dict, dict.get());
+  PyObject *new_dict = PyDict_New();
+  dict.Reset(PyRefType::Owned, new_dict);
+  EXPECT_EQ(new_dict, dict.get());
 
-    dict.Reset(PyRefType::Owned, nullptr);
-    EXPECT_EQ(nullptr, dict.get());
+  dict.Reset(PyRefType::Owned, nullptr);
+  EXPECT_EQ(nullptr, dict.get());
 
-    dict.Reset(PyRefType::Owned, PyDict_New());
-    EXPECT_NE(nullptr, dict.get());
-    dict.Reset();
-    EXPECT_EQ(nullptr, dict.get());
+  dict.Reset(PyRefType::Owned, PyDict_New());
+  EXPECT_NE(nullptr, dict.get());
+  dict.Reset();
+  EXPECT_EQ(nullptr, dict.get());
 }
 
-TEST_F(PythonDataObjectsTest, TestBorrowedReferences)
-{
-    PythonInteger long_value(PyRefType::Owned, PyLong_FromLong(3));
-    Py_ssize_t original_refcnt = long_value.get()->ob_refcnt;
-    EXPECT_LE(1, original_refcnt);
+TEST_F(PythonDataObjectsTest, TestBorrowedReferences) {
+  PythonInteger long_value(PyRefType::Owned, PyLong_FromLong(3));
+  Py_ssize_t original_refcnt = long_value.get()->ob_refcnt;
+  EXPECT_LE(1, original_refcnt);
 
-    PythonInteger borrowed_long(PyRefType::Borrowed, long_value.get());
-    EXPECT_EQ(original_refcnt + 1, borrowed_long.get()->ob_refcnt);
+  PythonInteger borrowed_long(PyRefType::Borrowed, long_value.get());
+  EXPECT_EQ(original_refcnt + 1, borrowed_long.get()->ob_refcnt);
 }
 
-TEST_F(PythonDataObjectsTest, TestGlobalNameResolutionNoDot)
-{
-    PythonObject sys_module = m_main_module.ResolveName("sys");
-    EXPECT_EQ(m_sys_module.get(), sys_module.get());
-    EXPECT_TRUE(sys_module.IsAllocated());
-    EXPECT_TRUE(PythonModule::Check(sys_module.get()));
+TEST_F(PythonDataObjectsTest, TestGlobalNameResolutionNoDot) {
+  PythonObject sys_module = m_main_module.ResolveName("sys");
+  EXPECT_EQ(m_sys_module.get(), sys_module.get());
+  EXPECT_TRUE(sys_module.IsAllocated());
+  EXPECT_TRUE(PythonModule::Check(sys_module.get()));
 }
 
-TEST_F(PythonDataObjectsTest, TestModuleNameResolutionNoDot)
-{
-    PythonObject sys_path = m_sys_module.ResolveName("path");
-    PythonObject sys_version_info = m_sys_module.ResolveName("version_info");
-    EXPECT_TRUE(sys_path.IsAllocated());
-    EXPECT_TRUE(sys_version_info.IsAllocated());
+TEST_F(PythonDataObjectsTest, TestModuleNameResolutionNoDot) {
+  PythonObject sys_path = m_sys_module.ResolveName("path");
+  PythonObject sys_version_info = m_sys_module.ResolveName("version_info");
+  EXPECT_TRUE(sys_path.IsAllocated());
+  EXPECT_TRUE(sys_version_info.IsAllocated());
 
-    EXPECT_TRUE(PythonList::Check(sys_path.get()));
+  EXPECT_TRUE(PythonList::Check(sys_path.get()));
 }
 
-TEST_F(PythonDataObjectsTest, TestTypeNameResolutionNoDot)
-{
-    PythonObject sys_version_info = m_sys_module.ResolveName("version_info");
+TEST_F(PythonDataObjectsTest, TestTypeNameResolutionNoDot) {
+  PythonObject sys_version_info = m_sys_module.ResolveName("version_info");
 
-    PythonObject version_info_type(PyRefType::Owned, PyObject_Type(sys_version_info.get()));
-    EXPECT_TRUE(version_info_type.IsAllocated());
-    PythonObject major_version_field = version_info_type.ResolveName("major");
-    EXPECT_TRUE(major_version_field.IsAllocated());
+  PythonObject version_info_type(PyRefType::Owned,
+                                 PyObject_Type(sys_version_info.get()));
+  EXPECT_TRUE(version_info_type.IsAllocated());
+  PythonObject major_version_field = version_info_type.ResolveName("major");
+  EXPECT_TRUE(major_version_field.IsAllocated());
 }
 
-TEST_F(PythonDataObjectsTest, TestInstanceNameResolutionNoDot)
-{
-    PythonObject sys_version_info = m_sys_module.ResolveName("version_info");
-    PythonObject major_version_field = sys_version_info.ResolveName("major");
-    PythonObject minor_version_field = sys_version_info.ResolveName("minor");
+TEST_F(PythonDataObjectsTest, TestInstanceNameResolutionNoDot) {
+  PythonObject sys_version_info = m_sys_module.ResolveName("version_info");
+  PythonObject major_version_field = sys_version_info.ResolveName("major");
+  PythonObject minor_version_field = sys_version_info.ResolveName("minor");
 
-    EXPECT_TRUE(major_version_field.IsAllocated());
-    EXPECT_TRUE(minor_version_field.IsAllocated());
+  EXPECT_TRUE(major_version_field.IsAllocated());
+  EXPECT_TRUE(minor_version_field.IsAllocated());
 
-    PythonInteger major_version_value = major_version_field.AsType<PythonInteger>();
-    PythonInteger minor_version_value = minor_version_field.AsType<PythonInteger>();
+  PythonInteger major_version_value =
+      major_version_field.AsType<PythonInteger>();
+  PythonInteger minor_version_value =
+      minor_version_field.AsType<PythonInteger>();
 
-    EXPECT_EQ(PY_MAJOR_VERSION, major_version_value.GetInteger());
-    EXPECT_EQ(PY_MINOR_VERSION, minor_version_value.GetInteger());
+  EXPECT_EQ(PY_MAJOR_VERSION, major_version_value.GetInteger());
+  EXPECT_EQ(PY_MINOR_VERSION, minor_version_value.GetInteger());
 }
 
-TEST_F(PythonDataObjectsTest, TestGlobalNameResolutionWithDot)
-{
-    PythonObject sys_path = m_main_module.ResolveName("sys.path");
-    EXPECT_TRUE(sys_path.IsAllocated());
-    EXPECT_TRUE(PythonList::Check(sys_path.get()));
+TEST_F(PythonDataObjectsTest, TestGlobalNameResolutionWithDot) {
+  PythonObject sys_path = m_main_module.ResolveName("sys.path");
+  EXPECT_TRUE(sys_path.IsAllocated());
+  EXPECT_TRUE(PythonList::Check(sys_path.get()));
 
-    PythonInteger version_major = m_main_module.ResolveName(
-        "sys.version_info.major").AsType<PythonInteger>();
-    PythonInteger version_minor = m_main_module.ResolveName(
-        "sys.version_info.minor").AsType<PythonInteger>();
-    EXPECT_TRUE(version_major.IsAllocated());
-    EXPECT_TRUE(version_minor.IsAllocated());
-    EXPECT_EQ(PY_MAJOR_VERSION, version_major.GetInteger());
-    EXPECT_EQ(PY_MINOR_VERSION, version_minor.GetInteger());
+  PythonInteger version_major =
+      m_main_module.ResolveName("sys.version_info.major")
+          .AsType<PythonInteger>();
+  PythonInteger version_minor =
+      m_main_module.ResolveName("sys.version_info.minor")
+          .AsType<PythonInteger>();
+  EXPECT_TRUE(version_major.IsAllocated());
+  EXPECT_TRUE(version_minor.IsAllocated());
+  EXPECT_EQ(PY_MAJOR_VERSION, version_major.GetInteger());
+  EXPECT_EQ(PY_MINOR_VERSION, version_minor.GetInteger());
 }
 
-TEST_F(PythonDataObjectsTest, TestDictionaryResolutionWithDot)
-{
-    // Make up a custom dictionary with "sys" pointing to the `sys` module.
-    PythonDictionary dict(PyInitialValue::Empty);
-    dict.SetItemForKey(PythonString("sys"), m_sys_module);
+TEST_F(PythonDataObjectsTest, TestDictionaryResolutionWithDot) {
+  // Make up a custom dictionary with "sys" pointing to the `sys` module.
+  PythonDictionary dict(PyInitialValue::Empty);
+  dict.SetItemForKey(PythonString("sys"), m_sys_module);
 
-    // Now use that dictionary to resolve `sys.version_info.major`
-    PythonInteger version_major = PythonObject::ResolveNameWithDictionary(
-        "sys.version_info.major", dict).AsType<PythonInteger>();
-    PythonInteger version_minor = PythonObject::ResolveNameWithDictionary(
-        "sys.version_info.minor", dict).AsType<PythonInteger>();
-    EXPECT_EQ(PY_MAJOR_VERSION, version_major.GetInteger());
-    EXPECT_EQ(PY_MINOR_VERSION, version_minor.GetInteger());
+  // Now use that dictionary to resolve `sys.version_info.major`
+  PythonInteger version_major =
+      PythonObject::ResolveNameWithDictionary("sys.version_info.major", dict)
+          .AsType<PythonInteger>();
+  PythonInteger version_minor =
+      PythonObject::ResolveNameWithDictionary("sys.version_info.minor", dict)
+          .AsType<PythonInteger>();
+  EXPECT_EQ(PY_MAJOR_VERSION, version_major.GetInteger());
+  EXPECT_EQ(PY_MINOR_VERSION, version_minor.GetInteger());
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonInteger)
-{
+TEST_F(PythonDataObjectsTest, TestPythonInteger) {
 // Test that integers behave correctly when wrapped by a PythonInteger.
 
 #if PY_MAJOR_VERSION < 3
-    // Verify that `PythonInt` works correctly when given a PyInt object.
-    // Note that PyInt doesn't exist in Python 3.x, so this is only for 2.x
-    PyObject *py_int = PyInt_FromLong(12);
-    EXPECT_TRUE(PythonInteger::Check(py_int));
-    PythonInteger python_int(PyRefType::Owned, py_int);
-
-    EXPECT_EQ(PyObjectType::Integer, python_int.GetObjectType());
-    EXPECT_EQ(12, python_int.GetInteger());
+  // Verify that `PythonInt` works correctly when given a PyInt object.
+  // Note that PyInt doesn't exist in Python 3.x, so this is only for 2.x
+  PyObject *py_int = PyInt_FromLong(12);
+  EXPECT_TRUE(PythonInteger::Check(py_int));
+  PythonInteger python_int(PyRefType::Owned, py_int);
+
+  EXPECT_EQ(PyObjectType::Integer, python_int.GetObjectType());
+  EXPECT_EQ(12, python_int.GetInteger());
 #endif
 
-    // Verify that `PythonInteger` works correctly when given a PyLong object.
-    PyObject *py_long = PyLong_FromLong(12);
-    EXPECT_TRUE(PythonInteger::Check(py_long));
-    PythonInteger python_long(PyRefType::Owned, py_long);
-    EXPECT_EQ(PyObjectType::Integer, python_long.GetObjectType());
+  // Verify that `PythonInteger` works correctly when given a PyLong object.
+  PyObject *py_long = PyLong_FromLong(12);
+  EXPECT_TRUE(PythonInteger::Check(py_long));
+  PythonInteger python_long(PyRefType::Owned, py_long);
+  EXPECT_EQ(PyObjectType::Integer, python_long.GetObjectType());
 
-    // Verify that you can reset the value and that it is reflected properly.
-    python_long.SetInteger(40);
-    EXPECT_EQ(40, python_long.GetInteger());
+  // Verify that you can reset the value and that it is reflected properly.
+  python_long.SetInteger(40);
+  EXPECT_EQ(40, python_long.GetInteger());
 
-    // Test that creating a `PythonInteger` object works correctly with the
-    // int constructor.
-    PythonInteger constructed_int(7);
-    EXPECT_EQ(7, constructed_int.GetInteger());
+  // Test that creating a `PythonInteger` object works correctly with the
+  // int constructor.
+  PythonInteger constructed_int(7);
+  EXPECT_EQ(7, constructed_int.GetInteger());
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonBytes)
-{
-    static const char *test_bytes = "PythonDataObjectsTest::TestPythonBytes";
-    PyObject *py_bytes = PyBytes_FromString(test_bytes);
-    EXPECT_TRUE(PythonBytes::Check(py_bytes));
-    PythonBytes python_bytes(PyRefType::Owned, py_bytes);
+TEST_F(PythonDataObjectsTest, TestPythonBytes) {
+  static const char *test_bytes = "PythonDataObjectsTest::TestPythonBytes";
+  PyObject *py_bytes = PyBytes_FromString(test_bytes);
+  EXPECT_TRUE(PythonBytes::Check(py_bytes));
+  PythonBytes python_bytes(PyRefType::Owned, py_bytes);
 
 #if PY_MAJOR_VERSION < 3
-    EXPECT_TRUE(PythonString::Check(py_bytes));
-    EXPECT_EQ(PyObjectType::String, python_bytes.GetObjectType());
+  EXPECT_TRUE(PythonString::Check(py_bytes));
+  EXPECT_EQ(PyObjectType::String, python_bytes.GetObjectType());
 #else
-    EXPECT_FALSE(PythonString::Check(py_bytes));
-    EXPECT_EQ(PyObjectType::Bytes, python_bytes.GetObjectType());
+  EXPECT_FALSE(PythonString::Check(py_bytes));
+  EXPECT_EQ(PyObjectType::Bytes, python_bytes.GetObjectType());
 #endif
 
-    llvm::ArrayRef<uint8_t> bytes = python_bytes.GetBytes();
-    EXPECT_EQ(bytes.size(), strlen(test_bytes));
-    EXPECT_EQ(0, ::memcmp(bytes.data(), test_bytes, bytes.size()));
+  llvm::ArrayRef<uint8_t> bytes = python_bytes.GetBytes();
+  EXPECT_EQ(bytes.size(), strlen(test_bytes));
+  EXPECT_EQ(0, ::memcmp(bytes.data(), test_bytes, bytes.size()));
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonByteArray)
-{
-    static const char *test_bytes = "PythonDataObjectsTest::TestPythonByteArray";
-    llvm::StringRef orig_bytes(test_bytes);
-    PyObject *py_bytes = PyByteArray_FromStringAndSize(test_bytes, orig_bytes.size());
-    EXPECT_TRUE(PythonByteArray::Check(py_bytes));
-    PythonByteArray python_bytes(PyRefType::Owned, py_bytes);
-    EXPECT_EQ(PyObjectType::ByteArray, python_bytes.GetObjectType());
+TEST_F(PythonDataObjectsTest, TestPythonByteArray) {
+  static const char *test_bytes = "PythonDataObjectsTest::TestPythonByteArray";
+  llvm::StringRef orig_bytes(test_bytes);
+  PyObject *py_bytes =
+      PyByteArray_FromStringAndSize(test_bytes, orig_bytes.size());
+  EXPECT_TRUE(PythonByteArray::Check(py_bytes));
+  PythonByteArray python_bytes(PyRefType::Owned, py_bytes);
+  EXPECT_EQ(PyObjectType::ByteArray, python_bytes.GetObjectType());
 
-    llvm::ArrayRef<uint8_t> after_bytes = python_bytes.GetBytes();
-    EXPECT_EQ(after_bytes.size(), orig_bytes.size());
-    EXPECT_EQ(0, ::memcmp(orig_bytes.data(), test_bytes, orig_bytes.size()));
+  llvm::ArrayRef<uint8_t> after_bytes = python_bytes.GetBytes();
+  EXPECT_EQ(after_bytes.size(), orig_bytes.size());
+  EXPECT_EQ(0, ::memcmp(orig_bytes.data(), test_bytes, orig_bytes.size()));
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonString)
-{
-    // Test that strings behave correctly when wrapped by a PythonString.
+TEST_F(PythonDataObjectsTest, TestPythonString) {
+  // Test that strings behave correctly when wrapped by a PythonString.
 
-    static const char *test_string = "PythonDataObjectsTest::TestPythonString1";
-    static const char *test_string2 = "PythonDataObjectsTest::TestPythonString2";
+  static const char *test_string = "PythonDataObjectsTest::TestPythonString1";
+  static const char *test_string2 = "PythonDataObjectsTest::TestPythonString2";
 
 #if PY_MAJOR_VERSION < 3
-    // Verify that `PythonString` works correctly when given a PyString object.
-    // Note that PyString doesn't exist in Python 3.x, so this is only for 2.x
-    PyObject *py_string = PyString_FromString(test_string);
-    EXPECT_TRUE(PythonString::Check(py_string));
-    PythonString python_string(PyRefType::Owned, py_string);
-
-    EXPECT_EQ(PyObjectType::String, python_string.GetObjectType());
-    EXPECT_STREQ(test_string, python_string.GetString().data());
+  // Verify that `PythonString` works correctly when given a PyString object.
+  // Note that PyString doesn't exist in Python 3.x, so this is only for 2.x
+  PyObject *py_string = PyString_FromString(test_string);
+  EXPECT_TRUE(PythonString::Check(py_string));
+  PythonString python_string(PyRefType::Owned, py_string);
+
+  EXPECT_EQ(PyObjectType::String, python_string.GetObjectType());
+  EXPECT_STREQ(test_string, python_string.GetString().data());
 #else
-    // Verify that `PythonString` works correctly when given a PyUnicode object.
-    PyObject *py_unicode = PyUnicode_FromString(test_string);
-    EXPECT_TRUE(PythonString::Check(py_unicode));
-    PythonString python_unicode(PyRefType::Owned, py_unicode);
-    EXPECT_EQ(PyObjectType::String, python_unicode.GetObjectType());
-    EXPECT_STREQ(test_string, python_unicode.GetString().data());
+  // Verify that `PythonString` works correctly when given a PyUnicode object.
+  PyObject *py_unicode = PyUnicode_FromString(test_string);
+  EXPECT_TRUE(PythonString::Check(py_unicode));
+  PythonString python_unicode(PyRefType::Owned, py_unicode);
+  EXPECT_EQ(PyObjectType::String, python_unicode.GetObjectType());
+  EXPECT_STREQ(test_string, python_unicode.GetString().data());
 #endif
 
-    // Test that creating a `PythonString` object works correctly with the
-    // string constructor
-    PythonString constructed_string(test_string2);
-    EXPECT_STREQ(test_string2, constructed_string.GetString().str().c_str());
+  // Test that creating a `PythonString` object works correctly with the
+  // string constructor
+  PythonString constructed_string(test_string2);
+  EXPECT_STREQ(test_string2, constructed_string.GetString().str().c_str());
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonStringToStr)
-{
-    const char *c_str = "PythonDataObjectsTest::TestPythonStringToStr";
+TEST_F(PythonDataObjectsTest, TestPythonStringToStr) {
+  const char *c_str = "PythonDataObjectsTest::TestPythonStringToStr";
 
-    PythonString str(c_str);
-    EXPECT_STREQ(c_str, str.GetString().str().c_str());
+  PythonString str(c_str);
+  EXPECT_STREQ(c_str, str.GetString().str().c_str());
 
-    PythonString str_str = str.Str();
-    EXPECT_STREQ(c_str, str_str.GetString().str().c_str());
+  PythonString str_str = str.Str();
+  EXPECT_STREQ(c_str, str_str.GetString().str().c_str());
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonIntegerToStr)
-{
-}
+TEST_F(PythonDataObjectsTest, TestPythonIntegerToStr) {}
 
-TEST_F(PythonDataObjectsTest, TestPythonIntegerToStructuredInteger)
-{
-    PythonInteger integer(7);
-    auto int_sp = integer.CreateStructuredInteger();
-    EXPECT_EQ(7U, int_sp->GetValue());
+TEST_F(PythonDataObjectsTest, TestPythonIntegerToStructuredInteger) {
+  PythonInteger integer(7);
+  auto int_sp = integer.CreateStructuredInteger();
+  EXPECT_EQ(7U, int_sp->GetValue());
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonStringToStructuredString)
-{
-    static const char *test_string = "PythonDataObjectsTest::TestPythonStringToStructuredString";
-    PythonString constructed_string(test_string);
-    auto string_sp = constructed_string.CreateStructuredString();
-    EXPECT_STREQ(test_string, string_sp->GetStringValue().c_str());
+TEST_F(PythonDataObjectsTest, TestPythonStringToStructuredString) {
+  static const char *test_string =
+      "PythonDataObjectsTest::TestPythonStringToStructuredString";
+  PythonString constructed_string(test_string);
+  auto string_sp = constructed_string.CreateStructuredString();
+  EXPECT_STREQ(test_string, string_sp->GetStringValue().c_str());
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonListValueEquality)
-{
-    // Test that a list which is built through the native
-    // Python API behaves correctly when wrapped by a PythonList.
-    static const unsigned list_size = 2;
-    static const long long_value0 = 5;
-    static const char *const string_value1 = "String Index 1";
+TEST_F(PythonDataObjectsTest, TestPythonListValueEquality) {
+  // Test that a list which is built through the native
+  // Python API behaves correctly when wrapped by a PythonList.
+  static const unsigned list_size = 2;
+  static const long long_value0 = 5;
+  static const char *const string_value1 = "String Index 1";
 
-    PyObject *py_list = PyList_New(2);
-    EXPECT_TRUE(PythonList::Check(py_list));
-    PythonList list(PyRefType::Owned, py_list);
+  PyObject *py_list = PyList_New(2);
+  EXPECT_TRUE(PythonList::Check(py_list));
+  PythonList list(PyRefType::Owned, py_list);
 
-    PythonObject list_items[list_size];
-    list_items[0].Reset(PythonInteger(long_value0));
-    list_items[1].Reset(PythonString(string_value1));
+  PythonObject list_items[list_size];
+  list_items[0].Reset(PythonInteger(long_value0));
+  list_items[1].Reset(PythonString(string_value1));
 
-    for (unsigned i = 0; i < list_size; ++i)
-        list.SetItemAtIndex(i, list_items[i]);
+  for (unsigned i = 0; i < list_size; ++i)
+    list.SetItemAtIndex(i, list_items[i]);
 
-    EXPECT_EQ(list_size, list.GetSize());
-    EXPECT_EQ(PyObjectType::List, list.GetObjectType());
+  EXPECT_EQ(list_size, list.GetSize());
+  EXPECT_EQ(PyObjectType::List, list.GetObjectType());
 
-    // Verify that the values match
-    PythonObject chk_value1 = list.GetItemAtIndex(0);
-    PythonObject chk_value2 = list.GetItemAtIndex(1);
-    EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
-    EXPECT_TRUE(PythonString::Check(chk_value2.get()));
+  // Verify that the values match
+  PythonObject chk_value1 = list.GetItemAtIndex(0);
+  PythonObject chk_value2 = list.GetItemAtIndex(1);
+  EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
+  EXPECT_TRUE(PythonString::Check(chk_value2.get()));
 
-    PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
-    PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
+  PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
+  PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
 
-    EXPECT_EQ(long_value0, chk_int.GetInteger());
-    EXPECT_STREQ(string_value1, chk_str.GetString().str().c_str());
+  EXPECT_EQ(long_value0, chk_int.GetInteger());
+  EXPECT_STREQ(string_value1, chk_str.GetString().str().c_str());
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonListManipulation)
-{
-    // Test that manipulation of a PythonList behaves correctly when
-    // wrapped by a PythonDictionary.
+TEST_F(PythonDataObjectsTest, TestPythonListManipulation) {
+  // Test that manipulation of a PythonList behaves correctly when
+  // wrapped by a PythonDictionary.
 
-    static const long long_value0 = 5;
-    static const char *const string_value1 = "String Index 1";
+  static const long long_value0 = 5;
+  static const char *const string_value1 = "String Index 1";
 
-    PythonList list(PyInitialValue::Empty);
-    PythonInteger integer(long_value0);
-    PythonString string(string_value1);
+  PythonList list(PyInitialValue::Empty);
+  PythonInteger integer(long_value0);
+  PythonString string(string_value1);
 
-    list.AppendItem(integer);
-    list.AppendItem(string);
-    EXPECT_EQ(2U, list.GetSize());
+  list.AppendItem(integer);
+  list.AppendItem(string);
+  EXPECT_EQ(2U, list.GetSize());
 
-    // Verify that the values match
-    PythonObject chk_value1 = list.GetItemAtIndex(0);
-    PythonObject chk_value2 = list.GetItemAtIndex(1);
-    EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
-    EXPECT_TRUE(PythonString::Check(chk_value2.get()));
+  // Verify that the values match
+  PythonObject chk_value1 = list.GetItemAtIndex(0);
+  PythonObject chk_value2 = list.GetItemAtIndex(1);
+  EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
+  EXPECT_TRUE(PythonString::Check(chk_value2.get()));
 
-    PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
-    PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
+  PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
+  PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
 
-    EXPECT_EQ(long_value0, chk_int.GetInteger());
-    EXPECT_STREQ(string_value1, chk_str.GetString().str().c_str());
+  EXPECT_EQ(long_value0, chk_int.GetInteger());
+  EXPECT_STREQ(string_value1, chk_str.GetString().str().c_str());
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonListToStructuredList)
-{
-    static const long long_value0 = 5;
-    static const char *const string_value1 = "String Index 1";
+TEST_F(PythonDataObjectsTest, TestPythonListToStructuredList) {
+  static const long long_value0 = 5;
+  static const char *const string_value1 = "String Index 1";
 
-    PythonList list(PyInitialValue::Empty);
-    list.AppendItem(PythonInteger(long_value0));
-    list.AppendItem(PythonString(string_value1));
+  PythonList list(PyInitialValue::Empty);
+  list.AppendItem(PythonInteger(long_value0));
+  list.AppendItem(PythonString(string_value1));
 
-    auto array_sp = list.CreateStructuredArray();
-    EXPECT_EQ(StructuredData::Type::eTypeInteger, array_sp->GetItemAtIndex(0)->GetType());
-    EXPECT_EQ(StructuredData::Type::eTypeString, array_sp->GetItemAtIndex(1)->GetType());
+  auto array_sp = list.CreateStructuredArray();
+  EXPECT_EQ(StructuredData::Type::eTypeInteger,
+            array_sp->GetItemAtIndex(0)->GetType());
+  EXPECT_EQ(StructuredData::Type::eTypeString,
+            array_sp->GetItemAtIndex(1)->GetType());
 
-    auto int_sp = array_sp->GetItemAtIndex(0)->GetAsInteger();
-    auto string_sp = array_sp->GetItemAtIndex(1)->GetAsString();
+  auto int_sp = array_sp->GetItemAtIndex(0)->GetAsInteger();
+  auto string_sp = array_sp->GetItemAtIndex(1)->GetAsString();
 
-    EXPECT_EQ(long_value0, long(int_sp->GetValue()));
-    EXPECT_STREQ(string_value1, string_sp->GetValue().c_str());
+  EXPECT_EQ(long_value0, long(int_sp->GetValue()));
+  EXPECT_STREQ(string_value1, string_sp->GetValue().c_str());
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonTupleSize)
-{
-    PythonTuple tuple(PyInitialValue::Empty);
-    EXPECT_EQ(0U, tuple.GetSize());
+TEST_F(PythonDataObjectsTest, TestPythonTupleSize) {
+  PythonTuple tuple(PyInitialValue::Empty);
+  EXPECT_EQ(0U, tuple.GetSize());
 
-    tuple = PythonTuple(3);
-    EXPECT_EQ(3U, tuple.GetSize());
+  tuple = PythonTuple(3);
+  EXPECT_EQ(3U, tuple.GetSize());
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonTupleValues)
-{
-    PythonTuple tuple(3);
+TEST_F(PythonDataObjectsTest, TestPythonTupleValues) {
+  PythonTuple tuple(3);
+
+  PythonInteger int_value(1);
+  PythonString string_value("Test");
+  PythonObject none_value(PyRefType::Borrowed, Py_None);
+
+  tuple.SetItemAtIndex(0, int_value);
+  tuple.SetItemAtIndex(1, string_value);
+  tuple.SetItemAtIndex(2, none_value);
 
-    PythonInteger int_value(1);
-    PythonString string_value("Test");
-    PythonObject none_value(PyRefType::Borrowed, Py_None);
+  EXPECT_EQ(tuple.GetItemAtIndex(0).get(), int_value.get());
+  EXPECT_EQ(tuple.GetItemAtIndex(1).get(), string_value.get());
+  EXPECT_EQ(tuple.GetItemAtIndex(2).get(), none_value.get());
+}
 
-    tuple.SetItemAtIndex(0, int_value);
-    tuple.SetItemAtIndex(1, string_value);
-    tuple.SetItemAtIndex(2, none_value);
+TEST_F(PythonDataObjectsTest, TestPythonTupleInitializerList) {
+  PythonInteger int_value(1);
+  PythonString string_value("Test");
+  PythonObject none_value(PyRefType::Borrowed, Py_None);
+  PythonTuple tuple{int_value, string_value, none_value};
+  EXPECT_EQ(3U, tuple.GetSize());
 
-    EXPECT_EQ(tuple.GetItemAtIndex(0).get(), int_value.get());
-    EXPECT_EQ(tuple.GetItemAtIndex(1).get(), string_value.get());
-    EXPECT_EQ(tuple.GetItemAtIndex(2).get(), none_value.get());
+  EXPECT_EQ(tuple.GetItemAtIndex(0).get(), int_value.get());
+  EXPECT_EQ(tuple.GetItemAtIndex(1).get(), string_value.get());
+  EXPECT_EQ(tuple.GetItemAtIndex(2).get(), none_value.get());
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonTupleInitializerList)
-{
-    PythonInteger int_value(1);
-    PythonString string_value("Test");
-    PythonObject none_value(PyRefType::Borrowed, Py_None);
-    PythonTuple tuple{ int_value, string_value, none_value };
-    EXPECT_EQ(3U, tuple.GetSize());
+TEST_F(PythonDataObjectsTest, TestPythonTupleInitializerList2) {
+  PythonInteger int_value(1);
+  PythonString string_value("Test");
+  PythonObject none_value(PyRefType::Borrowed, Py_None);
+
+  PythonTuple tuple{int_value.get(), string_value.get(), none_value.get()};
+  EXPECT_EQ(3U, tuple.GetSize());
 
-    EXPECT_EQ(tuple.GetItemAtIndex(0).get(), int_value.get());
-    EXPECT_EQ(tuple.GetItemAtIndex(1).get(), string_value.get());
-    EXPECT_EQ(tuple.GetItemAtIndex(2).get(), none_value.get());
+  EXPECT_EQ(tuple.GetItemAtIndex(0).get(), int_value.get());
+  EXPECT_EQ(tuple.GetItemAtIndex(1).get(), string_value.get());
+  EXPECT_EQ(tuple.GetItemAtIndex(2).get(), none_value.get());
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonTupleInitializerList2)
-{
-    PythonInteger int_value(1);
-    PythonString string_value("Test");
-    PythonObject none_value(PyRefType::Borrowed, Py_None);
+TEST_F(PythonDataObjectsTest, TestPythonTupleToStructuredList) {
+  PythonInteger int_value(1);
+  PythonString string_value("Test");
 
-    PythonTuple tuple{ int_value.get(), string_value.get(), none_value.get() };
-    EXPECT_EQ(3U, tuple.GetSize());
+  PythonTuple tuple{int_value.get(), string_value.get()};
 
-    EXPECT_EQ(tuple.GetItemAtIndex(0).get(), int_value.get());
-    EXPECT_EQ(tuple.GetItemAtIndex(1).get(), string_value.get());
-    EXPECT_EQ(tuple.GetItemAtIndex(2).get(), none_value.get());
+  auto array_sp = tuple.CreateStructuredArray();
+  EXPECT_EQ(tuple.GetSize(), array_sp->GetSize());
+  EXPECT_EQ(StructuredData::Type::eTypeInteger,
+            array_sp->GetItemAtIndex(0)->GetType());
+  EXPECT_EQ(StructuredData::Type::eTypeString,
+            array_sp->GetItemAtIndex(1)->GetType());
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonTupleToStructuredList)
-{
-    PythonInteger int_value(1);
-    PythonString string_value("Test");
+TEST_F(PythonDataObjectsTest, TestPythonDictionaryValueEquality) {
+  // Test that a dictionary which is built through the native
+  // Python API behaves correctly when wrapped by a PythonDictionary.
+  static const unsigned dict_entries = 2;
+  const char *key_0 = "Key 0";
+  int key_1 = 1;
+  const int value_0 = 0;
+  const char *value_1 = "Value 1";
+
+  PythonObject py_keys[dict_entries];
+  PythonObject py_values[dict_entries];
+
+  py_keys[0].Reset(PythonString(key_0));
+  py_keys[1].Reset(PythonInteger(key_1));
+  py_values[0].Reset(PythonInteger(value_0));
+  py_values[1].Reset(PythonString(value_1));
+
+  PyObject *py_dict = PyDict_New();
+  EXPECT_TRUE(PythonDictionary::Check(py_dict));
+  PythonDictionary dict(PyRefType::Owned, py_dict);
+
+  for (unsigned i = 0; i < dict_entries; ++i)
+    PyDict_SetItem(py_dict, py_keys[i].get(), py_values[i].get());
+  EXPECT_EQ(dict.GetSize(), dict_entries);
+  EXPECT_EQ(PyObjectType::Dictionary, dict.GetObjectType());
+
+  // Verify that the values match
+  PythonObject chk_value1 = dict.GetItemForKey(py_keys[0]);
+  PythonObject chk_value2 = dict.GetItemForKey(py_keys[1]);
+  EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
+  EXPECT_TRUE(PythonString::Check(chk_value2.get()));
 
-    PythonTuple tuple{ int_value.get(), string_value.get() };
+  PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
+  PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
 
-    auto array_sp = tuple.CreateStructuredArray();
-    EXPECT_EQ(tuple.GetSize(), array_sp->GetSize());
-    EXPECT_EQ(StructuredData::Type::eTypeInteger, array_sp->GetItemAtIndex(0)->GetType());
-    EXPECT_EQ(StructuredData::Type::eTypeString, array_sp->GetItemAtIndex(1)->GetType());
+  EXPECT_EQ(value_0, chk_int.GetInteger());
+  EXPECT_STREQ(value_1, chk_str.GetString().str().c_str());
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonDictionaryValueEquality)
-{
-    // Test that a dictionary which is built through the native
-    // Python API behaves correctly when wrapped by a PythonDictionary.
-    static const unsigned dict_entries = 2;
-    const char *key_0 = "Key 0";
-    int key_1 = 1;
-    const int value_0 = 0;
-    const char *value_1 = "Value 1";
+TEST_F(PythonDataObjectsTest, TestPythonDictionaryManipulation) {
+  // Test that manipulation of a dictionary behaves correctly when wrapped
+  // by a PythonDictionary.
+  static const unsigned dict_entries = 2;
 
-    PythonObject py_keys[dict_entries];
-    PythonObject py_values[dict_entries];
+  const char *const key_0 = "Key 0";
+  const char *const key_1 = "Key 1";
+  const long value_0 = 1;
+  const char *const value_1 = "Value 1";
 
-    py_keys[0].Reset(PythonString(key_0));
-    py_keys[1].Reset(PythonInteger(key_1));
-    py_values[0].Reset(PythonInteger(value_0));
-    py_values[1].Reset(PythonString(value_1));
+  PythonString keys[dict_entries];
+  PythonObject values[dict_entries];
 
-    PyObject *py_dict = PyDict_New();
-    EXPECT_TRUE(PythonDictionary::Check(py_dict));
-    PythonDictionary dict(PyRefType::Owned, py_dict);
+  keys[0].Reset(PythonString(key_0));
+  keys[1].Reset(PythonString(key_1));
+  values[0].Reset(PythonInteger(value_0));
+  values[1].Reset(PythonString(value_1));
 
-    for (unsigned i = 0; i < dict_entries; ++i)
-        PyDict_SetItem(py_dict, py_keys[i].get(), py_values[i].get());
-    EXPECT_EQ(dict.GetSize(), dict_entries);
-    EXPECT_EQ(PyObjectType::Dictionary, dict.GetObjectType());
+  PythonDictionary dict(PyInitialValue::Empty);
+  for (int i = 0; i < 2; ++i)
+    dict.SetItemForKey(keys[i], values[i]);
 
-    // Verify that the values match
-    PythonObject chk_value1 = dict.GetItemForKey(py_keys[0]);
-    PythonObject chk_value2 = dict.GetItemForKey(py_keys[1]);
-    EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
-    EXPECT_TRUE(PythonString::Check(chk_value2.get()));
+  EXPECT_EQ(dict_entries, dict.GetSize());
 
-    PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
-    PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
+  // Verify that the keys and values match
+  PythonObject chk_value1 = dict.GetItemForKey(keys[0]);
+  PythonObject chk_value2 = dict.GetItemForKey(keys[1]);
+  EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
+  EXPECT_TRUE(PythonString::Check(chk_value2.get()));
 
-    EXPECT_EQ(value_0, chk_int.GetInteger());
-    EXPECT_STREQ(value_1, chk_str.GetString().str().c_str());
+  PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
+  PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
+
+  EXPECT_EQ(value_0, chk_int.GetInteger());
+  EXPECT_STREQ(value_1, chk_str.GetString().str().c_str());
 }
 
-TEST_F(PythonDataObjectsTest, TestPythonDictionaryManipulation)
-{
-    // Test that manipulation of a dictionary behaves correctly when wrapped
-    // by a PythonDictionary.
-    static const unsigned dict_entries = 2;
+TEST_F(PythonDataObjectsTest, TestPythonDictionaryToStructuredDictionary) {
+  static const char *const string_key0 = "String Key 0";
+  static const char *const string_key1 = "String Key 1";
 
-    const char *const key_0 = "Key 0";
-    const char *const key_1 = "Key 1";
-    const long value_0 = 1;
-    const char *const value_1 = "Value 1";
+  static const char *const string_value0 = "String Value 0";
+  static const long int_value1 = 7;
 
-    PythonString keys[dict_entries];
-    PythonObject values[dict_entries];
+  PythonDictionary dict(PyInitialValue::Empty);
+  dict.SetItemForKey(PythonString(string_key0), PythonString(string_value0));
+  dict.SetItemForKey(PythonString(string_key1), PythonInteger(int_value1));
+
+  auto dict_sp = dict.CreateStructuredDictionary();
+  EXPECT_EQ(2U, dict_sp->GetSize());
 
-    keys[0].Reset(PythonString(key_0));
-    keys[1].Reset(PythonString(key_1));
-    values[0].Reset(PythonInteger(value_0));
-    values[1].Reset(PythonString(value_1));
+  EXPECT_TRUE(dict_sp->HasKey(string_key0));
+  EXPECT_TRUE(dict_sp->HasKey(string_key1));
+
+  auto string_sp = dict_sp->GetValueForKey(string_key0)->GetAsString();
+  auto int_sp = dict_sp->GetValueForKey(string_key1)->GetAsInteger();
+
+  EXPECT_STREQ(string_value0, string_sp->GetValue().c_str());
+  EXPECT_EQ(int_value1, long(int_sp->GetValue()));
+}
+
+TEST_F(PythonDataObjectsTest, TestPythonCallableCheck) {
+  PythonObject sys_exc_info = m_sys_module.ResolveName("exc_info");
+  PythonObject none(PyRefType::Borrowed, Py_None);
+
+  EXPECT_TRUE(PythonCallable::Check(sys_exc_info.get()));
+  EXPECT_FALSE(PythonCallable::Check(none.get()));
+}
 
-    PythonDictionary dict(PyInitialValue::Empty);
-    for (int i = 0; i < 2; ++i)
-        dict.SetItemForKey(keys[i], values[i]);
+TEST_F(PythonDataObjectsTest, TestPythonCallableInvoke) {
+  auto list = m_builtins_module.ResolveName("list").AsType<PythonCallable>();
+  PythonInteger one(1);
+  PythonString two("two");
+  PythonTuple three = {one, two};
 
-    EXPECT_EQ(dict_entries, dict.GetSize());
+  PythonTuple tuple_to_convert = {one, two, three};
+  PythonObject result = list({tuple_to_convert});
 
-    // Verify that the keys and values match
-    PythonObject chk_value1 = dict.GetItemForKey(keys[0]);
-    PythonObject chk_value2 = dict.GetItemForKey(keys[1]);
-    EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
-    EXPECT_TRUE(PythonString::Check(chk_value2.get()));
+  EXPECT_TRUE(PythonList::Check(result.get()));
+  auto list_result = result.AsType<PythonList>();
+  EXPECT_EQ(3U, list_result.GetSize());
+  EXPECT_EQ(one.get(), list_result.GetItemAtIndex(0).get());
+  EXPECT_EQ(two.get(), list_result.GetItemAtIndex(1).get());
+  EXPECT_EQ(three.get(), list_result.GetItemAtIndex(2).get());
+}
 
-    PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
-    PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
-
-    EXPECT_EQ(value_0, chk_int.GetInteger());
-    EXPECT_STREQ(value_1, chk_str.GetString().str().c_str());
-}
-
-TEST_F(PythonDataObjectsTest, TestPythonDictionaryToStructuredDictionary)
-{
-    static const char *const string_key0 = "String Key 0";
-    static const char *const string_key1 = "String Key 1";
-
-    static const char *const string_value0 = "String Value 0";
-    static const long int_value1 = 7;
-
-    PythonDictionary dict(PyInitialValue::Empty);
-    dict.SetItemForKey(PythonString(string_key0), PythonString(string_value0));
-    dict.SetItemForKey(PythonString(string_key1), PythonInteger(int_value1));
-
-    auto dict_sp = dict.CreateStructuredDictionary();
-    EXPECT_EQ(2U, dict_sp->GetSize());
-
-    EXPECT_TRUE(dict_sp->HasKey(string_key0));
-    EXPECT_TRUE(dict_sp->HasKey(string_key1));
-
-    auto string_sp = dict_sp->GetValueForKey(string_key0)->GetAsString();
-    auto int_sp = dict_sp->GetValueForKey(string_key1)->GetAsInteger();
-
-    EXPECT_STREQ(string_value0, string_sp->GetValue().c_str());
-    EXPECT_EQ(int_value1, long(int_sp->GetValue()));
-}
-
-TEST_F(PythonDataObjectsTest, TestPythonCallableCheck)
-{
-    PythonObject sys_exc_info = m_sys_module.ResolveName("exc_info");
-    PythonObject none(PyRefType::Borrowed, Py_None);
-
-    EXPECT_TRUE(PythonCallable::Check(sys_exc_info.get()));
-    EXPECT_FALSE(PythonCallable::Check(none.get()));
-}
-
-TEST_F(PythonDataObjectsTest, TestPythonCallableInvoke)
-{
-    auto list = m_builtins_module.ResolveName("list").AsType<PythonCallable>();
-    PythonInteger one(1);
-    PythonString two("two");
-    PythonTuple three = { one, two };
-
-    PythonTuple tuple_to_convert = { one, two, three };
-    PythonObject result = list({ tuple_to_convert });
-
-    EXPECT_TRUE(PythonList::Check(result.get()));
-    auto list_result = result.AsType<PythonList>();
-    EXPECT_EQ(3U, list_result.GetSize());
-    EXPECT_EQ(one.get(), list_result.GetItemAtIndex(0).get());
-    EXPECT_EQ(two.get(), list_result.GetItemAtIndex(1).get());
-    EXPECT_EQ(three.get(), list_result.GetItemAtIndex(2).get());
-}
-
-TEST_F(PythonDataObjectsTest, TestPythonFile)
-{
-    File file(FileSystem::DEV_NULL, File::eOpenOptionRead);
-    PythonFile py_file(file, "r");
-    EXPECT_TRUE(PythonFile::Check(py_file.get()));
+TEST_F(PythonDataObjectsTest, TestPythonFile) {
+  File file(FileSystem::DEV_NULL, File::eOpenOptionRead);
+  PythonFile py_file(file, "r");
+  EXPECT_TRUE(PythonFile::Check(py_file.get()));
 }
-
-TEST_F(PythonDataObjectsTest, TestObjectAttributes)
-{
-    PythonInteger py_int(42);
-    EXPECT_TRUE(py_int.HasAttribute("numerator"));
-    EXPECT_FALSE(py_int.HasAttribute("this_should_not_exist"));
-
-    PythonInteger numerator_attr = py_int.GetAttributeValue("numerator").AsType<PythonInteger>();
-    EXPECT_TRUE(numerator_attr.IsAllocated());
-    EXPECT_EQ(42, numerator_attr.GetInteger());
-}
-
-TEST_F(PythonDataObjectsTest, TestExtractingUInt64ThroughStructuredData)
-{
-    // Make up a custom dictionary with "sys" pointing to the `sys` module.
-    const char *key_name = "addr";
-    const uint64_t value = 0xf000000000000000ull;
-    PythonDictionary python_dict(PyInitialValue::Empty);
-    PythonInteger python_ull_value(PyRefType::Owned, PyLong_FromUnsignedLongLong(value));
-    python_dict.SetItemForKey(PythonString(key_name), python_ull_value);
-    StructuredData::ObjectSP structured_data_sp = python_dict.CreateStructuredObject();
-    EXPECT_TRUE((bool)structured_data_sp);
-    if (structured_data_sp)
-    {
-        StructuredData::Dictionary *structured_dict_ptr = structured_data_sp->GetAsDictionary();
-        EXPECT_TRUE(structured_dict_ptr != nullptr);
-        if (structured_dict_ptr)
-        {
-            StructuredData::ObjectSP structured_addr_value_sp = structured_dict_ptr->GetValueForKey(key_name);
-            EXPECT_TRUE((bool)structured_addr_value_sp);
-            const uint64_t extracted_value = structured_addr_value_sp->GetIntegerValue(123);
-            EXPECT_TRUE(extracted_value == value);
-        }
+
+TEST_F(PythonDataObjectsTest, TestObjectAttributes) {
+  PythonInteger py_int(42);
+  EXPECT_TRUE(py_int.HasAttribute("numerator"));
+  EXPECT_FALSE(py_int.HasAttribute("this_should_not_exist"));
+
+  PythonInteger numerator_attr =
+      py_int.GetAttributeValue("numerator").AsType<PythonInteger>();
+  EXPECT_TRUE(numerator_attr.IsAllocated());
+  EXPECT_EQ(42, numerator_attr.GetInteger());
+}
+
+TEST_F(PythonDataObjectsTest, TestExtractingUInt64ThroughStructuredData) {
+  // Make up a custom dictionary with "sys" pointing to the `sys` module.
+  const char *key_name = "addr";
+  const uint64_t value = 0xf000000000000000ull;
+  PythonDictionary python_dict(PyInitialValue::Empty);
+  PythonInteger python_ull_value(PyRefType::Owned,
+                                 PyLong_FromUnsignedLongLong(value));
+  python_dict.SetItemForKey(PythonString(key_name), python_ull_value);
+  StructuredData::ObjectSP structured_data_sp =
+      python_dict.CreateStructuredObject();
+  EXPECT_TRUE((bool)structured_data_sp);
+  if (structured_data_sp) {
+    StructuredData::Dictionary *structured_dict_ptr =
+        structured_data_sp->GetAsDictionary();
+    EXPECT_TRUE(structured_dict_ptr != nullptr);
+    if (structured_dict_ptr) {
+      StructuredData::ObjectSP structured_addr_value_sp =
+          structured_dict_ptr->GetValueForKey(key_name);
+      EXPECT_TRUE((bool)structured_addr_value_sp);
+      const uint64_t extracted_value =
+          structured_addr_value_sp->GetIntegerValue(123);
+      EXPECT_TRUE(extracted_value == value);
     }
+  }
 }
diff --git a/lldb/unittests/ScriptInterpreter/Python/PythonExceptionStateTests.cpp b/lldb/unittests/ScriptInterpreter/Python/PythonExceptionStateTests.cpp
index ddac220c795..523a07ee807 100644
--- a/lldb/unittests/ScriptInterpreter/Python/PythonExceptionStateTests.cpp
+++ b/lldb/unittests/ScriptInterpreter/Python/PythonExceptionStateTests.cpp
@@ -1,4 +1,5 @@
-//===-- PythonExceptionStateTest.cpp ------------------------------*- C++ -*-===//
+//===-- PythonExceptionStateTest.cpp ------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -9,166 +10,156 @@
 
 #include "gtest/gtest.h"
 
-#include "Plugins/ScriptInterpreter/Python/lldb-python.h"
 #include "Plugins/ScriptInterpreter/Python/PythonDataObjects.h"
 #include "Plugins/ScriptInterpreter/Python/PythonExceptionState.h"
 #include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
+#include "Plugins/ScriptInterpreter/Python/lldb-python.h"
 
 #include "PythonTestSuite.h"
 
 using namespace lldb_private;
 
-class PythonExceptionStateTest : public PythonTestSuite
-{
-  public:
-  protected:
-    void
-    RaiseException()
-    {
-        PyErr_SetString(PyExc_RuntimeError, "PythonExceptionStateTest test error");
-    }
+class PythonExceptionStateTest : public PythonTestSuite {
+public:
+protected:
+  void RaiseException() {
+    PyErr_SetString(PyExc_RuntimeError, "PythonExceptionStateTest test error");
+  }
 };
 
-TEST_F(PythonExceptionStateTest, TestExceptionStateChecking)
-{
-    PyErr_Clear();
-    EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
+TEST_F(PythonExceptionStateTest, TestExceptionStateChecking) {
+  PyErr_Clear();
+  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
 
-    RaiseException();
-    EXPECT_TRUE(PythonExceptionState::HasErrorOccurred());
+  RaiseException();
+  EXPECT_TRUE(PythonExceptionState::HasErrorOccurred());
 
-    PyErr_Clear();
+  PyErr_Clear();
 }
 
-TEST_F(PythonExceptionStateTest, TestAcquisitionSemantics)
-{
-    PyErr_Clear();
-    PythonExceptionState no_error(false);
-    EXPECT_FALSE(no_error.IsError());
-    EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-
-    PyErr_Clear();
-    RaiseException();
-    PythonExceptionState error(false);
-    EXPECT_TRUE(error.IsError());
-    EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-    error.Discard();
-
-    PyErr_Clear();
-    RaiseException();
-    error.Acquire(false);
-    EXPECT_TRUE(error.IsError());
-    EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-
-    PyErr_Clear();
+TEST_F(PythonExceptionStateTest, TestAcquisitionSemantics) {
+  PyErr_Clear();
+  PythonExceptionState no_error(false);
+  EXPECT_FALSE(no_error.IsError());
+  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
+
+  PyErr_Clear();
+  RaiseException();
+  PythonExceptionState error(false);
+  EXPECT_TRUE(error.IsError());
+  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
+  error.Discard();
+
+  PyErr_Clear();
+  RaiseException();
+  error.Acquire(false);
+  EXPECT_TRUE(error.IsError());
+  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
+
+  PyErr_Clear();
 }
 
-TEST_F(PythonExceptionStateTest, TestDiscardSemantics)
-{
-    PyErr_Clear();
+TEST_F(PythonExceptionStateTest, TestDiscardSemantics) {
+  PyErr_Clear();
 
-    // Test that discarding an exception does not restore the exception
-    // state even when auto-restore==true is set
-    RaiseException();
-    PythonExceptionState error(true);
-    EXPECT_TRUE(error.IsError());
-    EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
+  // Test that discarding an exception does not restore the exception
+  // state even when auto-restore==true is set
+  RaiseException();
+  PythonExceptionState error(true);
+  EXPECT_TRUE(error.IsError());
+  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
 
-    error.Discard();
-    EXPECT_FALSE(error.IsError());
-    EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
+  error.Discard();
+  EXPECT_FALSE(error.IsError());
+  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
 }
 
-TEST_F(PythonExceptionStateTest, TestResetSemantics)
-{
-    PyErr_Clear();
-
-    // Resetting when auto-restore is true should restore.
-    RaiseException();
-    PythonExceptionState error(true);
-    EXPECT_TRUE(error.IsError());
-    EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-    error.Reset();
-    EXPECT_FALSE(error.IsError());
-    EXPECT_TRUE(PythonExceptionState::HasErrorOccurred());
+TEST_F(PythonExceptionStateTest, TestResetSemantics) {
+  PyErr_Clear();
+
+  // Resetting when auto-restore is true should restore.
+  RaiseException();
+  PythonExceptionState error(true);
+  EXPECT_TRUE(error.IsError());
+  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
+  error.Reset();
+  EXPECT_FALSE(error.IsError());
+  EXPECT_TRUE(PythonExceptionState::HasErrorOccurred());
+
+  PyErr_Clear();
+
+  // Resetting when auto-restore is false should discard.
+  RaiseException();
+  PythonExceptionState error2(false);
+  EXPECT_TRUE(error2.IsError());
+  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
+  error2.Reset();
+  EXPECT_FALSE(error2.IsError());
+  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
+
+  PyErr_Clear();
+}
 
-    PyErr_Clear();
+TEST_F(PythonExceptionStateTest, TestManualRestoreSemantics) {
+  PyErr_Clear();
+  RaiseException();
+  PythonExceptionState error(false);
+  EXPECT_TRUE(error.IsError());
+  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
 
-    // Resetting when auto-restore is false should discard.
-    RaiseException();
-    PythonExceptionState error2(false);
-    EXPECT_TRUE(error2.IsError());
-    EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-    error2.Reset();
-    EXPECT_FALSE(error2.IsError());
-    EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
+  error.Restore();
+  EXPECT_FALSE(error.IsError());
+  EXPECT_TRUE(PythonExceptionState::HasErrorOccurred());
 
-    PyErr_Clear();
+  PyErr_Clear();
 }
 
-TEST_F(PythonExceptionStateTest, TestManualRestoreSemantics)
-{
-    PyErr_Clear();
+TEST_F(PythonExceptionStateTest, TestAutoRestoreSemantics) {
+  PyErr_Clear();
+  // Test that using the auto-restore flag correctly restores the exception
+  // state on destruction, and not using the auto-restore flag correctly
+  // does NOT restore the state on destruction.
+  {
     RaiseException();
     PythonExceptionState error(false);
     EXPECT_TRUE(error.IsError());
     EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
+  }
+  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
 
-    error.Restore();
-    EXPECT_FALSE(error.IsError());
-    EXPECT_TRUE(PythonExceptionState::HasErrorOccurred());
-
-    PyErr_Clear();
-}
-
-TEST_F(PythonExceptionStateTest, TestAutoRestoreSemantics)
-{
-    PyErr_Clear();
-    // Test that using the auto-restore flag correctly restores the exception
-    // state on destruction, and not using the auto-restore flag correctly
-    // does NOT restore the state on destruction.
-    {
-        RaiseException();
-        PythonExceptionState error(false);
-        EXPECT_TRUE(error.IsError());
-        EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-    }
+  PyErr_Clear();
+  {
+    RaiseException();
+    PythonExceptionState error(true);
+    EXPECT_TRUE(error.IsError());
     EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
+  }
+  EXPECT_TRUE(PythonExceptionState::HasErrorOccurred());
 
-    PyErr_Clear();
-    {
-        RaiseException();
-        PythonExceptionState error(true);
-        EXPECT_TRUE(error.IsError());
-        EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
-    }
-    EXPECT_TRUE(PythonExceptionState::HasErrorOccurred());
-
-    PyErr_Clear();
+  PyErr_Clear();
 }
 
-TEST_F(PythonExceptionStateTest, TestAutoRestoreChanged)
-{
-    // Test that if we re-acquire with different auto-restore semantics,
-    // that the new semantics are respected.
-    PyErr_Clear();
+TEST_F(PythonExceptionStateTest, TestAutoRestoreChanged) {
+  // Test that if we re-acquire with different auto-restore semantics,
+  // that the new semantics are respected.
+  PyErr_Clear();
 
-    RaiseException();
-    PythonExceptionState error(false);
-    EXPECT_TRUE(error.IsError());
+  RaiseException();
+  PythonExceptionState error(false);
+  EXPECT_TRUE(error.IsError());
 
-    error.Reset();
-    EXPECT_FALSE(error.IsError());
-    EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
+  error.Reset();
+  EXPECT_FALSE(error.IsError());
+  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
 
-    RaiseException();
-    error.Acquire(true);
-    EXPECT_TRUE(error.IsError());
-    EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
+  RaiseException();
+  error.Acquire(true);
+  EXPECT_TRUE(error.IsError());
+  EXPECT_FALSE(PythonExceptionState::HasErrorOccurred());
 
-    error.Reset();
-    EXPECT_FALSE(error.IsError());
-    EXPECT_TRUE(PythonExceptionState::HasErrorOccurred());
+  error.Reset();
+  EXPECT_FALSE(error.IsError());
+  EXPECT_TRUE(PythonExceptionState::HasErrorOccurred());
 
-    PyErr_Clear();
+  PyErr_Clear();
 }
diff --git a/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp b/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp
index 0f75bf28131..608f3ee45e5 100644
--- a/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp
+++ b/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp
@@ -7,37 +7,33 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "gtest/gtest.h"
 #include "Plugins/ScriptInterpreter/Python/lldb-python.h"
+#include "gtest/gtest.h"
 
-#include "lldb/Host/HostInfo.h"
 #include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
+#include "lldb/Host/HostInfo.h"
 
 #include "PythonTestSuite.h"
 
 using namespace lldb_private;
 
-void
-PythonTestSuite::SetUp()
-{
-    HostInfoBase::Initialize();
-    // ScriptInterpreterPython::Initialize() depends on HostInfo being
-    // initializedso it can compute the python directory etc.
-    ScriptInterpreterPython::Initialize();
-    ScriptInterpreterPython::InitializePrivate();
-
-    // Although we don't care about concurrency for the purposes of running
-    // this test suite, Python requires the GIL to be locked even for
-    // deallocating memory, which can happen when you call Py_DECREF or
-    // Py_INCREF.  So acquire the GIL for the entire duration of this
-    // test suite.
-    m_gil_state = PyGILState_Ensure();
+void PythonTestSuite::SetUp() {
+  HostInfoBase::Initialize();
+  // ScriptInterpreterPython::Initialize() depends on HostInfo being
+  // initializedso it can compute the python directory etc.
+  ScriptInterpreterPython::Initialize();
+  ScriptInterpreterPython::InitializePrivate();
+
+  // Although we don't care about concurrency for the purposes of running
+  // this test suite, Python requires the GIL to be locked even for
+  // deallocating memory, which can happen when you call Py_DECREF or
+  // Py_INCREF.  So acquire the GIL for the entire duration of this
+  // test suite.
+  m_gil_state = PyGILState_Ensure();
 }
 
-void
-PythonTestSuite::TearDown()
-{
-    PyGILState_Release(m_gil_state);
+void PythonTestSuite::TearDown() {
+  PyGILState_Release(m_gil_state);
 
-    ScriptInterpreterPython::Terminate();
+  ScriptInterpreterPython::Terminate();
 }
diff --git a/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.h b/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.h
index 461fc1d5676..ad0478875be 100644
--- a/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.h
+++ b/lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.h
@@ -11,16 +11,12 @@
 
 using namespace lldb_private;
 
-class PythonTestSuite : public testing::Test
-{
+class PythonTestSuite : public testing::Test {
 public:
-    void
-    SetUp() override;
+  void SetUp() override;
 
-    void
-    TearDown() override;
+  void TearDown() override;
 
 private:
-    PyGILState_STATE m_gil_state;
+  PyGILState_STATE m_gil_state;
 };
-
diff --git a/lldb/unittests/Symbol/TestClangASTContext.cpp b/lldb/unittests/Symbol/TestClangASTContext.cpp
index 3f166ab9cc7..e1bd3a63fd5 100644
--- a/lldb/unittests/Symbol/TestClangASTContext.cpp
+++ b/lldb/unittests/Symbol/TestClangASTContext.cpp
@@ -1,4 +1,5 @@
-//===-- TestClangASTContext.cpp ---------------------------------------*- C++ -*-===//
+//===-- TestClangASTContext.cpp ---------------------------------------*- C++
+//-*-===//
 
 //
 //                     The LLVM Compiler Infrastructure
@@ -20,296 +21,358 @@ using namespace clang;
 using namespace lldb;
 using namespace lldb_private;
 
-class TestClangASTContext : public testing::Test
-{
+class TestClangASTContext : public testing::Test {
 public:
-    static void
-    SetUpTestCase()
-    {
-        HostInfo::Initialize();
-    }
-
-    static void
-    TearDownTestCase()
-    {
-        HostInfo::Terminate();
-    }
-
-    virtual void
-    SetUp() override
-    {
-        std::string triple = HostInfo::GetTargetTriple();
-        m_ast.reset(new ClangASTContext(triple.c_str()));
-    }
-
-    virtual void
-    TearDown() override
-    {
-        m_ast.reset();
-    }
+  static void SetUpTestCase() { HostInfo::Initialize(); }
+
+  static void TearDownTestCase() { HostInfo::Terminate(); }
+
+  virtual void SetUp() override {
+    std::string triple = HostInfo::GetTargetTriple();
+    m_ast.reset(new ClangASTContext(triple.c_str()));
+  }
+
+  virtual void TearDown() override { m_ast.reset(); }
 
 protected:
-    std::unique_ptr<ClangASTContext> m_ast;
-
-    QualType
-    GetBasicQualType(BasicType type) const
-    {
-        return ClangUtil::GetQualType(m_ast->GetBasicTypeFromAST(type));
-    }
-
-    QualType
-    GetBasicQualType(const char *name) const
-    {
-        return ClangUtil::GetQualType(m_ast->GetBuiltinTypeByName(ConstString(name)));
-    }
+  std::unique_ptr<ClangASTContext> m_ast;
+
+  QualType GetBasicQualType(BasicType type) const {
+    return ClangUtil::GetQualType(m_ast->GetBasicTypeFromAST(type));
+  }
+
+  QualType GetBasicQualType(const char *name) const {
+    return ClangUtil::GetQualType(
+        m_ast->GetBuiltinTypeByName(ConstString(name)));
+  }
 };
 
-TEST_F(TestClangASTContext, TestGetBasicTypeFromEnum)
-{
-    clang::ASTContext *context = m_ast->getASTContext();
-
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeBool), context->BoolTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeChar), context->CharTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeChar16), context->Char16Ty));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeChar32), context->Char32Ty));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeDouble), context->DoubleTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeDoubleComplex), context->DoubleComplexTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeFloat), context->FloatTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeFloatComplex), context->FloatComplexTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeHalf), context->HalfTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeInt), context->IntTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeInt128), context->Int128Ty));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeLong), context->LongTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeLongDouble), context->LongDoubleTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeLongDoubleComplex), context->LongDoubleComplexTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeLongLong), context->LongLongTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeNullPtr), context->NullPtrTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeObjCClass), context->getObjCClassType()));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeObjCID), context->getObjCIdType()));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeObjCSel), context->getObjCSelType()));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeShort), context->ShortTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeSignedChar), context->SignedCharTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedChar), context->UnsignedCharTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedInt), context->UnsignedIntTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedInt128), context->UnsignedInt128Ty));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedLong), context->UnsignedLongTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedLongLong), context->UnsignedLongLongTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedShort), context->UnsignedShortTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeVoid), context->VoidTy));
-    EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeWChar), context->WCharTy));
+TEST_F(TestClangASTContext, TestGetBasicTypeFromEnum) {
+  clang::ASTContext *context = m_ast->getASTContext();
+
+  EXPECT_TRUE(
+      context->hasSameType(GetBasicQualType(eBasicTypeBool), context->BoolTy));
+  EXPECT_TRUE(
+      context->hasSameType(GetBasicQualType(eBasicTypeChar), context->CharTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeChar16),
+                                   context->Char16Ty));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeChar32),
+                                   context->Char32Ty));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeDouble),
+                                   context->DoubleTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeDoubleComplex),
+                                   context->DoubleComplexTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeFloat),
+                                   context->FloatTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeFloatComplex),
+                                   context->FloatComplexTy));
+  EXPECT_TRUE(
+      context->hasSameType(GetBasicQualType(eBasicTypeHalf), context->HalfTy));
+  EXPECT_TRUE(
+      context->hasSameType(GetBasicQualType(eBasicTypeInt), context->IntTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeInt128),
+                                   context->Int128Ty));
+  EXPECT_TRUE(
+      context->hasSameType(GetBasicQualType(eBasicTypeLong), context->LongTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeLongDouble),
+                                   context->LongDoubleTy));
+  EXPECT_TRUE(
+      context->hasSameType(GetBasicQualType(eBasicTypeLongDoubleComplex),
+                           context->LongDoubleComplexTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeLongLong),
+                                   context->LongLongTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeNullPtr),
+                                   context->NullPtrTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeObjCClass),
+                                   context->getObjCClassType()));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeObjCID),
+                                   context->getObjCIdType()));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeObjCSel),
+                                   context->getObjCSelType()));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeShort),
+                                   context->ShortTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeSignedChar),
+                                   context->SignedCharTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedChar),
+                                   context->UnsignedCharTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedInt),
+                                   context->UnsignedIntTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedInt128),
+                                   context->UnsignedInt128Ty));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedLong),
+                                   context->UnsignedLongTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedLongLong),
+                                   context->UnsignedLongLongTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeUnsignedShort),
+                                   context->UnsignedShortTy));
+  EXPECT_TRUE(
+      context->hasSameType(GetBasicQualType(eBasicTypeVoid), context->VoidTy));
+  EXPECT_TRUE(context->hasSameType(GetBasicQualType(eBasicTypeWChar),
+                                   context->WCharTy));
 }
 
-TEST_F(TestClangASTContext, TestGetBasicTypeFromName)
-{
-    EXPECT_EQ(GetBasicQualType(eBasicTypeChar), GetBasicQualType("char"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeSignedChar), GetBasicQualType("signed char"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedChar), GetBasicQualType("unsigned char"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeWChar), GetBasicQualType("wchar_t"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeSignedWChar), GetBasicQualType("signed wchar_t"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedWChar), GetBasicQualType("unsigned wchar_t"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeShort), GetBasicQualType("short"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeShort), GetBasicQualType("short int"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedShort), GetBasicQualType("unsigned short"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedShort), GetBasicQualType("unsigned short int"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeInt), GetBasicQualType("int"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeInt), GetBasicQualType("signed int"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedInt), GetBasicQualType("unsigned int"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedInt), GetBasicQualType("unsigned"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeLong), GetBasicQualType("long"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeLong), GetBasicQualType("long int"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedLong), GetBasicQualType("unsigned long"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedLong), GetBasicQualType("unsigned long int"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeLongLong), GetBasicQualType("long long"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeLongLong), GetBasicQualType("long long int"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedLongLong), GetBasicQualType("unsigned long long"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedLongLong), GetBasicQualType("unsigned long long int"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeInt128), GetBasicQualType("__int128_t"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedInt128), GetBasicQualType("__uint128_t"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeVoid), GetBasicQualType("void"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeBool), GetBasicQualType("bool"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeFloat), GetBasicQualType("float"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeDouble), GetBasicQualType("double"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeLongDouble), GetBasicQualType("long double"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeObjCID), GetBasicQualType("id"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeObjCSel), GetBasicQualType("SEL"));
-    EXPECT_EQ(GetBasicQualType(eBasicTypeNullPtr), GetBasicQualType("nullptr"));
+TEST_F(TestClangASTContext, TestGetBasicTypeFromName) {
+  EXPECT_EQ(GetBasicQualType(eBasicTypeChar), GetBasicQualType("char"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeSignedChar),
+            GetBasicQualType("signed char"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedChar),
+            GetBasicQualType("unsigned char"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeWChar), GetBasicQualType("wchar_t"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeSignedWChar),
+            GetBasicQualType("signed wchar_t"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedWChar),
+            GetBasicQualType("unsigned wchar_t"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeShort), GetBasicQualType("short"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeShort), GetBasicQualType("short int"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedShort),
+            GetBasicQualType("unsigned short"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedShort),
+            GetBasicQualType("unsigned short int"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeInt), GetBasicQualType("int"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeInt), GetBasicQualType("signed int"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedInt),
+            GetBasicQualType("unsigned int"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedInt),
+            GetBasicQualType("unsigned"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeLong), GetBasicQualType("long"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeLong), GetBasicQualType("long int"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedLong),
+            GetBasicQualType("unsigned long"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedLong),
+            GetBasicQualType("unsigned long int"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeLongLong),
+            GetBasicQualType("long long"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeLongLong),
+            GetBasicQualType("long long int"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedLongLong),
+            GetBasicQualType("unsigned long long"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedLongLong),
+            GetBasicQualType("unsigned long long int"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeInt128), GetBasicQualType("__int128_t"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeUnsignedInt128),
+            GetBasicQualType("__uint128_t"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeVoid), GetBasicQualType("void"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeBool), GetBasicQualType("bool"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeFloat), GetBasicQualType("float"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeDouble), GetBasicQualType("double"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeLongDouble),
+            GetBasicQualType("long double"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeObjCID), GetBasicQualType("id"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeObjCSel), GetBasicQualType("SEL"));
+  EXPECT_EQ(GetBasicQualType(eBasicTypeNullPtr), GetBasicQualType("nullptr"));
 }
 
-void
-VerifyEncodingAndBitSize(clang::ASTContext *context, lldb::Encoding encoding, int bit_size)
-{
-    CompilerType type = ClangASTContext::GetBuiltinTypeForEncodingAndBitSize(context, encoding, bit_size);
-    EXPECT_TRUE(type.IsValid());
-
-    QualType qtype = ClangUtil::GetQualType(type);
-    EXPECT_FALSE(qtype.isNull());
-    if (qtype.isNull())
-        return;
-
-    uint64_t actual_size = context->getTypeSize(qtype);
-    EXPECT_EQ(bit_size, actual_size);
-
-    const clang::Type *type_ptr = qtype.getTypePtr();
-    EXPECT_NE(nullptr, type_ptr);
-    if (!type_ptr)
-        return;
-
-    EXPECT_TRUE(type_ptr->isBuiltinType());
-    if (encoding == eEncodingSint)
-        EXPECT_TRUE(type_ptr->isSignedIntegerType());
-    else if (encoding == eEncodingUint)
-        EXPECT_TRUE(type_ptr->isUnsignedIntegerType());
-    else if (encoding == eEncodingIEEE754)
-        EXPECT_TRUE(type_ptr->isFloatingType());
+void VerifyEncodingAndBitSize(clang::ASTContext *context,
+                              lldb::Encoding encoding, int bit_size) {
+  CompilerType type = ClangASTContext::GetBuiltinTypeForEncodingAndBitSize(
+      context, encoding, bit_size);
+  EXPECT_TRUE(type.IsValid());
+
+  QualType qtype = ClangUtil::GetQualType(type);
+  EXPECT_FALSE(qtype.isNull());
+  if (qtype.isNull())
+    return;
+
+  uint64_t actual_size = context->getTypeSize(qtype);
+  EXPECT_EQ(bit_size, actual_size);
+
+  const clang::Type *type_ptr = qtype.getTypePtr();
+  EXPECT_NE(nullptr, type_ptr);
+  if (!type_ptr)
+    return;
+
+  EXPECT_TRUE(type_ptr->isBuiltinType());
+  if (encoding == eEncodingSint)
+    EXPECT_TRUE(type_ptr->isSignedIntegerType());
+  else if (encoding == eEncodingUint)
+    EXPECT_TRUE(type_ptr->isUnsignedIntegerType());
+  else if (encoding == eEncodingIEEE754)
+    EXPECT_TRUE(type_ptr->isFloatingType());
 }
 
-TEST_F(TestClangASTContext, TestBuiltinTypeForEncodingAndBitSize)
-{
-    clang::ASTContext *context = m_ast->getASTContext();
-
-    // Make sure we can get types of every possible size in every possible encoding.
-    // We can't make any guarantee about which specific type we get, because the standard
-    // isn't that specific.  We only need to make sure the compiler hands us some type that
-    // is both a builtin type and matches the requested bit size.
-    VerifyEncodingAndBitSize(context, eEncodingSint, 8);
-    VerifyEncodingAndBitSize(context, eEncodingSint, 16);
-    VerifyEncodingAndBitSize(context, eEncodingSint, 32);
-    VerifyEncodingAndBitSize(context, eEncodingSint, 64);
-    VerifyEncodingAndBitSize(context, eEncodingSint, 128);
-
-    VerifyEncodingAndBitSize(context, eEncodingUint, 8);
-    VerifyEncodingAndBitSize(context, eEncodingUint, 16);
-    VerifyEncodingAndBitSize(context, eEncodingUint, 32);
-    VerifyEncodingAndBitSize(context, eEncodingUint, 64);
-    VerifyEncodingAndBitSize(context, eEncodingUint, 128);
-
-    VerifyEncodingAndBitSize(context, eEncodingIEEE754, 32);
-    VerifyEncodingAndBitSize(context, eEncodingIEEE754, 64);
+TEST_F(TestClangASTContext, TestBuiltinTypeForEncodingAndBitSize) {
+  clang::ASTContext *context = m_ast->getASTContext();
+
+  // Make sure we can get types of every possible size in every possible
+  // encoding.
+  // We can't make any guarantee about which specific type we get, because the
+  // standard
+  // isn't that specific.  We only need to make sure the compiler hands us some
+  // type that
+  // is both a builtin type and matches the requested bit size.
+  VerifyEncodingAndBitSize(context, eEncodingSint, 8);
+  VerifyEncodingAndBitSize(context, eEncodingSint, 16);
+  VerifyEncodingAndBitSize(context, eEncodingSint, 32);
+  VerifyEncodingAndBitSize(context, eEncodingSint, 64);
+  VerifyEncodingAndBitSize(context, eEncodingSint, 128);
+
+  VerifyEncodingAndBitSize(context, eEncodingUint, 8);
+  VerifyEncodingAndBitSize(context, eEncodingUint, 16);
+  VerifyEncodingAndBitSize(context, eEncodingUint, 32);
+  VerifyEncodingAndBitSize(context, eEncodingUint, 64);
+  VerifyEncodingAndBitSize(context, eEncodingUint, 128);
+
+  VerifyEncodingAndBitSize(context, eEncodingIEEE754, 32);
+  VerifyEncodingAndBitSize(context, eEncodingIEEE754, 64);
 }
 
-TEST_F(TestClangASTContext, TestIsClangType)
-{
-    clang::ASTContext *context = m_ast->getASTContext();
-    lldb::opaque_compiler_type_t bool_ctype = ClangASTContext::GetOpaqueCompilerType(context, lldb::eBasicTypeBool);
-    CompilerType bool_type(m_ast.get(), bool_ctype);
-    CompilerType record_type = m_ast->CreateRecordType(nullptr, lldb::eAccessPublic, "FooRecord", clang::TTK_Struct,
-                                                       lldb::eLanguageTypeC_plus_plus, nullptr);
-    // Clang builtin type and record type should pass
-    EXPECT_TRUE(ClangUtil::IsClangType(bool_type));
-    EXPECT_TRUE(ClangUtil::IsClangType(record_type));
-
-    // Default constructed type should fail
-    EXPECT_FALSE(ClangUtil::IsClangType(CompilerType()));
-
-    // Go type should fail
-    GoASTContext go_ast;
-    CompilerType go_type(&go_ast, bool_ctype);
-    EXPECT_FALSE(ClangUtil::IsClangType(go_type));
+TEST_F(TestClangASTContext, TestIsClangType) {
+  clang::ASTContext *context = m_ast->getASTContext();
+  lldb::opaque_compiler_type_t bool_ctype =
+      ClangASTContext::GetOpaqueCompilerType(context, lldb::eBasicTypeBool);
+  CompilerType bool_type(m_ast.get(), bool_ctype);
+  CompilerType record_type = m_ast->CreateRecordType(
+      nullptr, lldb::eAccessPublic, "FooRecord", clang::TTK_Struct,
+      lldb::eLanguageTypeC_plus_plus, nullptr);
+  // Clang builtin type and record type should pass
+  EXPECT_TRUE(ClangUtil::IsClangType(bool_type));
+  EXPECT_TRUE(ClangUtil::IsClangType(record_type));
+
+  // Default constructed type should fail
+  EXPECT_FALSE(ClangUtil::IsClangType(CompilerType()));
+
+  // Go type should fail
+  GoASTContext go_ast;
+  CompilerType go_type(&go_ast, bool_ctype);
+  EXPECT_FALSE(ClangUtil::IsClangType(go_type));
 }
 
-TEST_F(TestClangASTContext, TestRemoveFastQualifiers)
-{
-    CompilerType record_type = m_ast->CreateRecordType(nullptr, lldb::eAccessPublic, "FooRecord", clang::TTK_Struct,
-                                                       lldb::eLanguageTypeC_plus_plus, nullptr);
-    QualType qt;
-
-    qt = ClangUtil::GetQualType(record_type);
-    EXPECT_EQ(0, qt.getLocalFastQualifiers());
-    record_type = record_type.AddConstModifier();
-    record_type = record_type.AddVolatileModifier();
-    record_type = record_type.AddRestrictModifier();
-    qt = ClangUtil::GetQualType(record_type);
-    EXPECT_NE(0, qt.getLocalFastQualifiers());
-    record_type = ClangUtil::RemoveFastQualifiers(record_type);
-    qt = ClangUtil::GetQualType(record_type);
-    EXPECT_EQ(0, qt.getLocalFastQualifiers());
+TEST_F(TestClangASTContext, TestRemoveFastQualifiers) {
+  CompilerType record_type = m_ast->CreateRecordType(
+      nullptr, lldb::eAccessPublic, "FooRecord", clang::TTK_Struct,
+      lldb::eLanguageTypeC_plus_plus, nullptr);
+  QualType qt;
+
+  qt = ClangUtil::GetQualType(record_type);
+  EXPECT_EQ(0, qt.getLocalFastQualifiers());
+  record_type = record_type.AddConstModifier();
+  record_type = record_type.AddVolatileModifier();
+  record_type = record_type.AddRestrictModifier();
+  qt = ClangUtil::GetQualType(record_type);
+  EXPECT_NE(0, qt.getLocalFastQualifiers());
+  record_type = ClangUtil::RemoveFastQualifiers(record_type);
+  qt = ClangUtil::GetQualType(record_type);
+  EXPECT_EQ(0, qt.getLocalFastQualifiers());
 }
 
-TEST_F(TestClangASTContext, TestConvertAccessTypeToAccessSpecifier)
-{
-    EXPECT_EQ(AS_none, ClangASTContext::ConvertAccessTypeToAccessSpecifier(eAccessNone));
-    EXPECT_EQ(AS_none, ClangASTContext::ConvertAccessTypeToAccessSpecifier(eAccessPackage));
-    EXPECT_EQ(AS_public, ClangASTContext::ConvertAccessTypeToAccessSpecifier(eAccessPublic));
-    EXPECT_EQ(AS_private, ClangASTContext::ConvertAccessTypeToAccessSpecifier(eAccessPrivate));
-    EXPECT_EQ(AS_protected, ClangASTContext::ConvertAccessTypeToAccessSpecifier(eAccessProtected));
+TEST_F(TestClangASTContext, TestConvertAccessTypeToAccessSpecifier) {
+  EXPECT_EQ(AS_none,
+            ClangASTContext::ConvertAccessTypeToAccessSpecifier(eAccessNone));
+  EXPECT_EQ(AS_none, ClangASTContext::ConvertAccessTypeToAccessSpecifier(
+                         eAccessPackage));
+  EXPECT_EQ(AS_public,
+            ClangASTContext::ConvertAccessTypeToAccessSpecifier(eAccessPublic));
+  EXPECT_EQ(AS_private, ClangASTContext::ConvertAccessTypeToAccessSpecifier(
+                            eAccessPrivate));
+  EXPECT_EQ(AS_protected, ClangASTContext::ConvertAccessTypeToAccessSpecifier(
+                              eAccessProtected));
 }
 
-TEST_F(TestClangASTContext, TestUnifyAccessSpecifiers)
-{
-    // Unifying two of the same type should return the same type
-    EXPECT_EQ(AS_public, ClangASTContext::UnifyAccessSpecifiers(AS_public, AS_public));
-    EXPECT_EQ(AS_private, ClangASTContext::UnifyAccessSpecifiers(AS_private, AS_private));
-    EXPECT_EQ(AS_protected, ClangASTContext::UnifyAccessSpecifiers(AS_protected, AS_protected));
-
-    // Otherwise the result should be the strictest of the two.
-    EXPECT_EQ(AS_private, ClangASTContext::UnifyAccessSpecifiers(AS_private, AS_public));
-    EXPECT_EQ(AS_private, ClangASTContext::UnifyAccessSpecifiers(AS_private, AS_protected));
-    EXPECT_EQ(AS_private, ClangASTContext::UnifyAccessSpecifiers(AS_public, AS_private));
-    EXPECT_EQ(AS_private, ClangASTContext::UnifyAccessSpecifiers(AS_protected, AS_private));
-    EXPECT_EQ(AS_protected, ClangASTContext::UnifyAccessSpecifiers(AS_protected, AS_public));
-    EXPECT_EQ(AS_protected, ClangASTContext::UnifyAccessSpecifiers(AS_public, AS_protected));
-
-    // None is stricter than everything (by convention)
-    EXPECT_EQ(AS_none, ClangASTContext::UnifyAccessSpecifiers(AS_none, AS_public));
-    EXPECT_EQ(AS_none, ClangASTContext::UnifyAccessSpecifiers(AS_none, AS_protected));
-    EXPECT_EQ(AS_none, ClangASTContext::UnifyAccessSpecifiers(AS_none, AS_private));
-    EXPECT_EQ(AS_none, ClangASTContext::UnifyAccessSpecifiers(AS_public, AS_none));
-    EXPECT_EQ(AS_none, ClangASTContext::UnifyAccessSpecifiers(AS_protected, AS_none));
-    EXPECT_EQ(AS_none, ClangASTContext::UnifyAccessSpecifiers(AS_private, AS_none));
+TEST_F(TestClangASTContext, TestUnifyAccessSpecifiers) {
+  // Unifying two of the same type should return the same type
+  EXPECT_EQ(AS_public,
+            ClangASTContext::UnifyAccessSpecifiers(AS_public, AS_public));
+  EXPECT_EQ(AS_private,
+            ClangASTContext::UnifyAccessSpecifiers(AS_private, AS_private));
+  EXPECT_EQ(AS_protected,
+            ClangASTContext::UnifyAccessSpecifiers(AS_protected, AS_protected));
+
+  // Otherwise the result should be the strictest of the two.
+  EXPECT_EQ(AS_private,
+            ClangASTContext::UnifyAccessSpecifiers(AS_private, AS_public));
+  EXPECT_EQ(AS_private,
+            ClangASTContext::UnifyAccessSpecifiers(AS_private, AS_protected));
+  EXPECT_EQ(AS_private,
+            ClangASTContext::UnifyAccessSpecifiers(AS_public, AS_private));
+  EXPECT_EQ(AS_private,
+            ClangASTContext::UnifyAccessSpecifiers(AS_protected, AS_private));
+  EXPECT_EQ(AS_protected,
+            ClangASTContext::UnifyAccessSpecifiers(AS_protected, AS_public));
+  EXPECT_EQ(AS_protected,
+            ClangASTContext::UnifyAccessSpecifiers(AS_public, AS_protected));
+
+  // None is stricter than everything (by convention)
+  EXPECT_EQ(AS_none,
+            ClangASTContext::UnifyAccessSpecifiers(AS_none, AS_public));
+  EXPECT_EQ(AS_none,
+            ClangASTContext::UnifyAccessSpecifiers(AS_none, AS_protected));
+  EXPECT_EQ(AS_none,
+            ClangASTContext::UnifyAccessSpecifiers(AS_none, AS_private));
+  EXPECT_EQ(AS_none,
+            ClangASTContext::UnifyAccessSpecifiers(AS_public, AS_none));
+  EXPECT_EQ(AS_none,
+            ClangASTContext::UnifyAccessSpecifiers(AS_protected, AS_none));
+  EXPECT_EQ(AS_none,
+            ClangASTContext::UnifyAccessSpecifiers(AS_private, AS_none));
 }
 
-TEST_F(TestClangASTContext, TestRecordHasFields)
-{
-    CompilerType int_type = ClangASTContext::GetBasicType(m_ast->getASTContext(), eBasicTypeInt);
-
-    // Test that a record with no fields returns false
-    CompilerType empty_base = m_ast->CreateRecordType(nullptr, lldb::eAccessPublic, "EmptyBase", clang::TTK_Struct,
-                                                      lldb::eLanguageTypeC_plus_plus, nullptr);
-    ClangASTContext::StartTagDeclarationDefinition(empty_base);
-    ClangASTContext::CompleteTagDeclarationDefinition(empty_base);
-
-    RecordDecl *empty_base_decl = ClangASTContext::GetAsRecordDecl(empty_base);
-    EXPECT_NE(nullptr, empty_base_decl);
-    EXPECT_FALSE(ClangASTContext::RecordHasFields(empty_base_decl));
-
-    // Test that a record with direct fields returns true
-    CompilerType non_empty_base = m_ast->CreateRecordType(nullptr, lldb::eAccessPublic, "NonEmptyBase",
-                                                          clang::TTK_Struct, lldb::eLanguageTypeC_plus_plus, nullptr);
-    ClangASTContext::StartTagDeclarationDefinition(non_empty_base);
-    FieldDecl *non_empty_base_field_decl =
-        m_ast->AddFieldToRecordType(non_empty_base, "MyField", int_type, eAccessPublic, 0);
-    ClangASTContext::CompleteTagDeclarationDefinition(non_empty_base);
-    RecordDecl *non_empty_base_decl = ClangASTContext::GetAsRecordDecl(non_empty_base);
-    EXPECT_NE(nullptr, non_empty_base_decl);
-    EXPECT_NE(nullptr, non_empty_base_field_decl);
-    EXPECT_TRUE(ClangASTContext::RecordHasFields(non_empty_base_decl));
-
-    // Test that a record with no direct fields, but fields in a base returns true
-    CompilerType empty_derived = m_ast->CreateRecordType(nullptr, lldb::eAccessPublic, "EmptyDerived",
-                                                         clang::TTK_Struct, lldb::eLanguageTypeC_plus_plus, nullptr);
-    ClangASTContext::StartTagDeclarationDefinition(empty_derived);
-    CXXBaseSpecifier *non_empty_base_spec =
-        m_ast->CreateBaseClassSpecifier(non_empty_base.GetOpaqueQualType(), lldb::eAccessPublic, false, false);
-    bool result = m_ast->SetBaseClassesForClassType(empty_derived.GetOpaqueQualType(), &non_empty_base_spec, 1);
-    ClangASTContext::CompleteTagDeclarationDefinition(empty_derived);
-    EXPECT_TRUE(result);
-    CXXRecordDecl *empty_derived_non_empty_base_cxx_decl = m_ast->GetAsCXXRecordDecl(empty_derived.GetOpaqueQualType());
-    RecordDecl *empty_derived_non_empty_base_decl = ClangASTContext::GetAsRecordDecl(empty_derived);
-    EXPECT_EQ(1, ClangASTContext::GetNumBaseClasses(empty_derived_non_empty_base_cxx_decl, false));
-    EXPECT_TRUE(ClangASTContext::RecordHasFields(empty_derived_non_empty_base_decl));
-
-    // Test that a record with no direct fields, but fields in a virtual base returns true
-    CompilerType empty_derived2 = m_ast->CreateRecordType(nullptr, lldb::eAccessPublic, "EmptyDerived2",
-                                                          clang::TTK_Struct, lldb::eLanguageTypeC_plus_plus, nullptr);
-    ClangASTContext::StartTagDeclarationDefinition(empty_derived2);
-    CXXBaseSpecifier *non_empty_vbase_spec =
-        m_ast->CreateBaseClassSpecifier(non_empty_base.GetOpaqueQualType(), lldb::eAccessPublic, true, false);
-    result = m_ast->SetBaseClassesForClassType(empty_derived2.GetOpaqueQualType(), &non_empty_vbase_spec, 1);
-    ClangASTContext::CompleteTagDeclarationDefinition(empty_derived2);
-    EXPECT_TRUE(result);
-    CXXRecordDecl *empty_derived_non_empty_vbase_cxx_decl =
-        m_ast->GetAsCXXRecordDecl(empty_derived2.GetOpaqueQualType());
-    RecordDecl *empty_derived_non_empty_vbase_decl = ClangASTContext::GetAsRecordDecl(empty_derived2);
-    EXPECT_EQ(1, ClangASTContext::GetNumBaseClasses(empty_derived_non_empty_vbase_cxx_decl, false));
-    EXPECT_TRUE(ClangASTContext::RecordHasFields(empty_derived_non_empty_vbase_decl));
+TEST_F(TestClangASTContext, TestRecordHasFields) {
+  CompilerType int_type =
+      ClangASTContext::GetBasicType(m_ast->getASTContext(), eBasicTypeInt);
+
+  // Test that a record with no fields returns false
+  CompilerType empty_base = m_ast->CreateRecordType(
+      nullptr, lldb::eAccessPublic, "EmptyBase", clang::TTK_Struct,
+      lldb::eLanguageTypeC_plus_plus, nullptr);
+  ClangASTContext::StartTagDeclarationDefinition(empty_base);
+  ClangASTContext::CompleteTagDeclarationDefinition(empty_base);
+
+  RecordDecl *empty_base_decl = ClangASTContext::GetAsRecordDecl(empty_base);
+  EXPECT_NE(nullptr, empty_base_decl);
+  EXPECT_FALSE(ClangASTContext::RecordHasFields(empty_base_decl));
+
+  // Test that a record with direct fields returns true
+  CompilerType non_empty_base = m_ast->CreateRecordType(
+      nullptr, lldb::eAccessPublic, "NonEmptyBase", clang::TTK_Struct,
+      lldb::eLanguageTypeC_plus_plus, nullptr);
+  ClangASTContext::StartTagDeclarationDefinition(non_empty_base);
+  FieldDecl *non_empty_base_field_decl = m_ast->AddFieldToRecordType(
+      non_empty_base, "MyField", int_type, eAccessPublic, 0);
+  ClangASTContext::CompleteTagDeclarationDefinition(non_empty_base);
+  RecordDecl *non_empty_base_decl =
+      ClangASTContext::GetAsRecordDecl(non_empty_base);
+  EXPECT_NE(nullptr, non_empty_base_decl);
+  EXPECT_NE(nullptr, non_empty_base_field_decl);
+  EXPECT_TRUE(ClangASTContext::RecordHasFields(non_empty_base_decl));
+
+  // Test that a record with no direct fields, but fields in a base returns true
+  CompilerType empty_derived = m_ast->CreateRecordType(
+      nullptr, lldb::eAccessPublic, "EmptyDerived", clang::TTK_Struct,
+      lldb::eLanguageTypeC_plus_plus, nullptr);
+  ClangASTContext::StartTagDeclarationDefinition(empty_derived);
+  CXXBaseSpecifier *non_empty_base_spec = m_ast->CreateBaseClassSpecifier(
+      non_empty_base.GetOpaqueQualType(), lldb::eAccessPublic, false, false);
+  bool result = m_ast->SetBaseClassesForClassType(
+      empty_derived.GetOpaqueQualType(), &non_empty_base_spec, 1);
+  ClangASTContext::CompleteTagDeclarationDefinition(empty_derived);
+  EXPECT_TRUE(result);
+  CXXRecordDecl *empty_derived_non_empty_base_cxx_decl =
+      m_ast->GetAsCXXRecordDecl(empty_derived.GetOpaqueQualType());
+  RecordDecl *empty_derived_non_empty_base_decl =
+      ClangASTContext::GetAsRecordDecl(empty_derived);
+  EXPECT_EQ(1, ClangASTContext::GetNumBaseClasses(
+                   empty_derived_non_empty_base_cxx_decl, false));
+  EXPECT_TRUE(
+      ClangASTContext::RecordHasFields(empty_derived_non_empty_base_decl));
+
+  // Test that a record with no direct fields, but fields in a virtual base
+  // returns true
+  CompilerType empty_derived2 = m_ast->CreateRecordType(
+      nullptr, lldb::eAccessPublic, "EmptyDerived2", clang::TTK_Struct,
+      lldb::eLanguageTypeC_plus_plus, nullptr);
+  ClangASTContext::StartTagDeclarationDefinition(empty_derived2);
+  CXXBaseSpecifier *non_empty_vbase_spec = m_ast->CreateBaseClassSpecifier(
+      non_empty_base.GetOpaqueQualType(), lldb::eAccessPublic, true, false);
+  result = m_ast->SetBaseClassesForClassType(empty_derived2.GetOpaqueQualType(),
+                                             &non_empty_vbase_spec, 1);
+  ClangASTContext::CompleteTagDeclarationDefinition(empty_derived2);
+  EXPECT_TRUE(result);
+  CXXRecordDecl *empty_derived_non_empty_vbase_cxx_decl =
+      m_ast->GetAsCXXRecordDecl(empty_derived2.GetOpaqueQualType());
+  RecordDecl *empty_derived_non_empty_vbase_decl =
+      ClangASTContext::GetAsRecordDecl(empty_derived2);
+  EXPECT_EQ(1, ClangASTContext::GetNumBaseClasses(
+                   empty_derived_non_empty_vbase_cxx_decl, false));
+  EXPECT_TRUE(
+      ClangASTContext::RecordHasFields(empty_derived_non_empty_vbase_decl));
 }
diff --git a/lldb/unittests/SymbolFile/PDB/Inputs/test-dwarf.cpp b/lldb/unittests/SymbolFile/PDB/Inputs/test-dwarf.cpp
index f86ff3d875b..a987e6a9a36 100644
--- a/lldb/unittests/SymbolFile/PDB/Inputs/test-dwarf.cpp
+++ b/lldb/unittests/SymbolFile/PDB/Inputs/test-dwarf.cpp
@@ -1,14 +1,6 @@
 // Compile with "cl /c /Zi /GR- test.cpp"
 // Link with "link test.obj /debug /nodefaultlib /entry:main /out:test.exe"
 
-int __cdecl _purecall(void)
-{
-    return 0;
-}
+int __cdecl _purecall(void) { return 0; }
 
-int
-main(int argc, char **argv)
-{
-
-    return 0;
-}
+int main(int argc, char **argv) { return 0; }
diff --git a/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb-alt.cpp b/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb-alt.cpp
index d36f15e53fb..33d7df0e4a8 100644
--- a/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb-alt.cpp
+++ b/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb-alt.cpp
@@ -1,9 +1,7 @@
 // Compile with "cl /c /Zi /GR- test-pdb-alt.cpp"
-// Link with "link test-pdb.obj test-pdb-alt.obj /debug /nodefaultlib /entry:main /out:test-pdb.exe"
+// Link with "link test-pdb.obj test-pdb-alt.obj /debug /nodefaultlib
+// /entry:main /out:test-pdb.exe"
 
 #include "test-pdb.h"
 
-int bar(int n)
-{
-    return n-1;
-}
+int bar(int n) { return n - 1; }
diff --git a/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb-nested.h b/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb-nested.h
index fc63b50d13c..d0a93d8f39e 100644
--- a/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb-nested.h
+++ b/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb-nested.h
@@ -1,9 +1,6 @@
 #ifndef TEST_PDB_NESTED_H
 #define TEST_PDB_NESTED_H
 
-inline int baz(int n)
-{
-    return n+1;
-}
+inline int baz(int n) { return n + 1; }
 
 #endif
\ No newline at end of file
diff --git a/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb-types.cpp b/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb-types.cpp
index 9639a3f4b72..89d69c12963 100644
--- a/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb-types.cpp
+++ b/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb-types.cpp
@@ -1,5 +1,6 @@
 // Compile with "cl /c /Zi /GR- /EHsc test-pdb-types.cpp"

-// Link with "link test-pdb-types.obj /debug /nodefaultlib /entry:main /out:test-pdb-types.exe"

+// Link with "link test-pdb-types.obj /debug /nodefaultlib /entry:main

+// /out:test-pdb-types.exe"

 

 using namespace std;

 

@@ -21,42 +22,29 @@ static const int sizeof_double = sizeof(double);
 static const int sizeof_bool = sizeof(bool);

 static const int sizeof_wchar = sizeof(wchar_t);

 

-enum Enum

-{

-    EValue1 = 1,

-    EValue2 = 2,

+enum Enum {

+  EValue1 = 1,

+  EValue2 = 2,

 };

 

-enum ShortEnum : short

-{

-    ESValue1 = 1,

-    ESValue2 = 2

-};

+enum ShortEnum : short { ESValue1 = 1, ESValue2 = 2 };

 

-namespace NS

-{

-class NSClass

-{

-    float f;

-    double d;

+namespace NS {

+class NSClass {

+  float f;

+  double d;

 };

 }

 

-class Class

-{

+class Class {

 public:

-    class NestedClass

-    {

-        Enum e;

-    };

-    ShortEnum se;

+  class NestedClass {

+    Enum e;

+  };

+  ShortEnum se;

 };

 

-int

-test_func(int a, int b)

-{

-    return a + b;

-}

+int test_func(int a, int b) { return a + b; }

 

 typedef Class ClassTypedef;

 typedef NS::NSClass NSClassTypedef;

@@ -71,16 +59,14 @@ static const int sizeof_ClassTypedef = sizeof(ClassTypedef);
 static const int sizeof_NSClassTypedef = sizeof(NSClassTypedef);

 static const int sizeof_GlobalArray = sizeof(GlobalArray);

 

-int

-main(int argc, char **argv)

-{

-    ShortEnum e1;

-    Enum e2;

-    Class c1;

-    Class::NestedClass c2;

-    NS::NSClass c3;

+int main(int argc, char **argv) {

+  ShortEnum e1;

+  Enum e2;

+  Class c1;

+  Class::NestedClass c2;

+  NS::NSClass c3;

 

-    ClassTypedef t1;

-    NSClassTypedef t2;

-    return test_func(1, 2);

+  ClassTypedef t1;

+  NSClassTypedef t2;

+  return test_func(1, 2);

 }

diff --git a/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb.cpp b/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb.cpp
index c9bf057cfbf..77956acd875 100644
--- a/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb.cpp
+++ b/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb.cpp
@@ -1,15 +1,9 @@
 // Compile with "cl /c /Zi /GR- test-pdb.cpp"
-// Link with "link test-pdb.obj /debug /nodefaultlib /entry:main /out:test-pdb.exe"
+// Link with "link test-pdb.obj /debug /nodefaultlib /entry:main
+// /out:test-pdb.exe"
 
 #include "test-pdb.h"
 
-int __cdecl _purecall(void)
-{
-    return 0;
-}
+int __cdecl _purecall(void) { return 0; }
 
-int
-main(int argc, char **argv)
-{
-    return foo(argc) + bar(argc);
-}
+int main(int argc, char **argv) { return foo(argc) + bar(argc); }
diff --git a/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb.h b/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb.h
index 273343bb03b..077d9d6b1fa 100644
--- a/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb.h
+++ b/lldb/unittests/SymbolFile/PDB/Inputs/test-pdb.h
@@ -5,9 +5,6 @@
 
 int bar(int n);
 
-inline int foo(int n)
-{
-    return baz(n)+1;
-}
+inline int foo(int n) { return baz(n) + 1; }
 
 #endif
\ No newline at end of file
diff --git a/lldb/unittests/SymbolFile/PDB/SymbolFilePDBTests.cpp b/lldb/unittests/SymbolFile/PDB/SymbolFilePDBTests.cpp
index b303ae7bac4..4d602516b49 100644
--- a/lldb/unittests/SymbolFile/PDB/SymbolFilePDBTests.cpp
+++ b/lldb/unittests/SymbolFile/PDB/SymbolFilePDBTests.cpp
@@ -42,126 +42,116 @@ extern const char *TestMainArgv0;
 
 using namespace lldb_private;
 
-class SymbolFilePDBTests : public testing::Test
-{
+class SymbolFilePDBTests : public testing::Test {
 public:
-    void
-    SetUp() override
-    {
+  void SetUp() override {
 // Initialize and TearDown the plugin every time, so we get a brand new
 // AST every time so that modifications to the AST from each test don't
 // leak into the next test.
 #if defined(_MSC_VER)
-        ::CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+    ::CoInitializeEx(nullptr, COINIT_MULTITHREADED);
 #endif
 
-        HostInfo::Initialize();
-        ObjectFilePECOFF::Initialize();
-        SymbolFileDWARF::Initialize();
-        ClangASTContext::Initialize();
-        SymbolFilePDB::Initialize();
-
-        llvm::StringRef exe_folder = llvm::sys::path::parent_path(TestMainArgv0);
-        llvm::SmallString<128> inputs_folder = exe_folder;
-        llvm::sys::path::append(inputs_folder, "Inputs");
-
-        m_pdb_test_exe = inputs_folder;
-        m_dwarf_test_exe = inputs_folder;
-        m_types_test_exe = inputs_folder;
-        llvm::sys::path::append(m_pdb_test_exe, "test-pdb.exe");
-        llvm::sys::path::append(m_dwarf_test_exe, "test-dwarf.exe");
-        llvm::sys::path::append(m_types_test_exe, "test-pdb-types.exe");
-    }
-
-    void
-    TearDown() override
-    {
-        SymbolFilePDB::Terminate();
-        ClangASTContext::Initialize();
-        SymbolFileDWARF::Terminate();
-        ObjectFilePECOFF::Terminate();
-        HostInfo::Terminate();
+    HostInfo::Initialize();
+    ObjectFilePECOFF::Initialize();
+    SymbolFileDWARF::Initialize();
+    ClangASTContext::Initialize();
+    SymbolFilePDB::Initialize();
+
+    llvm::StringRef exe_folder = llvm::sys::path::parent_path(TestMainArgv0);
+    llvm::SmallString<128> inputs_folder = exe_folder;
+    llvm::sys::path::append(inputs_folder, "Inputs");
+
+    m_pdb_test_exe = inputs_folder;
+    m_dwarf_test_exe = inputs_folder;
+    m_types_test_exe = inputs_folder;
+    llvm::sys::path::append(m_pdb_test_exe, "test-pdb.exe");
+    llvm::sys::path::append(m_dwarf_test_exe, "test-dwarf.exe");
+    llvm::sys::path::append(m_types_test_exe, "test-pdb-types.exe");
+  }
+
+  void TearDown() override {
+    SymbolFilePDB::Terminate();
+    ClangASTContext::Initialize();
+    SymbolFileDWARF::Terminate();
+    ObjectFilePECOFF::Terminate();
+    HostInfo::Terminate();
 
 #if defined(_MSC_VER)
-        ::CoUninitialize();
+    ::CoUninitialize();
 #endif
-    }
+  }
 
 protected:
-    llvm::SmallString<128> m_pdb_test_exe;
-    llvm::SmallString<128> m_dwarf_test_exe;
-    llvm::SmallString<128> m_types_test_exe;
-
-    bool
-    FileSpecMatchesAsBaseOrFull(const FileSpec &left, const FileSpec &right) const
-    {
-        // If the filenames don't match, the paths can't be equal
-        if (!left.FileEquals(right))
-            return false;
-        // If BOTH have a directory, also compare the directories.
-        if (left.GetDirectory() && right.GetDirectory())
-            return left.DirectoryEquals(right);
-
-        // If one has a directory but not the other, they match.
+  llvm::SmallString<128> m_pdb_test_exe;
+  llvm::SmallString<128> m_dwarf_test_exe;
+  llvm::SmallString<128> m_types_test_exe;
+
+  bool FileSpecMatchesAsBaseOrFull(const FileSpec &left,
+                                   const FileSpec &right) const {
+    // If the filenames don't match, the paths can't be equal
+    if (!left.FileEquals(right))
+      return false;
+    // If BOTH have a directory, also compare the directories.
+    if (left.GetDirectory() && right.GetDirectory())
+      return left.DirectoryEquals(right);
+
+    // If one has a directory but not the other, they match.
+    return true;
+  }
+
+  void VerifyLineEntry(lldb::ModuleSP module, const SymbolContext &sc,
+                       const FileSpec &spec, LineTable &lt, uint32_t line,
+                       lldb::addr_t addr) {
+    LineEntry entry;
+    Address address;
+    EXPECT_TRUE(module->ResolveFileAddress(addr, address));
+
+    EXPECT_TRUE(lt.FindLineEntryByAddress(address, entry));
+    EXPECT_EQ(line, entry.line);
+    EXPECT_EQ(address, entry.range.GetBaseAddress());
+
+    EXPECT_TRUE(FileSpecMatchesAsBaseOrFull(spec, entry.file));
+  }
+
+  bool ContainsCompileUnit(const SymbolContextList &sc_list,
+                           const FileSpec &spec) const {
+    for (size_t i = 0; i < sc_list.GetSize(); ++i) {
+      const SymbolContext &sc = sc_list[i];
+      if (FileSpecMatchesAsBaseOrFull(*sc.comp_unit, spec))
         return true;
     }
-
-    void
-    VerifyLineEntry(lldb::ModuleSP module, const SymbolContext &sc, const FileSpec &spec, LineTable &lt, uint32_t line,
-                    lldb::addr_t addr)
-    {
-        LineEntry entry;
-        Address address;
-        EXPECT_TRUE(module->ResolveFileAddress(addr, address));
-
-        EXPECT_TRUE(lt.FindLineEntryByAddress(address, entry));
-        EXPECT_EQ(line, entry.line);
-        EXPECT_EQ(address, entry.range.GetBaseAddress());
-
-        EXPECT_TRUE(FileSpecMatchesAsBaseOrFull(spec, entry.file));
-    }
-
-    bool
-    ContainsCompileUnit(const SymbolContextList &sc_list, const FileSpec &spec) const
-    {
-        for (size_t i = 0; i < sc_list.GetSize(); ++i)
-        {
-            const SymbolContext &sc = sc_list[i];
-            if (FileSpecMatchesAsBaseOrFull(*sc.comp_unit, spec))
-                return true;
-        }
-        return false;
-    }
-
-    int
-    GetGlobalConstantInteger(const llvm::pdb::IPDBSession &session, llvm::StringRef var) const
-    {
-        auto global = session.getGlobalScope();
-        auto results =
-            global->findChildren(llvm::pdb::PDB_SymType::Data, var, llvm::pdb::PDB_NameSearchFlags::NS_Default);
-        uint32_t count = results->getChildCount();
-        if (count == 0)
-            return -1;
-
-        auto item = results->getChildAtIndex(0);
-        auto symbol = llvm::dyn_cast<llvm::pdb::PDBSymbolData>(item.get());
-        if (!symbol)
-            return -1;
-        llvm::pdb::Variant value = symbol->getValue();
-        switch (value.Type)
-        {
-            case llvm::pdb::PDB_VariantType::Int16:
-                return value.Value.Int16;
-            case llvm::pdb::PDB_VariantType::Int32:
-                return value.Value.Int32;
-            case llvm::pdb::PDB_VariantType::UInt16:
-                return value.Value.UInt16;
-            case llvm::pdb::PDB_VariantType::UInt32:
-                return value.Value.UInt32;
-            default:
-                return 0;
-        }
+    return false;
+  }
+
+  int GetGlobalConstantInteger(const llvm::pdb::IPDBSession &session,
+                               llvm::StringRef var) const {
+    auto global = session.getGlobalScope();
+    auto results =
+        global->findChildren(llvm::pdb::PDB_SymType::Data, var,
+                             llvm::pdb::PDB_NameSearchFlags::NS_Default);
+    uint32_t count = results->getChildCount();
+    if (count == 0)
+      return -1;
+
+    auto item = results->getChildAtIndex(0);
+    auto symbol = llvm::dyn_cast<llvm::pdb::PDBSymbolData>(item.get());
+    if (!symbol)
+      return -1;
+    llvm::pdb::Variant value = symbol->getValue();
+    switch (value.Type) {
+    case llvm::pdb::PDB_VariantType::Int16:
+      return value.Value.Int16;
+    case llvm::pdb::PDB_VariantType::Int32:
+      return value.Value.Int32;
+    case llvm::pdb::PDB_VariantType::UInt16:
+      return value.Value.UInt16;
+    case llvm::pdb::PDB_VariantType::UInt32:
+      return value.Value.UInt32;
+    default:
+      return 0;
     }
+  }
 };
 
 #if defined(HAVE_DIA_SDK)
@@ -170,414 +160,443 @@ protected:
 #define REQUIRES_DIA_SDK(TestName) DISABLED_##TestName
 #endif
 
-TEST_F(SymbolFilePDBTests, TestAbilitiesForDWARF)
-{
-    // Test that when we have Dwarf debug info, SymbolFileDWARF is used.
-    FileSpec fspec(m_dwarf_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
-
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    EXPECT_NE(nullptr, plugin);
-    SymbolFile *symfile = plugin->GetSymbolFile();
-    EXPECT_NE(nullptr, symfile);
-    EXPECT_EQ(symfile->GetPluginName(), SymbolFileDWARF::GetPluginNameStatic());
-
-    uint32_t expected_abilities = SymbolFile::kAllAbilities;
-    EXPECT_EQ(expected_abilities, symfile->CalculateAbilities());
-}
+TEST_F(SymbolFilePDBTests, TestAbilitiesForDWARF) {
+  // Test that when we have Dwarf debug info, SymbolFileDWARF is used.
+  FileSpec fspec(m_dwarf_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestAbilitiesForPDB))
-{
-    // Test that when we have PDB debug info, SymbolFilePDB is used.
-    FileSpec fspec(m_pdb_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
-
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    EXPECT_NE(nullptr, plugin);
-    SymbolFile *symfile = plugin->GetSymbolFile();
-    EXPECT_NE(nullptr, symfile);
-    EXPECT_EQ(symfile->GetPluginName(), SymbolFilePDB::GetPluginNameStatic());
-
-    uint32_t expected_abilities = SymbolFile::CompileUnits | SymbolFile::LineTables;
-    EXPECT_EQ(expected_abilities, symfile->CalculateAbilities());
-}
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  EXPECT_NE(nullptr, plugin);
+  SymbolFile *symfile = plugin->GetSymbolFile();
+  EXPECT_NE(nullptr, symfile);
+  EXPECT_EQ(symfile->GetPluginName(), SymbolFileDWARF::GetPluginNameStatic());
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestResolveSymbolContextBasename))
-{
-    // Test that attempting to call ResolveSymbolContext with only a basename finds all full paths
-    // with the same basename
-    FileSpec fspec(m_pdb_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
-
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    EXPECT_NE(nullptr, plugin);
-    SymbolFile *symfile = plugin->GetSymbolFile();
-
-    FileSpec header_spec("test-pdb.cpp", false);
-    SymbolContextList sc_list;
-    uint32_t result_count = symfile->ResolveSymbolContext(header_spec, 0, false, lldb::eSymbolContextCompUnit, sc_list);
-    EXPECT_EQ(1u, result_count);
-    EXPECT_TRUE(ContainsCompileUnit(sc_list, header_spec));
+  uint32_t expected_abilities = SymbolFile::kAllAbilities;
+  EXPECT_EQ(expected_abilities, symfile->CalculateAbilities());
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestResolveSymbolContextFullPath))
-{
-    // Test that attempting to call ResolveSymbolContext with a full path only finds the one source
-    // file that matches the full path.
-    FileSpec fspec(m_pdb_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
-
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    EXPECT_NE(nullptr, plugin);
-    SymbolFile *symfile = plugin->GetSymbolFile();
-
-    FileSpec header_spec(R"spec(D:\src\llvm\tools\lldb\unittests\SymbolFile\PDB\Inputs\test-pdb.cpp)spec", false);
-    SymbolContextList sc_list;
-    uint32_t result_count = symfile->ResolveSymbolContext(header_spec, 0, false, lldb::eSymbolContextCompUnit, sc_list);
-    EXPECT_GE(1u, result_count);
-    EXPECT_TRUE(ContainsCompileUnit(sc_list, header_spec));
+TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestAbilitiesForPDB)) {
+  // Test that when we have PDB debug info, SymbolFilePDB is used.
+  FileSpec fspec(m_pdb_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  EXPECT_NE(nullptr, plugin);
+  SymbolFile *symfile = plugin->GetSymbolFile();
+  EXPECT_NE(nullptr, symfile);
+  EXPECT_EQ(symfile->GetPluginName(), SymbolFilePDB::GetPluginNameStatic());
+
+  uint32_t expected_abilities =
+      SymbolFile::CompileUnits | SymbolFile::LineTables;
+  EXPECT_EQ(expected_abilities, symfile->CalculateAbilities());
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestLookupOfHeaderFileWithInlines))
-{
-    // Test that when looking up a header file via ResolveSymbolContext (i.e. a file that was not by itself
-    // compiled, but only contributes to the combined code of other source files), a SymbolContext is returned
-    // for each compiland which has line contributions from the requested header.
-    FileSpec fspec(m_pdb_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
-
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    EXPECT_NE(nullptr, plugin);
-    SymbolFile *symfile = plugin->GetSymbolFile();
-
-    FileSpec header_specs[] = {FileSpec("test-pdb.h", false), FileSpec("test-pdb-nested.h", false)};
-    FileSpec main_cpp_spec("test-pdb.cpp", false);
-    FileSpec alt_cpp_spec("test-pdb-alt.cpp", false);
-    for (const auto &hspec : header_specs)
-    {
-        SymbolContextList sc_list;
-        uint32_t result_count = symfile->ResolveSymbolContext(hspec, 0, true, lldb::eSymbolContextCompUnit, sc_list);
-        EXPECT_EQ(2u, result_count);
-        EXPECT_TRUE(ContainsCompileUnit(sc_list, main_cpp_spec));
-        EXPECT_TRUE(ContainsCompileUnit(sc_list, alt_cpp_spec));
-    }
+TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestResolveSymbolContextBasename)) {
+  // Test that attempting to call ResolveSymbolContext with only a basename
+  // finds all full paths
+  // with the same basename
+  FileSpec fspec(m_pdb_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  EXPECT_NE(nullptr, plugin);
+  SymbolFile *symfile = plugin->GetSymbolFile();
+
+  FileSpec header_spec("test-pdb.cpp", false);
+  SymbolContextList sc_list;
+  uint32_t result_count = symfile->ResolveSymbolContext(
+      header_spec, 0, false, lldb::eSymbolContextCompUnit, sc_list);
+  EXPECT_EQ(1u, result_count);
+  EXPECT_TRUE(ContainsCompileUnit(sc_list, header_spec));
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestLookupOfHeaderFileWithNoInlines))
-{
-    // Test that when looking up a header file via ResolveSymbolContext (i.e. a file that was not by itself
-    // compiled, but only contributes to the combined code of other source files), that if check_inlines
-    // is false, no SymbolContexts are returned.
-    FileSpec fspec(m_pdb_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
-
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    EXPECT_NE(nullptr, plugin);
-    SymbolFile *symfile = plugin->GetSymbolFile();
-
-    FileSpec header_specs[] = {FileSpec("test-pdb.h", false), FileSpec("test-pdb-nested.h", false)};
-    for (const auto &hspec : header_specs)
-    {
-        SymbolContextList sc_list;
-        uint32_t result_count = symfile->ResolveSymbolContext(hspec, 0, false, lldb::eSymbolContextCompUnit, sc_list);
-        EXPECT_EQ(0u, result_count);
-    }
+TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestResolveSymbolContextFullPath)) {
+  // Test that attempting to call ResolveSymbolContext with a full path only
+  // finds the one source
+  // file that matches the full path.
+  FileSpec fspec(m_pdb_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  EXPECT_NE(nullptr, plugin);
+  SymbolFile *symfile = plugin->GetSymbolFile();
+
+  FileSpec header_spec(
+      R"spec(D:\src\llvm\tools\lldb\unittests\SymbolFile\PDB\Inputs\test-pdb.cpp)spec",
+      false);
+  SymbolContextList sc_list;
+  uint32_t result_count = symfile->ResolveSymbolContext(
+      header_spec, 0, false, lldb::eSymbolContextCompUnit, sc_list);
+  EXPECT_GE(1u, result_count);
+  EXPECT_TRUE(ContainsCompileUnit(sc_list, header_spec));
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestLineTablesMatchAll))
-{
-    // Test that when calling ResolveSymbolContext with a line number of 0, all line entries from
-    // the specified files are returned.
-    FileSpec fspec(m_pdb_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
-
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    SymbolFile *symfile = plugin->GetSymbolFile();
-
-    FileSpec source_file("test-pdb.cpp", false);
-    FileSpec header1("test-pdb.h", false);
-    FileSpec header2("test-pdb-nested.h", false);
-    uint32_t cus = symfile->GetNumCompileUnits();
-    EXPECT_EQ(2u, cus);
-
+TEST_F(SymbolFilePDBTests,
+       REQUIRES_DIA_SDK(TestLookupOfHeaderFileWithInlines)) {
+  // Test that when looking up a header file via ResolveSymbolContext (i.e. a
+  // file that was not by itself
+  // compiled, but only contributes to the combined code of other source files),
+  // a SymbolContext is returned
+  // for each compiland which has line contributions from the requested header.
+  FileSpec fspec(m_pdb_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  EXPECT_NE(nullptr, plugin);
+  SymbolFile *symfile = plugin->GetSymbolFile();
+
+  FileSpec header_specs[] = {FileSpec("test-pdb.h", false),
+                             FileSpec("test-pdb-nested.h", false)};
+  FileSpec main_cpp_spec("test-pdb.cpp", false);
+  FileSpec alt_cpp_spec("test-pdb-alt.cpp", false);
+  for (const auto &hspec : header_specs) {
     SymbolContextList sc_list;
-    uint32_t scope = lldb::eSymbolContextCompUnit | lldb::eSymbolContextLineEntry;
-
-    uint32_t count = symfile->ResolveSymbolContext(source_file, 0, true, scope, sc_list);
-    EXPECT_EQ(1u, count);
-    SymbolContext sc;
-    EXPECT_TRUE(sc_list.GetContextAtIndex(0, sc));
-
-    LineTable *lt = sc.comp_unit->GetLineTable();
-    EXPECT_NE(nullptr, lt);
-    count = lt->GetSize();
-    // We expect one extra entry for termination (per function)
-    EXPECT_EQ(16u, count);
-
-    VerifyLineEntry(module, sc, source_file, *lt, 7, 0x401040);
-    VerifyLineEntry(module, sc, source_file, *lt, 8, 0x401043);
-    VerifyLineEntry(module, sc, source_file, *lt, 9, 0x401045);
-
-    VerifyLineEntry(module, sc, source_file, *lt, 13, 0x401050);
-    VerifyLineEntry(module, sc, source_file, *lt, 14, 0x401054);
-    VerifyLineEntry(module, sc, source_file, *lt, 15, 0x401070);
-
-    VerifyLineEntry(module, sc, header1, *lt, 9, 0x401090);
-    VerifyLineEntry(module, sc, header1, *lt, 10, 0x401093);
-    VerifyLineEntry(module, sc, header1, *lt, 11, 0x4010a2);
-
-    VerifyLineEntry(module, sc, header2, *lt, 5, 0x401080);
-    VerifyLineEntry(module, sc, header2, *lt, 6, 0x401083);
-    VerifyLineEntry(module, sc, header2, *lt, 7, 0x401089);
+    uint32_t result_count = symfile->ResolveSymbolContext(
+        hspec, 0, true, lldb::eSymbolContextCompUnit, sc_list);
+    EXPECT_EQ(2u, result_count);
+    EXPECT_TRUE(ContainsCompileUnit(sc_list, main_cpp_spec));
+    EXPECT_TRUE(ContainsCompileUnit(sc_list, alt_cpp_spec));
+  }
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestLineTablesMatchSpecific))
-{
-    // Test that when calling ResolveSymbolContext with a specific line number, only line entries
-    // which match the requested line are returned.
-    FileSpec fspec(m_pdb_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
-
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    SymbolFile *symfile = plugin->GetSymbolFile();
-
-    FileSpec source_file("test-pdb.cpp", false);
-    FileSpec header1("test-pdb.h", false);
-    FileSpec header2("test-pdb-nested.h", false);
-    uint32_t cus = symfile->GetNumCompileUnits();
-    EXPECT_EQ(2u, cus);
-
+TEST_F(SymbolFilePDBTests,
+       REQUIRES_DIA_SDK(TestLookupOfHeaderFileWithNoInlines)) {
+  // Test that when looking up a header file via ResolveSymbolContext (i.e. a
+  // file that was not by itself
+  // compiled, but only contributes to the combined code of other source files),
+  // that if check_inlines
+  // is false, no SymbolContexts are returned.
+  FileSpec fspec(m_pdb_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  EXPECT_NE(nullptr, plugin);
+  SymbolFile *symfile = plugin->GetSymbolFile();
+
+  FileSpec header_specs[] = {FileSpec("test-pdb.h", false),
+                             FileSpec("test-pdb-nested.h", false)};
+  for (const auto &hspec : header_specs) {
     SymbolContextList sc_list;
-    uint32_t scope = lldb::eSymbolContextCompUnit | lldb::eSymbolContextLineEntry;
-
-    // First test with line 7, and verify that only line 7 entries are added.
-    uint32_t count = symfile->ResolveSymbolContext(source_file, 7, true, scope, sc_list);
-    EXPECT_EQ(1u, count);
-    SymbolContext sc;
-    EXPECT_TRUE(sc_list.GetContextAtIndex(0, sc));
-
-    LineTable *lt = sc.comp_unit->GetLineTable();
-    EXPECT_NE(nullptr, lt);
-    count = lt->GetSize();
-    // We expect one extra entry for termination
-    EXPECT_EQ(3u, count);
-
-    VerifyLineEntry(module, sc, source_file, *lt, 7, 0x401040);
-    VerifyLineEntry(module, sc, header2, *lt, 7, 0x401089);
-
-    sc_list.Clear();
-    // Then test with line 9, and verify that only line 9 entries are added.
-    count = symfile->ResolveSymbolContext(source_file, 9, true, scope, sc_list);
-    EXPECT_EQ(1u, count);
-    EXPECT_TRUE(sc_list.GetContextAtIndex(0, sc));
-
-    lt = sc.comp_unit->GetLineTable();
-    EXPECT_NE(nullptr, lt);
-    count = lt->GetSize();
-    // We expect one extra entry for termination
-    EXPECT_EQ(3u, count);
-
-    VerifyLineEntry(module, sc, source_file, *lt, 9, 0x401045);
-    VerifyLineEntry(module, sc, header1, *lt, 9, 0x401090);
+    uint32_t result_count = symfile->ResolveSymbolContext(
+        hspec, 0, false, lldb::eSymbolContextCompUnit, sc_list);
+    EXPECT_EQ(0u, result_count);
+  }
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestSimpleClassTypes))
-{
-    FileSpec fspec(m_types_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
-
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    SymbolFilePDB *symfile = static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
-    const llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
-    SymbolContext sc;
-    llvm::DenseSet<SymbolFile *> searched_files;
-    TypeMap results;
-    EXPECT_EQ(1u, symfile->FindTypes(sc, ConstString("Class"), nullptr, false, 0, searched_files, results));
-    EXPECT_EQ(1u, results.GetSize());
-    lldb::TypeSP udt_type = results.GetTypeAtIndex(0);
-    EXPECT_EQ(ConstString("Class"), udt_type->GetName());
-    CompilerType compiler_type = udt_type->GetForwardCompilerType();
-    EXPECT_TRUE(ClangASTContext::IsClassType(compiler_type.GetOpaqueQualType()));
-    EXPECT_EQ(uint64_t(GetGlobalConstantInteger(session, "sizeof_Class")), udt_type->GetByteSize());
+TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestLineTablesMatchAll)) {
+  // Test that when calling ResolveSymbolContext with a line number of 0, all
+  // line entries from
+  // the specified files are returned.
+  FileSpec fspec(m_pdb_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  SymbolFile *symfile = plugin->GetSymbolFile();
+
+  FileSpec source_file("test-pdb.cpp", false);
+  FileSpec header1("test-pdb.h", false);
+  FileSpec header2("test-pdb-nested.h", false);
+  uint32_t cus = symfile->GetNumCompileUnits();
+  EXPECT_EQ(2u, cus);
+
+  SymbolContextList sc_list;
+  uint32_t scope = lldb::eSymbolContextCompUnit | lldb::eSymbolContextLineEntry;
+
+  uint32_t count =
+      symfile->ResolveSymbolContext(source_file, 0, true, scope, sc_list);
+  EXPECT_EQ(1u, count);
+  SymbolContext sc;
+  EXPECT_TRUE(sc_list.GetContextAtIndex(0, sc));
+
+  LineTable *lt = sc.comp_unit->GetLineTable();
+  EXPECT_NE(nullptr, lt);
+  count = lt->GetSize();
+  // We expect one extra entry for termination (per function)
+  EXPECT_EQ(16u, count);
+
+  VerifyLineEntry(module, sc, source_file, *lt, 7, 0x401040);
+  VerifyLineEntry(module, sc, source_file, *lt, 8, 0x401043);
+  VerifyLineEntry(module, sc, source_file, *lt, 9, 0x401045);
+
+  VerifyLineEntry(module, sc, source_file, *lt, 13, 0x401050);
+  VerifyLineEntry(module, sc, source_file, *lt, 14, 0x401054);
+  VerifyLineEntry(module, sc, source_file, *lt, 15, 0x401070);
+
+  VerifyLineEntry(module, sc, header1, *lt, 9, 0x401090);
+  VerifyLineEntry(module, sc, header1, *lt, 10, 0x401093);
+  VerifyLineEntry(module, sc, header1, *lt, 11, 0x4010a2);
+
+  VerifyLineEntry(module, sc, header2, *lt, 5, 0x401080);
+  VerifyLineEntry(module, sc, header2, *lt, 6, 0x401083);
+  VerifyLineEntry(module, sc, header2, *lt, 7, 0x401089);
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestNestedClassTypes))
-{
-    FileSpec fspec(m_types_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
-
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    SymbolFilePDB *symfile = static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
-    const llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
-    SymbolContext sc;
-    llvm::DenseSet<SymbolFile *> searched_files;
-    TypeMap results;
-    EXPECT_EQ(1u, symfile->FindTypes(sc, ConstString("Class::NestedClass"), nullptr, false, 0, searched_files, results));
-    EXPECT_EQ(1u, results.GetSize());
-    lldb::TypeSP udt_type = results.GetTypeAtIndex(0);
-    EXPECT_EQ(ConstString("Class::NestedClass"), udt_type->GetName());
-    CompilerType compiler_type = udt_type->GetForwardCompilerType();
-    EXPECT_TRUE(ClangASTContext::IsClassType(compiler_type.GetOpaqueQualType()));
-    EXPECT_EQ(uint64_t(GetGlobalConstantInteger(session, "sizeof_NestedClass")), udt_type->GetByteSize());
-}
-
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestClassInNamespace))
-{
-    FileSpec fspec(m_types_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
-
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    SymbolFilePDB *symfile = static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
-    const llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
-    SymbolContext sc;
-    llvm::DenseSet<SymbolFile *> searched_files;
-    TypeMap results;
-    EXPECT_EQ(1u, symfile->FindTypes(sc, ConstString("NS::NSClass"), nullptr, false, 0, searched_files, results));
-    EXPECT_EQ(1u, results.GetSize());
-    lldb::TypeSP udt_type = results.GetTypeAtIndex(0);
-    EXPECT_EQ(ConstString("NS::NSClass"), udt_type->GetName());
-    CompilerType compiler_type = udt_type->GetForwardCompilerType();
-    EXPECT_TRUE(ClangASTContext::IsClassType(compiler_type.GetOpaqueQualType()));
-    EXPECT_EQ(GetGlobalConstantInteger(session, "sizeof_NSClass"), udt_type->GetByteSize());
+TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestLineTablesMatchSpecific)) {
+  // Test that when calling ResolveSymbolContext with a specific line number,
+  // only line entries
+  // which match the requested line are returned.
+  FileSpec fspec(m_pdb_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  SymbolFile *symfile = plugin->GetSymbolFile();
+
+  FileSpec source_file("test-pdb.cpp", false);
+  FileSpec header1("test-pdb.h", false);
+  FileSpec header2("test-pdb-nested.h", false);
+  uint32_t cus = symfile->GetNumCompileUnits();
+  EXPECT_EQ(2u, cus);
+
+  SymbolContextList sc_list;
+  uint32_t scope = lldb::eSymbolContextCompUnit | lldb::eSymbolContextLineEntry;
+
+  // First test with line 7, and verify that only line 7 entries are added.
+  uint32_t count =
+      symfile->ResolveSymbolContext(source_file, 7, true, scope, sc_list);
+  EXPECT_EQ(1u, count);
+  SymbolContext sc;
+  EXPECT_TRUE(sc_list.GetContextAtIndex(0, sc));
+
+  LineTable *lt = sc.comp_unit->GetLineTable();
+  EXPECT_NE(nullptr, lt);
+  count = lt->GetSize();
+  // We expect one extra entry for termination
+  EXPECT_EQ(3u, count);
+
+  VerifyLineEntry(module, sc, source_file, *lt, 7, 0x401040);
+  VerifyLineEntry(module, sc, header2, *lt, 7, 0x401089);
+
+  sc_list.Clear();
+  // Then test with line 9, and verify that only line 9 entries are added.
+  count = symfile->ResolveSymbolContext(source_file, 9, true, scope, sc_list);
+  EXPECT_EQ(1u, count);
+  EXPECT_TRUE(sc_list.GetContextAtIndex(0, sc));
+
+  lt = sc.comp_unit->GetLineTable();
+  EXPECT_NE(nullptr, lt);
+  count = lt->GetSize();
+  // We expect one extra entry for termination
+  EXPECT_EQ(3u, count);
+
+  VerifyLineEntry(module, sc, source_file, *lt, 9, 0x401045);
+  VerifyLineEntry(module, sc, header1, *lt, 9, 0x401090);
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestEnumTypes))
-{
-    FileSpec fspec(m_types_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
-
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    SymbolFilePDB *symfile = static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
-    const llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
-    SymbolContext sc;
-    llvm::DenseSet<SymbolFile *> searched_files;
-    const char *EnumsToCheck[] = {"Enum", "ShortEnum"};
-    for (auto Enum : EnumsToCheck)
-    {
-        TypeMap results;
-        EXPECT_EQ(1u, symfile->FindTypes(sc, ConstString(Enum), nullptr, false, 0, searched_files, results));
-        EXPECT_EQ(1u, results.GetSize());
-        lldb::TypeSP enum_type = results.GetTypeAtIndex(0);
-        EXPECT_EQ(ConstString(Enum), enum_type->GetName());
-        CompilerType compiler_type = enum_type->GetFullCompilerType();
-        EXPECT_TRUE(ClangASTContext::IsEnumType(compiler_type.GetOpaqueQualType()));
-        clang::EnumDecl *enum_decl = ClangASTContext::GetAsEnumDecl(compiler_type);
-        EXPECT_NE(nullptr, enum_decl);
-        EXPECT_EQ(2, std::distance(enum_decl->enumerator_begin(), enum_decl->enumerator_end()));
-
-        std::string sizeof_var = "sizeof_";
-        sizeof_var.append(Enum);
-        EXPECT_EQ(GetGlobalConstantInteger(session, sizeof_var.c_str()), enum_type->GetByteSize());
-    }
+TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestSimpleClassTypes)) {
+  FileSpec fspec(m_types_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  SymbolFilePDB *symfile =
+      static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
+  const llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
+  SymbolContext sc;
+  llvm::DenseSet<SymbolFile *> searched_files;
+  TypeMap results;
+  EXPECT_EQ(1u, symfile->FindTypes(sc, ConstString("Class"), nullptr, false, 0,
+                                   searched_files, results));
+  EXPECT_EQ(1u, results.GetSize());
+  lldb::TypeSP udt_type = results.GetTypeAtIndex(0);
+  EXPECT_EQ(ConstString("Class"), udt_type->GetName());
+  CompilerType compiler_type = udt_type->GetForwardCompilerType();
+  EXPECT_TRUE(ClangASTContext::IsClassType(compiler_type.GetOpaqueQualType()));
+  EXPECT_EQ(uint64_t(GetGlobalConstantInteger(session, "sizeof_Class")),
+            udt_type->GetByteSize());
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestArrayTypes))
-{
-    // In order to get this test working, we need to support lookup by symbol name.  Because array
-    // types themselves do not have names, only the symbols have names (i.e. the name of the array).
+TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestNestedClassTypes)) {
+  FileSpec fspec(m_types_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  SymbolFilePDB *symfile =
+      static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
+  const llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
+  SymbolContext sc;
+  llvm::DenseSet<SymbolFile *> searched_files;
+  TypeMap results;
+  EXPECT_EQ(1u, symfile->FindTypes(sc, ConstString("Class::NestedClass"),
+                                   nullptr, false, 0, searched_files, results));
+  EXPECT_EQ(1u, results.GetSize());
+  lldb::TypeSP udt_type = results.GetTypeAtIndex(0);
+  EXPECT_EQ(ConstString("Class::NestedClass"), udt_type->GetName());
+  CompilerType compiler_type = udt_type->GetForwardCompilerType();
+  EXPECT_TRUE(ClangASTContext::IsClassType(compiler_type.GetOpaqueQualType()));
+  EXPECT_EQ(uint64_t(GetGlobalConstantInteger(session, "sizeof_NestedClass")),
+            udt_type->GetByteSize());
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestFunctionTypes))
-{
-    // In order to get this test working, we need to support lookup by symbol name.  Because array
-    // types themselves do not have names, only the symbols have names (i.e. the name of the array).
+TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestClassInNamespace)) {
+  FileSpec fspec(m_types_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  SymbolFilePDB *symfile =
+      static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
+  const llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
+  SymbolContext sc;
+  llvm::DenseSet<SymbolFile *> searched_files;
+  TypeMap results;
+  EXPECT_EQ(1u, symfile->FindTypes(sc, ConstString("NS::NSClass"), nullptr,
+                                   false, 0, searched_files, results));
+  EXPECT_EQ(1u, results.GetSize());
+  lldb::TypeSP udt_type = results.GetTypeAtIndex(0);
+  EXPECT_EQ(ConstString("NS::NSClass"), udt_type->GetName());
+  CompilerType compiler_type = udt_type->GetForwardCompilerType();
+  EXPECT_TRUE(ClangASTContext::IsClassType(compiler_type.GetOpaqueQualType()));
+  EXPECT_EQ(GetGlobalConstantInteger(session, "sizeof_NSClass"),
+            udt_type->GetByteSize());
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestTypedefs))
-{
-    FileSpec fspec(m_types_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
-
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    SymbolFilePDB *symfile = static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
-    const llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
-    SymbolContext sc;
-    llvm::DenseSet<SymbolFile *> searched_files;
+TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestEnumTypes)) {
+  FileSpec fspec(m_types_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  SymbolFilePDB *symfile =
+      static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
+  const llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
+  SymbolContext sc;
+  llvm::DenseSet<SymbolFile *> searched_files;
+  const char *EnumsToCheck[] = {"Enum", "ShortEnum"};
+  for (auto Enum : EnumsToCheck) {
     TypeMap results;
+    EXPECT_EQ(1u, symfile->FindTypes(sc, ConstString(Enum), nullptr, false, 0,
+                                     searched_files, results));
+    EXPECT_EQ(1u, results.GetSize());
+    lldb::TypeSP enum_type = results.GetTypeAtIndex(0);
+    EXPECT_EQ(ConstString(Enum), enum_type->GetName());
+    CompilerType compiler_type = enum_type->GetFullCompilerType();
+    EXPECT_TRUE(ClangASTContext::IsEnumType(compiler_type.GetOpaqueQualType()));
+    clang::EnumDecl *enum_decl = ClangASTContext::GetAsEnumDecl(compiler_type);
+    EXPECT_NE(nullptr, enum_decl);
+    EXPECT_EQ(2, std::distance(enum_decl->enumerator_begin(),
+                               enum_decl->enumerator_end()));
+
+    std::string sizeof_var = "sizeof_";
+    sizeof_var.append(Enum);
+    EXPECT_EQ(GetGlobalConstantInteger(session, sizeof_var.c_str()),
+              enum_type->GetByteSize());
+  }
+}
 
-    const char *TypedefsToCheck[] = {"ClassTypedef", "NSClassTypedef"};
-    for (auto Typedef : TypedefsToCheck)
-    {
-        TypeMap results;
-        EXPECT_EQ(1u, symfile->FindTypes(sc, ConstString(Typedef), nullptr, false, 0, searched_files, results));
-        EXPECT_EQ(1u, results.GetSize());
-        lldb::TypeSP typedef_type = results.GetTypeAtIndex(0);
-        EXPECT_EQ(ConstString(Typedef), typedef_type->GetName());
-        CompilerType compiler_type = typedef_type->GetFullCompilerType();
-        ClangASTContext *clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(compiler_type.GetTypeSystem());
-        EXPECT_TRUE(clang_type_system->IsTypedefType(compiler_type.GetOpaqueQualType()));
-
-        std::string sizeof_var = "sizeof_";
-        sizeof_var.append(Typedef);
-        EXPECT_EQ(GetGlobalConstantInteger(session, sizeof_var.c_str()), typedef_type->GetByteSize());
-    }
+TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestArrayTypes)) {
+  // In order to get this test working, we need to support lookup by symbol
+  // name.  Because array
+  // types themselves do not have names, only the symbols have names (i.e. the
+  // name of the array).
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestRegexNameMatch))
-{
-    FileSpec fspec(m_types_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestFunctionTypes)) {
+  // In order to get this test working, we need to support lookup by symbol
+  // name.  Because array
+  // types themselves do not have names, only the symbols have names (i.e. the
+  // name of the array).
+}
 
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    SymbolFilePDB *symfile = static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
-    SymbolContext sc;
-    llvm::DenseSet<SymbolFile *> searched_files;
+TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestTypedefs)) {
+  FileSpec fspec(m_types_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  SymbolFilePDB *symfile =
+      static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
+  const llvm::pdb::IPDBSession &session = symfile->GetPDBSession();
+  SymbolContext sc;
+  llvm::DenseSet<SymbolFile *> searched_files;
+  TypeMap results;
+
+  const char *TypedefsToCheck[] = {"ClassTypedef", "NSClassTypedef"};
+  for (auto Typedef : TypedefsToCheck) {
     TypeMap results;
-    uint32_t num_results = symfile->FindTypes(sc, ConstString(".*"), nullptr, false, 0, searched_files, results);
-    EXPECT_GT(num_results, 1u);
-    EXPECT_EQ(num_results, results.GetSize());
+    EXPECT_EQ(1u, symfile->FindTypes(sc, ConstString(Typedef), nullptr, false,
+                                     0, searched_files, results));
+    EXPECT_EQ(1u, results.GetSize());
+    lldb::TypeSP typedef_type = results.GetTypeAtIndex(0);
+    EXPECT_EQ(ConstString(Typedef), typedef_type->GetName());
+    CompilerType compiler_type = typedef_type->GetFullCompilerType();
+    ClangASTContext *clang_type_system =
+        llvm::dyn_cast_or_null<ClangASTContext>(compiler_type.GetTypeSystem());
+    EXPECT_TRUE(
+        clang_type_system->IsTypedefType(compiler_type.GetOpaqueQualType()));
+
+    std::string sizeof_var = "sizeof_";
+    sizeof_var.append(Typedef);
+    EXPECT_EQ(GetGlobalConstantInteger(session, sizeof_var.c_str()),
+              typedef_type->GetByteSize());
+  }
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestMaxMatches))
-{
-    FileSpec fspec(m_types_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
-
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    SymbolFilePDB *symfile = static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
-    SymbolContext sc;
-    llvm::DenseSet<SymbolFile *> searched_files;
-    TypeMap results;
-    uint32_t num_results = symfile->FindTypes(sc, ConstString(".*"), nullptr, false, 0, searched_files, results);
-    // Try to limit ourselves from 1 to 10 results, otherwise we could be doing this thousands of times.
-    // The idea is just to make sure that for a variety of values, the number of limited results always
-    // comes out to the number we are expecting.
-    uint32_t iterations = std::min(num_results, 10u);
-    for (uint32_t i = 1; i <= iterations; ++i)
-    {
-        uint32_t num_limited_results = symfile->FindTypes(sc, ConstString(".*"), nullptr, false, i, searched_files, results);
-        EXPECT_EQ(i, num_limited_results);
-        EXPECT_EQ(num_limited_results, results.GetSize());
-    }
+TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestRegexNameMatch)) {
+  FileSpec fspec(m_types_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  SymbolFilePDB *symfile =
+      static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
+  SymbolContext sc;
+  llvm::DenseSet<SymbolFile *> searched_files;
+  TypeMap results;
+  uint32_t num_results = symfile->FindTypes(sc, ConstString(".*"), nullptr,
+                                            false, 0, searched_files, results);
+  EXPECT_GT(num_results, 1u);
+  EXPECT_EQ(num_results, results.GetSize());
 }
 
-TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestNullName))
-{
-    FileSpec fspec(m_types_test_exe.c_str(), false);
-    ArchSpec aspec("i686-pc-windows");
-    lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestMaxMatches)) {
+  FileSpec fspec(m_types_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  SymbolFilePDB *symfile =
+      static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
+  SymbolContext sc;
+  llvm::DenseSet<SymbolFile *> searched_files;
+  TypeMap results;
+  uint32_t num_results = symfile->FindTypes(sc, ConstString(".*"), nullptr,
+                                            false, 0, searched_files, results);
+  // Try to limit ourselves from 1 to 10 results, otherwise we could be doing
+  // this thousands of times.
+  // The idea is just to make sure that for a variety of values, the number of
+  // limited results always
+  // comes out to the number we are expecting.
+  uint32_t iterations = std::min(num_results, 10u);
+  for (uint32_t i = 1; i <= iterations; ++i) {
+    uint32_t num_limited_results = symfile->FindTypes(
+        sc, ConstString(".*"), nullptr, false, i, searched_files, results);
+    EXPECT_EQ(i, num_limited_results);
+    EXPECT_EQ(num_limited_results, results.GetSize());
+  }
+}
 
-    SymbolVendor *plugin = module->GetSymbolVendor();
-    SymbolFilePDB *symfile = static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
-    SymbolContext sc;
-    llvm::DenseSet<SymbolFile *> searched_files;
-    TypeMap results;
-    uint32_t num_results = symfile->FindTypes(sc, ConstString(), nullptr, false, 0, searched_files, results);
-    EXPECT_EQ(0u, num_results);
-    EXPECT_EQ(0u, results.GetSize());
+TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestNullName)) {
+  FileSpec fspec(m_types_test_exe.c_str(), false);
+  ArchSpec aspec("i686-pc-windows");
+  lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
+
+  SymbolVendor *plugin = module->GetSymbolVendor();
+  SymbolFilePDB *symfile =
+      static_cast<SymbolFilePDB *>(plugin->GetSymbolFile());
+  SymbolContext sc;
+  llvm::DenseSet<SymbolFile *> searched_files;
+  TypeMap results;
+  uint32_t num_results = symfile->FindTypes(sc, ConstString(), nullptr, false,
+                                            0, searched_files, results);
+  EXPECT_EQ(0u, num_results);
+  EXPECT_EQ(0u, results.GetSize());
 }
diff --git a/lldb/unittests/Utility/Inputs/TestModule.c b/lldb/unittests/Utility/Inputs/TestModule.c
index 12374e1f7c6..6347f726494 100644
--- a/lldb/unittests/Utility/Inputs/TestModule.c
+++ b/lldb/unittests/Utility/Inputs/TestModule.c
@@ -1,10 +1,9 @@
 // Compile with $CC -nostdlib -shared TestModule.c -o TestModule.so
-// The actual contents of the test module is not important here. I am using this because it
+// The actual contents of the test module is not important here. I am using this
+// because it
 // produces an extremely tiny (but still perfectly valid) module.
 
-void
-boom(void)
-{
-    char *BOOM;
-    *BOOM = 47;
+void boom(void) {
+  char *BOOM;
+  *BOOM = 47;
 }
diff --git a/lldb/unittests/Utility/ModuleCacheTest.cpp b/lldb/unittests/Utility/ModuleCacheTest.cpp
index 53bfc882f23..911c278c162 100644
--- a/lldb/unittests/Utility/ModuleCacheTest.cpp
+++ b/lldb/unittests/Utility/ModuleCacheTest.cpp
@@ -16,24 +16,20 @@ extern const char *TestMainArgv0;
 using namespace lldb_private;
 using namespace lldb;
 
-namespace
-{
+namespace {
 
-class ModuleCacheTest : public testing::Test
-{
+class ModuleCacheTest : public testing::Test {
 public:
-    static void
-    SetUpTestCase();
+  static void SetUpTestCase();
 
-    static void
-    TearDownTestCase();
+  static void TearDownTestCase();
 
 protected:
-    static FileSpec s_cache_dir;
-    static llvm::SmallString<128> s_test_executable;
+  static FileSpec s_cache_dir;
+  static llvm::SmallString<128> s_test_executable;
 
-    void
-    TryGetAndPut(const FileSpec &cache_dir, const char *hostname, bool expect_download);
+  void TryGetAndPut(const FileSpec &cache_dir, const char *hostname,
+                    bool expect_download);
 };
 }
 
@@ -43,137 +39,131 @@ llvm::SmallString<128> ModuleCacheTest::s_test_executable;
 static const char dummy_hostname[] = "dummy_hostname";
 static const char dummy_remote_dir[] = "bin";
 static const char module_name[] = "TestModule.so";
-static const char module_uuid[] = "F4E7E991-9B61-6AD4-0073-561AC3D9FA10-C043A476";
+static const char module_uuid[] =
+    "F4E7E991-9B61-6AD4-0073-561AC3D9FA10-C043A476";
 static const uint32_t uuid_bytes = 20;
 static const size_t module_size = 5602;
 
-static FileSpec
-GetDummyRemotePath()
-{
-    FileSpec fs("/", false, FileSpec::ePathSyntaxPosix);
-    fs.AppendPathComponent(dummy_remote_dir);
-    fs.AppendPathComponent(module_name);
-    return fs;
+static FileSpec GetDummyRemotePath() {
+  FileSpec fs("/", false, FileSpec::ePathSyntaxPosix);
+  fs.AppendPathComponent(dummy_remote_dir);
+  fs.AppendPathComponent(module_name);
+  return fs;
 }
 
-static FileSpec
-GetUuidView(FileSpec spec)
-{
-    spec.AppendPathComponent(".cache");
-    spec.AppendPathComponent(module_uuid);
-    spec.AppendPathComponent(module_name);
-    return spec;
+static FileSpec GetUuidView(FileSpec spec) {
+  spec.AppendPathComponent(".cache");
+  spec.AppendPathComponent(module_uuid);
+  spec.AppendPathComponent(module_name);
+  return spec;
 }
 
-static FileSpec
-GetSysrootView(FileSpec spec, const char *hostname)
-{
-    spec.AppendPathComponent(hostname);
-    spec.AppendPathComponent(dummy_remote_dir);
-    spec.AppendPathComponent(module_name);
-    return spec;
+static FileSpec GetSysrootView(FileSpec spec, const char *hostname) {
+  spec.AppendPathComponent(hostname);
+  spec.AppendPathComponent(dummy_remote_dir);
+  spec.AppendPathComponent(module_name);
+  return spec;
 }
 
-void
-ModuleCacheTest::SetUpTestCase()
-{
-    HostInfo::Initialize();
-    ObjectFileELF::Initialize();
+void ModuleCacheTest::SetUpTestCase() {
+  HostInfo::Initialize();
+  ObjectFileELF::Initialize();
 
-    FileSpec tmpdir_spec;
-    HostInfo::GetLLDBPath(lldb::ePathTypeLLDBTempSystemDir, s_cache_dir);
+  FileSpec tmpdir_spec;
+  HostInfo::GetLLDBPath(lldb::ePathTypeLLDBTempSystemDir, s_cache_dir);
 
-    llvm::StringRef exe_folder = llvm::sys::path::parent_path(TestMainArgv0);
-    s_test_executable = exe_folder;
-    llvm::sys::path::append(s_test_executable, "Inputs", module_name);
+  llvm::StringRef exe_folder = llvm::sys::path::parent_path(TestMainArgv0);
+  s_test_executable = exe_folder;
+  llvm::sys::path::append(s_test_executable, "Inputs", module_name);
 }
 
-void
-ModuleCacheTest::TearDownTestCase()
-{
-    ObjectFileELF::Terminate();
-    HostInfo::Terminate();
+void ModuleCacheTest::TearDownTestCase() {
+  ObjectFileELF::Terminate();
+  HostInfo::Terminate();
 }
 
-static void
-VerifyDiskState(const FileSpec &cache_dir, const char *hostname)
-{
-    FileSpec uuid_view = GetUuidView(cache_dir);
-    EXPECT_TRUE(uuid_view.Exists()) << "uuid_view is: " << uuid_view.GetCString();
-    EXPECT_EQ(module_size, uuid_view.GetByteSize());
+static void VerifyDiskState(const FileSpec &cache_dir, const char *hostname) {
+  FileSpec uuid_view = GetUuidView(cache_dir);
+  EXPECT_TRUE(uuid_view.Exists()) << "uuid_view is: " << uuid_view.GetCString();
+  EXPECT_EQ(module_size, uuid_view.GetByteSize());
 
-    FileSpec sysroot_view = GetSysrootView(cache_dir, hostname);
-    EXPECT_TRUE(sysroot_view.Exists()) << "sysroot_view is: " << sysroot_view.GetCString();
-    EXPECT_EQ(module_size, sysroot_view.GetByteSize());
+  FileSpec sysroot_view = GetSysrootView(cache_dir, hostname);
+  EXPECT_TRUE(sysroot_view.Exists()) << "sysroot_view is: "
+                                     << sysroot_view.GetCString();
+  EXPECT_EQ(module_size, sysroot_view.GetByteSize());
 }
 
-void
-ModuleCacheTest::TryGetAndPut(const FileSpec &cache_dir, const char *hostname, bool expect_download)
-{
-    ModuleCache mc;
-    ModuleSpec module_spec;
-    module_spec.GetFileSpec() = GetDummyRemotePath();
-    module_spec.GetUUID().SetFromCString(module_uuid, uuid_bytes);
-    module_spec.SetObjectSize(module_size);
-    ModuleSP module_sp;
-    bool did_create;
-    bool download_called = false;
-
-    Error error = mc.GetAndPut(
-        cache_dir, hostname, module_spec,
-        [this, &download_called](const ModuleSpec &module_spec, const FileSpec &tmp_download_file_spec) {
-            download_called = true;
-            EXPECT_STREQ(GetDummyRemotePath().GetCString(), module_spec.GetFileSpec().GetCString());
-            std::error_code ec = llvm::sys::fs::copy_file(s_test_executable, tmp_download_file_spec.GetCString());
-            EXPECT_FALSE(ec);
-            return Error();
-        },
-        [](const ModuleSP &module_sp, const FileSpec &tmp_download_file_spec) { return Error("Not supported."); },
-        module_sp, &did_create);
-    EXPECT_EQ(expect_download, download_called);
-
-    EXPECT_TRUE(error.Success()) << "Error was: " << error.AsCString();
-    EXPECT_TRUE(did_create);
-    ASSERT_TRUE(bool(module_sp));
-
-    SymbolContextList sc_list;
-    EXPECT_EQ(1u, module_sp->FindFunctionSymbols(ConstString("boom"), eFunctionNameTypeFull, sc_list));
-    EXPECT_STREQ(GetDummyRemotePath().GetCString(), module_sp->GetPlatformFileSpec().GetCString());
-    EXPECT_STREQ(module_uuid, module_sp->GetUUID().GetAsString().c_str());
+void ModuleCacheTest::TryGetAndPut(const FileSpec &cache_dir,
+                                   const char *hostname, bool expect_download) {
+  ModuleCache mc;
+  ModuleSpec module_spec;
+  module_spec.GetFileSpec() = GetDummyRemotePath();
+  module_spec.GetUUID().SetFromCString(module_uuid, uuid_bytes);
+  module_spec.SetObjectSize(module_size);
+  ModuleSP module_sp;
+  bool did_create;
+  bool download_called = false;
+
+  Error error = mc.GetAndPut(
+      cache_dir, hostname, module_spec,
+      [this, &download_called](const ModuleSpec &module_spec,
+                               const FileSpec &tmp_download_file_spec) {
+        download_called = true;
+        EXPECT_STREQ(GetDummyRemotePath().GetCString(),
+                     module_spec.GetFileSpec().GetCString());
+        std::error_code ec = llvm::sys::fs::copy_file(
+            s_test_executable, tmp_download_file_spec.GetCString());
+        EXPECT_FALSE(ec);
+        return Error();
+      },
+      [](const ModuleSP &module_sp, const FileSpec &tmp_download_file_spec) {
+        return Error("Not supported.");
+      },
+      module_sp, &did_create);
+  EXPECT_EQ(expect_download, download_called);
+
+  EXPECT_TRUE(error.Success()) << "Error was: " << error.AsCString();
+  EXPECT_TRUE(did_create);
+  ASSERT_TRUE(bool(module_sp));
+
+  SymbolContextList sc_list;
+  EXPECT_EQ(1u, module_sp->FindFunctionSymbols(ConstString("boom"),
+                                               eFunctionNameTypeFull, sc_list));
+  EXPECT_STREQ(GetDummyRemotePath().GetCString(),
+               module_sp->GetPlatformFileSpec().GetCString());
+  EXPECT_STREQ(module_uuid, module_sp->GetUUID().GetAsString().c_str());
 }
 
-TEST_F(ModuleCacheTest, GetAndPut)
-{
-    FileSpec test_cache_dir = s_cache_dir;
-    test_cache_dir.AppendPathComponent("GetAndPut");
+TEST_F(ModuleCacheTest, GetAndPut) {
+  FileSpec test_cache_dir = s_cache_dir;
+  test_cache_dir.AppendPathComponent("GetAndPut");
 
-    const bool expect_download = true;
-    TryGetAndPut(test_cache_dir, dummy_hostname, expect_download);
-    VerifyDiskState(test_cache_dir, dummy_hostname);
+  const bool expect_download = true;
+  TryGetAndPut(test_cache_dir, dummy_hostname, expect_download);
+  VerifyDiskState(test_cache_dir, dummy_hostname);
 }
 
-TEST_F(ModuleCacheTest, GetAndPutUuidExists)
-{
-    FileSpec test_cache_dir = s_cache_dir;
-    test_cache_dir.AppendPathComponent("GetAndPutUuidExists");
+TEST_F(ModuleCacheTest, GetAndPutUuidExists) {
+  FileSpec test_cache_dir = s_cache_dir;
+  test_cache_dir.AppendPathComponent("GetAndPutUuidExists");
 
-    FileSpec uuid_view = GetUuidView(test_cache_dir);
-    std::error_code ec = llvm::sys::fs::create_directories(uuid_view.GetDirectory().GetCString());
-    ASSERT_FALSE(ec);
-    ec = llvm::sys::fs::copy_file(s_test_executable, uuid_view.GetCString());
-    ASSERT_FALSE(ec);
+  FileSpec uuid_view = GetUuidView(test_cache_dir);
+  std::error_code ec =
+      llvm::sys::fs::create_directories(uuid_view.GetDirectory().GetCString());
+  ASSERT_FALSE(ec);
+  ec = llvm::sys::fs::copy_file(s_test_executable, uuid_view.GetCString());
+  ASSERT_FALSE(ec);
 
-    const bool expect_download = false;
-    TryGetAndPut(test_cache_dir, dummy_hostname, expect_download);
-    VerifyDiskState(test_cache_dir, dummy_hostname);
+  const bool expect_download = false;
+  TryGetAndPut(test_cache_dir, dummy_hostname, expect_download);
+  VerifyDiskState(test_cache_dir, dummy_hostname);
 }
 
-TEST_F(ModuleCacheTest, GetAndPutStrangeHostname)
-{
-    FileSpec test_cache_dir = s_cache_dir;
-    test_cache_dir.AppendPathComponent("GetAndPutStrangeHostname");
+TEST_F(ModuleCacheTest, GetAndPutStrangeHostname) {
+  FileSpec test_cache_dir = s_cache_dir;
+  test_cache_dir.AppendPathComponent("GetAndPutStrangeHostname");
 
-    const bool expect_download = true;
-    TryGetAndPut(test_cache_dir, "tab\tcolon:asterisk*", expect_download);
-    VerifyDiskState(test_cache_dir, "tab_colon_asterisk_");
+  const bool expect_download = true;
+  TryGetAndPut(test_cache_dir, "tab\tcolon:asterisk*", expect_download);
+  VerifyDiskState(test_cache_dir, "tab_colon_asterisk_");
 }
diff --git a/lldb/unittests/Utility/StringExtractorTest.cpp b/lldb/unittests/Utility/StringExtractorTest.cpp
index 94cb4e58d07..42f7fb7d014 100644
--- a/lldb/unittests/Utility/StringExtractorTest.cpp
+++ b/lldb/unittests/Utility/StringExtractorTest.cpp
@@ -1,738 +1,698 @@
-#include <limits.h>
 #include "gtest/gtest.h"
+#include <limits.h>
 
 #include "lldb/Utility/StringExtractor.h"
 
-namespace
-{
-    class StringExtractorTest: public ::testing::Test
-    {
-    };
+namespace {
+class StringExtractorTest : public ::testing::Test {};
+}
+
+TEST_F(StringExtractorTest, InitEmpty) {
+  const char kEmptyString[] = "";
+  StringExtractor ex(kEmptyString);
+
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(0u, ex.GetFilePos());
+  ASSERT_STREQ(kEmptyString, ex.GetStringRef().c_str());
+  ASSERT_EQ(true, ex.Empty());
+  ASSERT_EQ(0u, ex.GetBytesLeft());
+  ASSERT_EQ(nullptr, ex.Peek());
+}
+
+TEST_F(StringExtractorTest, InitMisc) {
+  const char kInitMiscString[] = "Hello, StringExtractor!";
+  StringExtractor ex(kInitMiscString);
+
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(0u, ex.GetFilePos());
+  ASSERT_STREQ(kInitMiscString, ex.GetStringRef().c_str());
+  ASSERT_EQ(false, ex.Empty());
+  ASSERT_EQ(sizeof(kInitMiscString) - 1, ex.GetBytesLeft());
+  ASSERT_EQ(kInitMiscString[0], *ex.Peek());
 }
 
-TEST_F (StringExtractorTest, InitEmpty)
-{
-    const char kEmptyString[] = "";
-    StringExtractor ex (kEmptyString);
+TEST_F(StringExtractorTest, DecodeHexU8_Underflow) {
+  const char kEmptyString[] = "";
+  StringExtractor ex(kEmptyString);
 
-    ASSERT_EQ (true, ex.IsGood());
-    ASSERT_EQ (0u, ex.GetFilePos());
-    ASSERT_STREQ (kEmptyString, ex.GetStringRef().c_str());
-    ASSERT_EQ (true, ex.Empty());
-    ASSERT_EQ (0u, ex.GetBytesLeft());
-    ASSERT_EQ (nullptr, ex.Peek());
+  ASSERT_EQ(-1, ex.DecodeHexU8());
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(0u, ex.GetFilePos());
+  ASSERT_EQ(true, ex.Empty());
+  ASSERT_EQ(0u, ex.GetBytesLeft());
+  ASSERT_EQ(nullptr, ex.Peek());
 }
 
-TEST_F (StringExtractorTest, InitMisc)
-{
-    const char kInitMiscString[] = "Hello, StringExtractor!";
-    StringExtractor ex (kInitMiscString);
+TEST_F(StringExtractorTest, DecodeHexU8_Underflow2) {
+  const char kEmptyString[] = "1";
+  StringExtractor ex(kEmptyString);
 
-    ASSERT_EQ (true, ex.IsGood());
-    ASSERT_EQ (0u, ex.GetFilePos());
-    ASSERT_STREQ (kInitMiscString, ex.GetStringRef().c_str());
-    ASSERT_EQ (false, ex.Empty());
-    ASSERT_EQ (sizeof(kInitMiscString)-1, ex.GetBytesLeft());
-    ASSERT_EQ (kInitMiscString[0], *ex.Peek());
+  ASSERT_EQ(-1, ex.DecodeHexU8());
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(0u, ex.GetFilePos());
+  ASSERT_EQ(1u, ex.GetBytesLeft());
+  ASSERT_EQ('1', *ex.Peek());
 }
 
-TEST_F (StringExtractorTest, DecodeHexU8_Underflow)
-{
-    const char kEmptyString[] = "";
-    StringExtractor ex (kEmptyString);
+TEST_F(StringExtractorTest, DecodeHexU8_InvalidHex) {
+  const char kInvalidHex[] = "xa";
+  StringExtractor ex(kInvalidHex);
 
-    ASSERT_EQ (-1, ex.DecodeHexU8());
-    ASSERT_EQ (true, ex.IsGood());
-    ASSERT_EQ (0u, ex.GetFilePos());
-    ASSERT_EQ (true, ex.Empty());
-    ASSERT_EQ (0u, ex.GetBytesLeft());
-    ASSERT_EQ (nullptr, ex.Peek());
+  ASSERT_EQ(-1, ex.DecodeHexU8());
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(0u, ex.GetFilePos());
+  ASSERT_EQ(2u, ex.GetBytesLeft());
+  ASSERT_EQ('x', *ex.Peek());
 }
 
-TEST_F (StringExtractorTest, DecodeHexU8_Underflow2)
-{
-    const char kEmptyString[] = "1";
-    StringExtractor ex (kEmptyString);
-
-    ASSERT_EQ (-1, ex.DecodeHexU8());
-    ASSERT_EQ (true, ex.IsGood());
-    ASSERT_EQ (0u, ex.GetFilePos());
-    ASSERT_EQ (1u, ex.GetBytesLeft());
-    ASSERT_EQ ('1', *ex.Peek());
+TEST_F(StringExtractorTest, DecodeHexU8_InvalidHex2) {
+  const char kInvalidHex[] = "ax";
+  StringExtractor ex(kInvalidHex);
+
+  ASSERT_EQ(-1, ex.DecodeHexU8());
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(0u, ex.GetFilePos());
+  ASSERT_EQ(2u, ex.GetBytesLeft());
+  ASSERT_EQ('a', *ex.Peek());
 }
 
-TEST_F (StringExtractorTest, DecodeHexU8_InvalidHex)
-{
-    const char kInvalidHex[] = "xa";
-    StringExtractor ex (kInvalidHex);
-
-    ASSERT_EQ (-1, ex.DecodeHexU8());
-    ASSERT_EQ (true, ex.IsGood());
-    ASSERT_EQ (0u, ex.GetFilePos());
-    ASSERT_EQ (2u, ex.GetBytesLeft());
-    ASSERT_EQ ('x', *ex.Peek());
+TEST_F(StringExtractorTest, DecodeHexU8_Exact) {
+  const char kValidHexPair[] = "12";
+  StringExtractor ex(kValidHexPair);
+
+  ASSERT_EQ(0x12, ex.DecodeHexU8());
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(2u, ex.GetFilePos());
+  ASSERT_EQ(0u, ex.GetBytesLeft());
+  ASSERT_EQ(nullptr, ex.Peek());
 }
 
-TEST_F (StringExtractorTest, DecodeHexU8_InvalidHex2)
-{
-    const char kInvalidHex[] = "ax";
-    StringExtractor ex (kInvalidHex);
-
-    ASSERT_EQ (-1, ex.DecodeHexU8());
-    ASSERT_EQ (true, ex.IsGood());
-    ASSERT_EQ (0u, ex.GetFilePos());
-    ASSERT_EQ (2u, ex.GetBytesLeft());
-    ASSERT_EQ ('a', *ex.Peek());
+TEST_F(StringExtractorTest, DecodeHexU8_Extra) {
+  const char kValidHexPair[] = "1234";
+  StringExtractor ex(kValidHexPair);
+
+  ASSERT_EQ(0x12, ex.DecodeHexU8());
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(2u, ex.GetFilePos());
+  ASSERT_EQ(2u, ex.GetBytesLeft());
+  ASSERT_EQ('3', *ex.Peek());
 }
 
-TEST_F (StringExtractorTest, DecodeHexU8_Exact)
-{
-    const char kValidHexPair[] = "12";
-    StringExtractor ex (kValidHexPair);
-
-    ASSERT_EQ (0x12, ex.DecodeHexU8());
-    ASSERT_EQ (true, ex.IsGood());
-    ASSERT_EQ (2u, ex.GetFilePos());
-    ASSERT_EQ (0u, ex.GetBytesLeft());
-    ASSERT_EQ (nullptr, ex.Peek());
-}
+TEST_F(StringExtractorTest, GetHexU8_Underflow) {
+  const char kEmptyString[] = "";
+  StringExtractor ex(kEmptyString);
 
-TEST_F (StringExtractorTest, DecodeHexU8_Extra)
-{
-    const char kValidHexPair[] = "1234";
-    StringExtractor ex (kValidHexPair);
-
-    ASSERT_EQ (0x12, ex.DecodeHexU8());
-    ASSERT_EQ (true, ex.IsGood());
-    ASSERT_EQ (2u, ex.GetFilePos());
-    ASSERT_EQ (2u, ex.GetBytesLeft());
-    ASSERT_EQ ('3', *ex.Peek());
-}
-
-TEST_F (StringExtractorTest, GetHexU8_Underflow)
-{
-    const char kEmptyString[] = "";
-    StringExtractor ex (kEmptyString);
-
-    ASSERT_EQ (0xab, ex.GetHexU8(0xab));
-    ASSERT_EQ (false, ex.IsGood());
-    ASSERT_EQ (UINT64_MAX, ex.GetFilePos());
-    ASSERT_EQ (true, ex.Empty());
-    ASSERT_EQ (0u, ex.GetBytesLeft());
-    ASSERT_EQ (nullptr, ex.Peek());
-}
-
-TEST_F (StringExtractorTest, GetHexU8_Underflow2)
-{
-    const char kOneNibble[] = "1";
-    StringExtractor ex (kOneNibble);
-
-    ASSERT_EQ (0xbc, ex.GetHexU8(0xbc));
-    ASSERT_EQ (false, ex.IsGood());
-    ASSERT_EQ (UINT64_MAX, ex.GetFilePos());
-    ASSERT_EQ (0u, ex.GetBytesLeft());
-    ASSERT_EQ (nullptr, ex.Peek());
-}
-
-TEST_F (StringExtractorTest, GetHexU8_InvalidHex)
-{
-    const char kInvalidHex[] = "xx";
-    StringExtractor ex (kInvalidHex);
-
-    ASSERT_EQ (0xcd, ex.GetHexU8(0xcd));
-    ASSERT_EQ (false, ex.IsGood());
-    ASSERT_EQ (UINT64_MAX, ex.GetFilePos());
-    ASSERT_EQ (0u, ex.GetBytesLeft());
-    ASSERT_EQ (nullptr, ex.Peek());
-}
-
-TEST_F (StringExtractorTest, GetHexU8_Exact)
-{
-    const char kValidHexPair[] = "12";
-    StringExtractor ex (kValidHexPair);
-
-    ASSERT_EQ (0x12, ex.GetHexU8(0x12));
-    ASSERT_EQ (true, ex.IsGood());
-    ASSERT_EQ (2u, ex.GetFilePos());
-    ASSERT_EQ (0u, ex.GetBytesLeft());
-    ASSERT_EQ (nullptr, ex.Peek());
-}
-
-TEST_F (StringExtractorTest, GetHexU8_Extra)
-{
-    const char kValidHexPair[] = "1234";
-    StringExtractor ex (kValidHexPair);
-
-    ASSERT_EQ (0x12, ex.GetHexU8(0x12));
-    ASSERT_EQ (true, ex.IsGood());
-    ASSERT_EQ (2u, ex.GetFilePos());
-    ASSERT_EQ (2u, ex.GetBytesLeft());
-    ASSERT_EQ ('3', *ex.Peek());
-}
-
-TEST_F (StringExtractorTest, GetHexU8_Underflow_NoEof)
-{
-    const char kEmptyString[] = "";
-    StringExtractor ex (kEmptyString);
-    const bool kSetEofOnFail = false;
-
-    ASSERT_EQ (0xab, ex.GetHexU8(0xab, kSetEofOnFail));
-    ASSERT_EQ (false, ex.IsGood()); // this result seems inconsistent with kSetEofOnFail == false
-    ASSERT_EQ (UINT64_MAX, ex.GetFilePos());
-    ASSERT_EQ (true, ex.Empty());
-    ASSERT_EQ (0u, ex.GetBytesLeft());
-    ASSERT_EQ (nullptr, ex.Peek());
-}
-
-TEST_F (StringExtractorTest, GetHexU8_Underflow2_NoEof)
-{
-    const char kOneNibble[] = "1";
-    StringExtractor ex (kOneNibble);
-    const bool kSetEofOnFail = false;
-
-    ASSERT_EQ (0xbc, ex.GetHexU8(0xbc, kSetEofOnFail));
-    ASSERT_EQ (true, ex.IsGood());
-    ASSERT_EQ (0u, ex.GetFilePos());
-    ASSERT_EQ (1u, ex.GetBytesLeft());
-    ASSERT_EQ ('1', *ex.Peek());
-}
-
-TEST_F (StringExtractorTest, GetHexU8_InvalidHex_NoEof)
-{
-    const char kInvalidHex[] = "xx";
-    StringExtractor ex (kInvalidHex);
-    const bool kSetEofOnFail = false;
-
-    ASSERT_EQ (0xcd, ex.GetHexU8(0xcd, kSetEofOnFail));
-    ASSERT_EQ (true, ex.IsGood());
-    ASSERT_EQ (0u, ex.GetFilePos());
-    ASSERT_EQ (2u, ex.GetBytesLeft());
-    ASSERT_EQ ('x', *ex.Peek());
-}
-
-TEST_F (StringExtractorTest, GetHexU8_Exact_NoEof)
-{
-    const char kValidHexPair[] = "12";
-    StringExtractor ex (kValidHexPair);
-    const bool kSetEofOnFail = false;
-
-    ASSERT_EQ (0x12, ex.GetHexU8(0x12, kSetEofOnFail));
-    ASSERT_EQ (true, ex.IsGood());
-    ASSERT_EQ (2u, ex.GetFilePos());
-    ASSERT_EQ (0u, ex.GetBytesLeft());
-    ASSERT_EQ (nullptr, ex.Peek());
-}
-
-TEST_F (StringExtractorTest, GetHexU8_Extra_NoEof)
-{
-    const char kValidHexPair[] = "1234";
-    StringExtractor ex (kValidHexPair);
-    const bool kSetEofOnFail = false;
-
-    ASSERT_EQ (0x12, ex.GetHexU8(0x12, kSetEofOnFail));
-    ASSERT_EQ (true, ex.IsGood());
-    ASSERT_EQ (2u, ex.GetFilePos());
-    ASSERT_EQ (2u, ex.GetBytesLeft());
-    ASSERT_EQ ('3', *ex.Peek());
-}
-
-TEST_F (StringExtractorTest, GetHexBytes)
-{
-    const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
-    const size_t kValidHexPairs = 8;
-    StringExtractor ex(kHexEncodedBytes);
-
-    uint8_t dst[kValidHexPairs];
-    ASSERT_EQ(kValidHexPairs, ex.GetHexBytes (dst, 0xde));
-    EXPECT_EQ(0xab,dst[0]);
-    EXPECT_EQ(0xcd,dst[1]);
-    EXPECT_EQ(0xef,dst[2]);
-    EXPECT_EQ(0x01,dst[3]);
-    EXPECT_EQ(0x23,dst[4]);
-    EXPECT_EQ(0x45,dst[5]);
-    EXPECT_EQ(0x67,dst[6]);
-    EXPECT_EQ(0x89,dst[7]);
-
-    ASSERT_EQ(true, ex.IsGood());
-    ASSERT_EQ(2*kValidHexPairs, ex.GetFilePos());
-    ASSERT_EQ(false, ex.Empty());
-    ASSERT_EQ(4u, ex.GetBytesLeft());
-    ASSERT_EQ('x', *ex.Peek());
-}
-
-TEST_F(StringExtractorTest, GetHexBytes_FullString)
-{
-    const char kHexEncodedBytes[] = "abcdef0123456789";
-    const size_t kValidHexPairs = 8;
-    StringExtractor ex(kHexEncodedBytes);
-
-    uint8_t dst[kValidHexPairs];
-    ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
-    EXPECT_EQ(0xab, dst[0]);
-    EXPECT_EQ(0xcd, dst[1]);
-    EXPECT_EQ(0xef, dst[2]);
-    EXPECT_EQ(0x01, dst[3]);
-    EXPECT_EQ(0x23, dst[4]);
-    EXPECT_EQ(0x45, dst[5]);
-    EXPECT_EQ(0x67, dst[6]);
-    EXPECT_EQ(0x89, dst[7]);
-}
-
-TEST_F(StringExtractorTest, GetHexBytes_OddPair)
-{
-    const char kHexEncodedBytes[] = "abcdef012345678w";
-    const size_t kValidHexPairs = 7;
-    StringExtractor ex(kHexEncodedBytes);
-
-    uint8_t dst[8];
-    ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
-    EXPECT_EQ(0xab, dst[0]);
-    EXPECT_EQ(0xcd, dst[1]);
-    EXPECT_EQ(0xef, dst[2]);
-    EXPECT_EQ(0x01, dst[3]);
-    EXPECT_EQ(0x23, dst[4]);
-    EXPECT_EQ(0x45, dst[5]);
-    EXPECT_EQ(0x67, dst[6]);
-
-    // This one should be invalid
-    EXPECT_EQ(0xde, dst[7]);
-}
-
-
-TEST_F(StringExtractorTest, GetHexBytes_OddPair2)
-{
-    const char kHexEncodedBytes[] = "abcdef012345678";
-    const size_t kValidHexPairs = 7;
-    StringExtractor ex(kHexEncodedBytes);
-
-    uint8_t dst[8];
-    ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
-    EXPECT_EQ(0xab, dst[0]);
-    EXPECT_EQ(0xcd, dst[1]);
-    EXPECT_EQ(0xef, dst[2]);
-    EXPECT_EQ(0x01, dst[3]);
-    EXPECT_EQ(0x23, dst[4]);
-    EXPECT_EQ(0x45, dst[5]);
-    EXPECT_EQ(0x67, dst[6]);
-
-    EXPECT_EQ(0xde, dst[7]);
-}
-
-TEST_F (StringExtractorTest, GetHexBytes_Underflow)
-{
-    const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
-    const size_t kValidHexPairs = 8;
-    StringExtractor ex(kHexEncodedBytes);
-
-    uint8_t dst[12];
-    ASSERT_EQ(kValidHexPairs, ex.GetHexBytes (dst, 0xde));
-    EXPECT_EQ(0xab,dst[0]);
-    EXPECT_EQ(0xcd,dst[1]);
-    EXPECT_EQ(0xef,dst[2]);
-    EXPECT_EQ(0x01,dst[3]);
-    EXPECT_EQ(0x23,dst[4]);
-    EXPECT_EQ(0x45,dst[5]);
-    EXPECT_EQ(0x67,dst[6]);
-    EXPECT_EQ(0x89,dst[7]);
-    // these bytes should be filled with fail_fill_value 0xde
-    EXPECT_EQ(0xde,dst[8]);
-    EXPECT_EQ(0xde,dst[9]);
-    EXPECT_EQ(0xde,dst[10]);
-    EXPECT_EQ(0xde,dst[11]);
-
-    ASSERT_EQ(false, ex.IsGood());
-    ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
-    ASSERT_EQ(false, ex.Empty());
-    ASSERT_EQ(0u, ex.GetBytesLeft());
-    ASSERT_EQ(0, ex.Peek());
-}
-
-TEST_F (StringExtractorTest, GetHexBytes_Partial)
-{
-    const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
-    const size_t kReadBytes = 4;
-    StringExtractor ex(kHexEncodedBytes);
-
-    uint8_t dst[12];
-    memset(dst, 0xab, sizeof(dst));
-    ASSERT_EQ(kReadBytes, ex.GetHexBytes (llvm::MutableArrayRef<uint8_t>(dst, kReadBytes), 0xde));
-    EXPECT_EQ(0xab,dst[0]);
-    EXPECT_EQ(0xcd,dst[1]);
-    EXPECT_EQ(0xef,dst[2]);
-    EXPECT_EQ(0x01,dst[3]);
-    // these bytes should be unchanged
-    EXPECT_EQ(0xab,dst[4]);
-    EXPECT_EQ(0xab,dst[5]);
-    EXPECT_EQ(0xab,dst[6]);
-    EXPECT_EQ(0xab,dst[7]);
-    EXPECT_EQ(0xab,dst[8]);
-    EXPECT_EQ(0xab,dst[9]);
-    EXPECT_EQ(0xab,dst[10]);
-    EXPECT_EQ(0xab,dst[11]);
-
-    ASSERT_EQ(true, ex.IsGood());
-    ASSERT_EQ(kReadBytes*2, ex.GetFilePos());
-    ASSERT_EQ(false, ex.Empty());
-    ASSERT_EQ(12u, ex.GetBytesLeft());
-    ASSERT_EQ('2', *ex.Peek());
-}
-
-TEST_F (StringExtractorTest, GetHexBytesAvail)
-{
-    const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
-    const size_t kValidHexPairs = 8;
-    StringExtractor ex(kHexEncodedBytes);
-
-    uint8_t dst[kValidHexPairs];
-    ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail (dst));
-    EXPECT_EQ(0xab,dst[0]);
-    EXPECT_EQ(0xcd,dst[1]);
-    EXPECT_EQ(0xef,dst[2]);
-    EXPECT_EQ(0x01,dst[3]);
-    EXPECT_EQ(0x23,dst[4]);
-    EXPECT_EQ(0x45,dst[5]);
-    EXPECT_EQ(0x67,dst[6]);
-    EXPECT_EQ(0x89,dst[7]);
-
-    ASSERT_EQ(true, ex.IsGood());
-    ASSERT_EQ(2*kValidHexPairs, ex.GetFilePos());
-    ASSERT_EQ(false, ex.Empty());
-    ASSERT_EQ(4u, ex.GetBytesLeft());
-    ASSERT_EQ('x', *ex.Peek());
-}
-
-TEST_F(StringExtractorTest, GetHexBytesAvail_FullString)
-{
-    const char kHexEncodedBytes[] = "abcdef0123456789";
-    const size_t kValidHexPairs = 8;
-    StringExtractor ex(kHexEncodedBytes);
-
-    uint8_t dst[kValidHexPairs];
-    ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
-    EXPECT_EQ(0xab, dst[0]);
-    EXPECT_EQ(0xcd, dst[1]);
-    EXPECT_EQ(0xef, dst[2]);
-    EXPECT_EQ(0x01, dst[3]);
-    EXPECT_EQ(0x23, dst[4]);
-    EXPECT_EQ(0x45, dst[5]);
-    EXPECT_EQ(0x67, dst[6]);
-    EXPECT_EQ(0x89, dst[7]);
-}
-
-TEST_F(StringExtractorTest, GetHexBytesAvail_OddPair)
-{
-    const char kHexEncodedBytes[] = "abcdef012345678w";
-    const size_t kValidHexPairs = 7;
-    StringExtractor ex(kHexEncodedBytes);
-
-    uint8_t dst[8];
-    ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
-    EXPECT_EQ(0xab, dst[0]);
-    EXPECT_EQ(0xcd, dst[1]);
-    EXPECT_EQ(0xef, dst[2]);
-    EXPECT_EQ(0x01, dst[3]);
-    EXPECT_EQ(0x23, dst[4]);
-    EXPECT_EQ(0x45, dst[5]);
-    EXPECT_EQ(0x67, dst[6]);
-}
-
-
-TEST_F(StringExtractorTest, GetHexBytesAvail_OddPair2)
-{
-    const char kHexEncodedBytes[] = "abcdef012345678";
-    const size_t kValidHexPairs = 7;
-    StringExtractor ex(kHexEncodedBytes);
-
-    uint8_t dst[8];
-    ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
-    EXPECT_EQ(0xab, dst[0]);
-    EXPECT_EQ(0xcd, dst[1]);
-    EXPECT_EQ(0xef, dst[2]);
-    EXPECT_EQ(0x01, dst[3]);
-    EXPECT_EQ(0x23, dst[4]);
-    EXPECT_EQ(0x45, dst[5]);
-    EXPECT_EQ(0x67, dst[6]);
-}
-
-TEST_F (StringExtractorTest, GetHexBytesAvail_Underflow)
-{
-    const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
-    const size_t kValidHexPairs = 8;
-    StringExtractor ex(kHexEncodedBytes);
-
-    uint8_t dst[12];
-    memset(dst, 0xef, sizeof(dst));
-    ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail (dst));
-    EXPECT_EQ(0xab,dst[0]);
-    EXPECT_EQ(0xcd,dst[1]);
-    EXPECT_EQ(0xef,dst[2]);
-    EXPECT_EQ(0x01,dst[3]);
-    EXPECT_EQ(0x23,dst[4]);
-    EXPECT_EQ(0x45,dst[5]);
-    EXPECT_EQ(0x67,dst[6]);
-    EXPECT_EQ(0x89,dst[7]);
-    // these bytes should be unchanged
-    EXPECT_EQ(0xef,dst[8]);
-    EXPECT_EQ(0xef,dst[9]);
-    EXPECT_EQ(0xef,dst[10]);
-    EXPECT_EQ(0xef,dst[11]);
-
-    ASSERT_EQ(true, ex.IsGood());
-    ASSERT_EQ(kValidHexPairs*2, ex.GetFilePos());
-    ASSERT_EQ(false, ex.Empty());
-    ASSERT_EQ(4u, ex.GetBytesLeft());
-    ASSERT_EQ('x', *ex.Peek());
-}
-
-TEST_F (StringExtractorTest, GetHexBytesAvail_Partial)
-{
-    const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
-    const size_t kReadBytes = 4;
-    StringExtractor ex(kHexEncodedBytes);
-
-    uint8_t dst[12];
-    memset(dst, 0xab, sizeof(dst));
-    ASSERT_EQ(kReadBytes, ex.GetHexBytesAvail (llvm::MutableArrayRef<uint8_t>(dst, kReadBytes)));
-    EXPECT_EQ(0xab,dst[0]);
-    EXPECT_EQ(0xcd,dst[1]);
-    EXPECT_EQ(0xef,dst[2]);
-    EXPECT_EQ(0x01,dst[3]);
-    // these bytes should be unchanged
-    EXPECT_EQ(0xab,dst[4]);
-    EXPECT_EQ(0xab,dst[5]);
-    EXPECT_EQ(0xab,dst[6]);
-    EXPECT_EQ(0xab,dst[7]);
-    EXPECT_EQ(0xab,dst[8]);
-    EXPECT_EQ(0xab,dst[9]);
-    EXPECT_EQ(0xab,dst[10]);
-    EXPECT_EQ(0xab,dst[11]);
-
-    ASSERT_EQ(true, ex.IsGood());
-    ASSERT_EQ(kReadBytes*2, ex.GetFilePos());
-    ASSERT_EQ(false, ex.Empty());
-    ASSERT_EQ(12u, ex.GetBytesLeft());
-    ASSERT_EQ('2', *ex.Peek());
-}
-
-TEST_F(StringExtractorTest, GetNameColonValueSuccess)
-{
-    const char kNameColonPairs[] = "key1:value1;key2:value2;";
-    StringExtractor ex(kNameColonPairs);
-
-    llvm::StringRef name;
-    llvm::StringRef value;
-    EXPECT_TRUE(ex.GetNameColonValue(name, value));
-    EXPECT_EQ("key1", name);
-    EXPECT_EQ("value1", value);
-    EXPECT_TRUE(ex.GetNameColonValue(name, value));
-    EXPECT_EQ("key2", name);
-    EXPECT_EQ("value2", value);
-    EXPECT_EQ(0, ex.GetBytesLeft());
-}
-
-
-TEST_F(StringExtractorTest, GetNameColonValueContainsColon)
-{
-    const char kNameColonPairs[] = "key1:value1:value2;key2:value3;";
-    StringExtractor ex(kNameColonPairs);
-
-    llvm::StringRef name;
-    llvm::StringRef value;
-    EXPECT_TRUE(ex.GetNameColonValue(name, value));
-    EXPECT_EQ("key1", name);
-    EXPECT_EQ("value1:value2", value);
-    EXPECT_TRUE(ex.GetNameColonValue(name, value));
-    EXPECT_EQ("key2", name);
-    EXPECT_EQ("value3", value);
-    EXPECT_EQ(0, ex.GetBytesLeft());
-}
-
-TEST_F(StringExtractorTest, GetNameColonValueNoSemicolon)
-{
-    const char kNameColonPairs[] = "key1:value1";
-    StringExtractor ex(kNameColonPairs);
+  ASSERT_EQ(0xab, ex.GetHexU8(0xab));
+  ASSERT_EQ(false, ex.IsGood());
+  ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
+  ASSERT_EQ(true, ex.Empty());
+  ASSERT_EQ(0u, ex.GetBytesLeft());
+  ASSERT_EQ(nullptr, ex.Peek());
+}
 
-    llvm::StringRef name;
-    llvm::StringRef value;
-    EXPECT_FALSE(ex.GetNameColonValue(name, value));
-    EXPECT_EQ(0, ex.GetBytesLeft());
-}
+TEST_F(StringExtractorTest, GetHexU8_Underflow2) {
+  const char kOneNibble[] = "1";
+  StringExtractor ex(kOneNibble);
+
+  ASSERT_EQ(0xbc, ex.GetHexU8(0xbc));
+  ASSERT_EQ(false, ex.IsGood());
+  ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
+  ASSERT_EQ(0u, ex.GetBytesLeft());
+  ASSERT_EQ(nullptr, ex.Peek());
+}
+
+TEST_F(StringExtractorTest, GetHexU8_InvalidHex) {
+  const char kInvalidHex[] = "xx";
+  StringExtractor ex(kInvalidHex);
+
+  ASSERT_EQ(0xcd, ex.GetHexU8(0xcd));
+  ASSERT_EQ(false, ex.IsGood());
+  ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
+  ASSERT_EQ(0u, ex.GetBytesLeft());
+  ASSERT_EQ(nullptr, ex.Peek());
+}
+
+TEST_F(StringExtractorTest, GetHexU8_Exact) {
+  const char kValidHexPair[] = "12";
+  StringExtractor ex(kValidHexPair);
+
+  ASSERT_EQ(0x12, ex.GetHexU8(0x12));
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(2u, ex.GetFilePos());
+  ASSERT_EQ(0u, ex.GetBytesLeft());
+  ASSERT_EQ(nullptr, ex.Peek());
+}
+
+TEST_F(StringExtractorTest, GetHexU8_Extra) {
+  const char kValidHexPair[] = "1234";
+  StringExtractor ex(kValidHexPair);
+
+  ASSERT_EQ(0x12, ex.GetHexU8(0x12));
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(2u, ex.GetFilePos());
+  ASSERT_EQ(2u, ex.GetBytesLeft());
+  ASSERT_EQ('3', *ex.Peek());
+}
+
+TEST_F(StringExtractorTest, GetHexU8_Underflow_NoEof) {
+  const char kEmptyString[] = "";
+  StringExtractor ex(kEmptyString);
+  const bool kSetEofOnFail = false;
+
+  ASSERT_EQ(0xab, ex.GetHexU8(0xab, kSetEofOnFail));
+  ASSERT_EQ(false, ex.IsGood()); // this result seems inconsistent with
+                                 // kSetEofOnFail == false
+  ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
+  ASSERT_EQ(true, ex.Empty());
+  ASSERT_EQ(0u, ex.GetBytesLeft());
+  ASSERT_EQ(nullptr, ex.Peek());
+}
+
+TEST_F(StringExtractorTest, GetHexU8_Underflow2_NoEof) {
+  const char kOneNibble[] = "1";
+  StringExtractor ex(kOneNibble);
+  const bool kSetEofOnFail = false;
+
+  ASSERT_EQ(0xbc, ex.GetHexU8(0xbc, kSetEofOnFail));
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(0u, ex.GetFilePos());
+  ASSERT_EQ(1u, ex.GetBytesLeft());
+  ASSERT_EQ('1', *ex.Peek());
+}
+
+TEST_F(StringExtractorTest, GetHexU8_InvalidHex_NoEof) {
+  const char kInvalidHex[] = "xx";
+  StringExtractor ex(kInvalidHex);
+  const bool kSetEofOnFail = false;
+
+  ASSERT_EQ(0xcd, ex.GetHexU8(0xcd, kSetEofOnFail));
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(0u, ex.GetFilePos());
+  ASSERT_EQ(2u, ex.GetBytesLeft());
+  ASSERT_EQ('x', *ex.Peek());
+}
+
+TEST_F(StringExtractorTest, GetHexU8_Exact_NoEof) {
+  const char kValidHexPair[] = "12";
+  StringExtractor ex(kValidHexPair);
+  const bool kSetEofOnFail = false;
+
+  ASSERT_EQ(0x12, ex.GetHexU8(0x12, kSetEofOnFail));
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(2u, ex.GetFilePos());
+  ASSERT_EQ(0u, ex.GetBytesLeft());
+  ASSERT_EQ(nullptr, ex.Peek());
+}
+
+TEST_F(StringExtractorTest, GetHexU8_Extra_NoEof) {
+  const char kValidHexPair[] = "1234";
+  StringExtractor ex(kValidHexPair);
+  const bool kSetEofOnFail = false;
+
+  ASSERT_EQ(0x12, ex.GetHexU8(0x12, kSetEofOnFail));
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(2u, ex.GetFilePos());
+  ASSERT_EQ(2u, ex.GetBytesLeft());
+  ASSERT_EQ('3', *ex.Peek());
+}
+
+TEST_F(StringExtractorTest, GetHexBytes) {
+  const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
+  const size_t kValidHexPairs = 8;
+  StringExtractor ex(kHexEncodedBytes);
+
+  uint8_t dst[kValidHexPairs];
+  ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
+  EXPECT_EQ(0xab, dst[0]);
+  EXPECT_EQ(0xcd, dst[1]);
+  EXPECT_EQ(0xef, dst[2]);
+  EXPECT_EQ(0x01, dst[3]);
+  EXPECT_EQ(0x23, dst[4]);
+  EXPECT_EQ(0x45, dst[5]);
+  EXPECT_EQ(0x67, dst[6]);
+  EXPECT_EQ(0x89, dst[7]);
+
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(2 * kValidHexPairs, ex.GetFilePos());
+  ASSERT_EQ(false, ex.Empty());
+  ASSERT_EQ(4u, ex.GetBytesLeft());
+  ASSERT_EQ('x', *ex.Peek());
+}
+
+TEST_F(StringExtractorTest, GetHexBytes_FullString) {
+  const char kHexEncodedBytes[] = "abcdef0123456789";
+  const size_t kValidHexPairs = 8;
+  StringExtractor ex(kHexEncodedBytes);
+
+  uint8_t dst[kValidHexPairs];
+  ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
+  EXPECT_EQ(0xab, dst[0]);
+  EXPECT_EQ(0xcd, dst[1]);
+  EXPECT_EQ(0xef, dst[2]);
+  EXPECT_EQ(0x01, dst[3]);
+  EXPECT_EQ(0x23, dst[4]);
+  EXPECT_EQ(0x45, dst[5]);
+  EXPECT_EQ(0x67, dst[6]);
+  EXPECT_EQ(0x89, dst[7]);
+}
+
+TEST_F(StringExtractorTest, GetHexBytes_OddPair) {
+  const char kHexEncodedBytes[] = "abcdef012345678w";
+  const size_t kValidHexPairs = 7;
+  StringExtractor ex(kHexEncodedBytes);
+
+  uint8_t dst[8];
+  ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
+  EXPECT_EQ(0xab, dst[0]);
+  EXPECT_EQ(0xcd, dst[1]);
+  EXPECT_EQ(0xef, dst[2]);
+  EXPECT_EQ(0x01, dst[3]);
+  EXPECT_EQ(0x23, dst[4]);
+  EXPECT_EQ(0x45, dst[5]);
+  EXPECT_EQ(0x67, dst[6]);
+
+  // This one should be invalid
+  EXPECT_EQ(0xde, dst[7]);
+}
+
+TEST_F(StringExtractorTest, GetHexBytes_OddPair2) {
+  const char kHexEncodedBytes[] = "abcdef012345678";
+  const size_t kValidHexPairs = 7;
+  StringExtractor ex(kHexEncodedBytes);
+
+  uint8_t dst[8];
+  ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
+  EXPECT_EQ(0xab, dst[0]);
+  EXPECT_EQ(0xcd, dst[1]);
+  EXPECT_EQ(0xef, dst[2]);
+  EXPECT_EQ(0x01, dst[3]);
+  EXPECT_EQ(0x23, dst[4]);
+  EXPECT_EQ(0x45, dst[5]);
+  EXPECT_EQ(0x67, dst[6]);
+
+  EXPECT_EQ(0xde, dst[7]);
+}
+
+TEST_F(StringExtractorTest, GetHexBytes_Underflow) {
+  const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
+  const size_t kValidHexPairs = 8;
+  StringExtractor ex(kHexEncodedBytes);
+
+  uint8_t dst[12];
+  ASSERT_EQ(kValidHexPairs, ex.GetHexBytes(dst, 0xde));
+  EXPECT_EQ(0xab, dst[0]);
+  EXPECT_EQ(0xcd, dst[1]);
+  EXPECT_EQ(0xef, dst[2]);
+  EXPECT_EQ(0x01, dst[3]);
+  EXPECT_EQ(0x23, dst[4]);
+  EXPECT_EQ(0x45, dst[5]);
+  EXPECT_EQ(0x67, dst[6]);
+  EXPECT_EQ(0x89, dst[7]);
+  // these bytes should be filled with fail_fill_value 0xde
+  EXPECT_EQ(0xde, dst[8]);
+  EXPECT_EQ(0xde, dst[9]);
+  EXPECT_EQ(0xde, dst[10]);
+  EXPECT_EQ(0xde, dst[11]);
+
+  ASSERT_EQ(false, ex.IsGood());
+  ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
+  ASSERT_EQ(false, ex.Empty());
+  ASSERT_EQ(0u, ex.GetBytesLeft());
+  ASSERT_EQ(0, ex.Peek());
+}
+
+TEST_F(StringExtractorTest, GetHexBytes_Partial) {
+  const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
+  const size_t kReadBytes = 4;
+  StringExtractor ex(kHexEncodedBytes);
+
+  uint8_t dst[12];
+  memset(dst, 0xab, sizeof(dst));
+  ASSERT_EQ(
+      kReadBytes,
+      ex.GetHexBytes(llvm::MutableArrayRef<uint8_t>(dst, kReadBytes), 0xde));
+  EXPECT_EQ(0xab, dst[0]);
+  EXPECT_EQ(0xcd, dst[1]);
+  EXPECT_EQ(0xef, dst[2]);
+  EXPECT_EQ(0x01, dst[3]);
+  // these bytes should be unchanged
+  EXPECT_EQ(0xab, dst[4]);
+  EXPECT_EQ(0xab, dst[5]);
+  EXPECT_EQ(0xab, dst[6]);
+  EXPECT_EQ(0xab, dst[7]);
+  EXPECT_EQ(0xab, dst[8]);
+  EXPECT_EQ(0xab, dst[9]);
+  EXPECT_EQ(0xab, dst[10]);
+  EXPECT_EQ(0xab, dst[11]);
+
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(kReadBytes * 2, ex.GetFilePos());
+  ASSERT_EQ(false, ex.Empty());
+  ASSERT_EQ(12u, ex.GetBytesLeft());
+  ASSERT_EQ('2', *ex.Peek());
+}
+
+TEST_F(StringExtractorTest, GetHexBytesAvail) {
+  const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
+  const size_t kValidHexPairs = 8;
+  StringExtractor ex(kHexEncodedBytes);
+
+  uint8_t dst[kValidHexPairs];
+  ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
+  EXPECT_EQ(0xab, dst[0]);
+  EXPECT_EQ(0xcd, dst[1]);
+  EXPECT_EQ(0xef, dst[2]);
+  EXPECT_EQ(0x01, dst[3]);
+  EXPECT_EQ(0x23, dst[4]);
+  EXPECT_EQ(0x45, dst[5]);
+  EXPECT_EQ(0x67, dst[6]);
+  EXPECT_EQ(0x89, dst[7]);
+
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(2 * kValidHexPairs, ex.GetFilePos());
+  ASSERT_EQ(false, ex.Empty());
+  ASSERT_EQ(4u, ex.GetBytesLeft());
+  ASSERT_EQ('x', *ex.Peek());
+}
+
+TEST_F(StringExtractorTest, GetHexBytesAvail_FullString) {
+  const char kHexEncodedBytes[] = "abcdef0123456789";
+  const size_t kValidHexPairs = 8;
+  StringExtractor ex(kHexEncodedBytes);
+
+  uint8_t dst[kValidHexPairs];
+  ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
+  EXPECT_EQ(0xab, dst[0]);
+  EXPECT_EQ(0xcd, dst[1]);
+  EXPECT_EQ(0xef, dst[2]);
+  EXPECT_EQ(0x01, dst[3]);
+  EXPECT_EQ(0x23, dst[4]);
+  EXPECT_EQ(0x45, dst[5]);
+  EXPECT_EQ(0x67, dst[6]);
+  EXPECT_EQ(0x89, dst[7]);
+}
+
+TEST_F(StringExtractorTest, GetHexBytesAvail_OddPair) {
+  const char kHexEncodedBytes[] = "abcdef012345678w";
+  const size_t kValidHexPairs = 7;
+  StringExtractor ex(kHexEncodedBytes);
+
+  uint8_t dst[8];
+  ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
+  EXPECT_EQ(0xab, dst[0]);
+  EXPECT_EQ(0xcd, dst[1]);
+  EXPECT_EQ(0xef, dst[2]);
+  EXPECT_EQ(0x01, dst[3]);
+  EXPECT_EQ(0x23, dst[4]);
+  EXPECT_EQ(0x45, dst[5]);
+  EXPECT_EQ(0x67, dst[6]);
+}
+
+TEST_F(StringExtractorTest, GetHexBytesAvail_OddPair2) {
+  const char kHexEncodedBytes[] = "abcdef012345678";
+  const size_t kValidHexPairs = 7;
+  StringExtractor ex(kHexEncodedBytes);
+
+  uint8_t dst[8];
+  ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
+  EXPECT_EQ(0xab, dst[0]);
+  EXPECT_EQ(0xcd, dst[1]);
+  EXPECT_EQ(0xef, dst[2]);
+  EXPECT_EQ(0x01, dst[3]);
+  EXPECT_EQ(0x23, dst[4]);
+  EXPECT_EQ(0x45, dst[5]);
+  EXPECT_EQ(0x67, dst[6]);
+}
+
+TEST_F(StringExtractorTest, GetHexBytesAvail_Underflow) {
+  const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
+  const size_t kValidHexPairs = 8;
+  StringExtractor ex(kHexEncodedBytes);
+
+  uint8_t dst[12];
+  memset(dst, 0xef, sizeof(dst));
+  ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail(dst));
+  EXPECT_EQ(0xab, dst[0]);
+  EXPECT_EQ(0xcd, dst[1]);
+  EXPECT_EQ(0xef, dst[2]);
+  EXPECT_EQ(0x01, dst[3]);
+  EXPECT_EQ(0x23, dst[4]);
+  EXPECT_EQ(0x45, dst[5]);
+  EXPECT_EQ(0x67, dst[6]);
+  EXPECT_EQ(0x89, dst[7]);
+  // these bytes should be unchanged
+  EXPECT_EQ(0xef, dst[8]);
+  EXPECT_EQ(0xef, dst[9]);
+  EXPECT_EQ(0xef, dst[10]);
+  EXPECT_EQ(0xef, dst[11]);
+
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(kValidHexPairs * 2, ex.GetFilePos());
+  ASSERT_EQ(false, ex.Empty());
+  ASSERT_EQ(4u, ex.GetBytesLeft());
+  ASSERT_EQ('x', *ex.Peek());
+}
+
+TEST_F(StringExtractorTest, GetHexBytesAvail_Partial) {
+  const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
+  const size_t kReadBytes = 4;
+  StringExtractor ex(kHexEncodedBytes);
+
+  uint8_t dst[12];
+  memset(dst, 0xab, sizeof(dst));
+  ASSERT_EQ(kReadBytes, ex.GetHexBytesAvail(
+                            llvm::MutableArrayRef<uint8_t>(dst, kReadBytes)));
+  EXPECT_EQ(0xab, dst[0]);
+  EXPECT_EQ(0xcd, dst[1]);
+  EXPECT_EQ(0xef, dst[2]);
+  EXPECT_EQ(0x01, dst[3]);
+  // these bytes should be unchanged
+  EXPECT_EQ(0xab, dst[4]);
+  EXPECT_EQ(0xab, dst[5]);
+  EXPECT_EQ(0xab, dst[6]);
+  EXPECT_EQ(0xab, dst[7]);
+  EXPECT_EQ(0xab, dst[8]);
+  EXPECT_EQ(0xab, dst[9]);
+  EXPECT_EQ(0xab, dst[10]);
+  EXPECT_EQ(0xab, dst[11]);
+
+  ASSERT_EQ(true, ex.IsGood());
+  ASSERT_EQ(kReadBytes * 2, ex.GetFilePos());
+  ASSERT_EQ(false, ex.Empty());
+  ASSERT_EQ(12u, ex.GetBytesLeft());
+  ASSERT_EQ('2', *ex.Peek());
+}
+
+TEST_F(StringExtractorTest, GetNameColonValueSuccess) {
+  const char kNameColonPairs[] = "key1:value1;key2:value2;";
+  StringExtractor ex(kNameColonPairs);
+
+  llvm::StringRef name;
+  llvm::StringRef value;
+  EXPECT_TRUE(ex.GetNameColonValue(name, value));
+  EXPECT_EQ("key1", name);
+  EXPECT_EQ("value1", value);
+  EXPECT_TRUE(ex.GetNameColonValue(name, value));
+  EXPECT_EQ("key2", name);
+  EXPECT_EQ("value2", value);
+  EXPECT_EQ(0, ex.GetBytesLeft());
+}
+
+TEST_F(StringExtractorTest, GetNameColonValueContainsColon) {
+  const char kNameColonPairs[] = "key1:value1:value2;key2:value3;";
+  StringExtractor ex(kNameColonPairs);
+
+  llvm::StringRef name;
+  llvm::StringRef value;
+  EXPECT_TRUE(ex.GetNameColonValue(name, value));
+  EXPECT_EQ("key1", name);
+  EXPECT_EQ("value1:value2", value);
+  EXPECT_TRUE(ex.GetNameColonValue(name, value));
+  EXPECT_EQ("key2", name);
+  EXPECT_EQ("value3", value);
+  EXPECT_EQ(0, ex.GetBytesLeft());
+}
+
+TEST_F(StringExtractorTest, GetNameColonValueNoSemicolon) {
+  const char kNameColonPairs[] = "key1:value1";
+  StringExtractor ex(kNameColonPairs);
+
+  llvm::StringRef name;
+  llvm::StringRef value;
+  EXPECT_FALSE(ex.GetNameColonValue(name, value));
+  EXPECT_EQ(0, ex.GetBytesLeft());
+}
 
-TEST_F(StringExtractorTest, GetNameColonValueNoColon)
-{
-    const char kNameColonPairs[] = "key1value1;";
-    StringExtractor ex(kNameColonPairs);
+TEST_F(StringExtractorTest, GetNameColonValueNoColon) {
+  const char kNameColonPairs[] = "key1value1;";
+  StringExtractor ex(kNameColonPairs);
 
-    llvm::StringRef name;
-    llvm::StringRef value;
-    EXPECT_FALSE(ex.GetNameColonValue(name, value));
-    EXPECT_EQ(0, ex.GetBytesLeft());
+  llvm::StringRef name;
+  llvm::StringRef value;
+  EXPECT_FALSE(ex.GetNameColonValue(name, value));
+  EXPECT_EQ(0, ex.GetBytesLeft());
 }
 
-TEST_F(StringExtractorTest, GetU32LittleEndian)
-{
-    StringExtractor ex("");
-    EXPECT_EQ(0x0, ex.GetHexMaxU32(true, 0));
+TEST_F(StringExtractorTest, GetU32LittleEndian) {
+  StringExtractor ex("");
+  EXPECT_EQ(0x0, ex.GetHexMaxU32(true, 0));
 
-    ex.Reset("0");
-    EXPECT_EQ(0x0, ex.GetHexMaxU32(true, 1));
+  ex.Reset("0");
+  EXPECT_EQ(0x0, ex.GetHexMaxU32(true, 1));
 
-    ex.Reset("1");
-    EXPECT_EQ(0x1, ex.GetHexMaxU32(true, 0));
+  ex.Reset("1");
+  EXPECT_EQ(0x1, ex.GetHexMaxU32(true, 0));
 
-    ex.Reset("01");
-    EXPECT_EQ(0x1, ex.GetHexMaxU32(true, 0));
+  ex.Reset("01");
+  EXPECT_EQ(0x1, ex.GetHexMaxU32(true, 0));
 
-    ex.Reset("001");
-    EXPECT_EQ(0x100, ex.GetHexMaxU32(true, 0));
+  ex.Reset("001");
+  EXPECT_EQ(0x100, ex.GetHexMaxU32(true, 0));
 
-    ex.Reset("12");
-    EXPECT_EQ(0x12, ex.GetHexMaxU32(true, 0));
+  ex.Reset("12");
+  EXPECT_EQ(0x12, ex.GetHexMaxU32(true, 0));
 
-    ex.Reset("123");
-    EXPECT_EQ(0x312, ex.GetHexMaxU32(true, 0));
+  ex.Reset("123");
+  EXPECT_EQ(0x312, ex.GetHexMaxU32(true, 0));
 
-    ex.Reset("1203");
-    EXPECT_EQ(0x312, ex.GetHexMaxU32(true, 0));
+  ex.Reset("1203");
+  EXPECT_EQ(0x312, ex.GetHexMaxU32(true, 0));
 
-    ex.Reset("1234");
-    EXPECT_EQ(0x3412, ex.GetHexMaxU32(true, 0));
+  ex.Reset("1234");
+  EXPECT_EQ(0x3412, ex.GetHexMaxU32(true, 0));
 
-    ex.Reset("12340");
-    EXPECT_EQ(0x3412, ex.GetHexMaxU32(true, 0));
+  ex.Reset("12340");
+  EXPECT_EQ(0x3412, ex.GetHexMaxU32(true, 0));
 
-    ex.Reset("123400");
-    EXPECT_EQ(0x3412, ex.GetHexMaxU32(true, 0));
+  ex.Reset("123400");
+  EXPECT_EQ(0x3412, ex.GetHexMaxU32(true, 0));
 
-    ex.Reset("12345670");
-    EXPECT_EQ(0x70563412, ex.GetHexMaxU32(true, 0));
+  ex.Reset("12345670");
+  EXPECT_EQ(0x70563412, ex.GetHexMaxU32(true, 0));
 
-    ex.Reset("123456701");
-    EXPECT_EQ(0, ex.GetHexMaxU32(true, 0));
+  ex.Reset("123456701");
+  EXPECT_EQ(0, ex.GetHexMaxU32(true, 0));
 }
 
-TEST_F(StringExtractorTest, GetU32BigEndian)
-{
-    StringExtractor ex("");
-    EXPECT_EQ(0x0, ex.GetHexMaxU32(false, 0));
+TEST_F(StringExtractorTest, GetU32BigEndian) {
+  StringExtractor ex("");
+  EXPECT_EQ(0x0, ex.GetHexMaxU32(false, 0));
 
-    ex.Reset("0");
-    EXPECT_EQ(0x0, ex.GetHexMaxU32(false, 1));
+  ex.Reset("0");
+  EXPECT_EQ(0x0, ex.GetHexMaxU32(false, 1));
 
-    ex.Reset("1");
-    EXPECT_EQ(0x1, ex.GetHexMaxU32(false, 0));
+  ex.Reset("1");
+  EXPECT_EQ(0x1, ex.GetHexMaxU32(false, 0));
 
-    ex.Reset("01");
-    EXPECT_EQ(0x1, ex.GetHexMaxU32(false, 0));
+  ex.Reset("01");
+  EXPECT_EQ(0x1, ex.GetHexMaxU32(false, 0));
 
-    ex.Reset("001");
-    EXPECT_EQ(0x1, ex.GetHexMaxU32(false, 0));
+  ex.Reset("001");
+  EXPECT_EQ(0x1, ex.GetHexMaxU32(false, 0));
 
-    ex.Reset("12");
-    EXPECT_EQ(0x12, ex.GetHexMaxU32(false, 0));
+  ex.Reset("12");
+  EXPECT_EQ(0x12, ex.GetHexMaxU32(false, 0));
 
-    ex.Reset("123");
-    EXPECT_EQ(0x123, ex.GetHexMaxU32(false, 0));
+  ex.Reset("123");
+  EXPECT_EQ(0x123, ex.GetHexMaxU32(false, 0));
 
-    ex.Reset("1203");
-    EXPECT_EQ(0x1203, ex.GetHexMaxU32(false, 0));
+  ex.Reset("1203");
+  EXPECT_EQ(0x1203, ex.GetHexMaxU32(false, 0));
 
-    ex.Reset("1234");
-    EXPECT_EQ(0x1234, ex.GetHexMaxU32(false, 0));
+  ex.Reset("1234");
+  EXPECT_EQ(0x1234, ex.GetHexMaxU32(false, 0));
 
-    ex.Reset("12340");
-    EXPECT_EQ(0x12340, ex.GetHexMaxU32(false, 0));
+  ex.Reset("12340");
+  EXPECT_EQ(0x12340, ex.GetHexMaxU32(false, 0));
 
-    ex.Reset("123400");
-    EXPECT_EQ(0x123400, ex.GetHexMaxU32(false, 0));
+  ex.Reset("123400");
+  EXPECT_EQ(0x123400, ex.GetHexMaxU32(false, 0));
 
-    ex.Reset("12345670");
-    EXPECT_EQ(0x12345670, ex.GetHexMaxU32(false, 0));
+  ex.Reset("12345670");
+  EXPECT_EQ(0x12345670, ex.GetHexMaxU32(false, 0));
 
-    ex.Reset("123456700");
-    EXPECT_EQ(0, ex.GetHexMaxU32(false, 0));
+  ex.Reset("123456700");
+  EXPECT_EQ(0, ex.GetHexMaxU32(false, 0));
 }
 
-TEST_F(StringExtractorTest, GetU64LittleEndian)
-{
-    StringExtractor ex("");
-    EXPECT_EQ(0x0, ex.GetHexMaxU64(true, 0));
+TEST_F(StringExtractorTest, GetU64LittleEndian) {
+  StringExtractor ex("");
+  EXPECT_EQ(0x0, ex.GetHexMaxU64(true, 0));
 
-    ex.Reset("0");
-    EXPECT_EQ(0x0, ex.GetHexMaxU64(true, 1));
+  ex.Reset("0");
+  EXPECT_EQ(0x0, ex.GetHexMaxU64(true, 1));
 
-    ex.Reset("1");
-    EXPECT_EQ(0x1, ex.GetHexMaxU64(true, 0));
+  ex.Reset("1");
+  EXPECT_EQ(0x1, ex.GetHexMaxU64(true, 0));
 
-    ex.Reset("01");
-    EXPECT_EQ(0x1, ex.GetHexMaxU64(true, 0));
+  ex.Reset("01");
+  EXPECT_EQ(0x1, ex.GetHexMaxU64(true, 0));
 
-    ex.Reset("001");
-    EXPECT_EQ(0x100, ex.GetHexMaxU64(true, 0));
+  ex.Reset("001");
+  EXPECT_EQ(0x100, ex.GetHexMaxU64(true, 0));
 
-    ex.Reset("12");
-    EXPECT_EQ(0x12, ex.GetHexMaxU64(true, 0));
+  ex.Reset("12");
+  EXPECT_EQ(0x12, ex.GetHexMaxU64(true, 0));
 
-    ex.Reset("123");
-    EXPECT_EQ(0x312, ex.GetHexMaxU64(true, 0));
+  ex.Reset("123");
+  EXPECT_EQ(0x312, ex.GetHexMaxU64(true, 0));
 
-    ex.Reset("1203");
-    EXPECT_EQ(0x312, ex.GetHexMaxU64(true, 0));
+  ex.Reset("1203");
+  EXPECT_EQ(0x312, ex.GetHexMaxU64(true, 0));
 
-    ex.Reset("1234");
-    EXPECT_EQ(0x3412, ex.GetHexMaxU64(true, 0));
+  ex.Reset("1234");
+  EXPECT_EQ(0x3412, ex.GetHexMaxU64(true, 0));
 
-    ex.Reset("12340");
-    EXPECT_EQ(0x3412, ex.GetHexMaxU64(true, 0));
+  ex.Reset("12340");
+  EXPECT_EQ(0x3412, ex.GetHexMaxU64(true, 0));
 
-    ex.Reset("123400");
-    EXPECT_EQ(0x3412, ex.GetHexMaxU64(true, 0));
+  ex.Reset("123400");
+  EXPECT_EQ(0x3412, ex.GetHexMaxU64(true, 0));
 
-    ex.Reset("123456789ABCDEF0");
-    EXPECT_EQ(0xF0DEBC9A78563412ULL, ex.GetHexMaxU64(true, 0));
+  ex.Reset("123456789ABCDEF0");
+  EXPECT_EQ(0xF0DEBC9A78563412ULL, ex.GetHexMaxU64(true, 0));
 
-    ex.Reset("123456789ABCDEF01");
-    EXPECT_EQ(0, ex.GetHexMaxU64(true, 0));
+  ex.Reset("123456789ABCDEF01");
+  EXPECT_EQ(0, ex.GetHexMaxU64(true, 0));
 }
 
-TEST_F(StringExtractorTest, GetU64BigEndian)
-{
-    StringExtractor ex("");
-    EXPECT_EQ(0x0, ex.GetHexMaxU64(false, 0));
+TEST_F(StringExtractorTest, GetU64BigEndian) {
+  StringExtractor ex("");
+  EXPECT_EQ(0x0, ex.GetHexMaxU64(false, 0));
 
-    ex.Reset("0");
-    EXPECT_EQ(0x0, ex.GetHexMaxU64(false, 1));
+  ex.Reset("0");
+  EXPECT_EQ(0x0, ex.GetHexMaxU64(false, 1));
 
-    ex.Reset("1");
-    EXPECT_EQ(0x1, ex.GetHexMaxU64(false, 0));
+  ex.Reset("1");
+  EXPECT_EQ(0x1, ex.GetHexMaxU64(false, 0));
 
-    ex.Reset("01");
-    EXPECT_EQ(0x1, ex.GetHexMaxU64(false, 0));
+  ex.Reset("01");
+  EXPECT_EQ(0x1, ex.GetHexMaxU64(false, 0));
 
-    ex.Reset("001");
-    EXPECT_EQ(0x1, ex.GetHexMaxU64(false, 0));
+  ex.Reset("001");
+  EXPECT_EQ(0x1, ex.GetHexMaxU64(false, 0));
 
-    ex.Reset("12");
-    EXPECT_EQ(0x12, ex.GetHexMaxU64(false, 0));
+  ex.Reset("12");
+  EXPECT_EQ(0x12, ex.GetHexMaxU64(false, 0));
 
-    ex.Reset("123");
-    EXPECT_EQ(0x123, ex.GetHexMaxU64(false, 0));
+  ex.Reset("123");
+  EXPECT_EQ(0x123, ex.GetHexMaxU64(false, 0));
 
-    ex.Reset("1203");
-    EXPECT_EQ(0x1203, ex.GetHexMaxU64(false, 0));
+  ex.Reset("1203");
+  EXPECT_EQ(0x1203, ex.GetHexMaxU64(false, 0));
 
-    ex.Reset("1234");
-    EXPECT_EQ(0x1234, ex.GetHexMaxU64(false, 0));
+  ex.Reset("1234");
+  EXPECT_EQ(0x1234, ex.GetHexMaxU64(false, 0));
 
-    ex.Reset("12340");
-    EXPECT_EQ(0x12340, ex.GetHexMaxU64(false, 0));
+  ex.Reset("12340");
+  EXPECT_EQ(0x12340, ex.GetHexMaxU64(false, 0));
 
-    ex.Reset("123400");
-    EXPECT_EQ(0x123400, ex.GetHexMaxU64(false, 0));
+  ex.Reset("123400");
+  EXPECT_EQ(0x123400, ex.GetHexMaxU64(false, 0));
 
-    ex.Reset("123456789ABCDEF0");
-    EXPECT_EQ(0x123456789ABCDEF0ULL, ex.GetHexMaxU64(false, 0));
+  ex.Reset("123456789ABCDEF0");
+  EXPECT_EQ(0x123456789ABCDEF0ULL, ex.GetHexMaxU64(false, 0));
 
-    ex.Reset("123456789ABCDEF000");
-    EXPECT_EQ(0, ex.GetHexMaxU64(false, 0));
+  ex.Reset("123456789ABCDEF000");
+  EXPECT_EQ(0, ex.GetHexMaxU64(false, 0));
 }
diff --git a/lldb/unittests/Utility/TaskPoolTest.cpp b/lldb/unittests/Utility/TaskPoolTest.cpp
index 24431e2c789..172e32a9c6c 100644
--- a/lldb/unittests/Utility/TaskPoolTest.cpp
+++ b/lldb/unittests/Utility/TaskPoolTest.cpp
@@ -2,61 +2,53 @@
 
 #include "lldb/Utility/TaskPool.h"
 
-TEST (TaskPoolTest, AddTask)
-{
-    auto fn = [](int x) { return x * x + 1; };
-
-    auto f1 = TaskPool::AddTask(fn, 1);
-    auto f2 = TaskPool::AddTask(fn, 2);
-    auto f3 = TaskPool::AddTask(fn, 3);
-    auto f4 = TaskPool::AddTask(fn, 4);
-
-    ASSERT_EQ (10, f3.get());
-    ASSERT_EQ ( 2, f1.get());
-    ASSERT_EQ (17, f4.get());
-    ASSERT_EQ ( 5, f2.get());
+TEST(TaskPoolTest, AddTask) {
+  auto fn = [](int x) { return x * x + 1; };
+
+  auto f1 = TaskPool::AddTask(fn, 1);
+  auto f2 = TaskPool::AddTask(fn, 2);
+  auto f3 = TaskPool::AddTask(fn, 3);
+  auto f4 = TaskPool::AddTask(fn, 4);
+
+  ASSERT_EQ(10, f3.get());
+  ASSERT_EQ(2, f1.get());
+  ASSERT_EQ(17, f4.get());
+  ASSERT_EQ(5, f2.get());
 }
 
-TEST (TaskPoolTest, RunTasks)
-{
-    std::vector<int> r(4);
-
-    auto fn = [](int x, int& y) { y = x * x + 1; };
-    
-    TaskPool::RunTasks(
-        [fn, &r]() { fn(1, r[0]); },
-        [fn, &r]() { fn(2, r[1]); },
-        [fn, &r]() { fn(3, r[2]); },
-        [fn, &r]() { fn(4, r[3]); }
-    );
-
-    ASSERT_EQ ( 2, r[0]);
-    ASSERT_EQ ( 5, r[1]);
-    ASSERT_EQ (10, r[2]);
-    ASSERT_EQ (17, r[3]);
+TEST(TaskPoolTest, RunTasks) {
+  std::vector<int> r(4);
+
+  auto fn = [](int x, int &y) { y = x * x + 1; };
+
+  TaskPool::RunTasks([fn, &r]() { fn(1, r[0]); }, [fn, &r]() { fn(2, r[1]); },
+                     [fn, &r]() { fn(3, r[2]); }, [fn, &r]() { fn(4, r[3]); });
+
+  ASSERT_EQ(2, r[0]);
+  ASSERT_EQ(5, r[1]);
+  ASSERT_EQ(10, r[2]);
+  ASSERT_EQ(17, r[3]);
 }
 
-TEST (TaskPoolTest, TaskRunner)
-{
-    auto fn = [](int x) { return std::make_pair(x, x * x); };
-
-    TaskRunner<std::pair<int, int>> tr;
-    tr.AddTask(fn, 1);
-    tr.AddTask(fn, 2);
-    tr.AddTask(fn, 3);
-    tr.AddTask(fn, 4);
-
-    int count = 0;
-    while (true)
-    {
-        auto f = tr.WaitForNextCompletedTask();
-        if (!f.valid())
-            break;
-
-        ++count;
-        std::pair<int, int> v = f.get();
-        ASSERT_EQ (v.first * v.first, v.second);
-    }
-
-    ASSERT_EQ(4, count);
+TEST(TaskPoolTest, TaskRunner) {
+  auto fn = [](int x) { return std::make_pair(x, x * x); };
+
+  TaskRunner<std::pair<int, int>> tr;
+  tr.AddTask(fn, 1);
+  tr.AddTask(fn, 2);
+  tr.AddTask(fn, 3);
+  tr.AddTask(fn, 4);
+
+  int count = 0;
+  while (true) {
+    auto f = tr.WaitForNextCompletedTask();
+    if (!f.valid())
+      break;
+
+    ++count;
+    std::pair<int, int> v = f.get();
+    ASSERT_EQ(v.first * v.first, v.second);
+  }
+
+  ASSERT_EQ(4, count);
 }
diff --git a/lldb/unittests/Utility/UriParserTest.cpp b/lldb/unittests/Utility/UriParserTest.cpp
index fe0a6a70f21..2fd1960c0f0 100644
--- a/lldb/unittests/Utility/UriParserTest.cpp
+++ b/lldb/unittests/Utility/UriParserTest.cpp
@@ -1,159 +1,135 @@
-#include "gtest/gtest.h"
 #include "Utility/UriParser.h"
+#include "gtest/gtest.h"
 
-namespace
-{
-    class UriParserTest: public ::testing::Test
-    {
-    };
+namespace {
+class UriParserTest : public ::testing::Test {};
 }
 
 // result strings (scheme/hostname/port/path) passed into UriParser::Parse
-// are initialized to kAsdf so we can verify that they are unmodified if the 
+// are initialized to kAsdf so we can verify that they are unmodified if the
 // URI is invalid
-static const char* kAsdf = "asdf";
+static const char *kAsdf = "asdf";
 
-class UriTestCase
-{
+class UriTestCase {
 public:
-    UriTestCase(const char* uri, const char* scheme, const char* hostname, int port, const char* path) :
-      m_uri(uri),
-      m_result(true),
-      m_scheme(scheme),
-      m_hostname(hostname),
-      m_port(port),
-      m_path(path)
-    {
-    }
-
-    UriTestCase(const char* uri) :
-      m_uri(uri),
-      m_result(false),
-      m_scheme(kAsdf),
-      m_hostname(kAsdf),
-      m_port(1138),
-      m_path(kAsdf)
-    {
-    }
-
-    const char* m_uri;
-    bool        m_result;
-    const char* m_scheme;
-    const char* m_hostname;
-    int         m_port;
-    const char* m_path;
+  UriTestCase(const char *uri, const char *scheme, const char *hostname,
+              int port, const char *path)
+      : m_uri(uri), m_result(true), m_scheme(scheme), m_hostname(hostname),
+        m_port(port), m_path(path) {}
+
+  UriTestCase(const char *uri)
+      : m_uri(uri), m_result(false), m_scheme(kAsdf), m_hostname(kAsdf),
+        m_port(1138), m_path(kAsdf) {}
+
+  const char *m_uri;
+  bool m_result;
+  const char *m_scheme;
+  const char *m_hostname;
+  int m_port;
+  const char *m_path;
 };
 
-#define VALIDATE \
-    std::string scheme(kAsdf); \
-    std::string hostname(kAsdf); \
-    int port(1138); \
-    std::string path(kAsdf); \
-    EXPECT_EQ (testCase.m_result, UriParser::Parse(testCase.m_uri, scheme, hostname, port, path)); \
-    EXPECT_STREQ (testCase.m_scheme, scheme.c_str()); \
-    EXPECT_STREQ (testCase.m_hostname, hostname.c_str()); \
-    EXPECT_EQ (testCase.m_port, port); \
-    EXPECT_STREQ (testCase.m_path, path.c_str());
+#define VALIDATE                                                               \
+  std::string scheme(kAsdf);                                                   \
+  std::string hostname(kAsdf);                                                 \
+  int port(1138);                                                              \
+  std::string path(kAsdf);                                                     \
+  EXPECT_EQ(testCase.m_result,                                                 \
+            UriParser::Parse(testCase.m_uri, scheme, hostname, port, path));   \
+  EXPECT_STREQ(testCase.m_scheme, scheme.c_str());                             \
+  EXPECT_STREQ(testCase.m_hostname, hostname.c_str());                         \
+  EXPECT_EQ(testCase.m_port, port);                                            \
+  EXPECT_STREQ(testCase.m_path, path.c_str());
 
-TEST_F (UriParserTest, Minimal)
-{
-    const UriTestCase testCase("x://y", "x", "y", -1, "/");
-    VALIDATE
+TEST_F(UriParserTest, Minimal) {
+  const UriTestCase testCase("x://y", "x", "y", -1, "/");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, MinimalPort)
-{
-    const UriTestCase testCase("x://y:1", "x", "y", 1, "/");
-    VALIDATE
+TEST_F(UriParserTest, MinimalPort) {
+  const UriTestCase testCase("x://y:1", "x", "y", 1, "/");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, MinimalPath)
-{
-    const UriTestCase testCase("x://y/", "x", "y", -1, "/");
-    VALIDATE
+TEST_F(UriParserTest, MinimalPath) {
+  const UriTestCase testCase("x://y/", "x", "y", -1, "/");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, MinimalPortPath)
-{
-    const UriTestCase testCase("x://y:1/", "x", "y", 1, "/");
-    VALIDATE
+TEST_F(UriParserTest, MinimalPortPath) {
+  const UriTestCase testCase("x://y:1/", "x", "y", 1, "/");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, LongPath)
-{
-    const UriTestCase testCase("x://y/abc/def/xyz", "x", "y", -1, "/abc/def/xyz");
-    VALIDATE
+TEST_F(UriParserTest, LongPath) {
+  const UriTestCase testCase("x://y/abc/def/xyz", "x", "y", -1, "/abc/def/xyz");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, TypicalPortPath)
-{
-    const UriTestCase testCase("connect://192.168.100.132:5432/", "connect", "192.168.100.132", 5432, "/");
-    VALIDATE
+TEST_F(UriParserTest, TypicalPortPath) {
+  const UriTestCase testCase("connect://192.168.100.132:5432/", "connect",
+                             "192.168.100.132", 5432, "/");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, BracketedHostnamePort)
-{
-    const UriTestCase testCase("connect://[192.168.100.132]:5432/", "connect", "192.168.100.132", 5432, "/");
-    VALIDATE
+TEST_F(UriParserTest, BracketedHostnamePort) {
+  const UriTestCase testCase("connect://[192.168.100.132]:5432/", "connect",
+                             "192.168.100.132", 5432, "/");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, BracketedHostname)
-{
-    const UriTestCase testCase("connect://[192.168.100.132]", "connect", "192.168.100.132", -1, "/");
-    VALIDATE
+TEST_F(UriParserTest, BracketedHostname) {
+  const UriTestCase testCase("connect://[192.168.100.132]", "connect",
+                             "192.168.100.132", -1, "/");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, BracketedHostnameWithColon)
-{
-    const UriTestCase testCase("connect://[192.168.100.132:5555]:1234", "connect", "192.168.100.132:5555", 1234, "/");
-    VALIDATE
+TEST_F(UriParserTest, BracketedHostnameWithColon) {
+  const UriTestCase testCase("connect://[192.168.100.132:5555]:1234", "connect",
+                             "192.168.100.132:5555", 1234, "/");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, SchemeHostSeparator)
-{
-    const UriTestCase testCase("x:/y");
-    VALIDATE
+TEST_F(UriParserTest, SchemeHostSeparator) {
+  const UriTestCase testCase("x:/y");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, SchemeHostSeparator2)
-{
-    const UriTestCase testCase("x:y");
-    VALIDATE
+TEST_F(UriParserTest, SchemeHostSeparator2) {
+  const UriTestCase testCase("x:y");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, SchemeHostSeparator3)
-{
-    const UriTestCase testCase("x//y");
-    VALIDATE
+TEST_F(UriParserTest, SchemeHostSeparator3) {
+  const UriTestCase testCase("x//y");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, SchemeHostSeparator4)
-{
-    const UriTestCase testCase("x/y");
-    VALIDATE
+TEST_F(UriParserTest, SchemeHostSeparator4) {
+  const UriTestCase testCase("x/y");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, BadPort)
-{
-    const UriTestCase testCase("x://y:a/");
-    VALIDATE
+TEST_F(UriParserTest, BadPort) {
+  const UriTestCase testCase("x://y:a/");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, BadPort2)
-{
-    const UriTestCase testCase("x://y:5432a/");
-    VALIDATE
+TEST_F(UriParserTest, BadPort2) {
+  const UriTestCase testCase("x://y:5432a/");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, Empty)
-{
-    const UriTestCase testCase("");
-    VALIDATE
+TEST_F(UriParserTest, Empty) {
+  const UriTestCase testCase("");
+  VALIDATE
 }
 
-TEST_F (UriParserTest, PortOverflow)
-{
-    const UriTestCase testCase("x://y:0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789/");
-    VALIDATE
+TEST_F(UriParserTest, PortOverflow) {
+  const UriTestCase testCase("x://"
+                             "y:"
+                             "0123456789012345678901234567890123456789012345678"
+                             "9012345678901234567890123456789012345678901234567"
+                             "89/");
+  VALIDATE
 }
-
diff --git a/lldb/unittests/gtest_common.h b/lldb/unittests/gtest_common.h
index 006c9596ca4..c8fe9257594 100644
--- a/lldb/unittests/gtest_common.h
+++ b/lldb/unittests/gtest_common.h
@@ -17,8 +17,10 @@
 // units.  Be very leary about putting anything in this file.
 
 #if defined(_MSC_VER) && (_HAS_EXCEPTIONS == 0)
-// Due to a bug in <thread>, when _HAS_EXCEPTIONS == 0 the header will try to call
-// uncaught_exception() without having a declaration for it.  The fix for this is
+// Due to a bug in <thread>, when _HAS_EXCEPTIONS == 0 the header will try to
+// call
+// uncaught_exception() without having a declaration for it.  The fix for this
+// is
 // to manually #include <eh.h>, which contains this declaration.
 #include <eh.h>
 #endif