211 lines
7.5 KiB
C++
211 lines
7.5 KiB
C++
//===-- UnixSignalsTest.cpp -----------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
#include <string>
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
#include "lldb/Target/UnixSignals.h"
|
|
#include "llvm/Support/FormatVariadic.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
class TestSignals : public UnixSignals {
|
|
public:
|
|
TestSignals() {
|
|
m_signals.clear();
|
|
AddSignal(2, "SIG2", false, true, true, "DESC2");
|
|
AddSignal(4, "SIG4", true, false, true, "DESC4");
|
|
AddSignal(8, "SIG8", true, true, true, "DESC8");
|
|
AddSignal(16, "SIG16", true, false, false, "DESC16");
|
|
AddSignalCode(16, 1, "a specific type of SIG16");
|
|
AddSignalCode(16, 2, "SIG16 with a fault address",
|
|
SignalCodePrintOption::Address);
|
|
AddSignalCode(16, 3, "bounds violation", SignalCodePrintOption::Bounds);
|
|
}
|
|
};
|
|
|
|
void ExpectEqArrays(llvm::ArrayRef<int32_t> expected,
|
|
llvm::ArrayRef<int32_t> observed, const char *file,
|
|
int line) {
|
|
std::string location = llvm::formatv("{0}:{1}", file, line);
|
|
ASSERT_EQ(expected.size(), observed.size()) << location;
|
|
|
|
for (size_t i = 0; i < observed.size(); ++i) {
|
|
ASSERT_EQ(expected[i], observed[i])
|
|
<< "array index: " << i << "location:" << location;
|
|
}
|
|
}
|
|
|
|
#define EXPECT_EQ_ARRAYS(expected, observed) \
|
|
ExpectEqArrays((expected), (observed), __FILE__, __LINE__);
|
|
|
|
TEST(UnixSignalsTest, Iteration) {
|
|
TestSignals signals;
|
|
|
|
EXPECT_EQ(4, signals.GetNumSignals());
|
|
EXPECT_EQ(2, signals.GetFirstSignalNumber());
|
|
EXPECT_EQ(4, signals.GetNextSignalNumber(2));
|
|
EXPECT_EQ(8, signals.GetNextSignalNumber(4));
|
|
EXPECT_EQ(16, signals.GetNextSignalNumber(8));
|
|
EXPECT_EQ(LLDB_INVALID_SIGNAL_NUMBER, signals.GetNextSignalNumber(16));
|
|
}
|
|
|
|
TEST(UnixSignalsTest, Reset) {
|
|
TestSignals signals;
|
|
bool stop_val = signals.GetShouldStop(2);
|
|
bool notify_val = signals.GetShouldNotify(2);
|
|
bool suppress_val = signals.GetShouldSuppress(2);
|
|
|
|
// Change two, then reset one and make sure only that one was reset:
|
|
EXPECT_EQ(true, signals.SetShouldNotify(2, !notify_val));
|
|
EXPECT_EQ(true, signals.SetShouldSuppress(2, !suppress_val));
|
|
EXPECT_EQ(true, signals.ResetSignal(2, false, true, false));
|
|
EXPECT_EQ(stop_val, signals.GetShouldStop(2));
|
|
EXPECT_EQ(notify_val, signals.GetShouldStop(2));
|
|
EXPECT_EQ(!suppress_val, signals.GetShouldNotify(2));
|
|
|
|
// Make sure reset with no arguments resets them all:
|
|
EXPECT_EQ(true, signals.SetShouldSuppress(2, !suppress_val));
|
|
EXPECT_EQ(true, signals.SetShouldNotify(2, !notify_val));
|
|
EXPECT_EQ(true, signals.ResetSignal(2));
|
|
EXPECT_EQ(stop_val, signals.GetShouldStop(2));
|
|
EXPECT_EQ(notify_val, signals.GetShouldNotify(2));
|
|
EXPECT_EQ(suppress_val, signals.GetShouldSuppress(2));
|
|
}
|
|
|
|
TEST(UnixSignalsTest, GetInfo) {
|
|
TestSignals signals;
|
|
|
|
bool should_suppress = false, should_stop = false, should_notify = false;
|
|
int32_t signo = 4;
|
|
bool success =
|
|
signals.GetSignalInfo(signo, should_suppress, should_stop, should_notify);
|
|
ASSERT_TRUE(success);
|
|
EXPECT_EQ(true, should_suppress);
|
|
EXPECT_EQ(false, should_stop);
|
|
EXPECT_EQ(true, should_notify);
|
|
|
|
EXPECT_EQ(true, signals.GetShouldSuppress(signo));
|
|
EXPECT_EQ(false, signals.GetShouldStop(signo));
|
|
EXPECT_EQ(true, signals.GetShouldNotify(signo));
|
|
}
|
|
|
|
TEST(UnixSignalsTest, GetAsStringRef) {
|
|
TestSignals signals;
|
|
|
|
ASSERT_EQ(llvm::StringRef(), signals.GetSignalAsStringRef(100));
|
|
ASSERT_EQ("SIG16", signals.GetSignalAsStringRef(16));
|
|
}
|
|
|
|
TEST(UnixSignalsTest, GetAsString) {
|
|
TestSignals signals;
|
|
|
|
ASSERT_EQ("", signals.GetSignalDescription(100, std::nullopt));
|
|
ASSERT_EQ("SIG16", signals.GetSignalDescription(16, std::nullopt));
|
|
ASSERT_EQ("", signals.GetSignalDescription(100, 100));
|
|
ASSERT_EQ("SIG16", signals.GetSignalDescription(16, 100));
|
|
ASSERT_EQ("SIG16: a specific type of SIG16",
|
|
signals.GetSignalDescription(16, 1));
|
|
|
|
// Unknown code, won't use the address.
|
|
ASSERT_EQ("SIG16", signals.GetSignalDescription(16, 100, 0xCAFEF00D));
|
|
// Known code, that shouldn't print fault address.
|
|
ASSERT_EQ("SIG16: a specific type of SIG16",
|
|
signals.GetSignalDescription(16, 1, 0xCAFEF00D));
|
|
// Known code that should.
|
|
ASSERT_EQ("SIG16: SIG16 with a fault address (fault address: 0xcafef00d)",
|
|
signals.GetSignalDescription(16, 2, 0xCAFEF00D));
|
|
// No address given just print the code description.
|
|
ASSERT_EQ("SIG16: SIG16 with a fault address",
|
|
signals.GetSignalDescription(16, 2));
|
|
|
|
const char *expected = "SIG16: bounds violation";
|
|
// Must pass all needed info to get full output.
|
|
ASSERT_EQ(expected, signals.GetSignalDescription(16, 3));
|
|
ASSERT_EQ(expected, signals.GetSignalDescription(16, 3, 0xcafef00d));
|
|
ASSERT_EQ(expected, signals.GetSignalDescription(16, 3, 0xcafef00d, 0x1234));
|
|
|
|
ASSERT_EQ("SIG16: upper bound violation (fault address: 0x5679, lower bound: "
|
|
"0x1234, upper bound: 0x5678)",
|
|
signals.GetSignalDescription(16, 3, 0x5679, 0x1234, 0x5678));
|
|
ASSERT_EQ("SIG16: lower bound violation (fault address: 0x1233, lower bound: "
|
|
"0x1234, upper bound: 0x5678)",
|
|
signals.GetSignalDescription(16, 3, 0x1233, 0x1234, 0x5678));
|
|
}
|
|
|
|
TEST(UnixSignalsTest, VersionChange) {
|
|
TestSignals signals;
|
|
|
|
int32_t signo = 8;
|
|
uint64_t ver = signals.GetVersion();
|
|
EXPECT_GT(ver, 0ull);
|
|
EXPECT_EQ(true, signals.GetShouldSuppress(signo));
|
|
EXPECT_EQ(true, signals.GetShouldStop(signo));
|
|
EXPECT_EQ(true, signals.GetShouldNotify(signo));
|
|
|
|
EXPECT_EQ(signals.GetVersion(), ver);
|
|
|
|
signals.SetShouldSuppress(signo, false);
|
|
EXPECT_LT(ver, signals.GetVersion());
|
|
ver = signals.GetVersion();
|
|
|
|
signals.SetShouldStop(signo, true);
|
|
EXPECT_LT(ver, signals.GetVersion());
|
|
ver = signals.GetVersion();
|
|
|
|
signals.SetShouldNotify(signo, false);
|
|
EXPECT_LT(ver, signals.GetVersion());
|
|
ver = signals.GetVersion();
|
|
|
|
EXPECT_EQ(false, signals.GetShouldSuppress(signo));
|
|
EXPECT_EQ(true, signals.GetShouldStop(signo));
|
|
EXPECT_EQ(false, signals.GetShouldNotify(signo));
|
|
|
|
EXPECT_EQ(ver, signals.GetVersion());
|
|
}
|
|
|
|
TEST(UnixSignalsTest, GetFilteredSignals) {
|
|
TestSignals signals;
|
|
|
|
auto all_signals =
|
|
signals.GetFilteredSignals(std::nullopt, std::nullopt, std::nullopt);
|
|
std::vector<int32_t> expected = {2, 4, 8, 16};
|
|
EXPECT_EQ_ARRAYS(expected, all_signals);
|
|
|
|
auto supressed = signals.GetFilteredSignals(true, std::nullopt, std::nullopt);
|
|
expected = {4, 8, 16};
|
|
EXPECT_EQ_ARRAYS(expected, supressed);
|
|
|
|
auto not_supressed =
|
|
signals.GetFilteredSignals(false, std::nullopt, std::nullopt);
|
|
expected = {2};
|
|
EXPECT_EQ_ARRAYS(expected, not_supressed);
|
|
|
|
auto stopped = signals.GetFilteredSignals(std::nullopt, true, std::nullopt);
|
|
expected = {2, 8};
|
|
EXPECT_EQ_ARRAYS(expected, stopped);
|
|
|
|
auto not_stopped =
|
|
signals.GetFilteredSignals(std::nullopt, false, std::nullopt);
|
|
expected = {4, 16};
|
|
EXPECT_EQ_ARRAYS(expected, not_stopped);
|
|
|
|
auto notified = signals.GetFilteredSignals(std::nullopt, std::nullopt, true);
|
|
expected = {2, 4, 8};
|
|
EXPECT_EQ_ARRAYS(expected, notified);
|
|
|
|
auto not_notified =
|
|
signals.GetFilteredSignals(std::nullopt, std::nullopt, false);
|
|
expected = {16};
|
|
EXPECT_EQ_ARRAYS(expected, not_notified);
|
|
|
|
auto signal4 = signals.GetFilteredSignals(true, false, true);
|
|
expected = {4};
|
|
EXPECT_EQ_ARRAYS(expected, signal4);
|
|
}
|