Remove EXPECT_DEATH as the preparation of public absl

Author: taku910

src/common.h

@@ -85,9 +85,6 @@ namespace error {
 
 void Abort();
 void Exit(int code);
-void SetTestCounter(int c);
-void ResetTestMode();
-bool GetTestCounter();
 
 class Die {
  public:

src/error.cc

@@ -29,29 +29,18 @@ ABSL_FLAG(int32_t, minloglevel, 0,
 
 namespace sentencepiece {
 namespace error {
-int gTestCounter = 0;
 
 void Abort() {
-  if (GetTestCounter() == 1) {
-    SetTestCounter(2);
-  } else {
-    std::cerr << "Program terminated with an unrecoverable error." << std::endl;
-    ShutdownLibrary();
-    exit(-1);
-  }
+  std::cerr << "Program terminated with an unrecoverable error." << std::endl;
+  ShutdownLibrary();
+  std::exit(-1);
 }
 
 void Exit(int code) {
-  if (GetTestCounter() == 1) {
-    SetTestCounter(2);
-  } else {
-    ShutdownLibrary();
-    exit(code);
-  }
+  ShutdownLibrary();
+  std::exit(code);
 }
 
-void SetTestCounter(int c) { gTestCounter = c; }
-bool GetTestCounter() { return gTestCounter; }
 }  // namespace error
 
 namespace util {

src/init_test.cc

@@ -89,36 +89,6 @@ TEST(FlagsTest, ParseCommandLineFlagsTest3) {
   EXPECT_EQ(1, argc);
 }
 
-TEST(FlagsTest, ParseCommandLineFlagsHelpTest) {
-  const char *kFlags[] = {"program", "--help"};
-  int argc = std::size(kFlags);
-  char **argv = const_cast<char **>(kFlags);
-  EXPECT_DEATH(ParseCommandLineFlags(kFlags[0], &argc, &argv), "");
-  absl::SetFlag(&FLAGS_help, false);
-}
-
-TEST(FlagsTest, ParseCommandLineFlagsVersionTest) {
-  const char *kFlags[] = {"program", "--version"};
-  int argc = std::size(kFlags);
-  char **argv = const_cast<char **>(kFlags);
-  EXPECT_DEATH(ParseCommandLineFlags(kFlags[0], &argc, &argv), "");
-  absl::SetFlag(&FLAGS_version, false);
-}
-
-TEST(FlagsTest, ParseCommandLineFlagsUnknownTest) {
-  const char *kFlags[] = {"program", "--foo"};
-  int argc = std::size(kFlags);
-  char **argv = const_cast<char **>(kFlags);
-  EXPECT_DEATH(ParseCommandLineFlags(kFlags[0], &argc, &argv), "");
-}
-
-TEST(FlagsTest, ParseCommandLineFlagsInvalidBoolTest) {
-  const char *kFlags[] = {"program", "--bool_f=X"};
-  int argc = std::size(kFlags);
-  char **argv = const_cast<char **>(kFlags);
-  EXPECT_DEATH(ParseCommandLineFlags(kFlags[0], &argc, &argv), "");
-}
-
 TEST(FlagsTest, ParseCommandLineFlagsEmptyStringArgs) {
   const char *kFlags[] = {"program", "--string_f="};
   int argc = std::size(kFlags);
@@ -137,12 +107,6 @@ TEST(FlagsTest, ParseCommandLineFlagsEmptyBoolArgs) {
   EXPECT_TRUE(absl::GetFlag(FLAGS_bool_f));
 }
 
-TEST(FlagsTest, ParseCommandLineFlagsEmptyIntArgs) {
-  const char *kFlags[] = {"program", "--int32_f"};
-  int argc = std::size(kFlags);
-  char **argv = const_cast<char **>(kFlags);
-  EXPECT_DEATH(ParseCommandLineFlags(kFlags[0], &argc, &argv), );
-}
 }  // namespace absl
 
 #endif  // _USE_EXTERNAL_ABSL

src/testharness.h

@@ -136,13 +136,6 @@ class Tester {
 #define EXPECT_OK(c) EXPECT_EQ(c, ::sentencepiece::util::OkStatus())
 #define EXPECT_NOT_OK(c) EXPECT_NE(c, ::sentencepiece::util::OkStatus())
 
-#define EXPECT_DEATH(statement, condition)   \
-  {                                          \
-    sentencepiece::error::SetTestCounter(1); \
-    statement;                               \
-    sentencepiece::error::SetTestCounter(0); \
-  };
-
 #define ASSERT_TRUE EXPECT_TRUE
 #define ASSERT_FALSE EXPECT_FALSE
 #define ASSERT_STREQ EXPECT_STREQ
@@ -154,7 +147,6 @@ class Tester {
 #define ASSERT_LT EXPECT_LT
 #define ASSERT_NEAR EXPECT_NEAR
 #define ASSERT_NOT_OK EXPECT_NOT_OK
-#define ASSERT_DEATH ASSERT_DEATH
 
 template <typename T>
 class TestWithParam {

src/util_test.cc

@@ -313,19 +313,12 @@ TEST(UtilTest, MapUtilTest) {
 
   EXPECT_EQ("A", port::FindOrDie(kMap, "a"));
   EXPECT_EQ("B", port::FindOrDie(kMap, "b"));
-  EXPECT_DEATH(port::FindOrDie(kMap, "x"), "");
 
   EXPECT_EQ("A", port::FindWithDefault(kMap, "a", "x"));
   EXPECT_EQ("B", port::FindWithDefault(kMap, "b", "x"));
   EXPECT_EQ("x", port::FindWithDefault(kMap, "d", "x"));
 
   EXPECT_EQ("A", port::FindOrDie(kMap, "a"));
-  EXPECT_DEATH(port::FindOrDie(kMap, "d"), "");
-}
-
-TEST(UtilTest, MapUtilVecTest) {
-  const std::map<std::vector<int>, std::string> kMap = {{{0, 1}, "A"}};
-  EXPECT_DEATH(port::FindOrDie(kMap, {0, 2}), "");
 }
 
 TEST(UtilTest, InputOutputBufferTest) {