Use ASSERT_THAT_ERROR instead of logAllUnhandledErrors/exit

[gribozavr]

Summary

ASSERT_THAT_ERROR looks like the intended helper for use in tests.

[plotfi]

I tested this out. Seems to work fine, and print the Expected's Error. I am fine with it if @compnerd and @lhames and @jkorous are cool with it.

[plotfi]

This comment was removed by plotfi.

[plotfi]

plotfi@grendel:/mnt/nvme0/llvm-project$ build/tools/clang/unittests/DirectoryWatcher/./DirectoryWatcherTests --gtest_filter=DirectoryWatcherTest.AddFilesNote: Google Test filter = DirectoryWatcherTest.AddFiles
[==========] Running 1 test from 1 test case.
[----------] Global test environment set-up.
[----------] 1 test from DirectoryWatcherTest
[ RUN      ] DirectoryWatcherTest.AddFiles
/mnt/nvme0/llvm-project/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp:344: Failure
Value of: llvm::detail::TakeError(DW.takeError())
Expected: succeeded
  Actual: failed  (inotify_init1() error: Illegal seek)
[  FAILED  ] DirectoryWatcherTest.AddFiles (3 ms)
[----------] 1 test from DirectoryWatcherTest (3 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test case ran. (3 ms total)
[  PASSED  ] 0 tests.
[  FAILED  ] 1 test, listed below:
[  FAILED  ] DirectoryWatcherTest.AddFiles

 1 FAILED TEST

Is the output in the failure case. This seems fine to me.

[gribozavr]

In D65853#1619801, @plotfi wrote:

I tested this out. Seems to work fine, and print the Expected's Error. I am fine with it if @compnerd and @lhames and @jkorous are cool with it.

@compnerd @lhames @jkorous ping?

[lhames]

LGTM.

cfe/trunk/unittests/DirectoryWatcher/CMakeLists.txt

 if(APPLE OR CMAKE_SYSTEM_NAME MATCHES "Linux")
 
   set(LLVM_LINK_COMPONENTS
     Support
     )
 
   add_clang_unittest(DirectoryWatcherTests
     DirectoryWatcherTest.cpp
     )
 
   target_link_libraries(DirectoryWatcherTests
     PRIVATE
+    LLVMTestingSupport
     clangDirectoryWatcher
     clangBasic
     )
 
-endif()
+endif()
 

cfe/trunk/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp

 //===- unittests/DirectoryWatcher/DirectoryWatcherTest.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 "clang/DirectoryWatcher/DirectoryWatcher.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 #include <condition_variable>
 #include <future>
 #include <mutex>
 #include <thread>
 
 using namespace llvm;
 using namespace llvm::sys;
TEST(DirectoryWatcherTest, InitialScanSync) {
   llvm::Expected<std::unique_ptr<DirectoryWatcher>> DW =
       DirectoryWatcher::create(
           fixture.TestWatchedDir,
           [&TestConsumer](llvm::ArrayRef<DirectoryWatcher::Event> Events,
                           bool IsInitial) {
             TestConsumer.consume(Events, IsInitial);
           },
           /*waitForInitialSync=*/true);
-  if (!DW) {
-    logAllUnhandledErrors(
-        DW.takeError(), llvm::errs(),
-        "DirectoryWatcherTest Failure on DirectoryWatcher::create(): ");
-    exit(EXIT_FAILURE);
-  }
+  ASSERT_THAT_ERROR(DW.takeError(), Succeeded());
 
   checkEventualResultWithTimeout(TestConsumer);
 }
 
 TEST(DirectoryWatcherTest, InitialScanAsync) {
   DirectoryWatcherTestFixture fixture;
 
   fixture.addFile("a");
TEST(DirectoryWatcherTest, InitialScanAsync) {
   llvm::Expected<std::unique_ptr<DirectoryWatcher>> DW =
       DirectoryWatcher::create(
           fixture.TestWatchedDir,
           [&TestConsumer](llvm::ArrayRef<DirectoryWatcher::Event> Events,
                           bool IsInitial) {
             TestConsumer.consume(Events, IsInitial);
           },
           /*waitForInitialSync=*/false);
-  if (!DW) {
-    logAllUnhandledErrors(
-        DW.takeError(), llvm::errs(),
-        "DirectoryWatcherTest Failure on DirectoryWatcher::create(): ");
-    exit(EXIT_FAILURE);
-  }
+  ASSERT_THAT_ERROR(DW.takeError(), Succeeded());
 
   checkEventualResultWithTimeout(TestConsumer);
 }
 
 TEST(DirectoryWatcherTest, AddFiles) {
   DirectoryWatcherTestFixture fixture;
 
   VerifyingConsumer TestConsumer{
       {},
       {{EventKind::Modified, "a"},
        {EventKind::Modified, "b"},
        {EventKind::Modified, "c"}}};
 
   llvm::Expected<std::unique_ptr<DirectoryWatcher>> DW =
       DirectoryWatcher::create(
           fixture.TestWatchedDir,
           [&TestConsumer](llvm::ArrayRef<DirectoryWatcher::Event> Events,
                           bool IsInitial) {
             TestConsumer.consume(Events, IsInitial);
           },
           /*waitForInitialSync=*/true);
-  if (!DW) {
-    logAllUnhandledErrors(
-        DW.takeError(), llvm::errs(),
-        "DirectoryWatcherTest Failure on DirectoryWatcher::create(): ");
-    exit(EXIT_FAILURE);
-  }
+  ASSERT_THAT_ERROR(DW.takeError(), Succeeded());
 
   fixture.addFile("a");
   fixture.addFile("b");
   fixture.addFile("c");
 
   checkEventualResultWithTimeout(TestConsumer);
 }
 
TEST(DirectoryWatcherTest, ModifyFile) {
   llvm::Expected<std::unique_ptr<DirectoryWatcher>> DW =
       DirectoryWatcher::create(
           fixture.TestWatchedDir,
           [&TestConsumer](llvm::ArrayRef<DirectoryWatcher::Event> Events,
                           bool IsInitial) {
             TestConsumer.consume(Events, IsInitial);
           },
           /*waitForInitialSync=*/true);
-  if (!DW) {
-    logAllUnhandledErrors(
-        DW.takeError(), llvm::errs(),
-        "DirectoryWatcherTest Failure on DirectoryWatcher::create(): ");
-    exit(EXIT_FAILURE);
-  }
+  ASSERT_THAT_ERROR(DW.takeError(), Succeeded());
 
   // modify the file
   {
     std::error_code error;
     llvm::raw_fd_ostream bStream(fixture.getPathInWatched("a"), error,
                                  CD_OpenExisting);
     assert(!error);
     bStream << "foo";
TEST(DirectoryWatcherTest, DeleteFile) {
   llvm::Expected<std::unique_ptr<DirectoryWatcher>> DW =
       DirectoryWatcher::create(
           fixture.TestWatchedDir,
           [&TestConsumer](llvm::ArrayRef<DirectoryWatcher::Event> Events,
                           bool IsInitial) {
             TestConsumer.consume(Events, IsInitial);
           },
           /*waitForInitialSync=*/true);
-  if (!DW) {
-    logAllUnhandledErrors(
-        DW.takeError(), llvm::errs(),
-        "DirectoryWatcherTest Failure on DirectoryWatcher::create(): ");
-    exit(EXIT_FAILURE);
-  }
+  ASSERT_THAT_ERROR(DW.takeError(), Succeeded());
 
   fixture.deleteFile("a");
 
   checkEventualResultWithTimeout(TestConsumer);
 }
 
 TEST(DirectoryWatcherTest, DeleteWatchedDir) {
   DirectoryWatcherTestFixture fixture;
 
   VerifyingConsumer TestConsumer{
       {},
       {{EventKind::WatchedDirRemoved, ""},
        {EventKind::WatcherGotInvalidated, ""}}};
 
   llvm::Expected<std::unique_ptr<DirectoryWatcher>> DW =
       DirectoryWatcher::create(
           fixture.TestWatchedDir,
           [&TestConsumer](llvm::ArrayRef<DirectoryWatcher::Event> Events,
                           bool IsInitial) {
             TestConsumer.consume(Events, IsInitial);
           },
           /*waitForInitialSync=*/true);
-  if (!DW) {
-    logAllUnhandledErrors(
-        DW.takeError(), llvm::errs(),
-        "DirectoryWatcherTest Failure on DirectoryWatcher::create(): ");
-    exit(EXIT_FAILURE);
-  }
+  ASSERT_THAT_ERROR(DW.takeError(), Succeeded());
 
   remove_directories(fixture.TestWatchedDir);
 
   checkEventualResultWithTimeout(TestConsumer);
 }
 
 TEST(DirectoryWatcherTest, InvalidatedWatcher) {
   DirectoryWatcherTestFixture fixture;
 
   VerifyingConsumer TestConsumer{
       {}, {{EventKind::WatcherGotInvalidated, ""}}};
 
   {
     llvm::Expected<std::unique_ptr<DirectoryWatcher>> DW =
         DirectoryWatcher::create(
             fixture.TestWatchedDir,
             [&TestConsumer](llvm::ArrayRef<DirectoryWatcher::Event> Events,
                             bool IsInitial) {
               TestConsumer.consume(Events, IsInitial);
             },
             /*waitForInitialSync=*/true);
-    if (!DW) {
-      logAllUnhandledErrors(
-          DW.takeError(), llvm::errs(),
-          "DirectoryWatcherTest Failure on DirectoryWatcher::create(): ");
-      exit(EXIT_FAILURE);
-    }
+    ASSERT_THAT_ERROR(DW.takeError(), Succeeded());
   } // DW is destructed here.
 
   checkEventualResultWithTimeout(TestConsumer);
 }