Debian Codegraph @

llvm-project/lldb/unittests/Core/DiagnosticEventTest.cpp

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