lldb/unittests/Core/DiagnosticEventTest.cpp

   1 //===-- DiagnosticEventTest.cpp -------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "gtest/gtest.h"
  10
  11 #include "Plugins/Platform/MacOSX/PlatformMacOSX.h"
  12 #include "Plugins/Platform/MacOSX/PlatformRemoteMacOSX.h"
  13 #include "TestingSupport/SubsystemRAII.h"
  14 #include "lldb/Core/Debugger.h"
  15 #include "lldb/Core/DebuggerEvents.h"
  16 #include "lldb/Host/FileSystem.h"
  17 #include "lldb/Host/HostInfo.h"
  18 #include "lldb/Utility/Broadcaster.h"
  19 #include "lldb/Utility/Event.h"
  20 #include "lldb/Utility/Listener.h"
  21
  22 using namespace lldb;
  23 using namespace lldb_private;
  24 using namespace lldb_private::repro;
  25
  26 static const constexpr std::chrono::seconds TIMEOUT(0);
  27 static const constexpr size_t DEBUGGERS = 3;
  28
  29 static std::once_flag debugger_initialize_flag;
  30
  31 namespace {
  32 class DiagnosticEventTest : public ::testing::Test {
  33 public:
  34   void SetUp() override {
  35     FileSystem::Initialize();
  36     HostInfo::Initialize();
  37     PlatformMacOSX::Initialize();
  38     std::call_once(debugger_initialize_flag,
  39                    []() { Debugger::Initialize(nullptr); });
  40     ArchSpec arch("x86_64-apple-macosx-");
  41     Platform::SetHostPlatform(
  42         PlatformRemoteMacOSX::CreateInstance(true, &arch));
  43   }
  44   void TearDown() override {
  45     PlatformMacOSX::Terminate();
  46     HostInfo::Terminate();
  47     FileSystem::Terminate();
  48   }
  49 };
  50 } // namespace
  51
  52 TEST_F(DiagnosticEventTest, Warning) {
  53   DebuggerSP debugger_sp = Debugger::CreateInstance();
  54
  55   Broadcaster &broadcaster = debugger_sp->GetBroadcaster();
  56   ListenerSP listener_sp = Listener::MakeListener("test-listener");
  57
  58   listener_sp->StartListeningForEvents(&broadcaster,
  59                                        Debugger::eBroadcastBitWarning);
  60   EXPECT_TRUE(
  61       broadcaster.EventTypeHasListeners(Debugger::eBroadcastBitWarning));
  62
  63   Debugger::ReportWarning("foo", debugger_sp->GetID());
  64
  65   EventSP event_sp;
  66   EXPECT_TRUE(listener_sp->GetEvent(event_sp, TIMEOUT));
  67   ASSERT_TRUE(event_sp);
  68
  69   const DiagnosticEventData *data =
  70       DiagnosticEventData::GetEventDataFromEvent(event_sp.get());
  71   ASSERT_NE(data, nullptr);
  72   EXPECT_EQ(data->GetPrefix(), "warning");
  73   EXPECT_EQ(data->GetMessage(), "foo");
  74
  75   Debugger::Destroy(debugger_sp);
  76 }
  77
  78 TEST_F(DiagnosticEventTest, Error) {
  79   DebuggerSP debugger_sp = Debugger::CreateInstance();
  80
  81   Broadcaster &broadcaster = debugger_sp->GetBroadcaster();
  82   ListenerSP listener_sp = Listener::MakeListener("test-listener");
  83
  84   listener_sp->StartListeningForEvents(&broadcaster,
  85                                        Debugger::eBroadcastBitError);
  86   EXPECT_TRUE(broadcaster.EventTypeHasListeners(Debugger::eBroadcastBitError));
  87
  88   Debugger::ReportError("bar", debugger_sp->GetID());
  89
  90   EventSP event_sp;
  91   EXPECT_TRUE(listener_sp->GetEvent(event_sp, TIMEOUT));
  92   ASSERT_TRUE(event_sp);
  93
  94   const DiagnosticEventData *data =
  95       DiagnosticEventData::GetEventDataFromEvent(event_sp.get());
  96   ASSERT_NE(data, nullptr);
  97   EXPECT_EQ(data->GetPrefix(), "error");
  98   EXPECT_EQ(data->GetMessage(), "bar");
  99
 100   Debugger::Destroy(debugger_sp);
 101 }
 102
 103 TEST_F(DiagnosticEventTest, MultipleDebuggers) {
 104   std::vector<DebuggerSP> debuggers;
 105   std::vector<ListenerSP> listeners;
 106
 107   for (size_t i = 0; i < DEBUGGERS; ++i) {
 108     DebuggerSP debugger = Debugger::CreateInstance();
 109     ListenerSP listener = Listener::MakeListener("listener");
 110
 111     debuggers.push_back(debugger);
 112     listeners.push_back(listener);
 113
 114     listener->StartListeningForEvents(&debugger->GetBroadcaster(),
 115                                       Debugger::eBroadcastBitError);
 116   }
 117
 118   Debugger::ReportError("baz");
 119
 120   for (size_t i = 0; i < DEBUGGERS; ++i) {
 121     EventSP event_sp;
 122     EXPECT_TRUE(listeners[i]->GetEvent(event_sp, TIMEOUT));
 123     ASSERT_TRUE(event_sp);
 124
 125     const DiagnosticEventData *data =
 126         DiagnosticEventData::GetEventDataFromEvent(event_sp.get());
 127     ASSERT_NE(data, nullptr);
 128     EXPECT_EQ(data->GetPrefix(), "error");
 129     EXPECT_EQ(data->GetMessage(), "baz");
 130   }
 131
 132   for (size_t i = 0; i < DEBUGGERS; ++i) {
 133     Debugger::Destroy(debuggers[i]);
 134   }
 135 }
 136
 137 TEST_F(DiagnosticEventTest, WarningOnce) {
 138   DebuggerSP debugger_sp = Debugger::CreateInstance();
 139
 140   Broadcaster &broadcaster = debugger_sp->GetBroadcaster();
 141   ListenerSP listener_sp = Listener::MakeListener("test-listener");
 142
 143   listener_sp->StartListeningForEvents(&broadcaster,
 144                                        Debugger::eBroadcastBitWarning);
 145   EXPECT_TRUE(
 146       broadcaster.EventTypeHasListeners(Debugger::eBroadcastBitWarning));
 147
 148   std::once_flag once;
 149   Debugger::ReportWarning("foo", debugger_sp->GetID(), &once);
 150
 151   {
 152     EventSP event_sp;
 153     EXPECT_TRUE(listener_sp->GetEvent(event_sp, TIMEOUT));
 154     ASSERT_TRUE(event_sp);
 155
 156     const DiagnosticEventData *data =
 157         DiagnosticEventData::GetEventDataFromEvent(event_sp.get());
 158     ASSERT_NE(data, nullptr);
 159     EXPECT_EQ(data->GetPrefix(), "warning");
 160     EXPECT_EQ(data->GetMessage(), "foo");
 161   }
 162
 163   EventSP second_event_sp;
 164   EXPECT_FALSE(listener_sp->GetEvent(second_event_sp, TIMEOUT));
 165
 166   Debugger::ReportWarning("foo", debugger_sp->GetID(), &once);
 167   EXPECT_FALSE(listener_sp->GetEvent(second_event_sp, TIMEOUT));
 168
 169   Debugger::ReportWarning("foo", debugger_sp->GetID());
 170   EXPECT_TRUE(listener_sp->GetEvent(second_event_sp, TIMEOUT));
 171
 172   Debugger::Destroy(debugger_sp);
 173 }