Abseil Common Libraries (C++) (grcp 依赖)
https://abseil.io/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
156 lines
4.8 KiB
156 lines
4.8 KiB
// |
|
// Copyright 2018 The Abseil Authors. |
|
// |
|
// Licensed under the Apache License, Version 2.0 (the "License"); |
|
// you may not use this file except in compliance with the License. |
|
// You may obtain a copy of the License at |
|
// |
|
// https://www.apache.org/licenses/LICENSE-2.0 |
|
// |
|
// Unless required by applicable law or agreed to in writing, software |
|
// distributed under the License is distributed on an "AS IS" BASIS, |
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
// See the License for the specific language governing permissions and |
|
// limitations under the License. |
|
// |
|
|
|
#include "absl/debugging/failure_signal_handler.h" |
|
|
|
#include <csignal> |
|
#include <cstdio> |
|
#include <cstdlib> |
|
#include <cstring> |
|
#include <fstream> |
|
|
|
#include "gtest/gtest.h" |
|
#include "absl/base/internal/raw_logging.h" |
|
#include "absl/debugging/stacktrace.h" |
|
#include "absl/debugging/symbolize.h" |
|
#include "absl/strings/match.h" |
|
#include "absl/strings/str_cat.h" |
|
|
|
namespace { |
|
|
|
#if GTEST_HAS_DEATH_TEST |
|
|
|
// For the parameterized death tests. GetParam() returns the signal number. |
|
using FailureSignalHandlerDeathTest = ::testing::TestWithParam<int>; |
|
|
|
// This function runs in a fork()ed process on most systems. |
|
void InstallHandlerAndRaise(int signo) { |
|
absl::InstallFailureSignalHandler(absl::FailureSignalHandlerOptions()); |
|
raise(signo); |
|
} |
|
|
|
TEST_P(FailureSignalHandlerDeathTest, AbslFailureSignal) { |
|
const int signo = GetParam(); |
|
std::string exit_regex = absl::StrCat( |
|
"\\*\\*\\* ", absl::debugging_internal::FailureSignalToString(signo), |
|
" received at time="); |
|
#ifndef _WIN32 |
|
EXPECT_EXIT(InstallHandlerAndRaise(signo), testing::KilledBySignal(signo), |
|
exit_regex); |
|
#else |
|
// Windows doesn't have testing::KilledBySignal(). |
|
EXPECT_DEATH(InstallHandlerAndRaise(signo), exit_regex); |
|
#endif |
|
} |
|
|
|
ABSL_CONST_INIT FILE* error_file = nullptr; |
|
|
|
void WriteToErrorFile(const char* msg) { |
|
if (msg != nullptr) { |
|
ABSL_RAW_CHECK(fwrite(msg, strlen(msg), 1, error_file) == 1, |
|
"fwrite() failed"); |
|
} |
|
ABSL_RAW_CHECK(fflush(error_file) == 0, "fflush() failed"); |
|
} |
|
|
|
std::string GetTmpDir() { |
|
// TEST_TMPDIR is set by Bazel. Try the others when not running under Bazel. |
|
static const char* const kTmpEnvVars[] = {"TEST_TMPDIR", "TMPDIR", "TEMP", |
|
"TEMPDIR", "TMP"}; |
|
for (const char* const var : kTmpEnvVars) { |
|
const char* tmp_dir = std::getenv(var); |
|
if (tmp_dir != nullptr) { |
|
return tmp_dir; |
|
} |
|
} |
|
|
|
// Try something reasonable. |
|
return "/tmp"; |
|
} |
|
|
|
// This function runs in a fork()ed process on most systems. |
|
void InstallHandlerWithWriteToFileAndRaise(const char* file, int signo) { |
|
error_file = fopen(file, "w"); |
|
ABSL_RAW_CHECK(error_file != nullptr, "Failed create error_file"); |
|
absl::FailureSignalHandlerOptions options; |
|
options.writerfn = WriteToErrorFile; |
|
absl::InstallFailureSignalHandler(options); |
|
raise(signo); |
|
} |
|
|
|
TEST_P(FailureSignalHandlerDeathTest, AbslFatalSignalsWithWriterFn) { |
|
const int signo = GetParam(); |
|
std::string tmp_dir = GetTmpDir(); |
|
std::string file = absl::StrCat(tmp_dir, "/signo_", signo); |
|
|
|
std::string exit_regex = absl::StrCat( |
|
"\\*\\*\\* ", absl::debugging_internal::FailureSignalToString(signo), |
|
" received at time="); |
|
#ifndef _WIN32 |
|
EXPECT_EXIT(InstallHandlerWithWriteToFileAndRaise(file.c_str(), signo), |
|
testing::KilledBySignal(signo), exit_regex); |
|
#else |
|
// Windows doesn't have testing::KilledBySignal(). |
|
EXPECT_DEATH(InstallHandlerWithWriteToFileAndRaise(file.c_str(), signo), |
|
exit_regex); |
|
#endif |
|
|
|
// Open the file in this process and check its contents. |
|
std::fstream error_output(file); |
|
ASSERT_TRUE(error_output.is_open()) << file; |
|
std::string error_line; |
|
std::getline(error_output, error_line); |
|
EXPECT_TRUE(absl::StartsWith( |
|
error_line, |
|
absl::StrCat("*** ", |
|
absl::debugging_internal::FailureSignalToString(signo), |
|
" received at "))); |
|
|
|
if (absl::debugging_internal::StackTraceWorksForTest()) { |
|
std::getline(error_output, error_line); |
|
EXPECT_TRUE(absl::StartsWith(error_line, "PC: ")); |
|
} |
|
} |
|
|
|
constexpr int kFailureSignals[] = { |
|
SIGSEGV, SIGILL, SIGFPE, SIGABRT, SIGTERM, |
|
#ifndef _WIN32 |
|
SIGBUS, SIGTRAP, |
|
#endif |
|
}; |
|
|
|
std::string SignalParamToString(const ::testing::TestParamInfo<int>& info) { |
|
std::string result = |
|
absl::debugging_internal::FailureSignalToString(info.param); |
|
if (result.empty()) { |
|
result = absl::StrCat(info.param); |
|
} |
|
return result; |
|
} |
|
|
|
INSTANTIATE_TEST_SUITE_P(AbslDeathTest, FailureSignalHandlerDeathTest, |
|
::testing::ValuesIn(kFailureSignals), |
|
SignalParamToString); |
|
|
|
#endif // GTEST_HAS_DEATH_TEST |
|
|
|
} // namespace |
|
|
|
int main(int argc, char** argv) { |
|
absl::InitializeSymbolizer(argv[0]); |
|
testing::InitGoogleTest(&argc, argv); |
|
return RUN_ALL_TESTS(); |
|
}
|
|
|