1 //===-- UnixSignalsTest.cpp -------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 #include <string>
10 
11 #include "gtest/gtest.h"
12 
13 #include "lldb/Target/UnixSignals.h"
14 #include "llvm/Support/FormatVariadic.h"
15 
16 using namespace lldb;
17 using namespace lldb_private;
18 using llvm::None;
19 
20 class TestSignals : public UnixSignals {
21 public:
22   TestSignals() {
23     m_signals.clear();
24     AddSignal(2, "SIG2", false, true, true, "DESC2");
25     AddSignal(4, "SIG4", true, false, true, "DESC4");
26     AddSignal(8, "SIG8", true, true, true, "DESC8");
27     AddSignal(16, "SIG16", true, false, false, "DESC16");
28   }
29 };
30 
31 void ExpectEqArrays(llvm::ArrayRef<int32_t> expected,
32                     llvm::ArrayRef<int32_t> observed, const char *file,
33                     int line) {
34   std::string location = llvm::formatv("{0}:{1}", file, line);
35   ASSERT_EQ(expected.size(), observed.size()) << location;
36 
37   for (size_t i = 0; i < observed.size(); ++i) {
38     ASSERT_EQ(expected[i], observed[i])
39         << "array index: " << i << "location:" << location;
40   }
41 }
42 
43 #define EXPECT_EQ_ARRAYS(expected, observed)                                   \
44   ExpectEqArrays((expected), (observed), __FILE__, __LINE__);
45 
46 TEST(UnixSignalsTest, Iteration) {
47   TestSignals signals;
48 
49   EXPECT_EQ(4, signals.GetNumSignals());
50   EXPECT_EQ(2, signals.GetFirstSignalNumber());
51   EXPECT_EQ(4, signals.GetNextSignalNumber(2));
52   EXPECT_EQ(8, signals.GetNextSignalNumber(4));
53   EXPECT_EQ(16, signals.GetNextSignalNumber(8));
54   EXPECT_EQ(LLDB_INVALID_SIGNAL_NUMBER, signals.GetNextSignalNumber(16));
55 }
56 
57 TEST(UnixSignalsTest, GetInfo) {
58   TestSignals signals;
59 
60   bool should_suppress = false, should_stop = false, should_notify = false;
61   int32_t signo = 4;
62   std::string name =
63       signals.GetSignalInfo(signo, should_suppress, should_stop, should_notify);
64   EXPECT_EQ("SIG4", name);
65   EXPECT_EQ(true, should_suppress);
66   EXPECT_EQ(false, should_stop);
67   EXPECT_EQ(true, should_notify);
68 
69   EXPECT_EQ(true, signals.GetShouldSuppress(signo));
70   EXPECT_EQ(false, signals.GetShouldStop(signo));
71   EXPECT_EQ(true, signals.GetShouldNotify(signo));
72   EXPECT_EQ(name, signals.GetSignalAsCString(signo));
73 }
74 
75 TEST(UnixSignalsTest, VersionChange) {
76   TestSignals signals;
77 
78   int32_t signo = 8;
79   uint64_t ver = signals.GetVersion();
80   EXPECT_GT(ver, 0ull);
81   EXPECT_EQ(true, signals.GetShouldSuppress(signo));
82   EXPECT_EQ(true, signals.GetShouldStop(signo));
83   EXPECT_EQ(true, signals.GetShouldNotify(signo));
84 
85   EXPECT_EQ(signals.GetVersion(), ver);
86 
87   signals.SetShouldSuppress(signo, false);
88   EXPECT_LT(ver, signals.GetVersion());
89   ver = signals.GetVersion();
90 
91   signals.SetShouldStop(signo, true);
92   EXPECT_LT(ver, signals.GetVersion());
93   ver = signals.GetVersion();
94 
95   signals.SetShouldNotify(signo, false);
96   EXPECT_LT(ver, signals.GetVersion());
97   ver = signals.GetVersion();
98 
99   EXPECT_EQ(false, signals.GetShouldSuppress(signo));
100   EXPECT_EQ(true, signals.GetShouldStop(signo));
101   EXPECT_EQ(false, signals.GetShouldNotify(signo));
102 
103   EXPECT_EQ(ver, signals.GetVersion());
104 }
105 
106 TEST(UnixSignalsTest, GetFilteredSignals) {
107   TestSignals signals;
108 
109   auto all_signals = signals.GetFilteredSignals(None, None, None);
110   std::vector<int32_t> expected = {2, 4, 8, 16};
111   EXPECT_EQ_ARRAYS(expected, all_signals);
112 
113   auto supressed = signals.GetFilteredSignals(true, None, None);
114   expected = {4, 8, 16};
115   EXPECT_EQ_ARRAYS(expected, supressed);
116 
117   auto not_supressed = signals.GetFilteredSignals(false, None, None);
118   expected = {2};
119   EXPECT_EQ_ARRAYS(expected, not_supressed);
120 
121   auto stopped = signals.GetFilteredSignals(None, true, None);
122   expected = {2, 8};
123   EXPECT_EQ_ARRAYS(expected, stopped);
124 
125   auto not_stopped = signals.GetFilteredSignals(None, false, None);
126   expected = {4, 16};
127   EXPECT_EQ_ARRAYS(expected, not_stopped);
128 
129   auto notified = signals.GetFilteredSignals(None, None, true);
130   expected = {2, 4, 8};
131   EXPECT_EQ_ARRAYS(expected, notified);
132 
133   auto not_notified = signals.GetFilteredSignals(None, None, false);
134   expected = {16};
135   EXPECT_EQ_ARRAYS(expected, not_notified);
136 
137   auto signal4 = signals.GetFilteredSignals(true, false, true);
138   expected = {4};
139   EXPECT_EQ_ARRAYS(expected, signal4);
140 }
141