Imported Upstream version 6.10.0.49

Former-commit-id: 1d6753294b2993e1fbf92de9366bb9544db4189b

external/llvm-project/lldb/unittests/Core/BroadcasterTest.cpp

@@ -0,0 +1,75 @@
+//===-- BroadcasterTest.cpp -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "lldb/Core/Broadcaster.h"
+#include "lldb/Core/Event.h"
+#include "lldb/Core/Listener.h"
+#include "lldb/Host/Predicate.h"
+
+#include <thread>
+
+using namespace lldb;
+using namespace lldb_private;
+
+TEST(BroadcasterTest, BroadcastEvent) {
+  EventSP event_sp;
+  Broadcaster broadcaster(nullptr, "test-broadcaster");
+  std::chrono::seconds timeout(0);
+
+  // 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->GetEvent(event_sp, timeout));
+  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->GetEvent(event_sp, timeout));
+    EXPECT_EQ(event_mask2, event_sp->GetType());
+
+    // Both listeners should get this event.
+    broadcaster.BroadcastEvent(event_mask1, nullptr);
+    EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
+    EXPECT_EQ(event_mask1, event_sp->GetType());
+    EXPECT_TRUE(listener2_sp->GetEvent(event_sp, timeout));
+    EXPECT_EQ(event_mask2, event_sp->GetType());
+  }
+
+  // Now again only one listener should be active.
+  broadcaster.BroadcastEvent(event_mask1, nullptr);
+  EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
+  EXPECT_EQ(event_mask1, event_sp->GetType());
+}
+
+TEST(BroadcasterTest, EventTypeHasListeners) {
+  EventSP event_sp;
+  Broadcaster broadcaster(nullptr, "test-broadcaster");
+
+  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));
+  }
+
+  EXPECT_FALSE(broadcaster.EventTypeHasListeners(event_mask));
+}

external/llvm-project/lldb/unittests/Core/CMakeLists.txt

@@ -0,0 +1,14 @@
+add_lldb_unittest(LLDBCoreTests
+  BroadcasterTest.cpp
+  DataExtractorTest.cpp
+  ListenerTest.cpp
+  ScalarTest.cpp
+  StateTest.cpp
+  StreamCallbackTest.cpp
+
+  LINK_LIBS
+    lldbCore
+    lldbHost
+  LINK_COMPONENTS
+    Support
+  )

external/llvm-project/lldb/unittests/Core/DataExtractorTest.cpp

@@ -0,0 +1,168 @@
+//===-- DataExtractorTest.cpp -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "lldb/Utility/DataExtractor.h"
+
+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, 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 + 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));
+}
+
+TEST(DataExtractorTest, GetMaxU64) {
+  uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
+  DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
+                   sizeof(void *));
+  DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));
+
+  lldb::offset_t offset;
+
+  // Check with the minimum allowed byte size.
+  offset = 0;
+  EXPECT_EQ(0x01U, LE.GetMaxU64(&offset, 1));
+  EXPECT_EQ(1U, offset);
+  offset = 0;
+  EXPECT_EQ(0x01U, BE.GetMaxU64(&offset, 1));
+  EXPECT_EQ(1U, offset);
+
+  // Check with a non-zero offset.
+  offset = 1;
+  EXPECT_EQ(0x0302U, LE.GetMaxU64(&offset, 2));
+  EXPECT_EQ(3U, offset);
+  offset = 1;
+  EXPECT_EQ(0x0203U, BE.GetMaxU64(&offset, 2));
+  EXPECT_EQ(3U, offset);
+
+  // Check with the byte size not being a multiple of 2.
+  offset = 0;
+  EXPECT_EQ(0x07060504030201U, LE.GetMaxU64(&offset, 7));
+  EXPECT_EQ(7U, offset);
+  offset = 0;
+  EXPECT_EQ(0x01020304050607U, BE.GetMaxU64(&offset, 7));
+  EXPECT_EQ(7U, offset);
+
+  // Check with the maximum allowed byte size.
+  offset = 0;
+  EXPECT_EQ(0x0807060504030201U, LE.GetMaxU64(&offset, 8));
+  EXPECT_EQ(8U, offset);
+  offset = 0;
+  EXPECT_EQ(0x0102030405060708U, BE.GetMaxU64(&offset, 8));
+  EXPECT_EQ(8U, offset);
+}
+
+TEST(DataExtractorTest, GetMaxS64) {
+  uint8_t buffer[] = {0x01, 0x02, 0x83, 0x04, 0x05, 0x06, 0x07, 0x08};
+  DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
+                   sizeof(void *));
+  DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));
+
+  lldb::offset_t offset;
+
+  // Check with the minimum allowed byte size.
+  offset = 0;
+  EXPECT_EQ(0x01, LE.GetMaxS64(&offset, 1));
+  EXPECT_EQ(1U, offset);
+  offset = 0;
+  EXPECT_EQ(0x01, BE.GetMaxS64(&offset, 1));
+  EXPECT_EQ(1U, offset);
+
+  // Check that sign extension works correctly.
+  offset = 0;
+  int64_t value = LE.GetMaxS64(&offset, 3);
+  EXPECT_EQ(0xffffffffff830201U, *reinterpret_cast<uint64_t *>(&value));
+  EXPECT_EQ(3U, offset);
+  offset = 2;
+  value = BE.GetMaxS64(&offset, 3);
+  EXPECT_EQ(0xffffffffff830405U, *reinterpret_cast<uint64_t *>(&value));
+  EXPECT_EQ(5U, offset);
+
+  // Check with the maximum allowed byte size.
+  offset = 0;
+  EXPECT_EQ(0x0807060504830201, LE.GetMaxS64(&offset, 8));
+  EXPECT_EQ(8U, offset);
+  offset = 0;
+  EXPECT_EQ(0x0102830405060708, BE.GetMaxS64(&offset, 8));
+  EXPECT_EQ(8U, offset);
+}
+
+TEST(DataExtractorTest, GetMaxU64_unchecked) {
+  uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
+  DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
+                   sizeof(void *));
+  DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));
+
+  lldb::offset_t offset;
+
+  // Check with the minimum allowed byte size.
+  offset = 0;
+  EXPECT_EQ(0x01U, LE.GetMaxU64_unchecked(&offset, 1));
+  EXPECT_EQ(1U, offset);
+  offset = 0;
+  EXPECT_EQ(0x01U, BE.GetMaxU64_unchecked(&offset, 1));
+  EXPECT_EQ(1U, offset);
+
+  // Check with a non-zero offset.
+  offset = 1;
+  EXPECT_EQ(0x0302U, LE.GetMaxU64_unchecked(&offset, 2));
+  EXPECT_EQ(3U, offset);
+  offset = 1;
+  EXPECT_EQ(0x0203U, BE.GetMaxU64_unchecked(&offset, 2));
+  EXPECT_EQ(3U, offset);
+
+  // Check with the byte size not being a multiple of 2.
+  offset = 0;
+  EXPECT_EQ(0x07060504030201U, LE.GetMaxU64_unchecked(&offset, 7));
+  EXPECT_EQ(7U, offset);
+  offset = 0;
+  EXPECT_EQ(0x01020304050607U, BE.GetMaxU64_unchecked(&offset, 7));
+  EXPECT_EQ(7U, offset);
+
+  // Check with the maximum allowed byte size.
+  offset = 0;
+  EXPECT_EQ(0x0807060504030201U, LE.GetMaxU64_unchecked(&offset, 8));
+  EXPECT_EQ(8U, offset);
+  offset = 0;
+  EXPECT_EQ(0x0102030405060708U, BE.GetMaxU64_unchecked(&offset, 8));
+  EXPECT_EQ(8U, offset);
+}

external/llvm-project/lldb/unittests/Core/ListenerTest.cpp

@@ -0,0 +1,114 @@
+//===-- ListenerTest.cpp ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "lldb/Core/Broadcaster.h"
+#include "lldb/Core/Listener.h"
+#include <future>
+#include <thread>
+
+using namespace lldb;
+using namespace lldb_private;
+
+TEST(ListenerTest, GetEventImmediate) {
+  EventSP event_sp;
+  Broadcaster broadcaster(nullptr, "test-broadcaster");
+
+  // Create a listener, sign it up, make sure it recieves an event.
+  ListenerSP listener_sp = Listener::MakeListener("test-listener");
+  const uint32_t event_mask = 1;
+  ASSERT_EQ(event_mask,
+            listener_sp->StartListeningForEvents(&broadcaster, event_mask));
+
+  const std::chrono::seconds timeout(0);
+  // Without any events sent, these should return false.
+  EXPECT_FALSE(listener_sp->GetEvent(event_sp, timeout));
+  EXPECT_FALSE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
+  EXPECT_FALSE(
+      listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
+  EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
+      &broadcaster, event_mask, event_sp, timeout));
+
+  // Now send events and make sure they get it.
+  broadcaster.BroadcastEvent(event_mask, nullptr);
+  EXPECT_TRUE(listener_sp->GetEvent(event_sp, timeout));
+
+  broadcaster.BroadcastEvent(event_mask, nullptr);
+  EXPECT_TRUE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
+
+  broadcaster.BroadcastEvent(event_mask, nullptr);
+  EXPECT_TRUE(
+      listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
+
+  broadcaster.BroadcastEvent(event_mask, nullptr);
+  EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
+      &broadcaster, event_mask * 2, event_sp, timeout));
+  EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
+      &broadcaster, event_mask, event_sp, timeout));
+}
+
+TEST(ListenerTest, GetEventWait) {
+  EventSP event_sp;
+  Broadcaster broadcaster(nullptr, "test-broadcaster");
+
+  // Create a listener, sign it up, make sure it recieves an event.
+  ListenerSP listener_sp = Listener::MakeListener("test-listener");
+  const uint32_t event_mask = 1;
+  ASSERT_EQ(event_mask,
+            listener_sp->StartListeningForEvents(&broadcaster, event_mask));
+
+  // Without any events sent, these should make a short wait and return false.
+  std::chrono::microseconds timeout(10);
+  EXPECT_FALSE(listener_sp->GetEvent(event_sp, timeout));
+  EXPECT_FALSE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
+  EXPECT_FALSE(
+      listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
+  EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
+      &broadcaster, event_mask, event_sp, timeout));
+
+  // Now send events and make sure they get it.
+  broadcaster.BroadcastEvent(event_mask, nullptr);
+  EXPECT_TRUE(listener_sp->GetEvent(event_sp, timeout));
+
+  broadcaster.BroadcastEvent(event_mask, nullptr);
+  EXPECT_TRUE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
+
+  broadcaster.BroadcastEvent(event_mask, nullptr);
+  EXPECT_TRUE(
+      listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
+
+  broadcaster.BroadcastEvent(event_mask, nullptr);
+  EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
+      &broadcaster, event_mask * 2, event_sp, timeout));
+  EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
+      &broadcaster, event_mask, event_sp, timeout));
+
+  auto delayed_broadcast = [&] {
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    broadcaster.BroadcastEvent(event_mask, nullptr);
+  };
+
+  // These should do an infinite wait at return the event our asynchronous
+  // broadcast sends.
+  std::future<void> async_broadcast =
+      std::async(std::launch::async, delayed_broadcast);
+  EXPECT_TRUE(listener_sp->GetEvent(event_sp, llvm::None));
+  async_broadcast.get();
+
+  async_broadcast = std::async(std::launch::async, delayed_broadcast);
+  EXPECT_TRUE(
+      listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, llvm::None));
+  async_broadcast.get();
+
+  async_broadcast = std::async(std::launch::async, delayed_broadcast);
+  EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
+      &broadcaster, event_mask, event_sp, llvm::None));
+  async_broadcast.get();
+}

external/llvm-project/lldb/unittests/Core/ScalarTest.cpp

@@ -0,0 +1,134 @@
+//===-- ScalarTest.cpp ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "lldb/Core/Scalar.h"
+#include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Endian.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/Utility/StreamString.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, 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 *));
+  Status e_error =
+      e_scalar.SetValueFromData(e_data, lldb::eEncodingUint, sizeof(e));
+  DataExtractor f_data(f, sizeof(f), endian::InlHostByteOrder(),
+                       sizeof(void *));
+  Status 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, 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)));
+
+  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();
+}
+
+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("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()));
+}

external/llvm-project/lldb/unittests/Core/StateTest.cpp

@@ -0,0 +1,21 @@
+//===-- StateTest.cpp -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/State.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "gtest/gtest.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+TEST(StateTest, Formatv) {
+  EXPECT_EQ("exited", llvm::formatv("{0}", eStateExited).str());
+  EXPECT_EQ("stopped", llvm::formatv("{0}", eStateStopped).str());
+  EXPECT_EQ("unknown", llvm::formatv("{0}", StateType(-1)).str());
+}

external/llvm-project/lldb/unittests/Core/StreamCallbackTest.cpp

@@ -0,0 +1,28 @@
+//===-- StreamCallbackTest.cpp ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/StreamCallback.h"
+#include "gtest/gtest.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+static char test_baton;
+static size_t callback_count = 0;
+static void TestCallback(const char *data, void *baton) {
+  EXPECT_STREQ("Foobar", data);
+  EXPECT_EQ(&test_baton, baton);
+  ++callback_count;
+}
+
+TEST(StreamCallbackTest, Callback) {
+  StreamCallback stream(TestCallback, &test_baton);
+  stream << "Foobar";
+  EXPECT_EQ(1u, callback_count);
+}