*** 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

5 files changed, 864 insertions, 947 deletions

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
 }
-